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..0edcbe2 100644
--- a/django/template/__init__.py
+++ b/django/template/__init__.py
@@ -59,7 +59,7 @@ from django.utils.itercompat import is_iterable
 from django.utils.functional import curry, Promise
 from django.utils.text import smart_split, unescape_string_literal, get_text_list
 from django.utils.encoding import smart_unicode, force_unicode, smart_str
-from django.utils.translation import ugettext as _
+from django.utils.translation import ugettext as _, get_language, activate
 from django.utils.safestring import SafeData, EscapeData, mark_safe, mark_for_escaping
 from django.utils.formats import localize
 from django.utils.html import escape
@@ -819,13 +819,30 @@ class TextNode(Node):
     def render(self, context):
         return self.s
 
+def _localize_from_context(value, context):
+    """
+    Checks if context requires special localization and applies localization
+    if necessary
+    """
+    locale = context.get('_locale', None)
+    if locale is not None:
+        if not isinstance(locale, bool):
+            old_lang = get_language()
+            activate(locale)
+            value = localize(value, force=True)
+        elif locale:
+            value = localize(value, force=locale)
+    else:
+        value = localize(value)
+    return value
+
 def _render_value_in_context(value, context):
     """
     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_from_context(value, context)
     value = force_unicode(value)
     if (context.autoescape and not isinstance(value, SafeData)) or isinstance(value, EscapeData):
         return escape(value)
diff --git a/django/template/debug.py b/django/template/debug.py
index c21fb50..0ba4e02 100644
--- a/django/template/debug.py
+++ b/django/template/debug.py
@@ -1,4 +1,4 @@
-from django.template import Lexer, Parser, tag_re, NodeList, VariableNode, TemplateSyntaxError
+from django.template import Lexer, Parser, tag_re, NodeList, VariableNode, TemplateSyntaxError, _localize_from_context
 from django.utils.encoding import force_unicode
 from django.utils.html import escape
 from django.utils.safestring import SafeData, EscapeData
@@ -87,7 +87,7 @@ class DebugVariableNode(VariableNode):
     def render(self, context):
         try:
             output = self.filter_expression.resolve(context)
-            output = localize(output)
+            output = _localize_from_context(value, context)
             output = force_unicode(output)
         except TemplateSyntaxError, e:
             if not hasattr(e, 'source'):
diff --git a/django/template/defaulttags.py b/django/template/defaulttags.py
index 1b07413..c4c347a 100644
--- a/django/template/defaulttags.py
+++ b/django/template/defaulttags.py
@@ -433,6 +433,23 @@ class WithNode(Node):
         context.pop()
         return output
 
+class LocalizeNode(Node):
+    def __init__(self, nodelist, locale):
+        self.nodelist = nodelist
+        self.locale = locale
+
+    def __repr__(self):
+        return "<LocalizeNode>"
+
+    def render(self, context):
+        if isinstance(self.locale, bool):
+            context['_locale'] = self.locale
+        else:
+            context['_locale'] = self.locale.resolve(context)
+        output = self.nodelist.render(context)
+        del context['_locale']
+        return output
+
 #@register.tag
 def autoescape(parser, token):
     """
@@ -1216,3 +1233,28 @@ def do_with(parser, token):
     parser.delete_first_token()
     return WithNode(var, name, nodelist)
 do_with = register.tag('with', do_with)
+
+@register.tag
+def localize(parser, token):
+    """
+    Temporarely deactivates localization inside of this block, e.g.
+    to avoid rendering syntactically incorrect JavaScript code.
+    """
+    locale = None
+    bits = list(token.split_contents())
+    if len(bits) == 1:
+        locale = True
+    elif len(bits) > 2:
+        raise TemplateSyntaxError("%r expected argument is on/off or a single locale like de or en-us" % bits[0])
+    else:
+        if bits[1] == 'off':
+            print "off"
+            locale = False
+        elif bits[1] == 'on':
+            print "on"
+            locale = True
+        else:
+            locale = parser.compile_filter(bits[1])
+    nodelist = parser.parse(('endlocalize',))
+    parser.delete_first_token()
+    return LocalizeNode(nodelist, locale)
diff --git a/django/utils/formats.py b/django/utils/formats.py
index e64cc4e..6f8087d 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, force=False):
     """
     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 is the name of the format, e.g. 'DATE_FORMAT'.
     """
     format_type = smart_str(format_type)
-    if settings.USE_L10N:
+    if settings.USE_L10N or force:
         if lang is None:
             lang = get_language()
         cache_key = (format_type, lang)
@@ -65,48 +65,49 @@ 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, force=False):
     """
     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', force=force))
 
-def time_format(value, format=None):
+def time_format(value, format=None, force=False):
     """
     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', force=force))
 
-def number_format(value, decimal_pos=None):
+def number_format(value, decimal_pos=None, force=False):
     """
     Formats a numeric value using localization settings
     """
-    if settings.USE_L10N:
+    if settings.USE_L10N or force:
         lang = get_language()
     else:
         lang = None
     return numberformat.format(
         value,
-        get_format('DECIMAL_SEPARATOR', lang),
+        get_format('DECIMAL_SEPARATOR', lang, force=force),
         decimal_pos,
-        get_format('NUMBER_GROUPING', lang),
-        get_format('THOUSAND_SEPARATOR', lang),
+        get_format('NUMBER_GROUPING', lang, force=force),
+        get_format('THOUSAND_SEPARATOR', lang, force=force),
     )
 
-def localize(value):
+def localize(value, force=False):
     """
     Checks if value is a localizable type (date, number...) and returns it
     formatted as a string using current locale format
+    If force is True, localization is enabled without respecting settings.USE_L10N.
     """
     if isinstance(value, (decimal.Decimal, float, int, long)):
-        return number_format(value)
+        return number_format(value, force=force)
     elif isinstance(value, datetime.datetime):
-        return date_format(value, 'DATETIME_FORMAT')
+        return date_format(value, 'DATETIME_FORMAT', force=force)
     elif isinstance(value, datetime.date):
-        return date_format(value)
+        return date_format(value, force=force)
     elif isinstance(value, datetime.time):
-        return time_format(value, 'TIME_FORMAT')
+        return time_format(value, 'TIME_FORMAT', force=force)
     else:
         return value
 
diff --git a/docs/ref/templates/builtins.txt b/docs/ref/templates/builtins.txt
index 70f0ffd..b846b58 100644
--- a/docs/ref/templates/builtins.txt
+++ b/docs/ref/templates/builtins.txt
@@ -639,6 +639,39 @@ 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
+
+Adjusts localization behavior 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 %}
+
+You can use a different locale than the current one for a template block::
+
+    {% localize "de" %}
+        {{ value }}
+    {% endlocalize %}
+
+.. note::
+
+    The value of :setting:`USE_L10N` is not respected inside of a
+    `{% localize %}` block.    
+
 .. templatetag:: now
 
 now
diff --git a/tests/regressiontests/i18n/tests.py b/tests/regressiontests/i18n/tests.py
index 4aa52b6..19e4b6c 100644
--- a/tests/regressiontests/i18n/tests.py
+++ b/tests/regressiontests/i18n/tests.py
@@ -453,6 +453,34 @@ class FormattingTests(TestCase):
             settings.FORMAT_MODULE_PATH = old_format_module_path
             deactivate()
 
+    def test_localize_templatetag(self):
+        """
+        Tests the {% noloc %} templatetag
+        """
+        context = Context({'value': 3.14 })
+        template1 = Template("{{ value }};{% localize off %}{{ value }};{% endlocalize %}{{ value }}")
+        template2 = Template("{% localize %}{{ value }}{% endlocalize %};{% localize on %}{{ value }}{% endlocalize %}")
+        template3 = Template('{{ value }};{% localize "de" %}{{ value }}{% endlocalize %}')
+        output1 = '3,14;3.14;3,14'
+        output2 = '3,14;3,14'
+        output3 = '3.14;3,14'
+        old_debug = settings.TEMPLATE_DEBUG
+        old_localize = settings.USE_L10N
+        try:
+            for debug in (True, False):
+                settings.TEMPLATE_DEBUG = debug
+                settings.USE_L10N = False
+                self.assertEqual(template3.render(context), output3)
+                activate('de')
+                self.assertEqual(template2.render(context), output2)
+                settings.USE_L10N = True
+                self.assertEqual(template1.render(context), output1)
+                deactivate()
+        finally:
+            deactivate()
+            settings.TEMPLATE_DEBUG = old_debug
+            settings.USE_L10N = old_localize
+
 class MiscTests(TestCase):
 
     def test_parse_spec_http_header(self):
