diff --git a/django/template/loader_tags.py b/django/template/loader_tags.py
index b8bc741..db54c70 100644
--- a/django/template/loader_tags.py
+++ b/django/template/loader_tags.py
@@ -1,6 +1,7 @@
 from django.template import TemplateSyntaxError, TemplateDoesNotExist, Variable
 from django.template import Library, Node, TextNode
 from django.template.loader import get_template
+from django.template.defaulttags import kwarg_re
 from django.conf import settings
 from django.utils.safestring import mark_safe
 
@@ -125,10 +126,11 @@ class ExtendsNode(Node):
         return compiled_parent._render(context)
 
 class ConstantIncludeNode(Node):
-    def __init__(self, template_path):
+    def __init__(self, template_path, extra_context={}):
         try:
             t = get_template(template_path)
             self.template = t
+            self.extra_context = extra_context
         except:
             if settings.TEMPLATE_DEBUG:
                 raise
@@ -136,20 +138,31 @@ class ConstantIncludeNode(Node):
 
     def render(self, context):
         if self.template:
-            return self.template.render(context)
+            values = [(name, var.resolve(context)) for name, var
+                        in self.extra_context.iteritems()]
+            context.update(dict(values))
+            output = self.template.render(context)
+            context.pop()
+            return output
         else:
             return ''
 
 class IncludeNode(Node):
-    def __init__(self, template_name):
+    def __init__(self, template_name, extra_context={}):
         self.template_name = Variable(template_name)
+        self.extra_context = extra_context
 
     def render(self, context):
         try:
             template_name = self.template_name.resolve(context)
             t = get_template(template_name)
-            return t.render(context)
-        except TemplateSyntaxError, e:
+            values = [(name, var.resolve(context)) for name, var
+                        in self.extra_context.iteritems()]
+            context.update(dict(values))
+            output = t.render(context)
+            context.pop()
+            return output
+        except TemplateSyntaxError:
             if settings.TEMPLATE_DEBUG:
                 raise
             return ''
@@ -201,19 +214,39 @@ def do_extends(parser, token):
 
 def do_include(parser, token):
     """
-    Loads a template and renders it with the current context.
+    Loads a template and renders it with the current context. You can pass
+    additional context using keyword arguments.
 
     Example::
 
         {% include "foo/some_include" %}
+        {% include "foo/some_include" with bar="BAZZ!" %}
+
     """
     bits = token.split_contents()
-    if len(bits) != 2:
-        raise TemplateSyntaxError("%r tag takes one argument: the name of the template to be included" % bits[0])
+    if len(bits) < 2:
+        raise TemplateSyntaxError("%r tag takes at least one argument: the name of the template to be included." % bits[0])
+    namemap = {}
+    if len(bits) > 2:
+        if bits[2] == 'with':
+            for bit in bits[3:]:
+                match = kwarg_re.match(bit)
+                if not match:
+                    raise TemplateSyntaxError("Malformed arguments to %r tag." % bits[0])
+                name, value = match.groups()
+                if not name:
+                    raise TemplateSyntaxError('''"with" part of %r tag accepts only keyword arguments.''' % bits[0])
+                if name in namemap:
+                    raise TemplateSyntaxError("Tried to bind value to name %r more than once." % name)
+                namemap[name] = parser.compile_filter(value)
+            if not namemap:
+                raise TemplateSyntaxError('''"with" in %r tag needs at least one keyword argument.''' % bits[0])
+        else:
+            raise TemplateSyntaxError('''Invalid option %r for %r tag.''' % (bits[2], bits[0]))
     path = bits[1]
     if path[0] in ('"', "'") and path[-1] == path[0]:
-        return ConstantIncludeNode(path[1:-1])
-    return IncludeNode(bits[1])
+        return ConstantIncludeNode(path[1:-1], extra_context=namemap)
+    return IncludeNode(bits[1], extra_context=namemap)
 
 register.tag('block', do_block)
 register.tag('extends', do_extends)
diff --git a/docs/ref/templates/builtins.txt b/docs/ref/templates/builtins.txt
index a20ab17..6e84225 100644
--- a/docs/ref/templates/builtins.txt
+++ b/docs/ref/templates/builtins.txt
@@ -623,6 +623,15 @@ including it. This example produces the output ``"Hello, John"``:
 
 See also: ``{% ssi %}``.
 
+.. versionadded:: 1.3
+
+You can pass additional context to the template using keyword arguments::
+
+    {% include "name_snippet.html" person="Jane" %}
+
+This is pretty much syntactic sugar for wrapping :ttag:`include`
+with a :ttag:`with` tag.
+
 .. note::
     The :ttag:`include` tag should be considered as an implementation of
     "render this subtemplate and include the HTML", not as "parse this
diff --git a/tests/regressiontests/templates/tests.py b/tests/regressiontests/templates/tests.py
index 9e2d175..902f5f0 100644
--- a/tests/regressiontests/templates/tests.py
+++ b/tests/regressiontests/templates/tests.py
@@ -923,6 +923,17 @@ class Templates(unittest.TestCase):
             'include 05': ('template with a space', {}, 'template with a space'),
             'include06': ('{% include "include 05"%}', {}, 'template with a space'),
 
+            # extra inline context
+            'include07': ('{% include "basic-syntax02" with headline="Inline" %}', {'headline': 'Included'}, 'Inline'),
+            'include08': ('{% include headline with headline="Dynamic" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
+            'include09': ('{{ first }}--{% include "basic-syntax03" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),
+
+            'include-error01': ('{% include "basic-syntax01" with %}', {}, template.TemplateSyntaxError),
+            'include-error02': ('{% include "basic-syntax01" with "no key" %}', {}, template.TemplateSyntaxError),
+            'include-error03': ('{% include "basic-syntax01" with dotted.arg="error" %}', {}, template.TemplateSyntaxError),
+            'include-error04': ('{% include "basic-syntax01" something_random %}', {}, template.TemplateSyntaxError),
+            'include-error05': ('{% include "basic-syntax01" foo="duplicate" foo="key" %}', {}, template.TemplateSyntaxError),
+
             ### NAMED ENDBLOCKS #######################################################
 
             # Basic test
