diff --git a/django/conf/global_settings.py b/django/conf/global_settings.py
index fab2d0f..8ebaba6 100644
--- a/django/conf/global_settings.py
+++ b/django/conf/global_settings.py
@@ -263,6 +263,14 @@ MEDIA_ROOT = ''
 # Example: "http://media.lawrence.com"
 MEDIA_URL = ''
 
+# Absolute path to the directory that holds static files.
+# Example: "/home/media/media.lawrence.com/static/"
+STATIC_ROOT = ''
+
+# URL that handles the static files served from STATIC_ROOT.
+# Example: "http://media.lawrence.com/static/"
+STATIC_URL = None
+
 # List of upload handler classes to be applied in order.
 FILE_UPLOAD_HANDLERS = (
     'django.core.files.uploadhandler.MemoryFileUploadHandler',
@@ -552,14 +560,6 @@ FIXTURE_DIRS = ()
 # STATICFILES #
 ###############
 
-# Absolute path to the directory that holds media.
-# Example: "/home/media/media.lawrence.com/static/"
-STATICFILES_ROOT = ''
-
-# URL that handles the static files served from STATICFILES_ROOT.
-# Example: "http://media.lawrence.com/static/"
-STATICFILES_URL = '/static/'
-
 # A list of locations of additional static files
 STATICFILES_DIRS = ()
 
diff --git a/django/conf/project_template/settings.py b/django/conf/project_template/settings.py
index 07a823b..19d5ccd 100644
--- a/django/conf/project_template/settings.py
+++ b/django/conf/project_template/settings.py
@@ -54,11 +54,11 @@ MEDIA_URL = ''
 
 # Absolute path to the directory that holds media.
 # Example: "/home/media/media.lawrence.com/static/"
-STATICFILES_ROOT = ''
+STATIC_ROOT = ''
 
-# URL that handles the static files served from STATICFILES_ROOT.
+# URL that handles the static files served from STATIC_ROOT.
 # Example: "http://static.lawrence.com/", "http://example.com/static/"
-STATICFILES_URL = '/static/'
+STATIC_URL = '/static/'
 
 # URL prefix for admin media -- CSS, JavaScript and images.
 # Make sure to use a trailing slash.
diff --git a/django/contrib/staticfiles/context_processors.py b/django/contrib/staticfiles/context_processors.py
index 3ed0071..dafd3c2 100644
--- a/django/contrib/staticfiles/context_processors.py
+++ b/django/contrib/staticfiles/context_processors.py
@@ -2,5 +2,5 @@ from django.conf import settings
 
 def staticfiles(request):
     return {
-        'STATICFILES_URL': settings.STATICFILES_URL,
+        'STATIC_URL': settings.STATIC_URL,
     }
diff --git a/django/contrib/staticfiles/handlers.py b/django/contrib/staticfiles/handlers.py
index 20b0496..a7ac1a2 100644
--- a/django/contrib/staticfiles/handlers.py
+++ b/django/contrib/staticfiles/handlers.py
@@ -10,7 +10,7 @@ from django.contrib.staticfiles.views import serve
 class StaticFilesHandler(WSGIHandler):
     """
     WSGI middleware that intercepts calls to the static files directory, as
-    defined by the STATICFILES_URL setting, and serves those files.
+    defined by the STATIC_URL setting, and serves those files.
     """
     def __init__(self, application, media_dir=None):
         self.application = application
@@ -24,10 +24,10 @@ class StaticFilesHandler(WSGIHandler):
         super(StaticFilesHandler, self).__init__()
 
     def get_media_dir(self):
-        return settings.STATICFILES_ROOT
+        return settings.STATIC_ROOT
 
     def get_media_url(self):
-        return settings.STATICFILES_URL
+        return settings.STATIC_URL
 
     def _should_handle(self, path):
         """
diff --git a/django/contrib/staticfiles/management/commands/collectstatic.py b/django/contrib/staticfiles/management/commands/collectstatic.py
index d121223..8882ae2 100644
--- a/django/contrib/staticfiles/management/commands/collectstatic.py
+++ b/django/contrib/staticfiles/management/commands/collectstatic.py
@@ -12,7 +12,7 @@ from django.contrib.staticfiles import finders
 class Command(NoArgsCommand):
     """
     Command that allows to copy or symlink media files from different
-    locations to the settings.STATICFILES_ROOT.
+    locations to the settings.STATIC_ROOT.
     """
     option_list = NoArgsCommand.option_list + (
         make_option('--noinput', action='store_false', dest='interactive',
@@ -85,7 +85,7 @@ Type 'yes' to continue, or 'no' to cancel: """)
             self.stdout.write("\n%s static file%s %s to '%s'%s.\n"
                               % (actual_count, actual_count != 1 and 's' or '',
                                  symlink and 'symlinked' or 'copied',
-                                 settings.STATICFILES_ROOT,
+                                 settings.STATIC_ROOT,
                                  unmodified_count and ' (%s unmodified)'
                                  % unmodified_count or ''))
 
diff --git a/django/contrib/staticfiles/management/commands/runserver.py b/django/contrib/staticfiles/management/commands/runserver.py
index e138759..f4c2259 100644
--- a/django/contrib/staticfiles/management/commands/runserver.py
+++ b/django/contrib/staticfiles/management/commands/runserver.py
@@ -8,7 +8,7 @@ from django.contrib.staticfiles.handlers import StaticFilesHandler
 class Command(BaseRunserverCommand):
     option_list = BaseRunserverCommand.option_list + (
         make_option('--nostatic', action="store_false", dest='use_static_handler', default=True,
-            help='Tells Django to NOT automatically serve static files at STATICFILES_URL.'),
+            help='Tells Django to NOT automatically serve static files at STATIC_URL.'),
         make_option('--insecure', action="store_true", dest='insecure_serving', default=False,
             help='Allows serving static files even if DEBUG is False.'),
     )
diff --git a/django/contrib/staticfiles/storage.py b/django/contrib/staticfiles/storage.py
index b4bfea7..db55895 100644
--- a/django/contrib/staticfiles/storage.py
+++ b/django/contrib/staticfiles/storage.py
@@ -12,21 +12,21 @@ class StaticFilesStorage(FileSystemStorage):
     Standard file system storage for site media files.
     
     The defaults for ``location`` and ``base_url`` are
-    ``STATICFILES_ROOT`` and ``STATICFILES_URL``.
+    ``STATIC_ROOT`` and ``STATIC_URL``.
     """
     def __init__(self, location=None, base_url=None, *args, **kwargs):
         if location is None:
-            location = settings.STATICFILES_ROOT
+            location = settings.STATIC_ROOT
         if base_url is None:
-            base_url = settings.STATICFILES_URL
+            base_url = settings.STATIC_URL
         if not location:
             raise ImproperlyConfigured("You're using the staticfiles app "
-                "without having set the STATICFILES_ROOT setting. Set it to "
+                "without having set the STATIC_ROOT setting. Set it to "
                 "the absolute path of the directory that holds static media.")
         if not base_url:
             raise ImproperlyConfigured("You're using the staticfiles app "
-                "without having set the STATICFILES_URL setting. Set it to "
-                "URL that handles the files served from STATICFILES_ROOT.")
+                "without having set the STATIC_URL setting. Set it to "
+                "URL that handles the files served from STATIC_ROOT.")
         if settings.DEBUG:
             utils.check_settings()
         super(StaticFilesStorage, self).__init__(location, base_url, *args, **kwargs)
diff --git a/django/contrib/staticfiles/templatetags/staticfiles.py b/django/contrib/staticfiles/templatetags/staticfiles.py
deleted file mode 100644
index 6153f5a..0000000
--- a/django/contrib/staticfiles/templatetags/staticfiles.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from django import template
-from django.utils.encoding import iri_to_uri
-
-register = template.Library()
-
-class StaticFilesPrefixNode(template.Node):
-
-    def __init__(self, varname=None):
-        self.varname = varname
-
-    def render(self, context):
-        try:
-            from django.conf import settings
-        except ImportError:
-            prefix = ''
-        else:
-            prefix = iri_to_uri(settings.STATICFILES_URL)
-        if self.varname is None:
-            return prefix
-        context[self.varname] = prefix
-        return ''
-
-@register.tag
-def get_staticfiles_prefix(parser, token):
-    """
-    Populates a template variable with the prefix (settings.STATICFILES_URL).
-
-    Usage::
-
-        {% get_staticfiles_prefix [as varname] %}
-
-    Examples::
-
-        {% get_staticfiles_prefix %}
-        {% get_staticfiles_prefix as staticfiles_prefix %}
-
-    """
-    tokens = token.contents.split()
-    if len(tokens) > 1 and tokens[1] != 'as':
-        raise template.TemplateSyntaxError(
-            "First argument in '%s' must be 'as'" % tokens[0])
-    return StaticFilesPrefixNode(varname=(len(tokens) > 1 and tokens[2] or None))
-
diff --git a/django/contrib/staticfiles/urls.py b/django/contrib/staticfiles/urls.py
index 70f04f2..952491b 100644
--- a/django/contrib/staticfiles/urls.py
+++ b/django/contrib/staticfiles/urls.py
@@ -11,22 +11,22 @@ if settings.DEBUG:
         url(r'^(?P<path>.*)$', 'django.contrib.staticfiles.views.serve'),
     )
 
-def staticfiles_urlpatterns(prefix=None):
+def static_urlpatterns(prefix=None):
     """
     Helper function to return a URL pattern for serving static files.
     """
     if not settings.DEBUG:
         return []
     if prefix is None:
-        prefix = settings.STATICFILES_URL
+        prefix = settings.STATIC_URL
     if not prefix:
         raise ImproperlyConfigured(
-            "The prefix for the 'staticfiles_urlpatterns' helper is empty. "
-            "Make sure the STATICFILES_URL setting is set correctly.")
+            "The prefix for the 'static_urlpatterns' helper is empty. "
+            "Make sure the STATIC_URL setting is set correctly.")
     if '://' in prefix:
         raise ImproperlyConfigured(
-            "The STATICFILES_URL setting is a full URL, not a path and "
-            "can't be used with the 'staticfiles_urlpatterns' helper.")
+            "The STATIC_URL setting is a full URL, not a path and "
+            "can't be used with the 'static_urlpatterns' helper.")
     if prefix.startswith("/"):
         prefix = prefix[1:]
     return patterns('',
diff --git a/django/contrib/staticfiles/utils.py b/django/contrib/staticfiles/utils.py
index 0071dbd..4efcb47 100644
--- a/django/contrib/staticfiles/utils.py
+++ b/django/contrib/staticfiles/utils.py
@@ -36,10 +36,10 @@ def check_settings():
     Checks if the MEDIA_(ROOT|URL) and STATICFILES_(ROOT|URL)
     settings have the same value.
     """
-    if settings.MEDIA_URL == settings.STATICFILES_URL:
-        raise ImproperlyConfigured("The MEDIA_URL and STATICFILES_URL "
+    if settings.MEDIA_URL == settings.STATIC_URL:
+        raise ImproperlyConfigured("The MEDIA_URL and STATIC_URL "
                                    "settings must have individual values")
-    if ((settings.MEDIA_ROOT and settings.STATICFILES_ROOT) and
-            (settings.MEDIA_ROOT == settings.STATICFILES_ROOT)):
-        raise ImproperlyConfigured("The MEDIA_ROOT and STATICFILES_ROOT "
+    if ((settings.MEDIA_ROOT and settings.STATIC_ROOT) and
+            (settings.MEDIA_ROOT == settings.STATIC_ROOT)):
+        raise ImproperlyConfigured("The MEDIA_ROOT and STATIC_ROOT "
                                    "settings must have individual values")
diff --git a/django/forms/widgets.py b/django/forms/widgets.py
index cb12586..2b98638 100644
--- a/django/forms/widgets.py
+++ b/django/forms/widgets.py
@@ -1,9 +1,13 @@
 """
 HTML Widget classes
 """
+import datetime
+from itertools import chain
+import time
+from urlparse import urljoin
+from util import flatatt
 
 import django.utils.copycompat as copy
-from itertools import chain
 from django.conf import settings
 from django.utils.datastructures import MultiValueDict, MergeDict
 from django.utils.html import escape, conditional_escape
@@ -11,10 +15,6 @@ from django.utils.translation import ugettext, ugettext_lazy
 from django.utils.encoding import StrAndUnicode, force_unicode
 from django.utils.safestring import mark_safe
 from django.utils import datetime_safe, formats
-import time
-import datetime
-from util import flatatt
-from urlparse import urljoin
 
 __all__ = (
     'Media', 'MediaDefiningClass', 'Widget', 'TextInput', 'PasswordInput',
@@ -63,10 +63,14 @@ class Media(StrAndUnicode):
                     for path in self._css[medium]]
                 for medium in media])
 
-    def absolute_path(self, path):
+    def absolute_path(self, path, prefix=None):
         if path.startswith(u'http://') or path.startswith(u'https://') or path.startswith(u'/'):
             return path
-        return urljoin(settings.MEDIA_URL,path)
+        if prefix is None and settings.STATIC_URL is not None:
+            prefix = settings.STATIC_URL
+        else:
+            prefix = settings.MEDIA_URL # backwards compatibility
+        return urljoin(prefix, path)
 
     def __getitem__(self, name):
         "Returns a Media object that only contains media of the given type"
diff --git a/docs/howto/static-files.txt b/docs/howto/static-files.txt
index 37f1fc3..51ec2d2 100644
--- a/docs/howto/static-files.txt
+++ b/docs/howto/static-files.txt
@@ -50,12 +50,12 @@ Here's the basic usage in a nutshell:
        First, you'll need to make sure that ``django.contrib.staticfiles`` is in
        your :setting:`INSTALLED_APPS`.
 
-       Next, you'll need to edit :setting:`STATICFILES_ROOT` to point to where
+       Next, you'll need to edit :setting:`STATIC_ROOT` to point to where
        you'd like your static media stored. For example::
 
-            STATICFILES_ROOT = "/home/jacob/projects/mysite.com/static_media"
+            STATIC_ROOT = "/home/jacob/projects/mysite.com/static_media"
 
-       You may also want to set the :setting:`STATICFILES_URL` setting at this
+       You may also want to set the :setting:`STATIC_URL` setting at this
        time, though the default value (of ``/static/``) is perfect for local
        development.
 
@@ -69,22 +69,22 @@ Here's the basic usage in a nutshell:
             ./manage.py collectstatic
 
        This'll churn through your static file storage and move them into the
-       directory given by :setting:`STATICFILES_ROOT`. (This is not necessary
+       directory given by :setting:`STATIC_ROOT`. (This is not necessary
        in local development if you are using :djadmin:`runserver` or adding
-       ``staticfiles_urlpatterns`` to your URLconf; see below).
+       ``static_urlpatterns`` to your URLconf; see below).
 
     4. Deploy that media.
 
        If you're using the built-in development server (the
        :djadmin:`runserver` management command) and have the :setting:`DEBUG`
        setting set to ``True``, your staticfiles will automatically be served
-       from :setting:`STATICFILES_URL` in development.
+       from :setting:`STATIC_URL` in development.
 
        If you are using some other server for local development, you can
        quickly serve static media locally by adding::
 
-            from django.contrib.staticfiles.urls import staticfiles_urlpatterns
-            urlpatterns += staticfiles_urlpatterns()
+            from django.contrib.staticfiles.urls import static_urlpatterns
+            urlpatterns += static_urlpatterns()
 
        to the bottom of your URLconf. See :ref:`staticfiles-development` for
        details.
@@ -98,7 +98,7 @@ Here's the basic usage in a nutshell:
 
           .. code-block:: html+django
 
-               <img src="{{ STATICFILES_URL }}images/hi.jpg />
+               <img src="{{ STATIC_URL }}images/hi.jpg />
 
        See :ref:`staticfiles-in-templates` for more details, including an
        alternate method (using a template tag).
@@ -115,7 +115,7 @@ the framework see :doc:`the staticfiles reference </ref/contrib/staticfiles>`.
    app is to make it easier to keep static files separate from user-uploaded
    files. For this reason, you will probably want to make your
    :setting:`MEDIA_ROOT` and :setting:`MEDIA_URL` different from your
-   :setting:`STATICFILES_ROOT` and :setting:`STATICFILES_URL`. You will need to
+   :setting:`STATIC_ROOT` and :setting:`STATIC_URL`. You will need to
    arrange for serving of files in :setting:`MEDIA_ROOT` yourself;
    ``staticfiles`` does not deal with user-uploaded media at all.
 
@@ -136,7 +136,7 @@ development, and it makes it *very* hard to change where you've deployed your
 media. If, for example, you wanted to switch to using a content delivery network
 (CDN), then you'd need to change more or less every single template.
 
-A far better way is to use the value of the :setting:`STATICFILES_URL` setting
+A far better way is to use the value of the :setting:`STATIC_URL` setting
 directly in your templates. This means that a switch of media servers only
 requires changing that single value. Much better!
 
@@ -160,13 +160,13 @@ editing that setting by hand it should look something like::
         'django.contrib.staticfiles.context_processors.staticfiles',
     )
 
-Once that's done, you can refer to :setting:`STATICFILES_URL` in your templates:
+Once that's done, you can refer to :setting:`STATIC_URL` in your templates:
 
 .. code-block:: html+django
 
-     <img src="{{ STATICFILES_URL }}images/hi.jpg />
+     <img src="{{ STATIC_URL }}images/hi.jpg />
 
-If ``{{ STATICFILES_URL }}`` isn't working in your template, you're probably not
+If ``{{ STATIC_URL }}`` isn't working in your template, you're probably not
 using :class:`~django.template.RequestContext` when rendering the template.
 
 As a brief refresher, context processors add variables into the contexts of
@@ -180,15 +180,15 @@ To see how that works, and to read more details, check out
 With a template tag
 -------------------
 
-The second option is the :ttag:`get_staticfiles_prefix` template tag. You can
+The second option is the :ttag:`get_static_prefix` template tag. You can
 use this if you're not using :class:`~django.template.RequestContext`, or if you
-need more control over exactly where and how :setting:`STATICFILES_URL` is
+need more control over exactly where and how :setting:`STATIC_URL` is
 injected into the template. Here's an example:
 
 .. code-block:: html+django
 
     {% load staticfiles %}
-    <img src="{% get_staticfiles_prefix %}images/hi.jpg" />
+    <img src="{% get_static_prefix %}images/hi.jpg" />
 
 There's also a second form you can use to avoid extra processing if you need the
 value multiple times:
@@ -196,7 +196,7 @@ value multiple times:
 .. code-block:: html+django
 
     {% load staticfiles %}
-    {% get_staticfiles_prefix as STATIC_PREFIX %}
+    {% get_static_prefix as STATIC_PREFIX %}
 
     <img src="{{ STATIC_PREFIX }}images/hi.jpg" />
     <img src="{{ STATIC_PREFIX }}images/hi2.jpg" />
@@ -213,20 +213,20 @@ Thus, the ``staticfiles`` app ships with a quick and dirty helper view that you
 can use to serve files locally in development.
 
 This view is automatically enabled and will serve your static files at
-:setting:`STATICFILES_URL` when you use the built-in :djadmin:`runserver`.
+:setting:`STATIC_URL` when you use the built-in :djadmin:`runserver`.
 
 To enable this view if you are using some other server for local development,
 you'll add a couple of lines to your URLconf. The first line goes at the top of
 the file, and the last line at the bottom::
 
-    from django.contrib.staticfiles.urls import staticfiles_urlpatterns
+    from django.contrib.staticfiles.urls import static_urlpatterns
 
     # ... the rest of your URLconf goes here ...
 
-    urlpatterns += staticfiles_urlpatterns()
+    urlpatterns += static_urlpatterns()
 
-This will inspect your :setting:`STATICFILES_URL` and
-:setting:`STATICFILES_ROOT` settings and wire up the view to serve static media
+This will inspect your :setting:`STATIC_URL` and
+:setting:`STATIC_ROOT` settings and wire up the view to serve static media
 accordingly. Don't forget to set the :setting:`STATICFILES_DIRS` setting
 appropriately to let ``django.contrib.staticfiles`` know where to look for
 files.
@@ -249,7 +249,7 @@ Serving static files in production
 
 The basic outline of putting static files into production is simple: run the
 :djadmin:`collectstatic` command when static media changes, then arrange for the
-collected media directory (:setting:`STATICFILES_ROOT`) to be moved to the media
+collected media directory (:setting:`STATIC_ROOT`) to be moved to the media
 server and served.
 
 Of course, as with all deployment tasks, the devil's in the details. Every
@@ -264,8 +264,8 @@ app, the basic outline gets modified to look something like:
 
     * Push your code up to the deployment server.
     * On the server, run :djadmin:`collectstatic` to move all the media into
-      :setting:`STATICFILES_ROOT`.
-    * Point your web server at :setting:`STATICFILES_ROOT`. For example, here's
+      :setting:`STATIC_ROOT`.
+    * Point your web server at :setting:`STATIC_ROOT`. For example, here's
       :ref:`how to do this under Apache and mod_wsgi <serving-media-files>`.
 
 You'll probably want to automate this process, especially if you've got multiple
@@ -322,7 +322,7 @@ Since your media server won't be running Django, you'll need to modify the
 deployment strategy to look something like:
 
     * When your media changes, run :djadmin:`collectstatic` locally.
-    * Push your local :setting:`STATICFILES_ROOT` up to the media server
+    * Push your local :setting:`STATIC_ROOT` up to the media server
       into the directory that's being served. ``rsync`` is a good
       choice for this step since it only needs to transfer the
       bits of static media that have changed.
@@ -403,9 +403,6 @@ you'll need to make a few changes:
     * The management commands ``build_static`` and ``resolve_static`` are now
       called :djadmin:`collectstatic` and :djadmin:`findstatic`.
 
-    * The settings ``STATIC_URL`` and ``STATIC_ROOT`` were renamed to
-      :setting:`STATICFILES_URL` and :setting:`STATICFILES_ROOT`.
-
     * The settings ``STATICFILES_PREPEND_LABEL_APPS``,
       ``STATICFILES_MEDIA_DIRNAMES`` and ``STATICFILES_EXCLUDED_APPS`` were
       removed.
diff --git a/docs/man/django-admin.1 b/docs/man/django-admin.1
index 2197af6..f9b530a 100644
--- a/docs/man/django-admin.1
+++ b/docs/man/django-admin.1
@@ -165,7 +165,7 @@ Do not prompt the user for input.
 Disable the development server's auto\-reloader.
 .TP
 .I \-\-nostatic
-Disable automatic serving of static files from STATICFILES_URL.
+Disable automatic serving of static files from STATIC_URL.
 .TP
 .I \-\-insecure
 Enables serving of static files even if DEBUG is False.
diff --git a/docs/ref/contrib/staticfiles.txt b/docs/ref/contrib/staticfiles.txt
index f82fd79..4fe38d2 100644
--- a/docs/ref/contrib/staticfiles.txt
+++ b/docs/ref/contrib/staticfiles.txt
@@ -24,21 +24,21 @@ Settings
 .. highlight:: python
 
 The following settings control the behavior of the staticfiles app. Only
-:setting:`STATICFILES_ROOT` is required, but you'll probably also need to
-configure :setting:`STATICFILES_URL` as well.
+:setting:`STATIC_ROOT` is required, but you'll probably also need to
+configure :setting:`STATIC_URL` as well.
 
-.. setting:: STATICFILES_ROOT
+.. setting:: STATIC_ROOT
 
-STATICFILES_ROOT
-----------------
+STATIC_ROOT
+-----------
 
 Default: ``''`` (Empty string)
 
 The absolute path to the directory that the :djadmin:`collectstatic` management
 command will collect static files into, for serving from
-:setting:`STATICFILES_URL`::
+:setting:`STATIC_URL`::
 
-   STATICFILES_ROOT = "/home/example.com/static/"
+   STATIC_ROOT = "/home/example.com/static/"
 
 This is a **required setting** unless you've overridden
 :setting:`STATICFILES_STORAGE` and are using a custom storage backend.
@@ -47,22 +47,22 @@ This is not a place to store your static files permanently under version
 control; you should do that in directories that will be found by your
 :setting:`STATICFILES_FINDERS` (by default, per-app ``static/`` subdirectories,
 and any directories you include in :setting:`STATICFILES_DIRS`). Files from
-those locations will be collected into :setting:`STATICFILES_ROOT`.
+those locations will be collected into :setting:`STATIC_ROOT`.
 
-.. setting:: STATICFILES_URL
+.. setting:: STATIC_URL
 
-STATICFILES_URL
+STATIC_URL
 ---------------
 
 Default: ``'/static/'``
 
-The URL that handles the files served from :setting:`STATICFILES_ROOT`, e.g.::
+The URL that handles the files served from :setting:`STATIC_ROOT`, e.g.::
 
-    STATICFILES_URL = '/site_media/static/'
+    STATIC_URL = '/site_media/static/'
 
 ... or perhaps::
 
-    STATICFILES_URL = 'http://static.example.com/'
+    STATIC_URL = 'http://static.example.com/'
 
 This should **always** have a trailing slash.
 
@@ -98,7 +98,7 @@ tuples, e.g.::
 
 With this configuration, the :djadmin:`collectstatic` management command would
 for example collect the stats files in a ``'downloads'`` directory. So
-assuming you have :setting:`STATICFILES_URL` set ``'/static/'``, this would
+assuming you have :setting:`STATIC_URL` set ``'/static/'``, this would
 allow you to refer to the file ``'/opt/webfiles/stats/polls_20101022.tar.gz'``
 with ``'/static/downloads/polls_20101022.tar.gz'`` in your templates.
 
@@ -160,7 +160,7 @@ collectstatic
 
 .. django-admin:: collectstatic
 
-Collects the static files into :setting:`STATICFILES_ROOT`.
+Collects the static files into :setting:`STATIC_ROOT`.
 
 Duplicate file names are by default resolved in a similar way to how template
 resolution works: the file that is first found in one of the specified
@@ -223,39 +223,39 @@ collected for a given path.
 Other Helpers
 =============
 
-The ``staticfiles`` context processor
--------------------------------------
+The ``static`` context processor
+--------------------------------
 
-.. function:: django.contrib.staticfiles.context_processors.staticfiles
+.. function:: django.contrib.staticfiles.context_processors.static
 
-This context processor adds the :setting:`STATICFILES_URL` into each template
-context as the variable ``{{ STATICFILES_URL }}``. To use it, make sure that
-``'django.contrib.staticfiles.context_processors.staticfiles'`` appears
+This context processor adds the :setting:`STATIC_URL` into each template
+context as the variable ``{{ STATIC_URL }}``. To use it, make sure that
+``'django.contrib.staticfiles.context_processors.static'`` appears
 somewhere in your :setting:`TEMPLATE_CONTEXT_PROCESSORS` setting.
 
 Remember, only templates rendered with :class:`~django.template.RequestContext`
 will have acces to the data provided by this (and any) context processor.
 
-.. templatetag:: get_staticfiles_prefix
+.. templatetag:: get_static_prefix
 
-The ``get_staticfiles_prefix`` templatetag
-==========================================
+The ``get_static_prefix`` templatetag
+=====================================
 
 .. highlight:: html+django
 
 If you're not using :class:`~django.template.RequestContext`, or if you need
-more control over exactly where and how :setting:`STATICFILES_URL` is injected
-into the template, you can use the :ttag:`get_staticfiles_prefix` template tag
+more control over exactly where and how :setting:`STATIC_URL` is injected
+into the template, you can use the :ttag:`get_static_prefix` template tag
 instead::
 
     {% load staticfiles %}
-    <img src="{% get_staticfiles_prefix %}images/hi.jpg" />
+    <img src="{% get_static_prefix %}images/hi.jpg" />
 
 There's also a second form you can use to avoid extra processing if you need
 the value multiple times::
 
     {% load staticfiles %}
-    {% get_staticfiles_prefix as STATIC_PREFIX %}
+    {% get_static_prefix as STATIC_PREFIX %}
 
     <img src="{{ STATIC_PREFIX }}images/hi.jpg" />
     <img src="{{ STATIC_PREFIX }}images/hi2.jpg" />
@@ -292,18 +292,18 @@ primary URL configuration::
        )
 
 Note, the begin of the pattern (``r'^static/'``) should be your
-:setting:`STATICFILES_URL` setting.
+:setting:`STATIC_URL` setting.
 
 Since this is a bit finicky, there's also a helper function that'll do this for you:
 
-.. function:: django.contrib.staticfiles.urls.staticfiles_urlpatterns()
+.. function:: django.contrib.staticfiles.urls.static_urlpatterns()
 
 This will return the proper URL pattern for serving static files to your
 already defined pattern list. Use it like this::
 
-   from django.contrib.staticfiles.urls import staticfiles_urlpatterns
+   from django.contrib.staticfiles.urls import static_urlpatterns
 
    # ... the rest of your URLconf here ...
 
-   urlpatterns += staticfiles_urlpatterns()
+   urlpatterns += static_urlpatterns()
 
diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
index b394cd7..856e619 100644
--- a/docs/ref/settings.txt
+++ b/docs/ref/settings.txt
@@ -56,7 +56,7 @@ administrative interface. Make sure to use a trailing slash, and to have this be
 different from the :setting:``MEDIA_URL`` setting (since the same URL cannot be
 mapped onto two different sets of files). For integration with :doc:`staticfiles
 </ref/contrib/staticfiles>`, this should be the same as
-:setting:`STATICFILES_URL` followed by ``'admin/'``.
+:setting:`STATIC_URL` followed by ``'admin/'``.
 
 .. setting:: ADMINS
 
diff --git a/docs/releases/1.3.txt b/docs/releases/1.3.txt
index b5c0035..f795e77 100644
--- a/docs/releases/1.3.txt
+++ b/docs/releases/1.3.txt
@@ -59,7 +59,7 @@ In previous versions of Django, it was common to place static assets in
 app is to make it easier to keep static files separate from user-uploaded
 files. For this reason, you will probably want to make your
 :setting:`MEDIA_ROOT` and :setting:`MEDIA_URL` different from your
-:setting:`STATICFILES_ROOT` and :setting:`STATICFILES_URL`. You will need to
+:setting:`STATIC_ROOT` and :setting:`STATIC_URL`. You will need to
 arrange for serving of files in :setting:`MEDIA_ROOT` yourself;
 ``staticfiles`` does not deal with user-uploaded media at all.
 
diff --git a/tests/regressiontests/staticfiles_tests/tests.py b/tests/regressiontests/staticfiles_tests/tests.py
index 0a6c060..2d16983 100644
--- a/tests/regressiontests/staticfiles_tests/tests.py
+++ b/tests/regressiontests/staticfiles_tests/tests.py
@@ -23,8 +23,8 @@ class StaticFilesTestCase(TestCase):
     Test case with a couple utility assertions.
     """
     def setUp(self):
-        self.old_staticfiles_url = settings.STATICFILES_URL
-        self.old_staticfiles_root = settings.STATICFILES_ROOT
+        self.old_static_url = settings.STATIC_URL
+        self.old_static_root = settings.STATIC_ROOT
         self.old_staticfiles_dirs = settings.STATICFILES_DIRS
         self.old_staticfiles_finders = settings.STATICFILES_FINDERS
         self.old_media_root = settings.MEDIA_ROOT
@@ -40,8 +40,8 @@ class StaticFilesTestCase(TestCase):
         settings.DEBUG = True
         settings.MEDIA_ROOT =  os.path.join(site_media, 'media')
         settings.MEDIA_URL = '/media/'
-        settings.STATICFILES_ROOT = os.path.join(site_media, 'static')
-        settings.STATICFILES_URL = '/static/'
+        settings.STATIC_ROOT = os.path.join(site_media, 'static')
+        settings.STATIC_URL = '/static/'
         settings.ADMIN_MEDIA_PREFIX = '/static/admin/'
         settings.STATICFILES_DIRS = (
             os.path.join(TEST_ROOT, 'project', 'documents'),
@@ -52,6 +52,7 @@ class StaticFilesTestCase(TestCase):
             'django.contrib.staticfiles.finders.DefaultStorageFinder',
         )
         settings.INSTALLED_APPS = [
+            "django.contrib.staticfiles",
             "regressiontests.staticfiles_tests",
         ]
 
@@ -65,8 +66,8 @@ class StaticFilesTestCase(TestCase):
         settings.MEDIA_ROOT = self.old_media_root
         settings.MEDIA_URL = self.old_media_url
         settings.ADMIN_MEDIA_PREFIX = self.old_admin_media_prefix
-        settings.STATICFILES_ROOT = self.old_staticfiles_root
-        settings.STATICFILES_URL = self.old_staticfiles_url
+        settings.STATIC_ROOT = self.old_static_root
+        settings.STATIC_URL = self.old_static_url
         settings.STATICFILES_DIRS = self.old_staticfiles_dirs
         settings.STATICFILES_FINDERS = self.old_staticfiles_finders
         settings.INSTALLED_APPS = self.old_installed_apps
@@ -91,13 +92,13 @@ class BuildStaticTestCase(StaticFilesTestCase):
     def setUp(self):
         super(BuildStaticTestCase, self).setUp()
         self.old_staticfiles_storage = settings.STATICFILES_STORAGE
-        self.old_root = settings.STATICFILES_ROOT
-        settings.STATICFILES_ROOT = tempfile.mkdtemp()
+        self.old_root = settings.STATIC_ROOT
+        settings.STATIC_ROOT = tempfile.mkdtemp()
         self.run_collectstatic()
 
     def tearDown(self):
-        shutil.rmtree(settings.STATICFILES_ROOT)
-        settings.STATICFILES_ROOT = self.old_root
+        shutil.rmtree(settings.STATIC_ROOT)
+        settings.STATIC_ROOT = self.old_root
         super(BuildStaticTestCase, self).tearDown()
 
     def run_collectstatic(self, **kwargs):
@@ -106,7 +107,7 @@ class BuildStaticTestCase(StaticFilesTestCase):
 
     def _get_file(self, filepath):
         assert filepath, 'filepath is empty.'
-        filepath = os.path.join(settings.STATICFILES_ROOT, filepath)
+        filepath = os.path.join(settings.STATIC_ROOT, filepath)
         f = open(filepath)
         try:
             return f.read()
@@ -231,7 +232,7 @@ class TestBuildStaticDryRun(BuildStaticTestCase):
         """
         With --dry-run, no files created in destination dir.
         """
-        self.assertEquals(os.listdir(settings.STATICFILES_ROOT), [])
+        self.assertEquals(os.listdir(settings.STATIC_ROOT), [])
 
 
 if sys.platform != 'win32':
@@ -251,7 +252,7 @@ if sys.platform != 'win32':
             With ``--link``, symbolic links are created.
 
             """
-            self.failUnless(os.path.islink(os.path.join(settings.STATICFILES_ROOT, 'test.txt')))
+            self.failUnless(os.path.islink(os.path.join(settings.STATIC_ROOT, 'test.txt')))
 
 
 class TestServeStatic(StaticFilesTestCase):
@@ -262,7 +263,7 @@ class TestServeStatic(StaticFilesTestCase):
 
     def _response(self, filepath):
         return self.client.get(
-            posixpath.join(settings.STATICFILES_URL, filepath))
+            posixpath.join(settings.STATIC_URL, filepath))
 
     def assertFileContains(self, filepath, text):
         self.assertContains(self._response(filepath), text)
@@ -287,13 +288,13 @@ class TestServeDisabled(TestServeStatic):
 
 class TestServeStaticWithDefaultURL(TestServeStatic, TestDefaults):
     """
-    Test static asset serving view with staticfiles_urlpatterns helper.
+    Test static asset serving view with static_urlpatterns helper.
     """
     pass
 
 class TestServeStaticWithURLHelper(TestServeStatic, TestDefaults):
     """
-    Test static asset serving view with staticfiles_urlpatterns helper.
+    Test static asset serving view with static_urlpatterns helper.
     """
     urls = "regressiontests.staticfiles_tests.urls.helper"
 
@@ -374,22 +375,22 @@ class TestMiscFinder(TestCase):
             finders.get_finder, "foo.bar.FooBarFinder")
 
 
-class TemplateTagTest(TestCase):
-    def test_get_staticfiles_prefix(self):
+class TemplateTagTest(StaticFilesTestCase):
+    def test_get_static_prefix(self):
         """
-        Test the get_staticfiles_prefix helper return the STATICFILES_URL setting.
+        Test the get_static_prefix helper return the STATIC_URL setting.
         """
         self.assertEquals(Template(
-            "{% load staticfiles %}"
-            "{% get_staticfiles_prefix %}"
-        ).render(Context()), settings.STATICFILES_URL)
+            "{% load static %}"
+            "{% get_static_prefix %}"
+        ).render(Context()), settings.STATIC_URL)
 
-    def test_get_staticfiles_prefix_with_as(self):
+    def test_get_static_prefix_with_as(self):
         """
-        Test the get_staticfiles_prefix helper return the STATICFILES_URL setting.
+        Test the get_static_prefix helper return the STATIC_URL setting.
         """
         self.assertEquals(Template(
-            "{% load staticfiles %}"
-            "{% get_staticfiles_prefix as staticfiles_prefix %}"
-            "{{ staticfiles_prefix }}"
-        ).render(Context()), settings.STATICFILES_URL)
+            "{% load static %}"
+            "{% get_static_prefix as static_prefix %}"
+            "{{ static_prefix }}"
+        ).render(Context()), settings.STATIC_URL)
diff --git a/tests/regressiontests/staticfiles_tests/urls/helper.py b/tests/regressiontests/staticfiles_tests/urls/helper.py
index e4951d1..51ab63e 100644
--- a/tests/regressiontests/staticfiles_tests/urls/helper.py
+++ b/tests/regressiontests/staticfiles_tests/urls/helper.py
@@ -1,3 +1,3 @@
-from django.contrib.staticfiles.urls import staticfiles_urlpatterns
+from django.contrib.staticfiles.urls import static_urlpatterns
 
-urlpatterns = staticfiles_urlpatterns()
+urlpatterns = static_urlpatterns()
