diff --git a/django/contrib/humanize/templatetags/humanize.py b/django/contrib/humanize/templatetags/humanize.py
index 05d3223..5baf003 100644
--- a/django/contrib/humanize/templatetags/humanize.py
+++ b/django/contrib/humanize/templatetags/humanize.py
@@ -1,9 +1,11 @@
+import re
+from datetime import date
 from django.utils.translation import ungettext, ugettext as _
 from django.utils.encoding import force_unicode
+from django.utils.formats import number_format
 from django import template
 from django.template import defaultfilters
-from datetime import date
-import re
+from django.conf import settings
 
 register = template.Library()
 
@@ -28,6 +30,8 @@ def intcomma(value):
     Converts an integer to a string containing commas every three digits.
     For example, 3000 becomes '3,000' and 45000 becomes '45,000'.
     """
+    if settings.USE_L10N:
+        return number_format(value)
     orig = force_unicode(value)
     new = re.sub("^(-?\d+)(\d{3})", '\g<1>,\g<2>', orig)
     if orig == new:
@@ -46,15 +50,33 @@ def intword(value):
     value = int(value)
     if value < 1000000:
         return value
+
+    def _check_for_i18n(value, float_formatted, string_formatted):
+        """
+        Use the i18n enabled defaultfilters.floatformat if possible
+        """
+        if settings.USE_L10N:
+            return defaultfilters.floatformat(value, 1), string_formatted
+        return value, float_formatted
+
     if value < 1000000000:
         new_value = value / 1000000.0
-        return ungettext('%(value).1f million', '%(value).1f million', new_value) % {'value': new_value}
+        new_value, value_string = _check_for_i18n(new_value,
+            ungettext('%(value).1f million', '%(value).1f million', new_value),
+            ungettext('%(value)s million', '%(value)s million', new_value))
+        return value_string % {'value': new_value}
     if value < 1000000000000:
         new_value = value / 1000000000.0
-        return ungettext('%(value).1f billion', '%(value).1f billion', new_value) % {'value': new_value}
+        new_value, value_string = _check_for_i18n(new_value,
+            ungettext('%(value).1f billion', '%(value).1f billion', new_value),
+            ungettext('%(value)s billion', '%(value)s billion', new_value))
+        return value_string % {'value': new_value}
     if value < 1000000000000000:
         new_value = value / 1000000000000.0
-        return ungettext('%(value).1f trillion', '%(value).1f trillion', new_value) % {'value': new_value}
+        new_value, value_string = _check_for_i18n(new_value,
+            ungettext('%(value).1f trillion', '%(value).1f trillion', new_value),
+            ungettext('%(value)s trillion', '%(value)s trillion', new_value))
+        return value_string % {'value': new_value}
     return value
 intword.is_safe = False
 register.filter(intword)
diff --git a/docs/ref/contrib/humanize.txt b/docs/ref/contrib/humanize.txt
index 07a62a7..fe90150 100644
--- a/docs/ref/contrib/humanize.txt
+++ b/docs/ref/contrib/humanize.txt
@@ -40,6 +40,12 @@ Examples:
     * ``450000`` becomes ``'450,000'``.
     * ``4500000`` becomes ``'4,500,000'``.
 
+:ref:`Format localization <format-localization>` will be respected if enabled,
+e.g. with the ``'de'`` language:
+
+    * ``45000`` becomes ``'45.000'``.
+    * ``450000`` becomes ``'450.000'``.
+
 You can pass in either an integer or a string representation of an integer.
 
 intword
@@ -56,6 +62,13 @@ Examples:
 
 Values up to 1000000000000000 (one quadrillion) are supported.
 
+:ref:`Format localization <format-localization>` will be respected if enabled,
+e.g. with the ``'de'`` language:
+
+    * ``1000000`` becomes ``'1,0 Million'``.
+    * ``1200000`` becomes ``'1,2 Million'``.
+    * ``1200000000`` becomes ``'1,2 Milliarde'``.
+
 You can pass in either an integer or a string representation of an integer.
 
 ordinal
diff --git a/tests/regressiontests/humanize/tests.py b/tests/regressiontests/humanize/tests.py
index 6f60c6d..097bcb7 100644
--- a/tests/regressiontests/humanize/tests.py
+++ b/tests/regressiontests/humanize/tests.py
@@ -2,8 +2,9 @@ import unittest
 from datetime import timedelta, date
 from django.template import Template, Context, add_to_builtins
 from django.utils.dateformat import DateFormat
-from django.utils.translation import ugettext as _
+from django.utils.translation import ugettext as _, activate, deactivate
 from django.utils.html import escape
+from django.conf import settings
 
 add_to_builtins('django.contrib.humanize.templatetags.humanize')
 
@@ -37,6 +38,22 @@ class HumanizeTests(unittest.TestCase):
 
         self.humanize_tester(test_list, result_list, 'intcomma')
 
+    def test_i18n_intcomma(self):
+        test_list = (100, 1000, 10123, 10311, 1000000, 1234567.25,
+                     '100', '1000', '10123', '10311', '1000000', '1234567.1234567')
+        result_list = ('100', '1.000', '10.123', '10.311', '1.000.000', '1.234.567,25',
+                       '100', '1.000', '10.123', '10.311', '1.000.000', '1.234.567,1234567')
+        _use_l10n = settings.USE_L10N
+        _use_thousand_separator = settings.USE_THOUSAND_SEPARATOR
+        settings.USE_L10N = True
+        settings.USE_THOUSAND_SEPARATOR = True
+        try:
+            activate('de')
+            self.humanize_tester(test_list, result_list, 'intcomma')
+        finally:
+            settings.USE_L10N = _use_l10n
+            deactivate()
+
     def test_intword(self):
         test_list = ('100', '1000000', '1200000', '1290000',
                      '1000000000','2000000000','6000000000000')
@@ -45,6 +62,23 @@ class HumanizeTests(unittest.TestCase):
 
         self.humanize_tester(test_list, result_list, 'intword')
 
+    def test_i18n_intword(self):
+        test_list = ('100', '1000000', '1200000', '1290000',
+                     '1000000000','2000000000','6000000000000')
+        result_list = ('100', '1,0 million', '1,2 million', '1,3 million',
+                       '1,0 billion', '2,0 billion', '6,0 trillion')
+        _use_l10n = settings.USE_L10N
+        _use_thousand_separator = settings.USE_THOUSAND_SEPARATOR
+        settings.USE_L10N = True
+        settings.USE_THOUSAND_SEPARATOR = True
+        try:
+            activate('de')
+            self.humanize_tester(test_list, result_list, 'intword')
+        finally:
+            settings.USE_L10N = _use_l10n
+            settings.USE_THOUSAND_SEPARATOR = _use_thousand_separator
+            deactivate()
+
     def test_apnumber(self):
         test_list = [str(x) for x in range(1, 11)]
         result_list = (u'one', u'two', u'three', u'four', u'five', u'six',
