diff --git a/CHANGELOG.md b/CHANGELOG.md
index b2202fab..ec61a46a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,12 @@ All notable changes to MiniJinja are documented here.
 - Improve error reporting for failures in blocks and trying to
   `super()` when there is no parent block.
 - Performance improvements.
+- Added support for `{% import %}` / `{% from .. import .. %}`
+  and `{% macro %}`.  (#123)
+- Added `Value::is_kwargs` which disambiugates if an object passed
+  to a function or filter is a normal object or if it represents
+  keyword arguments.
+- Added the ability to call functions stored on objects.
 
 # 0.22.1
 
diff --git a/COMPATIBILITY.md b/COMPATIBILITY.md
index d6ec57f4..7f1e05b5 100644
--- a/COMPATIBILITY.md
+++ b/COMPATIBILITY.md
@@ -38,6 +38,10 @@ mapping them to filter functions is tricky.  This also means that some filters i
 MiniJinja do not accept the parameters with keyword arguments whereas in Jinja2
 they do.
 
+### Variadic Calls
+
+MiniJinja does not support the `*args` and `**kwargs` syntax for calls.
+
 ### Undefined
 
 The Jinja2 undefined type tracks the origin of creation, in MiniJinja the undefined
@@ -87,14 +91,19 @@ MiniJinja is different as mentioned above.
 
 ### `{% import %}`
 
-This tag is currently not supported.  If support for macros is added
-this would make sense to add.
+This tag is supported but the returned item is a map of the exported local
+variables.  This means that the rendered content of the template is lost.
 
 ### `{% macro %}`
 
-This tag is currently not supported.
+The macro tag works very similar to Jinja2 but with some differences.  Most
+importantly the special `caller`, `varargs` and `kwargs` arguments are not
+supported.  The external introspectable attributes `catch_kwargs`, `catch_varargs`
+and `caller` are not supported.
+
+### `{% call %}`
 
-**Tracking issue:** [#44](https://github.com/mitsuhiko/minijinja/issues/44)
+This tag is not supported.
 
 ### `{% with %}`
 
diff --git a/Makefile b/Makefile
index dc2b6f75..0ef6fcdc 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ build:
 	@cargo build --all
 
 doc:
-	@cd minijinja; RUSTC_BOOTSTRAP=1 RUSTDOCFLAGS="--cfg=docsrs --html-in-header doc-header.html" cargo doc --all --no-deps --features=$(DOC_FEATURES)
+	@cd minijinja; RUSTC_BOOTSTRAP=1 RUSTDOCFLAGS="--cfg=docsrs --html-in-header doc-header.html" cargo doc -p minijinja -p minijinja-autoreload --no-deps --features=$(DOC_FEATURES)
 
 test:
 	@$(MAKE) run-tests FEATURES=$(TEST_FEATURES)
diff --git a/doc-header.html b/doc-header.html
index aaa01395..49c60eb8 100644
--- a/doc-header.html
+++ b/doc-header.html
@@ -4,7 +4,7 @@
 <script>
   document.addEventListener("DOMContentLoaded", function() {
     document.querySelectorAll("pre code").forEach(function(node) {
-      if (node.parentNode.className.match(/jinja/)) {
+      if (node.parentNode.className.match(/jinja|json/)) {
         hljs.highlightElement(node.parentNode);
       }
     });
diff --git a/examples/README.md b/examples/README.md
index 46462907..db3e14d8 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -16,6 +16,7 @@ the `cargo run` command.  Alternatively you can do `cargo run -p example-name`.
 * [hello](hello): minimal Hello World example.
 * [inheritance](inheritance): demonstrates how to use template inheritance.
 * [loader](loader): shows how to load templates dynamically at runtime.
+* [macros](macros): Demonstrates how to use macros and imports.
 * [minimal](minimal): a Hello World example without default features.
 * [recursive-for](recursive-for): demonstrates the recursive for loop.
 * [render-macro](render-macro): minimal Hello World example using the `render!` macro.
diff --git a/examples/macros/Cargo.toml b/examples/macros/Cargo.toml
new file mode 100644
index 00000000..12a346b6
--- /dev/null
+++ b/examples/macros/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "macros"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+minijinja = { path = "../../minijinja" }
diff --git a/examples/macros/README.md b/examples/macros/README.md
new file mode 100644
index 00000000..8be5715f
--- /dev/null
+++ b/examples/macros/README.md
@@ -0,0 +1,7 @@
+# macros
+
+This example demonstrates how to use macros and imports.
+
+```console
+$ cargo run
+```
diff --git a/examples/macros/src/macros.html b/examples/macros/src/macros.html
new file mode 100644
index 00000000..f83d2680
--- /dev/null
+++ b/examples/macros/src/macros.html
@@ -0,0 +1,4 @@
+{% macro render_input(name, value, type="text") -%}
+  <input name="{{ name }}" value="{{ value }}" type="{{ type }}">
+{%- endmacro %}
+{% set alias = render_input %}
\ No newline at end of file
diff --git a/examples/macros/src/main.rs b/examples/macros/src/main.rs
new file mode 100644
index 00000000..4d765e45
--- /dev/null
+++ b/examples/macros/src/main.rs
@@ -0,0 +1,16 @@
+use minijinja::{context, Environment};
+
+fn main() {
+    let mut env = Environment::new();
+    env.add_template("macros.html", include_str!("macros.html"))
+        .unwrap();
+    env.add_template("template.html", include_str!("template.html"))
+        .unwrap();
+
+    let template = env.get_template("template.html").unwrap();
+    let context = context! {
+        username => "John Doe"
+    };
+
+    println!("{}", template.render(&context).unwrap());
+}
diff --git a/examples/macros/src/template.html b/examples/macros/src/template.html
new file mode 100644
index 00000000..71313b3b
--- /dev/null
+++ b/examples/macros/src/template.html
@@ -0,0 +1,15 @@
+<!doctype html>
+<title>Demo</title>
+{%- import "macros.html" as all_macros %}
+{%- from "macros.html" import render_input %}
+<form action="" method="post">
+  <dl>
+    <dt>Username</dt>
+    <dd>{{ render_input("username", username) }}</dd>
+    <dt>Password</dt>
+    <dd>{{ render_input("password", type="password") }}</dd>
+  </dl>
+</form>
+<!--
+  Declared macros: {{ all_macros|safe }}
+-->
\ No newline at end of file
diff --git a/minijinja/src/compiler/ast.rs b/minijinja/src/compiler/ast.rs
index 8f6aaea7..982cde53 100644
--- a/minijinja/src/compiler/ast.rs
+++ b/minijinja/src/compiler/ast.rs
@@ -4,7 +4,8 @@ use std::ops::Deref;
 use std::fmt;
 
 use crate::compiler::tokens::Span;
-use crate::value::{Value, ValueMap, ValueRepr};
+use crate::key::Key;
+use crate::value::{MapType, Value, ValueMap, ValueRepr};
 
 /// Container for nodes with location info.
 ///
@@ -63,6 +64,9 @@ pub enum Stmt<'a> {
     Include(Spanned<Include<'a>>),
     AutoEscape(Spanned<AutoEscape<'a>>),
     FilterBlock(Spanned<FilterBlock<'a>>),
+    Macro(Spanned<Macro<'a>>),
+    Import(Spanned<Import<'a>>),
+    FromImport(Spanned<FromImport<'a>>),
 }
 
 #[cfg(feature = "internal_debug")]
@@ -82,6 +86,9 @@ impl<'a> fmt::Debug for Stmt<'a> {
             Stmt::Include(s) => fmt::Debug::fmt(s, f),
             Stmt::AutoEscape(s) => fmt::Debug::fmt(s, f),
             Stmt::FilterBlock(s) => fmt::Debug::fmt(s, f),
+            Stmt::Macro(s) => fmt::Debug::fmt(s, f),
+            Stmt::Import(s) => fmt::Debug::fmt(s, f),
+            Stmt::FromImport(s) => fmt::Debug::fmt(s, f),
         }
     }
 }
@@ -102,6 +109,7 @@ pub enum Expr<'a> {
     Call(Spanned<Call<'a>>),
     List(Spanned<List<'a>>),
     Map(Spanned<Map<'a>>),
+    Kwargs(Spanned<Kwargs<'a>>),
 }
 
 #[cfg(feature = "internal_debug")]
@@ -121,6 +129,7 @@ impl<'a> fmt::Debug for Expr<'a> {
             Expr::Call(s) => fmt::Debug::fmt(s, f),
             Expr::List(s) => fmt::Debug::fmt(s, f),
             Expr::Map(s) => fmt::Debug::fmt(s, f),
+            Expr::Kwargs(s) => fmt::Debug::fmt(s, f),
         }
     }
 }
@@ -206,6 +215,29 @@ pub struct FilterBlock<'a> {
     pub body: Vec<Stmt<'a>>,
 }
 
+/// Declares a macro.
+#[cfg_attr(feature = "internal_debug", derive(Debug))]
+pub struct Macro<'a> {
+    pub name: &'a str,
+    pub args: Vec<Expr<'a>>,
+    pub defaults: Vec<Expr<'a>>,
+    pub body: Vec<Stmt<'a>>,
+}
+
+/// A "from" import
+#[cfg_attr(feature = "internal_debug", derive(Debug))]
+pub struct FromImport<'a> {
+    pub expr: Expr<'a>,
+    pub names: Vec<(Expr<'a>, Option<Expr<'a>>)>,
+}
+
+/// A full module import
+#[cfg_attr(feature = "internal_debug", derive(Debug))]
+pub struct Import<'a> {
+    pub expr: Expr<'a>,
+    pub name: Expr<'a>,
+}
+
 /// Outputs the expression.
 #[cfg_attr(feature = "internal_debug", derive(Debug))]
 pub struct EmitExpr<'a> {
@@ -351,6 +383,29 @@ impl<'a> List<'a> {
     }
 }
 
+/// Creates a map of kwargs
+#[cfg_attr(feature = "internal_debug", derive(Debug))]
+pub struct Kwargs<'a> {
+    pub pairs: Vec<(&'a str, Expr<'a>)>,
+}
+
+impl<'a> Kwargs<'a> {
+    pub fn as_const(&self) -> Option<Value> {
+        if !self.pairs.iter().all(|x| matches!(x.1, Expr::Const(_))) {
+            return None;
+        }
+
+        let mut rv = ValueMap::new();
+        for (key, value) in &self.pairs {
+            if let Expr::Const(value) = value {
+                rv.insert(Key::make_string_key(key), value.value.clone());
+            }
+        }
+
+        Some(Value(ValueRepr::Map(rv.into(), MapType::Kwargs)))
+    }
+}
+
 /// Creates a map of values.
 #[cfg_attr(feature = "internal_debug", derive(Debug))]
 pub struct Map<'a> {
@@ -376,7 +431,7 @@ impl<'a> Map<'a> {
             }
         }
 
-        Some(Value(ValueRepr::Map(rv.into())))
+        Some(Value(ValueRepr::Map(rv.into(), MapType::Normal)))
     }
 }
 
diff --git a/minijinja/src/compiler/codegen.rs b/minijinja/src/compiler/codegen.rs
index 011cca77..4be2440f 100644
--- a/minijinja/src/compiler/codegen.rs
+++ b/minijinja/src/compiler/codegen.rs
@@ -4,9 +4,10 @@ use crate::compiler::ast;
 use crate::compiler::instructions::{
     Instruction, Instructions, LocalId, LOOP_FLAG_RECURSIVE, LOOP_FLAG_WITH_LOOP_VAR, MAX_LOCALS,
 };
+use crate::compiler::meta::find_macro_closure;
 use crate::compiler::tokens::Span;
 use crate::error::Error;
-use crate::value::Value;
+use crate::value::{Value, ValueRepr};
 
 #[cfg(test)]
 use similar_asserts::assert_eq;
@@ -148,10 +149,10 @@ impl<'source> CodeGenerator<'source> {
                 {
                     *jump_target = loop_end;
                 } else {
-                    panic!("did not find iteration instruction");
+                    unreachable!();
                 }
             }
-            _ => panic!("not inside a loop"),
+            _ => unreachable!(),
         }
     }
 
@@ -187,7 +188,7 @@ impl<'source> CodeGenerator<'source> {
                 Instruction::JumpIfTrueOrPop(!0)
             }));
         } else {
-            panic!("tried to emit sc_bool from outside of sc_bool block");
+            unreachable!();
         }
     }
 
@@ -201,7 +202,7 @@ impl<'source> CodeGenerator<'source> {
                     | Some(Instruction::JumpIfTrueOrPop(ref mut target)) => {
                         *target = end;
                     }
-                    _ => panic!("tried to patch invalid instruction"),
+                    _ => unreachable!(),
                 }
             }
         }
@@ -216,7 +217,7 @@ impl<'source> CodeGenerator<'source> {
                 }
                 _ => {}
             },
-            _ => panic!("not inside a branch"),
+            _ => unreachable!(),
         }
     }
 
@@ -303,6 +304,33 @@ impl<'source> CodeGenerator<'source> {
                 self.compile_expr(&filter_block.filter)?;
                 self.add(Instruction::Emit);
             }
+            ast::Stmt::Macro(macro_decl) => {
+                self.compile_macro(macro_decl)?;
+            }
+            ast::Stmt::Import(import) => {
+                self.add(Instruction::BeginCapture);
+                self.add(Instruction::PushWith);
+                self.compile_expr(&import.expr)?;
+                self.add_with_span(Instruction::Include(false), import.span());
+                self.add(Instruction::ExportLocals);
+                self.add(Instruction::PopFrame);
+                self.compile_assignment(&import.name)?;
+                self.add(Instruction::EndCapture);
+            }
+            ast::Stmt::FromImport(from_import) => {
+                self.add(Instruction::BeginCapture);
+                self.add(Instruction::PushWith);
+                self.compile_expr(&from_import.expr)?;
+                self.add_with_span(Instruction::Include(false), from_import.span());
+                for (name, _) in &from_import.names {
+                    self.compile_expr(name)?;
+                }
+                self.add(Instruction::PopFrame);
+                for (name, alias) in from_import.names.iter().rev() {
+                    self.compile_assignment(alias.as_ref().unwrap_or(name))?;
+                }
+                self.add(Instruction::EndCapture);
+            }
         }
         Ok(())
     }
@@ -319,6 +347,62 @@ impl<'source> CodeGenerator<'source> {
         Ok(())
     }
 
+    fn compile_macro(
+        &mut self,
+        macro_decl: &ast::Spanned<ast::Macro<'source>>,
+    ) -> Result<(), Error> {
+        self.set_line_from_span(macro_decl.span());
+        let instr = self.add(Instruction::Jump(!0));
+
+        let mut defaults_iter = macro_decl.defaults.iter().rev();
+        for arg in macro_decl.args.iter().rev() {
+            if let Some(default) = defaults_iter.next() {
+                self.add(Instruction::DupTop);
+                self.add(Instruction::IsUndefined);
+                self.start_if();
+                self.add(Instruction::DiscardTop);
+                self.compile_expr(default)?;
+                self.end_if();
+            }
+            self.compile_assignment(arg)?;
+        }
+
+        for node in &macro_decl.body {
+            self.compile_stmt(node)?;
+        }
+        self.add(Instruction::Return);
+
+        let undeclared = find_macro_closure(macro_decl);
+        let macro_instr = self.next_instruction();
+        for name in &undeclared {
+            self.add(Instruction::LoadConst(Value::from(*name)));
+            self.add(Instruction::Lookup(name));
+        }
+        self.add(Instruction::BuildMap(undeclared.len()));
+
+        self.add(Instruction::LoadConst(Value::from(ValueRepr::Seq(
+            macro_decl
+                .args
+                .iter()
+                .map(|x| match x {
+                    ast::Expr::Var(var) => Value::from(var.id),
+                    _ => unreachable!(),
+                })
+                .collect::<Vec<_>>()
+                .into(),
+        ))));
+
+        self.add(Instruction::BuildMacro(macro_decl.name, instr + 1));
+        self.add(Instruction::StoreLocal(macro_decl.name));
+
+        if let Some(Instruction::Jump(ref mut target)) = self.instructions.get_mut(instr) {
+            *target = macro_instr;
+        } else {
+            unreachable!();
+        }
+        Ok(())
+    }
+
     fn compile_if_stmt(
         &mut self,
         if_cond: &ast::Spanned<ast::IfCond<'source>>,
@@ -422,7 +506,7 @@ impl<'source> CodeGenerator<'source> {
                 }
                 self.pop_span();
             }
-            _ => panic!("bad assignment target"),
+            _ => unreachable!(),
         }
         Ok(())
     }
@@ -545,6 +629,18 @@ impl<'source> CodeGenerator<'source> {
                     self.add(Instruction::BuildMap(m.keys.len()));
                 }
             }
+            ast::Expr::Kwargs(m) => {
+                if let Some(val) = m.as_const() {
+                    self.add(Instruction::LoadConst(val));
+                } else {
+                    self.set_line_from_span(m.span());
+                    for (key, value) in &m.pairs {
+                        self.add(Instruction::LoadConst(Value::from(*key)));
+                        self.compile_expr(value)?;
+                    }
+                    self.add(Instruction::BuildKwargs(m.pairs.len()));
+                }
+            }
         }
         Ok(())
     }
diff --git a/minijinja/src/compiler/instructions.rs b/minijinja/src/compiler/instructions.rs
index 245e5a34..eb38e992 100644
--- a/minijinja/src/compiler/instructions.rs
+++ b/minijinja/src/compiler/instructions.rs
@@ -21,6 +21,7 @@ pub const MAX_LOCALS: usize = 50;
 
 /// Represents an instruction for the VM.
 #[cfg_attr(feature = "internal_debug", derive(Debug))]
+#[derive(Clone)]
 pub enum Instruction<'source> {
     /// Emits raw source
     EmitRaw(&'source str),
@@ -46,6 +47,9 @@ pub enum Instruction<'source> {
     /// Builds a map of the last n pairs on the stack.
     BuildMap(usize),
 
+    /// Builds a kwargs map of the last n pairs on the stack.
+    BuildKwargs(usize),
+
     /// Builds a list of the last n pairs on the stack.
     BuildList(usize),
 
@@ -136,6 +140,9 @@ pub enum Instruction<'source> {
     /// Pops the topmost frame
     PopFrame,
 
+    /// True if the value is undefined
+    IsUndefined,
+
     /// Jump to a specific instruction
     Jump(usize),
 
@@ -189,6 +196,15 @@ pub enum Instruction<'source> {
 
     /// A fast loop recurse instruction without intermediate capturing.
     FastRecurse,
+
+    /// Builds a macro on the stack.
+    BuildMacro(&'source str, usize),
+
+    /// Builds a module
+    ExportLocals,
+
+    /// Breaks from the interpreter loop (exists a function)
+    Return,
 }
 
 #[derive(Copy, Clone)]
diff --git a/minijinja/src/compiler/meta.rs b/minijinja/src/compiler/meta.rs
new file mode 100644
index 00000000..5d9109a1
--- /dev/null
+++ b/minijinja/src/compiler/meta.rs
@@ -0,0 +1,216 @@
+use std::collections::HashSet;
+
+use crate::compiler::ast;
+
+struct AssignmentTracker<'a> {
+    out: HashSet<&'a str>,
+    assigned: Vec<HashSet<&'a str>>,
+}
+
+impl<'a> AssignmentTracker<'a> {
+    fn is_assigned(&self, name: &str) -> bool {
+        self.assigned.iter().any(|x| x.contains(name))
+    }
+
+    fn assign(&mut self, name: &'a str) {
+        self.assigned.last_mut().unwrap().insert(name);
+    }
+
+    fn push(&mut self) {
+        self.assigned.push(Default::default());
+    }
+
+    fn pop(&mut self) {
+        self.assigned.pop();
+    }
+}
+
+/// Finds all variables that need to be captured as closure for a macro.
+pub fn find_macro_closure<'a>(m: &ast::Macro<'a>) -> HashSet<&'a str> {
+    fn visit_expr<'a>(expr: &ast::Expr<'a>, state: &mut AssignmentTracker<'a>) {
+        match expr {
+            ast::Expr::Var(var) => {
+                if !state.is_assigned(var.id) {
+                    state.out.insert(var.id);
+                    state.assign(var.id);
+                }
+            }
+            ast::Expr::Const(_) => {}
+            ast::Expr::UnaryOp(expr) => visit_expr(&expr.expr, state),
+            ast::Expr::BinOp(expr) => {
+                visit_expr(&expr.left, state);
+                visit_expr(&expr.right, state);
+            }
+            ast::Expr::IfExpr(expr) => {
+                visit_expr(&expr.test_expr, state);
+                visit_expr(&expr.true_expr, state);
+                if let Some(ref false_expr) = expr.false_expr {
+                    visit_expr(false_expr, state);
+                }
+            }
+            ast::Expr::Filter(expr) => {
+                if let Some(ref expr) = expr.expr {
+                    visit_expr(expr, state);
+                }
+                for arg in &expr.args {
+                    visit_expr(arg, state);
+                }
+            }
+            ast::Expr::Test(expr) => {
+                visit_expr(&expr.expr, state);
+                for arg in &expr.args {
+                    visit_expr(arg, state);
+                }
+            }
+            ast::Expr::GetAttr(expr) => {
+                visit_expr(&expr.expr, state);
+            }
+            ast::Expr::GetItem(expr) => {
+                visit_expr(&expr.expr, state);
+                visit_expr(&expr.subscript_expr, state);
+            }
+            ast::Expr::Slice(slice) => {
+                if let Some(ref start) = slice.start {
+                    visit_expr(start, state);
+                }
+                if let Some(ref stop) = slice.stop {
+                    visit_expr(stop, state);
+                }
+                if let Some(ref step) = slice.step {
+                    visit_expr(step, state);
+                }
+            }
+            ast::Expr::Call(expr) => {
+                visit_expr(&expr.expr, state);
+                for arg in &expr.args {
+                    visit_expr(arg, state);
+                }
+            }
+            ast::Expr::List(expr) => {
+                for value in &expr.items {
+                    visit_expr(value, state);
+                }
+            }
+            ast::Expr::Map(expr) => {
+                for (key, value) in expr.keys.iter().zip(expr.values.iter()) {
+                    visit_expr(key, state);
+                    visit_expr(value, state);
+                }
+            }
+            ast::Expr::Kwargs(expr) => {
+                for (_, value) in &expr.pairs {
+                    visit_expr(value, state);
+                }
+            }
+        }
+    }
+
+    fn assign_nested<'a>(expr: &ast::Expr<'a>, state: &mut AssignmentTracker<'a>) {
+        match expr {
+            ast::Expr::Var(var) => {
+                state.assign(var.id);
+            }
+            ast::Expr::List(list) => {
+                for expr in &list.items {
+                    assign_nested(expr, state);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn walk<'a>(node: &ast::Stmt<'a>, state: &mut AssignmentTracker<'a>) {
+        match node {
+            ast::Stmt::Template(stmt) => {
+                state.assign("self");
+                stmt.children.iter().for_each(|x| walk(x, state));
+            }
+            ast::Stmt::EmitExpr(expr) => visit_expr(&expr.expr, state),
+            ast::Stmt::EmitRaw(_) | ast::Stmt::Extends(_) | ast::Stmt::Include(_) => {}
+            ast::Stmt::ForLoop(stmt) => {
+                state.push();
+                state.assign("loop");
+                visit_expr(&stmt.iter, state);
+                assign_nested(&stmt.target, state);
+                if let Some(ref filter_expr) = stmt.filter_expr {
+                    visit_expr(filter_expr, state);
+                }
+                stmt.body.iter().for_each(|x| walk(x, state));
+                state.pop();
+                state.push();
+                stmt.else_body.iter().for_each(|x| walk(x, state));
+                state.pop();
+            }
+            ast::Stmt::IfCond(stmt) => {
+                visit_expr(&stmt.expr, state);
+                state.push();
+                stmt.true_body.iter().for_each(|x| walk(x, state));
+                state.pop();
+                state.push();
+                stmt.false_body.iter().for_each(|x| walk(x, state));
+                state.pop();
+            }
+            ast::Stmt::WithBlock(stmt) => {
+                state.push();
+                for (target, expr) in &stmt.assignments {
+                    assign_nested(target, state);
+                    visit_expr(expr, state);
+                }
+                stmt.body.iter().for_each(|x| walk(x, state));
+                state.pop();
+            }
+            ast::Stmt::Set(stmt) => {
+                assign_nested(&stmt.target, state);
+                visit_expr(&stmt.expr, state);
+            }
+            ast::Stmt::Block(stmt) => {
+                state.push();
+                state.assign("super");
+                stmt.body.iter().for_each(|x| walk(x, state));
+                state.pop();
+            }
+            ast::Stmt::AutoEscape(stmt) => {
+                state.push();
+                stmt.body.iter().for_each(|x| walk(x, state));
+                state.pop();
+            }
+            ast::Stmt::FilterBlock(stmt) => {
+                state.push();
+                stmt.body.iter().for_each(|x| walk(x, state));
+                state.pop();
+            }
+            ast::Stmt::SetBlock(stmt) => {
+                assign_nested(&stmt.target, state);
+                state.push();
+                stmt.body.iter().for_each(|x| walk(x, state));
+                state.pop();
+            }
+            ast::Stmt::Macro(stmt) => {
+                state.assign(stmt.name);
+            }
+            ast::Stmt::Import(stmt) => {
+                assign_nested(&stmt.name, state);
+            }
+            ast::Stmt::FromImport(stmt) => {
+                for (arg, alias) in &stmt.names {
+                    assign_nested(alias.as_ref().unwrap_or(arg), state);
+                }
+            }
+        }
+    }
+
+    let mut state = AssignmentTracker {
+        out: HashSet::new(),
+        assigned: vec![Default::default()],
+    };
+
+    for arg in &m.args {
+        assign_nested(arg, &mut state);
+    }
+
+    for node in &m.body {
+        walk(node, &mut state);
+    }
+
+    state.out
+}
diff --git a/minijinja/src/compiler/mod.rs b/minijinja/src/compiler/mod.rs
index 97644ffa..33ca1155 100644
--- a/minijinja/src/compiler/mod.rs
+++ b/minijinja/src/compiler/mod.rs
@@ -4,5 +4,6 @@ pub mod ast;
 pub mod codegen;
 pub mod instructions;
 pub mod lexer;
+pub mod meta;
 pub mod parser;
 pub mod tokens;
diff --git a/minijinja/src/compiler/parser.rs b/minijinja/src/compiler/parser.rs
index bb634ed6..8a738b06 100644
--- a/minijinja/src/compiler/parser.rs
+++ b/minijinja/src/compiler/parser.rs
@@ -1,4 +1,4 @@
-use std::fmt;
+use std::{fmt, mem};
 
 use crate::compiler::ast::{self, Spanned};
 use crate::compiler::lexer::tokenize;
@@ -129,6 +129,7 @@ impl<'a> TokenStream<'a> {
 
 struct Parser<'a> {
     stream: TokenStream<'a>,
+    in_macro: bool,
 }
 
 macro_rules! binop {
@@ -144,11 +145,7 @@ macro_rules! binop {
                 self.stream.next()?;
                 let right = self.$next()?;
                 left = ast::Expr::BinOp(Spanned::new(
-                    ast::BinOp {
-                        op,
-                        left,
-                        right,
-                    },
+                    ast::BinOp { op, left, right, },
                     self.stream.expand_span(span),
                 ));
             }
@@ -181,6 +178,7 @@ impl<'a> Parser<'a> {
     pub fn new(source: &'a str, in_expr: bool) -> Parser<'a> {
         Parser {
             stream: TokenStream::new(source, in_expr),
+            in_macro: false,
         }
     }
 
@@ -439,15 +437,14 @@ impl<'a> Parser<'a> {
     fn parse_args(&mut self) -> Result<Vec<ast::Expr<'a>>, Error> {
         let mut args = Vec::new();
         let mut first_span = None;
-        let mut kwargs_keys = Vec::new();
-        let mut kwargs_values = Vec::new();
+        let mut kwargs = Vec::new();
 
         expect_token!(self, Token::ParenOpen, "`(`")?;
         loop {
             if matches!(self.stream.current()?, Some((Token::ParenClose, _))) {
                 break;
             }
-            if !args.is_empty() || !kwargs_keys.is_empty() {
+            if !args.is_empty() || !kwargs.is_empty() {
                 expect_token!(self, Token::Comma, "`,`")?;
             }
             if matches!(self.stream.current()?, Some((Token::ParenClose, _))) {
@@ -464,15 +461,9 @@ impl<'a> Parser<'a> {
                     if first_span.is_none() {
                         first_span = Some(var.span());
                     }
-                    kwargs_keys.push(ast::Expr::Const(Spanned::new(
-                        ast::Const {
-                            value: Value::from(var.id),
-                        },
-                        var.span(),
-                    )));
-                    kwargs_values.push(self.parse_expr_noif()?);
+                    kwargs.push((var.id, self.parse_expr_noif()?));
                 }
-                _ if !kwargs_keys.is_empty() => {
+                _ if !kwargs.is_empty() => {
                     return Err(Error::new(
                         ErrorKind::SyntaxError,
                         "non-keyword arg after keyword arg",
@@ -484,15 +475,12 @@ impl<'a> Parser<'a> {
             }
         }
 
-        if !kwargs_keys.is_empty() {
-            args.push(ast::Expr::Map(ast::Spanned::new(
-                ast::Map {
-                    keys: kwargs_keys,
-                    values: kwargs_values,
-                },
+        if !kwargs.is_empty() {
+            args.push(ast::Expr::Kwargs(ast::Spanned::new(
+                ast::Kwargs { pairs: kwargs },
                 self.stream.expand_span(first_span.unwrap()),
             )));
-        }
+        };
 
         expect_token!(self, Token::ParenClose, "`)`")?;
         Ok(args)
@@ -643,6 +631,18 @@ impl<'a> Parser<'a> {
                 self.parse_filter_block()?,
                 self.stream.expand_span(span),
             ))),
+            Token::Ident("macro") => Ok(ast::Stmt::Macro(Spanned::new(
+                self.parse_macro()?,
+                self.stream.expand_span(span),
+            ))),
+            Token::Ident("import") => Ok(ast::Stmt::Import(Spanned::new(
+                self.parse_import()?,
+                self.stream.expand_span(span),
+            ))),
+            Token::Ident("from") => Ok(ast::Stmt::FromImport(Spanned::new(
+                self.parse_from_import()?,
+                self.stream.expand_span(span),
+            ))),
             Token::Ident(name) => syntax_error!("unknown statement {}", name),
             token => syntax_error!("unknown {}, expected statement", token),
         }
@@ -830,6 +830,9 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_block(&mut self) -> Result<ast::Block<'a>, Error> {
+        if self.in_macro {
+            syntax_error!("block tags in macros are not allowed");
+        }
         let (name, _) = expect_token!(self, Token::Ident(name) => name, "identifier")?;
         expect_token!(self, Token::BlockEnd(..), "end of block")?;
         let body = self.subparse(&|tok| matches!(tok, Token::Ident("endblock")))?;
@@ -912,6 +915,76 @@ impl<'a> Parser<'a> {
         Ok(ast::FilterBlock { filter, body })
     }
 
+    fn parse_macro(&mut self) -> Result<ast::Macro<'a>, Error> {
+        let (name, _) = expect_token!(self, Token::Ident(name) => name, "identifier")?;
+        expect_token!(self, Token::ParenOpen, "`(`")?;
+        let mut args = Vec::new();
+        let mut defaults = Vec::new();
+        loop {
+            if matches!(self.stream.current()?, Some((Token::ParenClose, _))) {
+                break;
+            }
+            if !args.is_empty() {
+                expect_token!(self, Token::Comma, "`,`")?;
+            }
+            if matches!(self.stream.current()?, Some((Token::ParenClose, _))) {
+                break;
+            }
+            args.push(self.parse_assign_name()?);
+            if matches!(self.stream.current()?, Some((Token::Assign, _))) {
+                self.stream.next()?;
+                defaults.push(self.parse_expr()?);
+            } else if !defaults.is_empty() {
+                expect_token!(self, Token::Assign, "`=`")?;
+            }
+        }
+        expect_token!(self, Token::ParenClose, "`)`")?;
+        expect_token!(self, Token::BlockEnd(..), "end of block")?;
+        let old_in_macro = mem::replace(&mut self.in_macro, true);
+        let body = self.subparse(&|tok| matches!(tok, Token::Ident("endmacro")))?;
+        self.in_macro = old_in_macro;
+        self.stream.next()?;
+        Ok(ast::Macro {
+            name,
+            args,
+            defaults,
+            body,
+        })
+    }
+
+    fn parse_import(&mut self) -> Result<ast::Import<'a>, Error> {
+        let expr = self.parse_expr()?;
+        expect_token!(self, Token::Ident("as"), "as")?;
+        let name = self.parse_expr()?;
+        Ok(ast::Import { expr, name })
+    }
+
+    fn parse_from_import(&mut self) -> Result<ast::FromImport<'a>, Error> {
+        let expr = self.parse_expr()?;
+        let mut names = Vec::new();
+        expect_token!(self, Token::Ident("import"), "import")?;
+        loop {
+            if matches!(self.stream.current()?, Some((Token::BlockEnd(_), _))) {
+                break;
+            }
+            if !names.is_empty() {
+                expect_token!(self, Token::Comma, "`,`")?;
+            }
+            if matches!(self.stream.current()?, Some((Token::BlockEnd(_), _))) {
+                break;
+            }
+            let name = self.parse_assign_name()?;
+            let alias = if matches!(self.stream.current()?, Some((Token::Ident("as"), _))) {
+                self.stream.next()?;
+                Some(self.parse_assign_name()?)
+            } else {
+                None
+            };
+            names.push((name, alias));
+        }
+        Ok(ast::FromImport { expr, names })
+    }
+
     fn subparse(
         &mut self,
         end_check: &dyn Fn(&Token) -> bool,
diff --git a/minijinja/src/filters.rs b/minijinja/src/filters.rs
index 6f44b6a2..608af7fb 100644
--- a/minijinja/src/filters.rs
+++ b/minijinja/src/filters.rs
@@ -342,7 +342,7 @@ mod builtins {
     #[cfg_attr(docsrs, doc(cfg(feature = "builtins")))]
     pub fn dictsort(v: Value) -> Result<Value, Error> {
         let mut pairs = match v.0 {
-            ValueRepr::Map(ref v) => v.iter().collect::<Vec<_>>(),
+            ValueRepr::Map(ref v, _) => v.iter().collect::<Vec<_>>(),
             _ => {
                 return Err(Error::new(
                     ErrorKind::InvalidOperation,
@@ -380,7 +380,7 @@ mod builtins {
     pub fn items(v: Value) -> Result<Value, Error> {
         Ok(Value::from(
             match v.0 {
-                ValueRepr::Map(ref v) => v.iter(),
+                ValueRepr::Map(ref v, _) => v.iter(),
                 _ => {
                     return Err(Error::new(
                         ErrorKind::InvalidOperation,
@@ -592,7 +592,7 @@ mod builtins {
                 Ok(Value::from(s.chars().map(Value::from).collect::<Vec<_>>()))
             }
             ValueRepr::Seq(_) => Ok(value.clone()),
-            ValueRepr::Map(ref m) => Ok(Value::from(
+            ValueRepr::Map(ref m, _) => Ok(Value::from(
                 m.iter()
                     .map(|x| Value::from(x.0.clone()))
                     .collect::<Vec<_>>(),
@@ -775,7 +775,7 @@ mod builtins {
             ValueRepr::String(s) | ValueRepr::SafeString(s) => {
                 Ok(percent_encoding::utf8_percent_encode(s, SET).to_string())
             }
-            ValueRepr::Map(ref val) => {
+            ValueRepr::Map(ref val, _) => {
                 let mut rv = String::new();
                 for (idx, (k, v)) in val.iter().enumerate() {
                     if idx > 0 {
diff --git a/minijinja/src/functions.rs b/minijinja/src/functions.rs
index 36de66bf..e119d28f 100644
--- a/minijinja/src/functions.rs
+++ b/minijinja/src/functions.rs
@@ -40,6 +40,22 @@
 //! env.add_function("include_file", include_file);
 //! ```
 //!
+//! # Note on Keyword Arguments
+//!
+//! MiniJinja inherits a lot of the runtime model from Jinja2.  That includes support for
+//! keyword arguments.  These however are a concept not native to Rust which makes them
+//! somewhat unconfortable to work with.  In MiniJinja keyword arguments are implemented by
+//! converting them into an extra parameter represented by a map.  That means if you call
+//! a function as `foo(1, 2, three=3, four=4)` the function gets three arguments:
+//!
+//! ```json
+//! [1, 2, {"three": 3, "four": 4}]
+//! ```
+//!
+//! If a function wants to disambiugate between a value passed as keyword argument or not,
+//! the the [`Value::is_kwargs`] can be used which returns `true` if a value represents
+//! keyword arguments as oppsed to just a map.
+//!
 //! # Built-in Functions
 //!
 //! When the `builtins` feature is enabled a range of built-in functions are
diff --git a/minijinja/src/key/mod.rs b/minijinja/src/key/mod.rs
index dfa4493b..59a1624d 100644
--- a/minijinja/src/key/mod.rs
+++ b/minijinja/src/key/mod.rs
@@ -271,7 +271,7 @@ pub mod key_interning {
 
         for value in v.try_iter().unwrap() {
             match value.0 {
-                ValueRepr::Map(m) => {
+                ValueRepr::Map(m, _) => {
                     let k = m.iter().next().unwrap().0;
                     match k {
                         Key::String(s) => {
diff --git a/minijinja/src/macros.rs b/minijinja/src/macros.rs
index 4b7898fd..9988ae31 100644
--- a/minijinja/src/macros.rs
+++ b/minijinja/src/macros.rs
@@ -5,7 +5,7 @@ use similar_asserts::assert_eq;
 #[doc(hidden)]
 pub mod __context {
     use crate::key::Key;
-    use crate::value::{Value, ValueMap, ValueRepr};
+    use crate::value::{MapType, Value, ValueMap, ValueRepr};
     use crate::Environment;
     use std::sync::Arc;
 
@@ -21,7 +21,7 @@ pub mod __context {
 
     #[inline(always)]
     pub fn build(ctx: ValueMap) -> Value {
-        ValueRepr::Map(Arc::new(ctx)).into()
+        ValueRepr::Map(Arc::new(ctx), MapType::Normal).into()
     }
 
     pub fn thread_local_env() -> Environment<'static> {
diff --git a/minijinja/src/syntax.rs b/minijinja/src/syntax.rs
index fc0ac2ed..98c23cd7 100644
--- a/minijinja/src/syntax.rs
+++ b/minijinja/src/syntax.rs
@@ -17,9 +17,11 @@
 //!   - [`{% extends %}`](#-extends-)
 //!   - [`{% block %}`](#-block-)
 //!   - [`{% include %}`](#-include-)
+//!   - [`{% import %}`](#-import-)
 //!   - [`{% with %}`](#-with-)
 //!   - [`{% set %}`](#-set-)
 //!   - [`{% filter %}`](#-filter-)
+//!   - [`{% macro %}`](#-macro-)
 //!   - [`{% autoescape %}`](#-autoescape-)
 //!   - [`{% raw %}`](#-raw-)
 //!
@@ -405,6 +407,33 @@
 //!  
 //! Included templates have access to the variables of the active context.
 //!
+//! ## `{% import #}`
+//!
+//! MiniJinja supports the `{% import %}` and `{% from ... import ... %}`
+//! syntax.  With it variables or macros can be included from other templates:
+//!
+//! ```jinja
+//! {% from "my_template.html" import my_macro, my_variable %}
+//! ```
+//!
+//! Imports can also be aliased:
+//!
+//! ```jinja
+//! {% from "my_template.html" import my_macro as other_name %}
+//! {{ other_name() }}
+//! ```
+//!
+//! Full modules can be imported with `{% import ... as ... %}`:
+//!
+//! ```jinja
+//! {% import "my_template.html" as helpers %}
+//! {{ helpers.my_macro() }}
+//! ```
+//!
+//! Note that unlike Jinja2, exported modules do not contain any template code.  Only
+//! variables and macros that are defined can be imported.  Also imports unlike in Jinja2
+//! are not cached and they get access to the full template context.
+//!
 //! ## `{% with %}`
 //!
 //! The with statement makes it possible to create a new inner scope.  Variables set within
@@ -469,6 +498,32 @@
 //! {% endfilter %}
 //! ```
 //!
+//! ## `{% macro %}`
+//!
+//! MiniJinja has limited support for macros.  They allow you to write reusable
+//! template functions.  hey are useful to put often used idioms into reusable
+//! functions to not repeat yourself (“DRY”).
+//!
+//! Here’s a small example of a macro that renders a form element:
+//!
+//! ```jinja
+//! {% macro input(name, value="", type="text") -%}
+//! <input type="{{ type }}" name="{{ name }}" value="{{ value }}">
+//! {%- endmacro %}
+//! ```
+//!
+//! The macro can then be called like a function in the namespace:
+//!
+//! ```jinja
+//! <p>{{ input('username') }}</p>
+//! <p>{{ input('password', type='password') }}</p>
+//! ```
+//!
+//! The behavior of macros with regards to undefined variables is that they capture
+//! them at macro declaration time (eg: they use a closure).
+//!
+//! Macros can be imported via `{% include %}` or `{% from ... import %}`.
+//!
 //! ## `{% autoescape %}`
 //!
 //! If you want you can activate and deactivate the autoescaping from within
diff --git a/minijinja/src/template.rs b/minijinja/src/template.rs
index cd2231aa..250594f8 100644
--- a/minijinja/src/template.rs
+++ b/minijinja/src/template.rs
@@ -10,7 +10,7 @@ use crate::environment::Environment;
 use crate::error::{attach_basic_debug_info, Error, ErrorKind};
 use crate::output::{Output, WriteWrapper};
 use crate::utils::AutoEscape;
-use crate::value::Value;
+use crate::value::{self, Value};
 use crate::vm::Vm;
 
 /// Represents a handle to a template.
@@ -183,13 +183,17 @@ impl<'source> CompiledTemplate<'source> {
         name: &'source str,
         source: &'source str,
     ) -> Result<CompiledTemplate<'source>, Error> {
-        let ast = parse(source, name)?;
-        let mut gen = CodeGenerator::new(name, source);
-        gen.compile_stmt(&ast)?;
-        let (instructions, blocks) = gen.finish();
-        Ok(CompiledTemplate {
-            instructions,
-            blocks,
+        // the parser/compiler combination can create constants in which case
+        // we can probably benefit from the value optimization a bit.
+        value::with_value_optimization(|| {
+            let ast = parse(source, name)?;
+            let mut gen = CodeGenerator::new(name, source);
+            gen.compile_stmt(&ast)?;
+            let (instructions, blocks) = gen.finish();
+            Ok(CompiledTemplate {
+                instructions,
+                blocks,
+            })
         })
     }
 }
diff --git a/minijinja/src/value/argtypes.rs b/minijinja/src/value/argtypes.rs
index dd99d9c2..76f5ccae 100644
--- a/minijinja/src/value/argtypes.rs
+++ b/minijinja/src/value/argtypes.rs
@@ -5,7 +5,7 @@ use std::ops::{Deref, DerefMut};
 
 use crate::error::{Error, ErrorKind};
 use crate::key::{Key, StaticKey};
-use crate::value::{Arc, Value, ValueRepr};
+use crate::value::{Arc, MapType, Value, ValueRepr};
 use crate::vm::State;
 
 /// A utility trait that represents the return value of functions and filters.
@@ -259,9 +259,10 @@ impl<'a> From<Key<'a>> for Value {
 
 impl<K: Into<StaticKey>, V: Into<Value>> From<BTreeMap<K, V>> for Value {
     fn from(val: BTreeMap<K, V>) -> Self {
-        ValueRepr::Map(Arc::new(
-            val.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
-        ))
+        ValueRepr::Map(
+            Arc::new(val.into_iter().map(|(k, v)| (k.into(), v.into())).collect()),
+            MapType::Normal,
+        )
         .into()
     }
 }
diff --git a/minijinja/src/value/deserialize.rs b/minijinja/src/value/deserialize.rs
index 37317053..e7b2196a 100644
--- a/minijinja/src/value/deserialize.rs
+++ b/minijinja/src/value/deserialize.rs
@@ -1,7 +1,7 @@
 use serde::de::{self, MapAccess, SeqAccess, Visitor};
 use serde::Deserialize;
 
-use crate::value::{Value, ValueMap, ValueRepr};
+use crate::value::{MapType, Value, ValueMap, ValueRepr};
 
 impl<'de> Deserialize<'de> for Value {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -98,6 +98,6 @@ impl<'de> Visitor<'de> for ValueVisitor {
         while let Some((k, v)) = map.next_entry()? {
             rv.insert(k, v);
         }
-        Ok(Value(ValueRepr::Map(rv.into())))
+        Ok(Value(ValueRepr::Map(rv.into(), MapType::Normal)))
     }
 }
diff --git a/minijinja/src/value/mod.rs b/minijinja/src/value/mod.rs
index 7cc7493b..b48377fe 100644
--- a/minijinja/src/value/mod.rs
+++ b/minijinja/src/value/mod.rs
@@ -60,7 +60,8 @@
 //!
 //! Values can also hold "dynamic" objects.  These are objects which implement the
 //! [`Object`] trait.  These can be used to implement dynamic functionality such as
-//! stateful values and more.
+//! stateful values and more.  Dynamic objects are internally also used to implement
+//! the special `loop` variable or macros.
 
 // this module is based on the content module in insta which in turn is based
 // on the content module in serde::private::ser.
@@ -203,6 +204,15 @@ impl fmt::Display for ValueKind {
     }
 }
 
+/// The type of map
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum MapType {
+    /// A regular map
+    Normal,
+    /// A map representing keyword arguments
+    Kwargs,
+}
+
 #[derive(Clone)]
 pub(crate) enum ValueRepr {
     Undefined,
@@ -218,7 +228,7 @@ pub(crate) enum ValueRepr {
     SafeString(Arc<String>),
     Bytes(Arc<Vec<u8>>),
     Seq(Arc<Vec<Value>>),
-    Map(Arc<ValueMap>),
+    Map(Arc<ValueMap>, MapType),
     Dynamic(Arc<dyn Object>),
 }
 
@@ -238,7 +248,7 @@ impl fmt::Debug for ValueRepr {
             ValueRepr::SafeString(val) => fmt::Debug::fmt(val, f),
             ValueRepr::Bytes(val) => fmt::Debug::fmt(val, f),
             ValueRepr::Seq(val) => fmt::Debug::fmt(val, f),
-            ValueRepr::Map(val) => fmt::Debug::fmt(val, f),
+            ValueRepr::Map(val, _) => fmt::Debug::fmt(val, f),
             ValueRepr::Dynamic(val) => fmt::Debug::fmt(val, f),
         }
     }
@@ -320,7 +330,7 @@ impl fmt::Display for Value {
                 }
                 write!(f, "]")
             }
-            ValueRepr::Map(m) => {
+            ValueRepr::Map(m, _) => {
                 write!(f, "{{")?;
                 for (idx, (key, val)) in m.iter().enumerate() {
                     if idx > 0 {
@@ -435,10 +445,15 @@ impl Value {
             ValueRepr::Bytes(_) => ValueKind::Bytes,
             ValueRepr::U128(_) => ValueKind::Number,
             ValueRepr::Seq(_) => ValueKind::Seq,
-            ValueRepr::Map(_) | ValueRepr::Dynamic(_) => ValueKind::Map,
+            ValueRepr::Map(..) | ValueRepr::Dynamic(_) => ValueKind::Map,
         }
     }
 
+    /// Returns `true` if the map represents keyword arguments.
+    pub fn is_kwargs(&self) -> bool {
+        matches!(self.0, ValueRepr::Map(_, MapType::Kwargs))
+    }
+
     /// If the value is a string, return it.
     pub fn as_str(&self) -> Option<&str> {
         match &self.0 {
@@ -483,7 +498,7 @@ impl Value {
             ValueRepr::Bytes(ref x) => !x.is_empty(),
             ValueRepr::None | ValueRepr::Undefined => false,
             ValueRepr::Seq(ref x) => !x.is_empty(),
-            ValueRepr::Map(ref x) => !x.is_empty(),
+            ValueRepr::Map(ref x, _) => !x.is_empty(),
             ValueRepr::Dynamic(_) => true,
         }
     }
@@ -507,7 +522,7 @@ impl Value {
     pub fn len(&self) -> Option<usize> {
         match self.0 {
             ValueRepr::String(ref s) | ValueRepr::SafeString(ref s) => Some(s.chars().count()),
-            ValueRepr::Map(ref items) => Some(items.len()),
+            ValueRepr::Map(ref items, _) => Some(items.len()),
             ValueRepr::Seq(ref items) => Some(items.len()),
             ValueRepr::Dynamic(ref dy) => Some(dy.attributes().len()),
             _ => None,
@@ -521,7 +536,7 @@ impl Value {
     /// that has attributes.
     pub fn get_attr(&self, key: &str) -> Result<Value, Error> {
         let value = match self.0 {
-            ValueRepr::Map(ref items) => {
+            ValueRepr::Map(ref items, _) => {
                 let lookup_key = Key::Str(key);
                 items.get(&lookup_key).cloned()
             }
@@ -559,7 +574,7 @@ impl Value {
         let key = Key::from_borrowed_value(key).ok()?;
 
         match self.0 {
-            ValueRepr::Map(ref items) => return items.get(&key).cloned(),
+            ValueRepr::Map(ref items, _) => return items.get(&key).cloned(),
             ValueRepr::Seq(ref items) => {
                 if let Key::I64(idx) = key {
                     let idx = isize::try_from(idx).ok()?;
@@ -612,14 +627,19 @@ impl Value {
         name: &str,
         args: &[Value],
     ) -> Result<Value, Error> {
-        if let ValueRepr::Dynamic(ref dy) = self.0 {
-            dy.call_method(state, name, args)
-        } else {
-            Err(Error::new(
-                ErrorKind::InvalidOperation,
-                format!("object has no method named {}", name),
-            ))
+        match self.0 {
+            ValueRepr::Dynamic(ref dy) => return dy.call_method(state, name, args),
+            ValueRepr::Map(ref map, _) => {
+                if let Some(value) = map.get(&Key::Str(name)) {
+                    return value.call(state, args);
+                }
+            }
+            _ => {}
         }
+        Err(Error::new(
+            ErrorKind::InvalidOperation,
+            format!("object has no method named {}", name),
+        ))
     }
 
     pub(crate) fn try_into_key(self) -> Result<StaticKey, Error> {
@@ -643,7 +663,7 @@ impl Value {
 
     pub(crate) fn iter_as_str_map(&self) -> impl Iterator<Item = (&str, Value)> {
         match self.0 {
-            ValueRepr::Map(ref m) => Box::new(
+            ValueRepr::Map(ref m, _) => Box::new(
                 m.iter()
                     .filter_map(|(k, v)| k.as_str().map(move |k| (k, v.clone()))),
             ) as Box<dyn Iterator<Item = _>>,
@@ -662,11 +682,11 @@ impl Value {
             ValueRepr::None | ValueRepr::Undefined => (ValueIteratorState::Empty, 0),
             ValueRepr::Seq(ref seq) => (ValueIteratorState::Seq(0, Arc::clone(seq)), seq.len()),
             #[cfg(feature = "preserve_order")]
-            ValueRepr::Map(ref items) => {
+            ValueRepr::Map(ref items, _) => {
                 (ValueIteratorState::Map(0, Arc::clone(items)), items.len())
             }
             #[cfg(not(feature = "preserve_order"))]
-            ValueRepr::Map(ref items) => (
+            ValueRepr::Map(ref items, _) => (
                 ValueIteratorState::Map(
                     items.iter().next().map(|x| x.0.clone()),
                     Arc::clone(items),
@@ -713,7 +733,7 @@ impl Serialize for Value {
             ValueRepr::SafeString(ref val) => serializer.serialize_str(val),
             ValueRepr::Bytes(ref b) => serializer.serialize_bytes(b),
             ValueRepr::Seq(ref elements) => elements.serialize(serializer),
-            ValueRepr::Map(ref entries) => {
+            ValueRepr::Map(ref entries, _) => {
                 use serde::ser::SerializeMap;
                 let mut map = serializer.serialize_map(Some(entries.len()))?;
                 for (ref k, ref v) in entries.iter() {
diff --git a/minijinja/src/value/ops.rs b/minijinja/src/value/ops.rs
index c7e74446..8195f071 100644
--- a/minijinja/src/value/ops.rs
+++ b/minijinja/src/value/ops.rs
@@ -238,7 +238,7 @@ pub fn string_concat(mut left: Value, right: &Value) -> Value {
 pub fn contains(container: &Value, value: &Value) -> Result<Value, Error> {
     match container.0 {
         ValueRepr::Seq(ref values) => Ok(Value::from(values.contains(value))),
-        ValueRepr::Map(ref map) => {
+        ValueRepr::Map(ref map, _) => {
             let key = match value.clone().try_into_key() {
                 Ok(key) => key,
                 Err(_) => return Ok(Value::from(false)),
diff --git a/minijinja/src/value/serialize.rs b/minijinja/src/value/serialize.rs
index 544ffb1c..1b4b0e22 100644
--- a/minijinja/src/value/serialize.rs
+++ b/minijinja/src/value/serialize.rs
@@ -4,7 +4,7 @@ use serde::{ser, Serialize, Serializer};
 
 use crate::error::Error;
 use crate::key::{Key, KeySerializer, StaticKey};
-use crate::value::{Arc, Value, ValueMap, ValueRepr, VALUE_HANDLES, VALUE_HANDLE_MARKER};
+use crate::value::{Arc, MapType, Value, ValueMap, ValueRepr, VALUE_HANDLES, VALUE_HANDLE_MARKER};
 
 pub struct ValueSerializer;
 
@@ -135,7 +135,7 @@ impl Serializer for ValueSerializer {
     {
         let mut map = ValueMap::new();
         map.insert(Key::from(variant), value.serialize(self)?);
-        Ok(ValueRepr::Map(Arc::new(map)).into())
+        Ok(ValueRepr::Map(Arc::new(map), MapType::Normal).into())
     }
 
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
@@ -328,7 +328,10 @@ impl ser::SerializeMap for SerializeMap {
     }
 
     fn end(self) -> Result<Value, Error> {
-        Ok(Value(ValueRepr::Map(Arc::new(self.entries))))
+        Ok(Value(ValueRepr::Map(
+            Arc::new(self.entries),
+            MapType::Normal,
+        )))
     }
 
     fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), Error>
@@ -375,7 +378,7 @@ impl ser::SerializeStruct for SerializeStruct {
                         .expect("value handle not in registry")
                 }))
             }
-            _ => Ok(ValueRepr::Map(Arc::new(self.fields)).into()),
+            _ => Ok(ValueRepr::Map(Arc::new(self.fields), MapType::Normal).into()),
         }
     }
 }
@@ -402,7 +405,7 @@ impl ser::SerializeStructVariant for SerializeStructVariant {
         let mut rv = BTreeMap::new();
         rv.insert(
             self.variant,
-            Value::from(ValueRepr::Map(Arc::new(self.map))),
+            Value::from(ValueRepr::Map(Arc::new(self.map), MapType::Normal)),
         );
         Ok(rv.into())
     }
diff --git a/minijinja/src/vm/context.rs b/minijinja/src/vm/context.rs
index 48dbed61..71665e25 100644
--- a/minijinja/src/vm/context.rs
+++ b/minijinja/src/vm/context.rs
@@ -3,7 +3,7 @@ use std::fmt;
 
 use crate::environment::Environment;
 use crate::value::Value;
-use crate::vm::forloop::ForLoop;
+use crate::vm::loop_object::ForLoop;
 
 type Locals<'env> = BTreeMap<&'env str, Value>;
 
@@ -80,6 +80,12 @@ impl Stack {
     }
 }
 
+impl From<Vec<Value>> for Stack {
+    fn from(values: Vec<Value>) -> Stack {
+        Stack { values }
+    }
+}
+
 #[derive(Default)]
 pub(crate) struct Context<'env> {
     stack: Vec<Frame<'env>>,
@@ -211,6 +217,11 @@ impl<'env> Context<'env> {
         self.stack.pop().expect("pop from empty context stack")
     }
 
+    /// Returns the current locals.
+    pub fn current_locals(&mut self) -> &mut Locals<'env> {
+        &mut self.stack.last_mut().expect("empty stack").locals
+    }
+
     /// Returns the current innermost loop.
     pub fn current_loop(&mut self) -> Option<&mut ForLoop> {
         self.stack
diff --git a/minijinja/src/vm/forloop.rs b/minijinja/src/vm/loop_object.rs
similarity index 100%
rename from minijinja/src/vm/forloop.rs
rename to minijinja/src/vm/loop_object.rs
diff --git a/minijinja/src/vm/macro_object.rs b/minijinja/src/vm/macro_object.rs
new file mode 100644
index 00000000..d2c6f14a
--- /dev/null
+++ b/minijinja/src/vm/macro_object.rs
@@ -0,0 +1,126 @@
+use std::collections::BTreeSet;
+use std::fmt;
+use std::sync::Arc;
+
+use crate::error::{Error, ErrorKind};
+use crate::key::Key;
+use crate::output::Output;
+use crate::utils::AutoEscape;
+use crate::value::{MapType, Object, Value, ValueRepr};
+use crate::vm::state::State;
+use crate::vm::Vm;
+
+pub(crate) struct Macro {
+    pub name: Arc<String>,
+    pub arg_spec: Vec<Arc<String>>,
+    // because values need to be 'static, we can't hold a reference to the
+    // instructions that declared the macro.  Instead of that we place the
+    // reference to the macro instruction (and the jump offset) in the
+    // state under `state.macros`.
+    pub macro_ref_id: usize,
+    pub closure: Value,
+}
+
+impl fmt::Debug for Macro {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl fmt::Display for Macro {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "<macro {}>", self.name)
+    }
+}
+
+impl Object for Macro {
+    fn attributes(&self) -> &[&str] {
+        &["name", "arguments"][..]
+    }
+
+    fn get_attr(&self, name: &str) -> Option<Value> {
+        match name {
+            "name" => Some(Value(ValueRepr::String(self.name.clone()))),
+            "arguments" => Some(Value::from(
+                self.arg_spec
+                    .iter()
+                    .map(|x| Value(ValueRepr::String(x.clone())))
+                    .collect::<Vec<_>>(),
+            )),
+            _ => None,
+        }
+    }
+
+    fn call(&self, state: &State, args: &[Value]) -> Result<Value, Error> {
+        let (args, kwargs) = match args.last() {
+            Some(Value(ValueRepr::Map(kwargs, MapType::Kwargs))) => {
+                (&args[..args.len() - 1], Some(kwargs))
+            }
+            _ => (args, None),
+        };
+
+        if args.len() > self.arg_spec.len() {
+            return Err(Error::from(ErrorKind::TooManyArguments));
+        }
+
+        let mut kwargs_used = BTreeSet::new();
+        let mut arg_values = Vec::with_capacity(self.arg_spec.len());
+        for (idx, name) in self.arg_spec.iter().enumerate() {
+            let kwarg = match kwargs {
+                Some(kwargs) => kwargs.get(&Key::Str(name)),
+                _ => None,
+            };
+            arg_values.push(match (args.get(idx), kwarg) {
+                (Some(_), Some(_)) => {
+                    return Err(Error::new(
+                        ErrorKind::TooManyArguments,
+                        format!("duplicate argument `{}`", name),
+                    ))
+                }
+                (Some(arg), None) => arg.clone(),
+                (None, Some(kwarg)) => {
+                    kwargs_used.insert(name as &str);
+                    kwarg.clone()
+                }
+                (None, None) => Value::UNDEFINED,
+            });
+        }
+
+        if let Some(kwargs) = kwargs {
+            for key in kwargs.keys().filter_map(|x| x.as_str()) {
+                if !kwargs_used.contains(key) {
+                    return Err(Error::new(
+                        ErrorKind::TooManyArguments,
+                        format!("unknown keyword argument `{}`", key),
+                    ));
+                }
+            }
+        }
+
+        let (instructions, offset) = &state.macros[self.macro_ref_id];
+        let vm = Vm::new(state.env());
+        let mut rv = String::new();
+        let mut out = Output::with_string(&mut rv);
+
+        // This requires some explanation here.  Because we get the state as &State and
+        // not &mut State we are required to create a new state here.  This is unfortunate
+        // but makes the calling interface more convenient for the rest of the system.
+        // Because macros cannot return anything other than strings (most importantly they)
+        // can't return other macros this is however not an issue, as modifications in the
+        // macro cannot leak out.
+        vm.eval_macro(
+            instructions,
+            *offset,
+            self.closure.clone(),
+            &mut out,
+            state,
+            arg_values,
+        )?;
+
+        Ok(if !matches!(state.auto_escape(), AutoEscape::None) {
+            Value::from_safe_string(rv)
+        } else {
+            Value::from(rv)
+        })
+    }
+}
diff --git a/minijinja/src/vm/mod.rs b/minijinja/src/vm/mod.rs
index f8b94556..b7062bd6 100644
--- a/minijinja/src/vm/mod.rs
+++ b/minijinja/src/vm/mod.rs
@@ -11,15 +11,17 @@ use crate::error::{Error, ErrorKind};
 use crate::key::Key;
 use crate::output::Output;
 use crate::utils::AutoEscape;
-use crate::value::{self, ops, Value, ValueRepr};
+use crate::value::{self, ops, MapType, Value, ValueMap, ValueRepr};
 use crate::vm::context::{Context, Frame, Stack};
-use crate::vm::forloop::{ForLoop, LoopState};
+use crate::vm::loop_object::{ForLoop, LoopState};
+use crate::vm::macro_object::Macro;
 use crate::vm::state::BlockStack;
 
 pub use crate::vm::state::State;
 
 mod context;
-mod forloop;
+mod loop_object;
+mod macro_object;
 mod state;
 
 /// Helps to evaluate something.
@@ -78,23 +80,62 @@ impl<'env> Vm<'env> {
                     instructions,
                     auto_escape,
                     blocks: prepare_blocks(blocks),
+                    macros: Arc::new(Vec::new()),
                 },
                 out,
             )
         })
     }
 
+    /// Evaluate a macro in a state.
+    #[inline(always)]
+    pub fn eval_macro(
+        &self,
+        instructions: &Instructions<'env>,
+        pc: usize,
+        root: Value,
+        out: &mut Output,
+        state: &State,
+        args: Vec<Value>,
+    ) -> Result<Option<Value>, Error> {
+        value::with_value_optimization(|| {
+            self.eval_impl(
+                &mut State {
+                    env: self.env,
+                    ctx: Context::new(Frame::new(root)),
+                    current_block: None,
+                    instructions,
+                    auto_escape: state.auto_escape(),
+                    blocks: BTreeMap::default(),
+                    macros: state.macros.clone(),
+                },
+                out,
+                Stack::from(args),
+                pc,
+            )
+        })
+    }
+
     /// This is the actual evaluation loop that works with a specific context.
+    #[inline(always)]
     fn eval_state(
         &self,
         state: &mut State<'_, 'env>,
         out: &mut Output,
+    ) -> Result<Option<Value>, Error> {
+        self.eval_impl(state, out, Stack::default(), 0)
+    }
+
+    fn eval_impl(
+        &self,
+        state: &mut State<'_, 'env>,
+        out: &mut Output,
+        mut stack: Stack,
+        mut pc: usize,
     ) -> Result<Option<Value>, Error> {
         let initial_auto_escape = state.auto_escape;
-        let mut stack = Stack::default();
         let mut auto_escape_stack = vec![];
         let mut next_loop_recursion_jump = None;
-        let mut pc = 0;
         let mut loaded_filters = [None; MAX_LOCALS];
         let mut loaded_tests = [None; MAX_LOCALS];
 
@@ -181,13 +222,22 @@ impl<'env> Vm<'env> {
                     stack.push(value.clone());
                 }
                 Instruction::BuildMap(pair_count) => {
-                    let mut map = BTreeMap::new();
+                    let mut map = ValueMap::new();
+                    for _ in 0..*pair_count {
+                        let value = stack.pop();
+                        let key = try_ctx!(stack.pop().try_into_key());
+                        map.insert(key, value);
+                    }
+                    stack.push(Value(ValueRepr::Map(map.into(), MapType::Normal)))
+                }
+                Instruction::BuildKwargs(pair_count) => {
+                    let mut map = ValueMap::new();
                     for _ in 0..*pair_count {
                         let value = stack.pop();
-                        let key: Key = try_ctx!(stack.pop().try_into_key());
+                        let key = stack.pop().try_into_key().unwrap();
                         map.insert(key, value);
                     }
-                    stack.push(Value::from(map));
+                    stack.push(Value(ValueRepr::Map(map.into(), MapType::Kwargs)))
                 }
                 Instruction::BuildList(count) => {
                     let mut v = Vec::with_capacity(*count);
@@ -258,6 +308,10 @@ impl<'env> Vm<'env> {
                         }
                     }
                 }
+                Instruction::IsUndefined => {
+                    let value = stack.pop();
+                    stack.push(Value::from(value.is_undefined()));
+                }
                 Instruction::PushLoop(flags) => {
                     let iterable = stack.pop();
                     try_ctx!(self.push_loop(
@@ -439,6 +493,18 @@ impl<'env> Vm<'env> {
                 Instruction::FastRecurse => {
                     recurse_loop!(false);
                 }
+                Instruction::BuildMacro(name, offset) => {
+                    self.build_macro(&mut stack, state, offset, name);
+                }
+                Instruction::ExportLocals => {
+                    let locals = state.ctx.current_locals();
+                    let mut module = ValueMap::new();
+                    for (key, value) in locals.iter() {
+                        module.insert(Key::make_string_key(key), value.clone());
+                    }
+                    stack.push(Value(ValueRepr::Map(module.into(), MapType::Normal)));
+                }
+                Instruction::Return => break,
             }
             pc += 1;
         }
@@ -665,6 +731,28 @@ impl<'env> Vm<'env> {
         }
         Ok(())
     }
+
+    fn build_macro(&self, stack: &mut Stack, state: &mut State, offset: &usize, name: &&str) {
+        let arg_spec = match stack.pop().0 {
+            ValueRepr::Seq(args) => args
+                .iter()
+                .map(|value| match &value.0 {
+                    ValueRepr::String(arg) => arg.clone(),
+                    _ => unreachable!(),
+                })
+                .collect(),
+            _ => unreachable!(),
+        };
+        let closure = stack.pop();
+        let macro_ref_id = state.macros.len();
+        Arc::make_mut(&mut state.macros).push((state.instructions, *offset as usize));
+        stack.push(Value::from_object(Macro {
+            name: Arc::new(name.to_string()),
+            arg_spec,
+            macro_ref_id,
+            closure,
+        }));
+    }
 }
 
 fn process_err(mut err: Error, pc: usize, state: &State) -> Error {
diff --git a/minijinja/src/vm/state.rs b/minijinja/src/vm/state.rs
index d455461a..b232a45f 100644
--- a/minijinja/src/vm/state.rs
+++ b/minijinja/src/vm/state.rs
@@ -1,5 +1,6 @@
 use std::collections::BTreeMap;
 use std::fmt;
+use std::sync::Arc;
 
 use crate::compiler::instructions::Instructions;
 use crate::environment::Environment;
@@ -27,6 +28,7 @@ pub struct State<'vm, 'env> {
     pub(crate) auto_escape: AutoEscape,
     pub(crate) instructions: &'vm Instructions<'env>,
     pub(crate) blocks: BTreeMap<&'env str, BlockStack<'vm, 'env>>,
+    pub(crate) macros: Arc<Vec<(&'vm Instructions<'env>, usize)>>,
 }
 
 impl<'vm, 'env> fmt::Debug for State<'vm, 'env> {
@@ -76,6 +78,7 @@ impl<'vm, 'env> State<'vm, 'env> {
             auto_escape: AutoEscape::None,
             instructions: &Instructions::new("<unknown>", ""),
             blocks: BTreeMap::new(),
+            macros: Arc::new(Vec::new()),
         })
     }
 
diff --git a/minijinja/tests/inputs/err_block_in_macro.txt b/minijinja/tests/inputs/err_block_in_macro.txt
new file mode 100644
index 00000000..81263fea
--- /dev/null
+++ b/minijinja/tests/inputs/err_block_in_macro.txt
@@ -0,0 +1,5 @@
+{}
+---
+{% macro two_args(a, b) %}
+  {% block foo %}{% endblock %}
+{% endmacro %}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/err_duplicate_macro_arg.txt b/minijinja/tests/inputs/err_duplicate_macro_arg.txt
new file mode 100644
index 00000000..96e0c10c
--- /dev/null
+++ b/minijinja/tests/inputs/err_duplicate_macro_arg.txt
@@ -0,0 +1,6 @@
+{}
+---
+{% macro two_args(a, b) %}
+  {{ a }} and {{ b }}
+{% endmacro %}
+{{ two_args(1, a=2) }}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/err_too_many_macro_args.txt b/minijinja/tests/inputs/err_too_many_macro_args.txt
new file mode 100644
index 00000000..20705f4a
--- /dev/null
+++ b/minijinja/tests/inputs/err_too_many_macro_args.txt
@@ -0,0 +1,6 @@
+{}
+---
+{% macro two_args(a, b) %}
+  {{ a }} and {{ b }}
+{% endmacro %}
+{{ two_args(1, 2, 3) }}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/err_too_many_macro_kwargs.txt b/minijinja/tests/inputs/err_too_many_macro_kwargs.txt
new file mode 100644
index 00000000..a2f24498
--- /dev/null
+++ b/minijinja/tests/inputs/err_too_many_macro_kwargs.txt
@@ -0,0 +1,6 @@
+{}
+---
+{% macro two_args(a, b) %}
+  {{ a }} and {{ b }}
+{% endmacro %}
+{{ two_args(c=42) }}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/err_too_many_macro_kwargs2.txt b/minijinja/tests/inputs/err_too_many_macro_kwargs2.txt
new file mode 100644
index 00000000..4dbb2419
--- /dev/null
+++ b/minijinja/tests/inputs/err_too_many_macro_kwargs2.txt
@@ -0,0 +1,6 @@
+{}
+---
+{% macro two_args(a, b) %}
+  {{ a }} and {{ b }}
+{% endmacro %}
+{{ two_args(c=42, d=23) }}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/macro_basic.txt b/minijinja/tests/inputs/macro_basic.txt
new file mode 100644
index 00000000..0938018e
--- /dev/null
+++ b/minijinja/tests/inputs/macro_basic.txt
@@ -0,0 +1,10 @@
+{}
+---
+{% macro add(a, b) %}{{ a }}|{{ b }}{% endmacro -%}
+{{ add(1, 2) }}
+{{ add(a=1, b=2) }}
+{{ add(b=2, a=1) }}
+{{ add(1, b=2) }}
+{{ add.name }}
+{{ add.arguments }}
+{{ add }}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/macro_calling_macro.txt b/minijinja/tests/inputs/macro_calling_macro.txt
new file mode 100644
index 00000000..eeff5c38
--- /dev/null
+++ b/minijinja/tests/inputs/macro_calling_macro.txt
@@ -0,0 +1,5 @@
+{}
+---
+{%- from "call_macro.txt" import call %}
+{%- macro my_macro(value) %}[{{ value }}]{% endmacro %}
+{{- call(my_macro, 42) }}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/macro_import.txt b/minijinja/tests/inputs/macro_import.txt
new file mode 100644
index 00000000..36c159ca
--- /dev/null
+++ b/minijinja/tests/inputs/macro_import.txt
@@ -0,0 +1,6 @@
+{"c": "The C Variable"}
+---
+{% from "include_with_var_and_macro.txt" import title, helper, missing -%}
+missing: {{ missing }}
+title: {{ title }}
+helper: {{ helper("a", "b") }}
diff --git a/minijinja/tests/inputs/macro_import2.txt b/minijinja/tests/inputs/macro_import2.txt
new file mode 100644
index 00000000..429d7d03
--- /dev/null
+++ b/minijinja/tests/inputs/macro_import2.txt
@@ -0,0 +1,7 @@
+{"c": "The C Variable"}
+---
+{% import "include_with_var_and_macro.txt" as helpers -%}
+{{ helpers }}
+missing: {{ helpers.missing }}
+title: {{ helpers.title }}
+helper: {{ helpers.helper("a", "b") }}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/macro_include.txt b/minijinja/tests/inputs/macro_include.txt
new file mode 100644
index 00000000..753a8933
--- /dev/null
+++ b/minijinja/tests/inputs/macro_include.txt
@@ -0,0 +1,6 @@
+{}
+---
+{%- include "example_macro.txt" %}
+{%- set d = "should never show up" %}
+{{ example(1, 2, 3) }}
+{{ example(1, 2) }}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/macro_kwargs.txt b/minijinja/tests/inputs/macro_kwargs.txt
new file mode 100644
index 00000000..0de6781c
--- /dev/null
+++ b/minijinja/tests/inputs/macro_kwargs.txt
@@ -0,0 +1,7 @@
+{}
+---
+{% macro foo(a, b, c, d) %}{{ [a, b, c, d] }}{% endmacro -%}
+{{ foo(1, 2, 3) }}
+{{ foo({"blub": "blah"}) }}
+{{ foo(a=1, b=2, c=3) }}
+{{ foo(a=1, b=2, c=3, d=4) }}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/refs/call_macro.txt b/minijinja/tests/inputs/refs/call_macro.txt
new file mode 100644
index 00000000..49c1aa03
--- /dev/null
+++ b/minijinja/tests/inputs/refs/call_macro.txt
@@ -0,0 +1 @@
+{% macro call(other, arg) %}{{ other(arg) }}{% endmacro %}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/refs/example_macro.txt b/minijinja/tests/inputs/refs/example_macro.txt
new file mode 100644
index 00000000..c1e0aa5a
--- /dev/null
+++ b/minijinja/tests/inputs/refs/example_macro.txt
@@ -0,0 +1,2 @@
+{% set d = "closure" -%}
+{% macro example(a, b, c="default") %}{{ [a, b, c, d] }}{% endmacro -%}
\ No newline at end of file
diff --git a/minijinja/tests/inputs/refs/include_with_var_and_macro.txt b/minijinja/tests/inputs/refs/include_with_var_and_macro.txt
new file mode 100644
index 00000000..2d13e9e0
--- /dev/null
+++ b/minijinja/tests/inputs/refs/include_with_var_and_macro.txt
@@ -0,0 +1,3 @@
+{% set title = "The Title" %}
+{% macro helper(a, b) %}{{ [a, b, c] }}{% endmacro %}
+Should not show up
\ No newline at end of file
diff --git a/minijinja/tests/parser-inputs/imports.txt b/minijinja/tests/parser-inputs/imports.txt
new file mode 100644
index 00000000..7eb28d1c
--- /dev/null
+++ b/minijinja/tests/parser-inputs/imports.txt
@@ -0,0 +1,9 @@
+{% from "foo.html" import a, b %}
+{% from "foo.html" import a %}
+{% from "foo.html" import a as b %}
+{% from "foo.html" import a as b, b as c %}
+{% from "foo.html" import a, b, %}
+{% from "foo.html" import a, %}
+{% from "foo.html" import a as b, %}
+{% from "foo.html" import a as b, b as c, %}
+{% import "foo.html" as x %}
diff --git a/minijinja/tests/parser-inputs/macros.txt b/minijinja/tests/parser-inputs/macros.txt
new file mode 100644
index 00000000..5add6e04
--- /dev/null
+++ b/minijinja/tests/parser-inputs/macros.txt
@@ -0,0 +1,5 @@
+{% macro foo() %}...{% endmacro %}
+{% macro foo(a, b) %}...{% endmacro %}
+{% macro foo(a, b=42) %}...{% endmacro %}
+{% macro foo(a, b,) %}...{% endmacro %}
+{% macro foo(a, b=42,) %}...{% endmacro %}
diff --git a/minijinja/tests/snapshots/test_parser__parser@call.txt.snap b/minijinja/tests/snapshots/test_parser__parser@call.txt.snap
index b0a25f1c..464eb4c7 100644
--- a/minijinja/tests/snapshots/test_parser__parser@call.txt.snap
+++ b/minijinja/tests/snapshots/test_parser__parser@call.txt.snap
@@ -64,22 +64,20 @@ Ok(
                         Const {
                             value: 2,
                         } @ 4:10-4:11,
-                        Map {
-                            keys: [
-                                Const {
-                                    value: "a",
-                                } @ 4:13-4:14,
-                                Const {
-                                    value: "b",
-                                } @ 4:18-4:19,
-                            ],
-                            values: [
-                                Const {
-                                    value: 3,
-                                } @ 4:15-4:16,
-                                Const {
-                                    value: 4,
-                                } @ 4:20-4:21,
+                        Kwargs {
+                            pairs: [
+                                (
+                                    "a",
+                                    Const {
+                                        value: 3,
+                                    } @ 4:15-4:16,
+                                ),
+                                (
+                                    "b",
+                                    Const {
+                                        value: 4,
+                                    } @ 4:20-4:21,
+                                ),
                             ],
                         } @ 4:13-4:21,
                     ],
@@ -118,16 +116,14 @@ Ok(
                         Const {
                             value: 2,
                         } @ 6:21-6:22,
-                        Map {
-                            keys: [
-                                Const {
-                                    value: "a",
-                                } @ 6:24-6:25,
-                            ],
-                            values: [
-                                Const {
-                                    value: 3,
-                                } @ 6:26-6:27,
+                        Kwargs {
+                            pairs: [
+                                (
+                                    "a",
+                                    Const {
+                                        value: 3,
+                                    } @ 6:26-6:27,
+                                ),
                             ],
                         } @ 6:24-6:28,
                     ],
diff --git a/minijinja/tests/snapshots/test_parser__parser@filter.txt.snap b/minijinja/tests/snapshots/test_parser__parser@filter.txt.snap
index 7fbd5514..42fb1c8a 100644
--- a/minijinja/tests/snapshots/test_parser__parser@filter.txt.snap
+++ b/minijinja/tests/snapshots/test_parser__parser@filter.txt.snap
@@ -69,16 +69,14 @@ Ok(
                         Const {
                             value: 2,
                         } @ 3:14-3:15,
-                        Map {
-                            keys: [
-                                Const {
-                                    value: "a",
-                                } @ 3:17-3:18,
-                            ],
-                            values: [
-                                Const {
-                                    value: 1,
-                                } @ 3:19-3:20,
+                        Kwargs {
+                            pairs: [
+                                (
+                                    "a",
+                                    Const {
+                                        value: 1,
+                                    } @ 3:19-3:20,
+                                ),
                             ],
                         } @ 3:17-3:20,
                     ],
@@ -102,16 +100,14 @@ Ok(
                         Const {
                             value: 2,
                         } @ 4:14-4:15,
-                        Map {
-                            keys: [
-                                Const {
-                                    value: "a",
-                                } @ 4:17-4:18,
-                            ],
-                            values: [
-                                Const {
-                                    value: 1,
-                                } @ 4:19-4:20,
+                        Kwargs {
+                            pairs: [
+                                (
+                                    "a",
+                                    Const {
+                                        value: 1,
+                                    } @ 4:19-4:20,
+                                ),
                             ],
                         } @ 4:17-4:21,
                     ],
diff --git a/minijinja/tests/snapshots/test_parser__parser@imports.txt.snap b/minijinja/tests/snapshots/test_parser__parser@imports.txt.snap
new file mode 100644
index 00000000..e395040b
--- /dev/null
+++ b/minijinja/tests/snapshots/test_parser__parser@imports.txt.snap
@@ -0,0 +1,195 @@
+---
+source: minijinja/tests/test_parser.rs
+description: "{% from \"foo.html\" import a, b %}\n{% from \"foo.html\" import a %}\n{% from \"foo.html\" import a as b %}\n{% from \"foo.html\" import a as b, b as c %}\n{% from \"foo.html\" import a, b, %}\n{% from \"foo.html\" import a, %}\n{% from \"foo.html\" import a as b, %}\n{% from \"foo.html\" import a as b, b as c, %}\n{% import \"foo.html\" as x %}"
+input_file: minijinja/tests/parser-inputs/imports.txt
+---
+Ok(
+    Template {
+        children: [
+            FromImport {
+                expr: Const {
+                    value: "foo.html",
+                } @ 1:8-1:18,
+                names: [
+                    (
+                        Var {
+                            id: "a",
+                        } @ 1:26-1:27,
+                        None,
+                    ),
+                    (
+                        Var {
+                            id: "b",
+                        } @ 1:29-1:30,
+                        None,
+                    ),
+                ],
+            } @ 1:3-1:30,
+            EmitRaw {
+                raw: "\n",
+            } @ 1:33-2:0,
+            FromImport {
+                expr: Const {
+                    value: "foo.html",
+                } @ 2:8-2:18,
+                names: [
+                    (
+                        Var {
+                            id: "a",
+                        } @ 2:26-2:27,
+                        None,
+                    ),
+                ],
+            } @ 2:3-2:27,
+            EmitRaw {
+                raw: "\n",
+            } @ 2:30-3:0,
+            FromImport {
+                expr: Const {
+                    value: "foo.html",
+                } @ 3:8-3:18,
+                names: [
+                    (
+                        Var {
+                            id: "a",
+                        } @ 3:26-3:27,
+                        Some(
+                            Var {
+                                id: "b",
+                            } @ 3:31-3:32,
+                        ),
+                    ),
+                ],
+            } @ 3:3-3:32,
+            EmitRaw {
+                raw: "\n",
+            } @ 3:35-4:0,
+            FromImport {
+                expr: Const {
+                    value: "foo.html",
+                } @ 4:8-4:18,
+                names: [
+                    (
+                        Var {
+                            id: "a",
+                        } @ 4:26-4:27,
+                        Some(
+                            Var {
+                                id: "b",
+                            } @ 4:31-4:32,
+                        ),
+                    ),
+                    (
+                        Var {
+                            id: "b",
+                        } @ 4:34-4:35,
+                        Some(
+                            Var {
+                                id: "c",
+                            } @ 4:39-4:40,
+                        ),
+                    ),
+                ],
+            } @ 4:3-4:40,
+            EmitRaw {
+                raw: "\n",
+            } @ 4:43-5:0,
+            FromImport {
+                expr: Const {
+                    value: "foo.html",
+                } @ 5:8-5:18,
+                names: [
+                    (
+                        Var {
+                            id: "a",
+                        } @ 5:26-5:27,
+                        None,
+                    ),
+                    (
+                        Var {
+                            id: "b",
+                        } @ 5:29-5:30,
+                        None,
+                    ),
+                ],
+            } @ 5:3-5:31,
+            EmitRaw {
+                raw: "\n",
+            } @ 5:34-6:0,
+            FromImport {
+                expr: Const {
+                    value: "foo.html",
+                } @ 6:8-6:18,
+                names: [
+                    (
+                        Var {
+                            id: "a",
+                        } @ 6:26-6:27,
+                        None,
+                    ),
+                ],
+            } @ 6:3-6:28,
+            EmitRaw {
+                raw: "\n",
+            } @ 6:31-7:0,
+            FromImport {
+                expr: Const {
+                    value: "foo.html",
+                } @ 7:8-7:18,
+                names: [
+                    (
+                        Var {
+                            id: "a",
+                        } @ 7:26-7:27,
+                        Some(
+                            Var {
+                                id: "b",
+                            } @ 7:31-7:32,
+                        ),
+                    ),
+                ],
+            } @ 7:3-7:33,
+            EmitRaw {
+                raw: "\n",
+            } @ 7:36-8:0,
+            FromImport {
+                expr: Const {
+                    value: "foo.html",
+                } @ 8:8-8:18,
+                names: [
+                    (
+                        Var {
+                            id: "a",
+                        } @ 8:26-8:27,
+                        Some(
+                            Var {
+                                id: "b",
+                            } @ 8:31-8:32,
+                        ),
+                    ),
+                    (
+                        Var {
+                            id: "b",
+                        } @ 8:34-8:35,
+                        Some(
+                            Var {
+                                id: "c",
+                            } @ 8:39-8:40,
+                        ),
+                    ),
+                ],
+            } @ 8:3-8:41,
+            EmitRaw {
+                raw: "\n",
+            } @ 8:44-9:0,
+            Import {
+                expr: Const {
+                    value: "foo.html",
+                } @ 9:10-9:20,
+                name: Var {
+                    id: "x",
+                } @ 9:24-9:25,
+            } @ 9:3-9:25,
+        ],
+    } @ 0:0-9:28,
+)
diff --git a/minijinja/tests/snapshots/test_parser__parser@macros.txt.snap b/minijinja/tests/snapshots/test_parser__parser@macros.txt.snap
new file mode 100644
index 00000000..38e18dc4
--- /dev/null
+++ b/minijinja/tests/snapshots/test_parser__parser@macros.txt.snap
@@ -0,0 +1,109 @@
+---
+source: minijinja/tests/test_parser.rs
+description: "{% macro foo() %}...{% endmacro %}\n{% macro foo(a, b) %}...{% endmacro %}\n{% macro foo(a, b=42) %}...{% endmacro %}\n{% macro foo(a, b,) %}...{% endmacro %}\n{% macro foo(a, b=42,) %}...{% endmacro %}"
+input_file: minijinja/tests/parser-inputs/macros.txt
+---
+Ok(
+    Template {
+        children: [
+            Macro {
+                name: "foo",
+                args: [],
+                defaults: [],
+                body: [
+                    EmitRaw {
+                        raw: "...",
+                    } @ 1:17-1:20,
+                ],
+            } @ 1:3-1:31,
+            EmitRaw {
+                raw: "\n",
+            } @ 1:34-2:0,
+            Macro {
+                name: "foo",
+                args: [
+                    Var {
+                        id: "a",
+                    } @ 2:13-2:14,
+                    Var {
+                        id: "b",
+                    } @ 2:16-2:17,
+                ],
+                defaults: [],
+                body: [
+                    EmitRaw {
+                        raw: "...",
+                    } @ 2:21-2:24,
+                ],
+            } @ 2:3-2:35,
+            EmitRaw {
+                raw: "\n",
+            } @ 2:38-3:0,
+            Macro {
+                name: "foo",
+                args: [
+                    Var {
+                        id: "a",
+                    } @ 3:13-3:14,
+                    Var {
+                        id: "b",
+                    } @ 3:16-3:17,
+                ],
+                defaults: [
+                    Const {
+                        value: 42,
+                    } @ 3:18-3:20,
+                ],
+                body: [
+                    EmitRaw {
+                        raw: "...",
+                    } @ 3:24-3:27,
+                ],
+            } @ 3:3-3:38,
+            EmitRaw {
+                raw: "\n",
+            } @ 3:41-4:0,
+            Macro {
+                name: "foo",
+                args: [
+                    Var {
+                        id: "a",
+                    } @ 4:13-4:14,
+                    Var {
+                        id: "b",
+                    } @ 4:16-4:17,
+                ],
+                defaults: [],
+                body: [
+                    EmitRaw {
+                        raw: "...",
+                    } @ 4:22-4:25,
+                ],
+            } @ 4:3-4:36,
+            EmitRaw {
+                raw: "\n",
+            } @ 4:39-5:0,
+            Macro {
+                name: "foo",
+                args: [
+                    Var {
+                        id: "a",
+                    } @ 5:13-5:14,
+                    Var {
+                        id: "b",
+                    } @ 5:16-5:17,
+                ],
+                defaults: [
+                    Const {
+                        value: 42,
+                    } @ 5:18-5:20,
+                ],
+                body: [
+                    EmitRaw {
+                        raw: "...",
+                    } @ 5:25-5:28,
+                ],
+            } @ 5:3-5:39,
+        ],
+    } @ 0:0-5:42,
+)
diff --git a/minijinja/tests/snapshots/test_templates__vm@debug.txt.snap b/minijinja/tests/snapshots/test_templates__vm@debug.txt.snap
index ddf53629..e72aa7fa 100644
--- a/minijinja/tests/snapshots/test_templates__vm@debug.txt.snap
+++ b/minijinja/tests/snapshots/test_templates__vm@debug.txt.snap
@@ -74,7 +74,10 @@ State {
         templates: [
             "a_plus_b.txt",
             "bad_basic_block.txt",
+            "call_macro.txt",
             "debug.txt",
+            "example_macro.txt",
+            "include_with_var_and_macro.txt",
             "simple2_layout.txt",
             "simple_include.txt",
             "simple_layout.txt",
diff --git a/minijinja/tests/snapshots/test_templates__vm@err_block_in_macro.txt.snap b/minijinja/tests/snapshots/test_templates__vm@err_block_in_macro.txt.snap
new file mode 100644
index 00000000..ea885bf7
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@err_block_in_macro.txt.snap
@@ -0,0 +1,23 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{% macro two_args(a, b) %}\n  {% block foo %}{% endblock %}\n{% endmacro %}"
+info: {}
+input_file: minijinja/tests/inputs/err_block_in_macro.txt
+---
+!!!SYNTAX ERROR!!!
+
+Error {
+    kind: SyntaxError,
+    detail: "block tags in macros are not allowed",
+    name: "err_block_in_macro.txt",
+    line: 2,
+}
+
+syntax error: block tags in macros are not allowed (in err_block_in_macro.txt:2)
+--------------------------- err_block_in_macro.txt ----------------------------
+   1 | {% macro two_args(a, b) %}
+   2 >   {% block foo %}{% endblock %}
+     i      ^^^^^ syntax error
+   3 | {% endmacro %}
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@err_duplicate_macro_arg.txt.snap b/minijinja/tests/snapshots/test_templates__vm@err_duplicate_macro_arg.txt.snap
new file mode 100644
index 00000000..c3aa3fa7
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@err_duplicate_macro_arg.txt.snap
@@ -0,0 +1,30 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{% macro two_args(a, b) %}\n  {{ a }} and {{ b }}\n{% endmacro %}\n{{ two_args(1, a=2) }}"
+info: {}
+input_file: minijinja/tests/inputs/err_duplicate_macro_arg.txt
+---
+!!!ERROR!!!
+
+Error {
+    kind: TooManyArguments,
+    detail: "duplicate argument `a`",
+    name: "err_duplicate_macro_arg.txt",
+    line: 4,
+}
+
+too many arguments: duplicate argument `a` (in err_duplicate_macro_arg.txt:4)
+------------------------- err_duplicate_macro_arg.txt -------------------------
+   1 | {% macro two_args(a, b) %}
+   2 |   {{ a }} and {{ b }}
+   3 | {% endmacro %}
+   4 > {{ two_args(1, a=2) }}
+     i    ^^^^^^^^^^^^^^^^ too many arguments
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Referenced variables: {
+    a: Undefined,
+    b: Undefined,
+    two_args: <macro two_args>,
+}
+-------------------------------------------------------------------------------
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@err_too_many_macro_args.txt.snap b/minijinja/tests/snapshots/test_templates__vm@err_too_many_macro_args.txt.snap
new file mode 100644
index 00000000..b1e6c701
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@err_too_many_macro_args.txt.snap
@@ -0,0 +1,29 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{% macro two_args(a, b) %}\n  {{ a }} and {{ b }}\n{% endmacro %}\n{{ two_args(1, 2, 3) }}"
+info: {}
+input_file: minijinja/tests/inputs/err_too_many_macro_args.txt
+---
+!!!ERROR!!!
+
+Error {
+    kind: TooManyArguments,
+    name: "err_too_many_macro_args.txt",
+    line: 4,
+}
+
+too many arguments (in err_too_many_macro_args.txt:4)
+------------------------- err_too_many_macro_args.txt -------------------------
+   1 | {% macro two_args(a, b) %}
+   2 |   {{ a }} and {{ b }}
+   3 | {% endmacro %}
+   4 > {{ two_args(1, 2, 3) }}
+     i    ^^^^^^^^^^^^^^^^^ too many arguments
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Referenced variables: {
+    a: Undefined,
+    b: Undefined,
+    two_args: <macro two_args>,
+}
+-------------------------------------------------------------------------------
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@err_too_many_macro_kwargs.txt.snap b/minijinja/tests/snapshots/test_templates__vm@err_too_many_macro_kwargs.txt.snap
new file mode 100644
index 00000000..e910780b
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@err_too_many_macro_kwargs.txt.snap
@@ -0,0 +1,30 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{% macro two_args(a, b) %}\n  {{ a }} and {{ b }}\n{% endmacro %}\n{{ two_args(c=42) }}"
+info: {}
+input_file: minijinja/tests/inputs/err_too_many_macro_kwargs.txt
+---
+!!!ERROR!!!
+
+Error {
+    kind: TooManyArguments,
+    detail: "unknown keyword argument `c`",
+    name: "err_too_many_macro_kwargs.txt",
+    line: 4,
+}
+
+too many arguments: unknown keyword argument `c` (in err_too_many_macro_kwargs.txt:4)
+------------------------ err_too_many_macro_kwargs.txt ------------------------
+   1 | {% macro two_args(a, b) %}
+   2 |   {{ a }} and {{ b }}
+   3 | {% endmacro %}
+   4 > {{ two_args(c=42) }}
+     i    ^^^^^^^^^^^^^^ too many arguments
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Referenced variables: {
+    a: Undefined,
+    b: Undefined,
+    two_args: <macro two_args>,
+}
+-------------------------------------------------------------------------------
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@err_too_many_macro_kwargs2.txt.snap b/minijinja/tests/snapshots/test_templates__vm@err_too_many_macro_kwargs2.txt.snap
new file mode 100644
index 00000000..24573a2d
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@err_too_many_macro_kwargs2.txt.snap
@@ -0,0 +1,30 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{% macro two_args(a, b) %}\n  {{ a }} and {{ b }}\n{% endmacro %}\n{{ two_args(c=42, d=23) }}"
+info: {}
+input_file: minijinja/tests/inputs/err_too_many_macro_kwargs2.txt
+---
+!!!ERROR!!!
+
+Error {
+    kind: TooManyArguments,
+    detail: "unknown keyword argument `c`",
+    name: "err_too_many_macro_kwargs2.txt",
+    line: 4,
+}
+
+too many arguments: unknown keyword argument `c` (in err_too_many_macro_kwargs2.txt:4)
+----------------------- err_too_many_macro_kwargs2.txt ------------------------
+   1 | {% macro two_args(a, b) %}
+   2 |   {{ a }} and {{ b }}
+   3 | {% endmacro %}
+   4 > {{ two_args(c=42, d=23) }}
+     i    ^^^^^^^^^^^^^^^^^^^^ too many arguments
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Referenced variables: {
+    a: Undefined,
+    b: Undefined,
+    two_args: <macro two_args>,
+}
+-------------------------------------------------------------------------------
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@macro_basic.txt.snap b/minijinja/tests/snapshots/test_templates__vm@macro_basic.txt.snap
new file mode 100644
index 00000000..24071df3
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@macro_basic.txt.snap
@@ -0,0 +1,14 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{% macro add(a, b) %}{{ a }}|{{ b }}{% endmacro -%}\n{{ add(1, 2) }}\n{{ add(a=1, b=2) }}\n{{ add(b=2, a=1) }}\n{{ add(1, b=2) }}\n{{ add.name }}\n{{ add.arguments }}\n{{ add }}"
+info: {}
+input_file: minijinja/tests/inputs/macro_basic.txt
+---
+1|2
+1|2
+1|2
+1|2
+add
+["a", "b"]
+<macro add>
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@macro_calling_macro.txt.snap b/minijinja/tests/snapshots/test_templates__vm@macro_calling_macro.txt.snap
new file mode 100644
index 00000000..9ec147d0
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@macro_calling_macro.txt.snap
@@ -0,0 +1,8 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{%- from \"call_macro.txt\" import call %}\n{%- macro my_macro(value) %}[{{ value }}]{% endmacro %}\n{{- call(my_macro, 42) }}"
+info: {}
+input_file: minijinja/tests/inputs/macro_calling_macro.txt
+---
+[42]
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@macro_import.txt.snap b/minijinja/tests/snapshots/test_templates__vm@macro_import.txt.snap
new file mode 100644
index 00000000..387acd26
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@macro_import.txt.snap
@@ -0,0 +1,11 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{% from \"include_with_var_and_macro.txt\" import title, helper, missing -%}\nmissing: {{ missing }}\ntitle: {{ title }}\nhelper: {{ helper(\"a\", \"b\") }}"
+info:
+  c: The C Variable
+input_file: minijinja/tests/inputs/macro_import.txt
+---
+missing: 
+title: The Title
+helper: ["a", "b", "The C Variable"]
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@macro_import2.txt.snap b/minijinja/tests/snapshots/test_templates__vm@macro_import2.txt.snap
new file mode 100644
index 00000000..f28d7f92
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@macro_import2.txt.snap
@@ -0,0 +1,12 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{% import \"include_with_var_and_macro.txt\" as helpers -%}\n{{ helpers }}\nmissing: {{ helpers.missing }}\ntitle: {{ helpers.title }}\nhelper: {{ helpers.helper(\"a\", \"b\") }}"
+info:
+  c: The C Variable
+input_file: minijinja/tests/inputs/macro_import2.txt
+---
+{"helper": <macro helper>, "title": "The Title"}
+missing: 
+title: The Title
+helper: ["a", "b", "The C Variable"]
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@macro_include.txt.snap b/minijinja/tests/snapshots/test_templates__vm@macro_include.txt.snap
new file mode 100644
index 00000000..6f286522
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@macro_include.txt.snap
@@ -0,0 +1,10 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{%- include \"example_macro.txt\" %}\n{%- set d = \"should never show up\" %}\n{{ example(1, 2, 3) }}\n{{ example(1, 2) }}"
+info: {}
+input_file: minijinja/tests/inputs/macro_include.txt
+---
+
+[1, 2, 3, "closure"]
+[1, 2, "default", "closure"]
+
diff --git a/minijinja/tests/snapshots/test_templates__vm@macro_kwargs.txt.snap b/minijinja/tests/snapshots/test_templates__vm@macro_kwargs.txt.snap
new file mode 100644
index 00000000..9aca38c4
--- /dev/null
+++ b/minijinja/tests/snapshots/test_templates__vm@macro_kwargs.txt.snap
@@ -0,0 +1,11 @@
+---
+source: minijinja/tests/test_templates.rs
+description: "{% macro foo(a, b, c, d) %}{{ [a, b, c, d] }}{% endmacro -%}\n{{ foo(1, 2, 3) }}\n{{ foo({\"blub\": \"blah\"}) }}\n{{ foo(a=1, b=2, c=3) }}\n{{ foo(a=1, b=2, c=3, d=4) }}"
+info: {}
+input_file: minijinja/tests/inputs/macro_kwargs.txt
+---
+[1, 2, 3, Undefined]
+[{"blub": "blah"}, Undefined, Undefined, Undefined]
+[1, 2, 3, Undefined]
+[1, 2, 3, 4]
+
diff --git a/minijinja/tests/test_templates.rs b/minijinja/tests/test_templates.rs
index 2a17cfb8..10c4e720 100644
--- a/minijinja/tests/test_templates.rs
+++ b/minijinja/tests/test_templates.rs
@@ -36,26 +36,31 @@ fn test_vm() {
         }
 
         let content = iter.next().unwrap();
-        env.add_template(filename, content).unwrap();
-        let template = env.get_template(filename).unwrap();
-
-        let rendered = match template.render(&ctx) {
-            Ok(mut rendered) => {
-                rendered.push('\n');
-                rendered
-            }
-            Err(err) => {
-                let mut rendered = format!("!!!ERROR!!!\n\n{:#?}\n\n", err);
-
-                writeln!(rendered, "{:#}", err).unwrap();
-                let mut err = &err as &dyn std::error::Error;
-                while let Some(next_err) = err.source() {
-                    writeln!(rendered).unwrap();
-                    writeln!(rendered, "caused by: {:#}", next_err).unwrap();
-                    err = next_err;
+        let rendered = if let Err(err) = env.add_template(filename, content) {
+            let mut rendered = format!("!!!SYNTAX ERROR!!!\n\n{:#?}\n\n", err);
+            writeln!(rendered, "{:#}", err).unwrap();
+            rendered
+        } else {
+            let template = env.get_template(filename).unwrap();
+
+            match template.render(&ctx) {
+                Ok(mut rendered) => {
+                    rendered.push('\n');
+                    rendered
+                }
+                Err(err) => {
+                    let mut rendered = format!("!!!ERROR!!!\n\n{:#?}\n\n", err);
+
+                    writeln!(rendered, "{:#}", err).unwrap();
+                    let mut err = &err as &dyn std::error::Error;
+                    while let Some(next_err) = err.source() {
+                        writeln!(rendered).unwrap();
+                        writeln!(rendered, "caused by: {:#}", next_err).unwrap();
+                        err = next_err;
+                    }
+
+                    rendered
                 }
-
-                rendered
             }
         };