diff --git a/django/contrib/gis/templates/gis/google/google-map.js b/django/contrib/gis/templates/gis/google/google-map.js
index 06f11e3..a8bcba5 100644
--- a/django/contrib/gis/templates/gis/google/google-map.js
+++ b/django/contrib/gis/templates/gis/google/google-map.js
@@ -1,4 +1,5 @@
 {% autoescape off %}
+{% localize off %}
 {% block vars %}var geodjango = {};{% for icon in icons %} 
 var {{ icon.varname }} = new GIcon(G_DEFAULT_ICON); 
 {% if icon.image %}{{ icon.varname }}.image = "{{ icon.image }}";{% endif %}
@@ -32,4 +33,4 @@ var {{ icon.varname }} = new GIcon(G_DEFAULT_ICON);
     alert("Sorry, the Google Maps API is not compatible with this browser.");
   }
 }
-{% endblock load %}{% endblock functions %}{% endautoescape %}
+{% endblock load %}{% endblock functions %}{% endlocalize %}{% endautoescape %}
diff --git a/django/template/__init__.py b/django/template/__init__.py
index c316786..ac8f117 100644
--- a/django/template/__init__.py
+++ b/django/template/__init__.py
@@ -789,11 +789,11 @@ class NodeList(list):
     # extend_nodelist().
     contains_nontext = False
 
-    def render(self, context):
+    def render(self, context, localization=None):
         bits = []
         for node in self:
             if isinstance(node, Node):
-                bits.append(self.render_node(node, context))
+                bits.append(self.render_node(node, context, localization))
             else:
                 bits.append(node)
         return mark_safe(''.join([force_unicode(b) for b in bits]))
@@ -805,7 +805,9 @@ class NodeList(list):
             nodes.extend(node.get_nodes_by_type(nodetype))
         return nodes
 
-    def render_node(self, node, context):
+    def render_node(self, node, context, localization=None):
+        if isinstance(node, VariableNode):
+            return node.render(context, localization)
         return node.render(context)
 
 class TextNode(Node):
@@ -819,13 +821,13 @@ class TextNode(Node):
     def render(self, context):
         return self.s
 
-def _render_value_in_context(value, context):
+def _render_value_in_context(value, context, localization=None):
     """
     Converts any value to a string to become part of a rendered template. This
     means escaping, if required, and conversion to a unicode object. If value
     is a string, it is expected to have already been translated.
     """
-    value = localize(value)
+    value = localize(value, localization)
     value = force_unicode(value)
     if (context.autoescape and not isinstance(value, SafeData)) or isinstance(value, EscapeData):
         return escape(value)
@@ -839,14 +841,14 @@ class VariableNode(Node):
     def __repr__(self):
         return "<Variable Node: %s>" % self.filter_expression
 
-    def render(self, context):
+    def render(self, context, localization):
         try:
             output = self.filter_expression.resolve(context)
         except UnicodeDecodeError:
             # Unicode conversion can fail sometimes for reasons out of our
             # control (e.g. exception rendering). In that case, we fail quietly.
             return ''
-        return _render_value_in_context(output, context)
+        return _render_value_in_context(output, context, localization)
 
 def generic_tag_compiler(params, defaults, name, node_class, parser, token):
     "Returns a template.Node subclass."
diff --git a/django/template/debug.py b/django/template/debug.py
index c21fb50..be2f3e4 100644
--- a/django/template/debug.py
+++ b/django/template/debug.py
@@ -84,10 +84,10 @@ class DebugNodeList(NodeList):
         return result
 
 class DebugVariableNode(VariableNode):
-    def render(self, context):
+    def render(self, context, localization=None):
         try:
             output = self.filter_expression.resolve(context)
-            output = localize(output)
+            output = localize(value, context, localization)
             output = force_unicode(output)
         except TemplateSyntaxError, e:
             if not hasattr(e, 'source'):
diff --git a/django/template/defaultfilters.py b/django/template/defaultfilters.py
index 1500a05..44e71b7 100644
--- a/django/template/defaultfilters.py
+++ b/django/template/defaultfilters.py
@@ -434,6 +434,17 @@ linebreaksbr.is_safe = True
 linebreaksbr.needs_autoescape = True
 linebreaksbr = stringfilter(linebreaksbr)
 
+def localize(value, localization='on'):
+    """
+    Localizes (or prevents localization) of a value, not respecting
+    ``settings.USE_L10N``.
+    """
+    if localization not in ('on', 'off'):
+        return value
+    localization = localization == 'on'
+    return force_unicode(formats.localize(value, localization))
+localize.is_safe = False
+
 def safe(value):
     """
     Marks the value as a string that should not be auto-escaped.
@@ -922,6 +933,7 @@ register.filter(linebreaks)
 register.filter(linebreaksbr)
 register.filter(linenumbers)
 register.filter(ljust)
+register.filter(localize)
 register.filter(lower)
 register.filter(make_list)
 register.filter(phone2numeric)
diff --git a/django/template/defaulttags.py b/django/template/defaulttags.py
index 1b07413..d0f654d 100644
--- a/django/template/defaulttags.py
+++ b/django/template/defaulttags.py
@@ -433,6 +433,17 @@ class WithNode(Node):
         context.pop()
         return output
 
+class LocalizeNode(Node):
+    def __init__(self, nodelist, localization):
+        self.nodelist = nodelist
+        self.localization = localization
+
+    def __repr__(self):
+        return "<LocalizeNode>"
+
+    def render(self, context):
+        return self.nodelist.render(context, self.localization)
+
 #@register.tag
 def autoescape(parser, token):
     """
@@ -929,6 +940,30 @@ def load(parser, token):
     return LoadNode()
 load = register.tag(load)
 
+@register.tag
+def localize(parser, token):
+    """
+    Forces or prevents localization without respect to `settings.USE_L10N`.
+    
+    Sample usage::
+    
+        {% localize off %}
+            var pi = {{ 3.1415 }};
+        {% endlocalize %}
+        
+    """
+    localization = None
+    bits = list(token.split_contents())
+    if len(bits) == 1:
+        localization = True
+    elif len(bits) > 2 or bits[1] not in ('on', 'off'):
+        raise TemplateSyntaxError("%r argument should be 'on' or 'off'" % bits[0])
+    else:
+        localization = bits[1] == 'on'
+    nodelist = parser.parse(('endlocalize',))
+    parser.delete_first_token()
+    return LocalizeNode(nodelist, localization)
+
 #@register.tag
 def now(parser, token):
     """
diff --git a/django/utils/formats.py b/django/utils/formats.py
index e64cc4e..9ace738 100644
--- a/django/utils/formats.py
+++ b/django/utils/formats.py
@@ -41,14 +41,14 @@ def get_format_modules(reverse=False):
         modules.reverse()
     return modules
 
-def get_format(format_type, lang=None):
+def get_format(format_type, lang=None, localization=None):
     """
     For a specific format type, returns the format for the current
     language (locale), defaults to the format in the settings.
     format_type is the name of the format, e.g. 'DATE_FORMAT'
     """
     format_type = smart_str(format_type)
-    if settings.USE_L10N:
+    if (localization is None and settings.USE_L10N) or localization:
         if lang is None:
             lang = get_language()
         cache_key = (format_type, lang)
@@ -65,48 +65,52 @@ def get_format(format_type, lang=None):
             _format_cache[cache_key] = None
     return getattr(settings, format_type)
 
-def date_format(value, format=None):
+def date_format(value, format=None, localization=None):
     """
     Formats a datetime.date or datetime.datetime object using a
     localizable format
     """
-    return dateformat.format(value, get_format(format or 'DATE_FORMAT'))
+    return dateformat.format(value, get_format(format or 'DATE_FORMAT', localization=localization))
 
-def time_format(value, format=None):
+def time_format(value, format=None, localization=None):
     """
     Formats a datetime.time object using a localizable format
     """
-    return dateformat.time_format(value, get_format(format or 'TIME_FORMAT'))
+    return dateformat.time_format(value, get_format(format or 'TIME_FORMAT', localization=localization))
 
-def number_format(value, decimal_pos=None):
+def number_format(value, decimal_pos=None, localization=None):
     """
     Formats a numeric value using localization settings
     """
-    if settings.USE_L10N:
+    if (localization is None and settings.USE_L10N) or localization:
         lang = get_language()
     else:
         lang = None
     return numberformat.format(
         value,
-        get_format('DECIMAL_SEPARATOR', lang),
+        get_format('DECIMAL_SEPARATOR', lang, localization),
         decimal_pos,
-        get_format('NUMBER_GROUPING', lang),
-        get_format('THOUSAND_SEPARATOR', lang),
+        get_format('NUMBER_GROUPING', lang, localization),
+        get_format('THOUSAND_SEPARATOR', lang, localization),
     )
 
-def localize(value):
+def localize(value, localization=None):
     """
     Checks if value is a localizable type (date, number...) and returns it
-    formatted as a string using current locale format
+    formatted as a string using current locale format.
+    If the value of `localization` is True or False, localization is enabled or
+    disabled without respect to `settings.USE_L10N`.
     """
+    if localization is False: # can't use truth value, None has special meaning
+        return value
     if isinstance(value, (decimal.Decimal, float, int, long)):
-        return number_format(value)
+        return number_format(value, localization=localization)
     elif isinstance(value, datetime.datetime):
-        return date_format(value, 'DATETIME_FORMAT')
+        return date_format(value, 'DATETIME_FORMAT', localization)
     elif isinstance(value, datetime.date):
-        return date_format(value)
+        return date_format(value, localization=localization)
     elif isinstance(value, datetime.time):
-        return time_format(value, 'TIME_FORMAT')
+        return time_format(value, 'TIME_FORMAT', localization)
     else:
         return value
 
diff --git a/docs/ref/templates/builtins.txt b/docs/ref/templates/builtins.txt
index 70f0ffd..9e86ee3 100644
--- a/docs/ref/templates/builtins.txt
+++ b/docs/ref/templates/builtins.txt
@@ -639,6 +639,35 @@ Load a custom template tag set.
 
 See :doc:`Custom tag and filter libraries </howto/custom-template-tags>` for more information.
 
+.. templatetag:: localize 
+
+localize
+~~~~~~~~
+
+.. versionadded:: 1.3
+
+Enables or disables localization for contained block.
+
+This tag allows a more fine grained control of localization than
+:setting:`USE_L10N`.
+
+To activate or deactivate localization for a template block, use::
+
+    {% localize on %}
+        {{ value }}
+    {% endlocalize %}
+    
+    {% localize off %}
+        {{ value }}
+    {% endlocalize %}
+
+.. note::
+
+    The value of :setting:`USE_L10N` is not respected inside of a
+    `{% localize %}` block.    
+
+See :tfilter:`localize` for the analog template filter.
+
 .. templatetag:: now
 
 now
@@ -1561,6 +1590,31 @@ For example::
 
 If ``value`` is ``Django``, the output will be ``"Django    "``.
 
+.. templatefilter:: localize
+
+localize
+~~~~~~~~
+
+.. versionadded:: 1.3
+
+Localizes (or prevents localization) of a value.
+
+**Argument:** "on" or "off"
+
+To prevent a value to be localized when :setting:`USE_L10N` is ``True``::
+
+    {{ value|localize:"off" }}
+    
+To force localization of a value::
+
+    {{ value|localize:"on" }}
+    
+or a shorthand::
+
+    {{ value|localize }}
+    
+See :ttag:`localize` for the analog template tag.
+
 .. templatefilter:: lower
 
 lower
diff --git a/tests/regressiontests/i18n/tests.py b/tests/regressiontests/i18n/tests.py
index 4aa52b6..6f8c3de 100644
--- a/tests/regressiontests/i18n/tests.py
+++ b/tests/regressiontests/i18n/tests.py
@@ -453,6 +453,33 @@ class FormattingTests(TestCase):
             settings.FORMAT_MODULE_PATH = old_format_module_path
             deactivate()
 
+    def test_localize_templatetag_and_filter(self):
+        """
+        Tests the {% localize %} templatetag
+        """
+        context = Context({'value': 3.14 })
+        template1 = Template("{% localize %}{{ value }}{% endlocalize %};{% localize on %}{{ value }}{% endlocalize %}")
+        template2 = Template("{{ value }};{% localize off %}{{ value }};{% endlocalize %}{{ value }}")
+        template3 = Template('{{ value }};{{ value|localize:"off" }}')
+        template4 = Template('{{ value }};{{ value|localize }};{{ value|localize:"on" }}')
+        output1 = '3,14;3,14'
+        output2 = '3,14;3.14;3,14'
+        output3 = '3,14;3.14'
+        output4 = '3.14;3,14;3,14'
+        old_localize = settings.USE_L10N
+        try:
+            activate('de')
+            settings.USE_L10N = False
+            self.assertEqual(template1.render(context), output1)
+            self.assertEqual(template4.render(context), output4)
+            settings.USE_L10N = True
+            self.assertEqual(template1.render(context), output1)
+            self.assertEqual(template2.render(context), output2)
+            self.assertEqual(template3.render(context), output3)
+        finally:
+            deactivate()
+            settings.USE_L10N = old_localize
+
 class MiscTests(TestCase):
 
     def test_parse_spec_http_header(self):
