diff --git a/examples/noop-tree-builder.rs b/examples/noop-tree-builder.rs
index c4336bb1..b2d18a9e 100644
--- a/examples/noop-tree-builder.rs
+++ b/examples/noop-tree-builder.rs
@@ -7,6 +7,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![cfg_attr(feature = "unstable", feature(plugin))]
+#![cfg_attr(feature = "unstable", plugin(string_cache_plugin))]
+
+#[macro_use]
 extern crate string_cache;
 extern crate tendril;
 extern crate html5ever;
@@ -31,7 +35,7 @@ struct Sink {
 impl Sink {
     fn get_id(&mut self) -> usize {
         let id = self.next_id;
-        self.next_id += 1;
+        self.next_id += 2;
         id
     }
 }
@@ -43,6 +47,14 @@ impl TreeSink for Sink {
         0
     }
 
+    fn get_template_contents(&self, target: usize) -> usize {
+        if let Some(&qualname!(HTML, template)) = self.names.get(&target) {
+            target + 1
+        } else {
+            panic!("not a template element")
+        }
+    }
+
     fn same_node(&self, x: usize, y: usize) -> bool {
         x == y
     }
diff --git a/examples/print-rcdom.rs b/examples/print-rcdom.rs
index 115794af..f4106204 100644
--- a/examples/print-rcdom.rs
+++ b/examples/print-rcdom.rs
@@ -44,7 +44,7 @@ fn walk(indent: usize, handle: Handle) {
         Comment(ref text)
             => println!("<!-- {} -->", escape_default(text)),
 
-        Element(ref name, ref attrs) => {
+        Element(ref name, _, ref attrs) => {
             assert!(name.ns == ns!(html));
             print!("<{}", name.local);
             for attr in attrs.iter() {
diff --git a/examples/print-tree-actions.rs b/examples/print-tree-actions.rs
index 9eebcc14..baf41e49 100644
--- a/examples/print-tree-actions.rs
+++ b/examples/print-tree-actions.rs
@@ -7,6 +7,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![cfg_attr(feature = "unstable", feature(plugin))]
+#![cfg_attr(feature = "unstable", plugin(string_cache_plugin))]
+
+#[macro_use]
 extern crate string_cache;
 extern crate tendril;
 extern crate html5ever;
@@ -31,7 +35,7 @@ struct Sink {
 impl Sink {
     fn get_id(&mut self) -> usize {
         let id = self.next_id;
-        self.next_id += 1;
+        self.next_id += 2;
         id
     }
 }
@@ -47,6 +51,14 @@ impl TreeSink for Sink {
         0
     }
 
+    fn get_template_contents(&self, target: usize) -> usize {
+        if let Some(&qualname!(HTML, template)) = self.names.get(&target) {
+            target + 1
+        } else {
+            panic!("not a template element")
+        }
+    }
+
     fn set_quirks_mode(&mut self, mode: QuirksMode) {
         println!("Set quirks mode to {:?}", mode);
     }
diff --git a/src/rcdom.rs b/src/rcdom.rs
index 667c75ae..c1fe5577 100644
--- a/src/rcdom.rs
+++ b/src/rcdom.rs
@@ -32,8 +32,21 @@ use serialize::TraversalScope;
 use serialize::TraversalScope::{IncludeNode, ChildrenOnly};
 use driver::ParseResult;
 
+pub use self::ElementEnum::{Normal, Script, Template};
 pub use self::NodeEnum::{Document, Doctype, Text, Comment, Element};
 
+/// The different kinds of elements in the DOM.
+#[derive(Debug)]
+pub enum ElementEnum {
+    Normal,
+    /// A script element and its "already started" flag.
+    /// https://html.spec.whatwg.org/multipage/#already-started
+    Script(bool),
+    /// A template element and its template contents.
+    /// https://html.spec.whatwg.org/multipage/#template-contents
+    Template(Handle),
+}
+
 /// The different kinds of nodes in the DOM.
 #[derive(Debug)]
 pub enum NodeEnum {
@@ -50,19 +63,15 @@ pub enum NodeEnum {
     Comment(StrTendril),
 
     /// An element with attributes.
-    Element(QualName, Vec<Attribute>),
+    Element(QualName, ElementEnum, Vec<Attribute>),
 }
 
 /// A DOM node.
+#[derive(Debug)]
 pub struct Node {
     pub node: NodeEnum,
     pub parent: Option<WeakHandle>,
     pub children: Vec<Handle>,
-
-    /// The "script already started" flag.
-    ///
-    /// Not meaningful for nodes other than HTML `<script>`.
-    pub script_already_started: bool,
 }
 
 impl Node {
@@ -71,13 +80,12 @@ impl Node {
             node: node,
             parent: None,
             children: vec!(),
-            script_already_started: false,
         }
     }
 }
 
 /// Reference to a DOM node.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Handle(Rc<RefCell<Node>>);
 
 impl Deref for Handle {
@@ -161,6 +169,14 @@ impl TreeSink for RcDom {
         self.document.clone()
     }
 
+    fn get_template_contents(&self, target: Handle) -> Handle {
+        if let Element(_, Template(ref contents), _) = target.borrow().node {
+            contents.clone()
+        } else {
+            panic!("not a template element!")
+        }
+    }
+
     fn set_quirks_mode(&mut self, mode: QuirksMode) {
         self.quirks_mode = mode;
     }
@@ -171,14 +187,20 @@ impl TreeSink for RcDom {
 
     fn elem_name(&self, target: Handle) -> QualName {
         // FIXME: rust-lang/rust#22252
-        return match target.borrow().node {
-            Element(ref name, _) => name.clone(),
-            _ => panic!("not an element!"),
-        };
+        if let Element(ref name, _, _) = target.borrow().node {
+            name.clone()
+        } else {
+            panic!("not an element!")
+        }
     }
 
     fn create_element(&mut self, name: QualName, attrs: Vec<Attribute>) -> Handle {
-        new_node(Element(name, attrs))
+        let info = match name {
+            qualname!(HTML, script) => Script(false),
+            qualname!(HTML, template) => Template(new_node(Document)),
+            _ => Normal,
+        };
+        new_node(Element(name, info, attrs))
     }
 
     fn create_comment(&mut self, text: StrTendril) -> Handle {
@@ -245,7 +267,7 @@ impl TreeSink for RcDom {
 
     fn add_attrs_if_missing(&mut self, target: Handle, attrs: Vec<Attribute>) {
         let mut node = target.borrow_mut();
-        let existing = if let Element(_, ref mut attrs) = node.deref_mut().node {
+        let existing = if let Element(_, _, ref mut attrs) = node.deref_mut().node {
             attrs
         } else {
             panic!("not an element")
@@ -274,8 +296,12 @@ impl TreeSink for RcDom {
         new_children.extend(mem::replace(children, Vec::new()).into_iter());
     }
 
-    fn mark_script_already_started(&mut self, node: Handle) {
-        node.borrow_mut().script_already_started = true;
+    fn mark_script_already_started(&mut self, target: Handle) {
+        if let Element(_, Script(ref mut script_already_started), _) = target.borrow_mut().node {
+            *script_already_started = true;
+        } else {
+            panic!("not a script element!");
+        }
     }
 }
 
@@ -302,7 +328,7 @@ impl Serializable for Handle {
                                   traversal_scope: TraversalScope) -> io::Result<()> {
         let node = self.borrow();
         match (traversal_scope, &node.node) {
-            (_, &Element(ref name, ref attrs)) => {
+            (_, &Element(ref name, _, ref attrs)) => {
                 if traversal_scope == IncludeNode {
                     try!(serializer.start_elem(name.clone(),
                         attrs.iter().map(|at| (&at.name, &at.value[..]))));
diff --git a/src/tree_builder/actions.rs b/src/tree_builder/actions.rs
index 69b601f9..2bc615a1 100644
--- a/src/tree_builder/actions.rs
+++ b/src/tree_builder/actions.rs
@@ -89,6 +89,7 @@ pub trait TreeBuilderActions<Handle> {
     fn in_scope_named<TagSet>(&self, scope: TagSet, name: Atom) -> bool where TagSet: Fn(QualName) -> bool;
     fn current_node_named(&self, name: Atom) -> bool;
     fn html_elem_named(&self, elem: Handle, name: Atom) -> bool;
+    fn in_html_elem_named(&self, name: Atom) -> bool;
     fn elem_in<TagSet>(&self, elem: Handle, set: TagSet) -> bool where TagSet: Fn(QualName) -> bool;
     fn in_scope<TagSet,Pred>(&self, scope: TagSet, pred: Pred) -> bool where TagSet: Fn(QualName) -> bool, Pred: Fn(Handle) -> bool;
     fn check_body_end(&mut self);
@@ -212,37 +213,37 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
         declare_tag_set!(foster_target = table tbody tfoot thead tr);
         let target = override_target.unwrap_or_else(|| self.current_node());
         if !(self.foster_parenting && self.elem_in(target.clone(), foster_target)) {
-            // No foster parenting (the common case).
-            return self.sink.append(target, child);
+            if self.html_elem_named(target.clone(), atom!(template)) {
+                // No foster parenting (inside template).
+                let contents = self.sink.get_template_contents(target);
+                self.sink.append(contents, child);
+            } else {
+                // No foster parenting (the common case).
+                self.sink.append(target, child);
+            }
+            return;
         }
 
         // Foster parenting
-        // FIXME: <template>
-        let last_table = self.open_elems.iter()
-            .enumerate()
-            .rev()
-            .filter(|&(_, e)| self.html_elem_named(e.clone(), atom!(table)))
-            .next();
-
-        match last_table {
-            None => {
-                let html_elem = self.html_elem();
-                self.sink.append(html_elem, child);
-            }
-            Some((idx, last_table)) => {
+        let mut iter = self.open_elems.iter().rev().peekable();
+        while let Some(elem) = iter.next() {
+            if self.html_elem_named(elem.clone(), atom!(template)) {
+                let contents = self.sink.get_template_contents(elem.clone());
+                self.sink.append(contents, child);
+                return;
+            } else if self.html_elem_named(elem.clone(), atom!(table)) {
                 // Try inserting "inside last table's parent node, immediately before last table"
-                match self.sink.append_before_sibling(last_table.clone(), child) {
-                    Ok(()) => (),
-
+                if let Err(child) = self.sink.append_before_sibling(elem.clone(), child) {
                     // If last_table has no parent, we regain ownership of the child.
                     // Insert "inside previous element, after its last child (if any)"
-                    Err(child) => {
-                        let previous_element = self.open_elems[idx-1].clone();
-                        self.sink.append(previous_element, child);
-                    }
+                    let previous_element = (*iter.peek().unwrap()).clone();
+                    self.sink.append(previous_element, child);
                 }
+                return;
             }
         }
+        let html_elem = self.html_elem();
+        self.sink.append(html_elem, child);
     }
 
     fn adoption_agency(&mut self, subject: Atom) {
@@ -563,6 +564,10 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
         self.sink.elem_name(elem) == QualName::new(ns!(HTML), name)
     }
 
+    fn in_html_elem_named(&self, name: Atom) -> bool {
+        self.open_elems.iter().any(|elem| self.html_elem_named(elem.clone(), name.clone()))
+    }
+
     fn current_node_named(&self, name: Atom) -> bool {
         self.html_elem_named(self.current_node(), name)
     }
@@ -691,15 +696,23 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
                 _ => continue,
             };
             match name {
-                // FIXME: <select> sub-steps
-                atom!(select) => return InSelect,
-
+                atom!(select) => {
+                    for ancestor in self.open_elems[0..i].iter().rev() {
+                        if self.html_elem_named(ancestor.clone(), atom!(template)) {
+                            return InSelect;
+                        } else if self.html_elem_named(ancestor.clone(), atom!(table)) {
+                            return InSelectInTable;
+                        }
+                    }
+                    return InSelect;
+                },
                 atom!(td) | atom!(th) => if !last { return InCell; },
                 atom!(tr) => return InRow,
                 atom!(tbody) | atom!(thead) | atom!(tfoot) => return InTableBody,
                 atom!(caption) => return InCaption,
                 atom!(colgroup) => return InColumnGroup,
                 atom!(table) => return InTable,
+                atom!(template) => return *self.template_modes.last().unwrap(),
                 atom!(head) => if !last { return InHead },
                 atom!(body) => return InBody,
                 atom!(frameset) => return InFrameset,
@@ -708,8 +721,6 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
                     Some(_) => return AfterHead,
                 },
 
-                atom!(template) => panic!("FIXME: <template> not implemented"),
-
                 _ => (),
             }
         }
diff --git a/src/tree_builder/interface.rs b/src/tree_builder/interface.rs
index 2f579544..81254c1b 100644
--- a/src/tree_builder/interface.rs
+++ b/src/tree_builder/interface.rs
@@ -59,6 +59,11 @@ pub trait TreeSink {
     /// Get a handle to the `Document` node.
     fn get_document(&mut self) -> Self::Handle;
 
+    /// Get a handle to a template's template contents. The tree builder
+    /// promises this will never be called with something else than
+    /// a template element.
+    fn get_template_contents(&self, target: Self::Handle) -> Self::Handle;
+
     /// Do two handles refer to the same node?
     fn same_node(&self, x: Self::Handle, y: Self::Handle) -> bool;
 
@@ -72,6 +77,12 @@ pub trait TreeSink {
     fn set_quirks_mode(&mut self, mode: QuirksMode);
 
     /// Create an element.
+    ///
+    /// When creating a template element (`name == qualname!(HTML, template)`),
+    /// an associated document fragment called the "template contents" should
+    /// also be created. Later calls to self.get_template_contents() with that
+    /// given element return it.
+    /// https://html.spec.whatwg.org/multipage/#htmltemplateelement
     fn create_element(&mut self, name: QualName, attrs: Vec<Attribute>) -> Self::Handle;
 
     /// Create a comment node.
diff --git a/src/tree_builder/rules.expanded.rs b/src/tree_builder/rules.expanded.rs
index 0d891794..e45d65e2 100644
--- a/src/tree_builder/rules.expanded.rs
+++ b/src/tree_builder/rules.expanded.rs
@@ -8,7 +8,7 @@
 // except according to those terms.
 
 // This file is generated from rules.rs
-// source SipHash: 11824921987729494326
+// source SipHash: 7583183069601139727
 
 # ! [
 doc =
@@ -239,7 +239,7 @@ impl <Handle, Sink> TreeBuilderStep for super::TreeBuilder<Handle, Sink> where
                                                 kind: ::tokenizer::EndTag,
                                                 name: atom!(template), .. })
                 => {
-                    if !self.in_scope_named(default_scope, atom!(template)) {
+                    if !self.in_html_elem_named(atom!(template)) {
                         self.unexpected(&tag);
                     } else {
                         self.generate_implied_end(thorough_implied_end);
@@ -464,8 +464,10 @@ impl <Handle, Sink> TreeBuilderStep for super::TreeBuilder<Handle, Sink> where
                                                 kind: ::tokenizer::StartTag,
                                                 name: atom!(html), .. }) => {
                     self.unexpected(&tag);
-                    let top = self.html_elem();
-                    self.sink.add_attrs_if_missing(top, tag.attrs);
+                    if !self.in_html_elem_named(atom!(template)) {
+                        let top = self.html_elem();
+                        self.sink.add_attrs_if_missing(top, tag.attrs);
+                    }
                     Done
                 }
                 ::tree_builder::types::TagToken(::tokenizer::Tag {
@@ -509,11 +511,14 @@ impl <Handle, Sink> TreeBuilderStep for super::TreeBuilder<Handle, Sink> where
                                                 name: atom!(body), .. }) => {
                     self.unexpected(&tag);
                     match self.body_elem() {
-                        None => (),
-                        Some(node) => {
+                        Some(ref node) if
+                        self.open_elems.len() != 1 &&
+                            !self.in_html_elem_named(atom!(template)) => {
                             self.frameset_ok = false;
-                            self.sink.add_attrs_if_missing(node, tag.attrs)
+                            self.sink.add_attrs_if_missing(node.clone(),
+                                                           tag.attrs)
                         }
+                        _ => { }
                     }
                     Done
                 }
@@ -534,7 +539,11 @@ impl <Handle, Sink> TreeBuilderStep for super::TreeBuilder<Handle, Sink> where
                     self.mode = InFrameset;
                     Done
                 }
-                EOFToken => { self.check_body_end(); self.stop_parsing() }
+                EOFToken => {
+                    if !self.template_modes.is_empty() {
+                        self.step(InTemplate, token)
+                    } else { self.check_body_end(); self.stop_parsing() }
+                }
                 ::tree_builder::types::TagToken(::tokenizer::Tag {
                                                 kind: ::tokenizer::EndTag,
                                                 name: atom!(body), .. }) => {
@@ -677,12 +686,15 @@ impl <Handle, Sink> TreeBuilderStep for super::TreeBuilder<Handle, Sink> where
                 ::tree_builder::types::TagToken(tag@::tokenizer::Tag {
                                                 kind: ::tokenizer::StartTag,
                                                 name: atom!(form), .. }) => {
-                    if self.form_elem.is_some() {
+                    if self.form_elem.is_some() &&
+                           !self.in_html_elem_named(atom!(template)) {
                         self.sink.parse_error(Borrowed("nested forms"));
                     } else {
                         self.close_p_element_in_button_scope();
                         let elem = self.insert_element_for(tag);
-                        self.form_elem = Some(elem);
+                        if !self.in_html_elem_named(atom!(template)) {
+                            self.form_elem = Some(elem);
+                        }
                     }
                     Done
                 }
@@ -840,26 +852,38 @@ impl <Handle, Sink> TreeBuilderStep for super::TreeBuilder<Handle, Sink> where
                 ::tree_builder::types::TagToken(::tokenizer::Tag {
                                                 kind: ::tokenizer::EndTag,
                                                 name: atom!(form), .. }) => {
-                    let node =
-                        match self.form_elem.take() {
-                            None => {
-                                self.sink.parse_error(Borrowed("Null form element pointer on </form>"));
-                                return Done;
-                            }
-                            Some(x) => x,
-                        };
-                    if !self.in_scope(default_scope,
-                                      |n|
-                                          self.sink.same_node(node.clone(),
-                                                              n)) {
-                        self.sink.parse_error(Borrowed("Form element not in scope on </form>"));
-                        return Done;
-                    }
-                    self.generate_implied_end(cursory_implied_end);
-                    let current = self.current_node();
-                    self.remove_from_stack(&node);
-                    if !self.sink.same_node(current, node) {
-                        self.sink.parse_error(Borrowed("Bad open element on </form>"));
+                    if !self.in_html_elem_named(atom!(template)) {
+                        let node =
+                            match self.form_elem.take() {
+                                None => {
+                                    self.sink.parse_error(Borrowed("Null form element pointer on </form>"));
+                                    return Done;
+                                }
+                                Some(x) => x,
+                            };
+                        if !self.in_scope(default_scope,
+                                          |n|
+                                              self.sink.same_node(node.clone(),
+                                                                  n)) {
+                            self.sink.parse_error(Borrowed("Form element not in scope on </form>"));
+                            return Done;
+                        }
+                        self.generate_implied_end(cursory_implied_end);
+                        let current = self.current_node();
+                        self.remove_from_stack(&node);
+                        if !self.sink.same_node(current, node) {
+                            self.sink.parse_error(Borrowed("Bad open element on </form>"));
+                        }
+                    } else {
+                        if !self.in_scope_named(default_scope, atom!(form)) {
+                            self.sink.parse_error(Borrowed("Form element not in scope on </form>"));
+                            return Done;
+                        }
+                        self.generate_implied_end(cursory_implied_end);
+                        if !self.current_node_named(atom!(form)) {
+                            self.sink.parse_error(Borrowed("Bad open element on </form>"));
+                        }
+                        self.pop_until_named(atom!(form));
                     }
                     Done
                 }
@@ -1468,7 +1492,8 @@ impl <Handle, Sink> TreeBuilderStep for super::TreeBuilder<Handle, Sink> where
                                                 kind: ::tokenizer::StartTag,
                                                 name: atom!(form), .. }) => {
                     self.unexpected(&tag);
-                    if self.form_elem.is_none() {
+                    if !self.in_html_elem_named(atom!(template)) &&
+                           self.form_elem.is_none() {
                         self.form_elem =
                             Some(self.insert_and_pop_element_for(tag));
                     }
@@ -2139,11 +2164,117 @@ impl <Handle, Sink> TreeBuilderStep for super::TreeBuilder<Handle, Sink> where
                     }
                 }
             },
-            InTemplate => {
-                if self.opts.ignore_missing_rules {
-                    self.step(InBody, token)
-                } else { panic!("FIXME: <template> not implemented"); }
-            }
+            InTemplate =>
+            match token {
+                CharacterTokens(_, _) => self.step(InBody, token),
+                CommentToken(_) => self.step(InBody, token),
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(base), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(basefont), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(bgsound), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(link), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(meta), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(noframes), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(script), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(style), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(template), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(title), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::EndTag,
+                                                name: atom!(template), .. })
+                => {
+                    self.step(InHead, token)
+                }
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(caption), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(colgroup), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(tbody), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(tfoot), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(thead), .. }) => {
+                    self.template_modes.pop();
+                    self.template_modes.push(InTable);
+                    Reprocess(InTable, token)
+                }
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(col), .. }) => {
+                    self.template_modes.pop();
+                    self.template_modes.push(InColumnGroup);
+                    Reprocess(InColumnGroup, token)
+                }
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(tr), .. }) => {
+                    self.template_modes.pop();
+                    self.template_modes.push(InTableBody);
+                    Reprocess(InTableBody, token)
+                }
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(td), .. }) |
+                ::tree_builder::types::TagToken(::tokenizer::Tag {
+                                                kind: ::tokenizer::StartTag,
+                                                name: atom!(th), .. }) => {
+                    self.template_modes.pop();
+                    self.template_modes.push(InRow);
+                    Reprocess(InRow, token)
+                }
+                EOFToken => {
+                    if !self.in_html_elem_named(atom!(template)) {
+                        self.stop_parsing()
+                    } else {
+                        self.unexpected(&token);
+                        self.pop_until_named(atom!(template));
+                        self.clear_active_formatting_to_marker();
+                        self.template_modes.pop();
+                        self.mode = self.reset_insertion_mode();
+                        Reprocess(self.reset_insertion_mode(), token)
+                    }
+                }
+                last_arm_token => {
+                    let enable_wildcards =
+                        match last_arm_token { _ => true, };
+                    match (enable_wildcards, last_arm_token) {
+                        (true,
+                         ::tree_builder::types::TagToken(tag@::tokenizer::Tag {
+                                                         kind: ::tokenizer::StartTag,
+                                                         .. })) => {
+                            self.template_modes.pop();
+                            self.template_modes.push(InBody);
+                            Reprocess(InBody, TagToken(tag))
+                        }
+                        (_, token) => self.unexpected(&token),
+                    }
+                }
+            },
             AfterBody =>
             match token {
                 CharacterTokens(NotSplit, text) => SplitWhitespace(text),
diff --git a/src/tree_builder/rules.rs b/src/tree_builder/rules.rs
index d5cd0d7e..d96f1fb8 100644
--- a/src/tree_builder/rules.rs
+++ b/src/tree_builder/rules.rs
@@ -165,7 +165,7 @@ impl<Handle, Sink> TreeBuilderStep
                 }
 
                 tag @ </template> => {
-                    if !self.in_scope_named(default_scope, atom!(template)) {
+                    if !self.in_html_elem_named(atom!(template)) {
                         self.unexpected(&tag);
                     } else {
                         self.generate_implied_end(thorough_implied_end);
@@ -276,9 +276,10 @@ impl<Handle, Sink> TreeBuilderStep
 
                 tag @ <html> => {
                     self.unexpected(&tag);
-                    // FIXME: <template>
-                    let top = self.html_elem();
-                    self.sink.add_attrs_if_missing(top, tag.attrs);
+                    if !self.in_html_elem_named(atom!(template)) {
+                        let top = self.html_elem();
+                        self.sink.add_attrs_if_missing(top, tag.attrs);
+                    }
                     Done
                 }
 
@@ -289,13 +290,13 @@ impl<Handle, Sink> TreeBuilderStep
 
                 tag @ <body> => {
                     self.unexpected(&tag);
-                    // FIXME: <template>
                     match self.body_elem() {
-                        None => (),
-                        Some(node) => {
+                        Some(ref node) if self.open_elems.len() != 1 &&
+                                          !self.in_html_elem_named(atom!(template)) => {
                             self.frameset_ok = false;
-                            self.sink.add_attrs_if_missing(node, tag.attrs)
-                        }
+                            self.sink.add_attrs_if_missing(node.clone(), tag.attrs)
+                        },
+                        _ => {}
                     }
                     Done
                 }
@@ -320,9 +321,12 @@ impl<Handle, Sink> TreeBuilderStep
                 }
 
                 EOFToken => {
-                    // FIXME: <template>
-                    self.check_body_end();
-                    self.stop_parsing()
+                    if !self.template_modes.is_empty() {
+                        self.step(InTemplate, token)
+                    } else {
+                        self.check_body_end();
+                        self.stop_parsing()
+                    }
                 }
 
                 </body> => {
@@ -372,14 +376,15 @@ impl<Handle, Sink> TreeBuilderStep
                 }
 
                 tag @ <form> => {
-                    // FIXME: <template>
-                    if self.form_elem.is_some() {
+                    if self.form_elem.is_some() &&
+                       !self.in_html_elem_named(atom!(template)) {
                         self.sink.parse_error(Borrowed("nested forms"));
                     } else {
                         self.close_p_element_in_button_scope();
                         let elem = self.insert_element_for(tag);
-                        // FIXME: <template>
-                        self.form_elem = Some(elem);
+                        if !self.in_html_elem_named(atom!(template)) {
+                            self.form_elem = Some(elem);
+                        }
                     }
                     Done
                 }
@@ -454,25 +459,35 @@ impl<Handle, Sink> TreeBuilderStep
                 }
 
                 </form> => {
-                    // FIXME: <template>
-                    // Can't use unwrap_or_return!() due to rust-lang/rust#16617.
-                    let node = match self.form_elem.take() {
-                        None => {
-                            self.sink.parse_error(Borrowed("Null form element pointer on </form>"));
+                    if !self.in_html_elem_named(atom!(template)) {
+                        // Can't use unwrap_or_return!() due to rust-lang/rust#16617.
+                        let node = match self.form_elem.take() {
+                            None => {
+                                self.sink.parse_error(Borrowed("Null form element pointer on </form>"));
+                                return Done;
+                            }
+                            Some(x) => x,
+                        };
+                        if !self.in_scope(default_scope, |n| self.sink.same_node(node.clone(), n)) {
+                            self.sink.parse_error(Borrowed("Form element not in scope on </form>"));
                             return Done;
                         }
-                        Some(x) => x,
-                    };
-                    if !self.in_scope(default_scope,
-                        |n| self.sink.same_node(node.clone(), n)) {
-                        self.sink.parse_error(Borrowed("Form element not in scope on </form>"));
-                        return Done;
-                    }
-                    self.generate_implied_end(cursory_implied_end);
-                    let current = self.current_node();
-                    self.remove_from_stack(&node);
-                    if !self.sink.same_node(current, node) {
-                        self.sink.parse_error(Borrowed("Bad open element on </form>"));
+                        self.generate_implied_end(cursory_implied_end);
+                        let current = self.current_node();
+                        self.remove_from_stack(&node);
+                        if !self.sink.same_node(current, node) {
+                            self.sink.parse_error(Borrowed("Bad open element on </form>"));
+                        }
+                    } else {
+                        if !self.in_scope_named(default_scope, atom!(form)) {
+                            self.sink.parse_error(Borrowed("Form element not in scope on </form>"));
+                            return Done;
+                        }
+                        self.generate_implied_end(cursory_implied_end);
+                        if !self.current_node_named(atom!(form)) {
+                            self.sink.parse_error(Borrowed("Bad open element on </form>"));
+                        }
+                        self.pop_until_named(atom!(form));
                     }
                     Done
                 }
@@ -821,8 +836,7 @@ impl<Handle, Sink> TreeBuilderStep
 
                 tag @ <form> => {
                     self.unexpected(&tag);
-                    // FIXME: <template>
-                    if self.form_elem.is_none() {
+                    if !self.in_html_elem_named(atom!(template)) && self.form_elem.is_none() {
                         self.form_elem = Some(self.insert_and_pop_element_for(tag));
                     }
                     Done
@@ -1179,18 +1193,60 @@ impl<Handle, Sink> TreeBuilderStep
             }),
 
             //§ parsing-main-intemplate
-            InTemplate => {
-                // NB: Implementing <template> requires not just adding
-                // the InTemplate rules here, but also inserting various
-                // extra logic at other points noted throughout the
-                // parser.
-
-                if self.opts.ignore_missing_rules {
-                    self.step(InBody, token)
-                } else {
-                    panic!("FIXME: <template> not implemented");
+            InTemplate => match_token!(token {
+                CharacterTokens(_, _) => self.step(InBody, token),
+                CommentToken(_) => self.step(InBody, token),
+
+                <base> <basefont> <bgsound> <link> <meta> <noframes> <script>
+                <style> <template> <title> </template> => {
+                    self.step(InHead, token)
                 }
-            }
+
+                <caption> <colgroup> <tbody> <tfoot> <thead> => {
+                    self.template_modes.pop();
+                    self.template_modes.push(InTable);
+                    Reprocess(InTable, token)
+                }
+
+                <col> => {
+                    self.template_modes.pop();
+                    self.template_modes.push(InColumnGroup);
+                    Reprocess(InColumnGroup, token)
+                }
+
+                <tr> => {
+                    self.template_modes.pop();
+                    self.template_modes.push(InTableBody);
+                    Reprocess(InTableBody, token)
+                }
+
+                <td> <th> => {
+                    self.template_modes.pop();
+                    self.template_modes.push(InRow);
+                    Reprocess(InRow, token)
+                }
+
+                EOFToken => {
+                    if !self.in_html_elem_named(atom!(template)) {
+                        self.stop_parsing()
+                    } else {
+                        self.unexpected(&token);
+                        self.pop_until_named(atom!(template));
+                        self.clear_active_formatting_to_marker();
+                        self.template_modes.pop();
+                        self.mode = self.reset_insertion_mode();
+                        Reprocess(self.reset_insertion_mode(), token)
+                    }
+                }
+
+                tag @ <_> => {
+                    self.template_modes.pop();
+                    self.template_modes.push(InBody);
+                    Reprocess(InBody, TagToken(tag))
+                }
+
+                token => self.unexpected(&token),
+            }),
 
             //§ parsing-main-afterbody
             AfterBody => match_token!(token {
diff --git a/tests/tree_builder.rs b/tests/tree_builder.rs
index 2498223f..22a17145 100644
--- a/tests/tree_builder.rs
+++ b/tests/tree_builder.rs
@@ -31,7 +31,8 @@ use std::collections::{HashSet, HashMap};
 #[cfg(feature = "unstable")] use test::ShouldPanic::No;
 
 use html5ever::{parse, parse_fragment, one_input};
-use html5ever::rcdom::{Document, Doctype, Text, Comment, Element, RcDom, Handle};
+use html5ever::rcdom::{Comment, Document, Doctype, Element, Handle, RcDom};
+use html5ever::rcdom::{Template, Text};
 
 use string_cache::Atom;
 use tendril::StrTendril;
@@ -109,7 +110,7 @@ fn serialize(buf: &mut String, indent: usize, handle: Handle) {
             buf.push_str(" -->\n");
         }
 
-        Element(ref name, ref attrs) => {
+        Element(ref name, _, ref attrs) => {
             buf.push_str("<");
             match name.ns {
                 ns!(SVG) => buf.push_str("svg "),
@@ -141,11 +142,16 @@ fn serialize(buf: &mut String, indent: usize, handle: Handle) {
     for child in node.children.iter() {
         serialize(buf, indent+2, child.clone());
     }
-}
 
-// Ignore tests containing these strings; we don't support these features yet.
-static IGNORE_SUBSTRS: &'static [&'static str]
-    = &["<template"];
+    if let Element(_, Template(ref content), _) = node.node {
+        buf.push_str("|");
+        buf.push_str(&repeat(" ").take(indent+2).collect::<String>());
+        buf.push_str("content\n");
+        for child in &content.borrow().children {
+            serialize(buf, indent+4, child.clone());
+        }
+    }
+}
 
 #[cfg(feature = "unstable")]
 fn make_test(
@@ -165,8 +171,7 @@ fn make_test(
     let context = fields.get("document-fragment")
                         .map(|field| Atom::from_slice(field.trim_right_matches('\n')));
     let name = format!("tb: {}-{}", filename, idx);
-    let ignore = ignores.contains(&name)
-        || IGNORE_SUBSTRS.iter().any(|&ig| data.contains(ig));
+    let ignore = ignores.contains(&name);
 
     tests.push(TestDescAndFn {
         desc: TestDesc {