diff --git a/.gitignore b/.gitignore
index 9ed279d9d74a2..c95e0720d63b8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -89,3 +89,8 @@ build/
 i686-pc-mingw32/
 src/librustc/lib/llvmdeps.rs
 *.pot
+src/doc/documentation/tmp
+src/doc/documentation/output
+src/doc/documentation/public
+src/doc/documentation/*.log
+src/doc/documentation/target
\ No newline at end of file
diff --git a/src/doc/documentation/Gemfile b/src/doc/documentation/Gemfile
new file mode 100644
index 0000000000000..686c654a4e68b
--- /dev/null
+++ b/src/doc/documentation/Gemfile
@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+
+ruby '2.1.1'
+
+gem 'builder'
+gem 'coderay'
+gem 'kramdown'
+gem 'mime-types', '~> 1.16'
+gem 'nanoc'
+gem 'nokogiri', '~> 1.6.0'
+gem 'pygments.rb'
+gem 'rake', '~> 0.9.2'
+gem 'thin'
+gem 'yajl-ruby', '~> 0.8.2'
+gem 'pandoc-ruby'
+
+group :development do
+  gem 'adsf'
+  gem 'fssm'
+end
\ No newline at end of file
diff --git a/src/doc/documentation/Gemfile.lock b/src/doc/documentation/Gemfile.lock
new file mode 100644
index 0000000000000..8b21267eb6abd
--- /dev/null
+++ b/src/doc/documentation/Gemfile.lock
@@ -0,0 +1,53 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    adsf (1.2.0)
+      rack (>= 1.0.0)
+    blankslate (3.1.2)
+    builder (3.2.2)
+    coderay (1.1.0)
+    colored (1.2)
+    cri (2.6.0)
+      colored (~> 1.2)
+    daemons (1.1.9)
+    eventmachine (1.0.3)
+    ffi (1.0.11)
+    fssm (0.2.10)
+    kramdown (1.3.3)
+    mime-types (1.25.1)
+    mini_portile (0.6.0)
+    nanoc (3.6.11)
+      cri (~> 2.3)
+    nokogiri (1.6.2.1)
+      mini_portile (= 0.6.0)
+    pandoc-ruby (0.7.5)
+    pygments.rb (0.2.13)
+      rubypython (~> 0.5.3)
+    rack (1.5.2)
+    rake (0.9.6)
+    rubypython (0.5.3)
+      blankslate (>= 2.1.2.3)
+      ffi (~> 1.0.7)
+    thin (1.6.2)
+      daemons (>= 1.0.9)
+      eventmachine (>= 1.0.0)
+      rack (>= 1.0.0)
+    yajl-ruby (0.8.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  adsf
+  builder
+  coderay
+  fssm
+  kramdown
+  mime-types (~> 1.16)
+  nanoc
+  nokogiri (~> 1.6.0)
+  pandoc-ruby
+  pygments.rb
+  rake (~> 0.9.2)
+  thin
+  yajl-ruby (~> 0.8.2)
diff --git a/src/doc/documentation/Makefile b/src/doc/documentation/Makefile
new file mode 100644
index 0000000000000..5eb79d3af501f
--- /dev/null
+++ b/src/doc/documentation/Makefile
@@ -0,0 +1,27 @@
+RUSTC ?= rustc
+RUSTC_FLAGS ?=
+
+check: validator-build
+	./target/validator content/
+
+validator-build: validator/bin.rs
+	mkdir -p target
+	$(RUSTC) validator/bin.rs --out-dir target
+
+validator-clean:
+	@rm -rf target
+
+doc-build:
+	@nanoc
+
+doc-server:
+	@nanoc autocompile -p 3002 -H thin
+
+doc-clean:
+	@rm -rf ./tmp
+	@rm -rf ./public
+	@rm crash.log
+
+clean: validator-clean doc-clean
+
+.PHONY: validator-clean doc-clean doc-build doc-server
\ No newline at end of file
diff --git a/src/doc/documentation/Rules b/src/doc/documentation/Rules
new file mode 100644
index 0000000000000..24ed76e951545
--- /dev/null
+++ b/src/doc/documentation/Rules
@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+compile '/static/*' do
+end
+
+compile '*' do
+  filter :erb
+  filter :pandoc
+  filter :colorize_syntax, :default_colorizer => :pygmentsrb
+  layout item[:layout] || 'default'
+end
+
+route '/static/*' do
+  item.identifier[7..-2]
+end
+
+route '*' do
+  item.identifier + 'index.html'
+end
+
+layout '*', :erb
diff --git a/src/doc/documentation/content/getting-started.md b/src/doc/documentation/content/getting-started.md
new file mode 100644
index 0000000000000..5d57473ca44d3
--- /dev/null
+++ b/src/doc/documentation/content/getting-started.md
@@ -0,0 +1,38 @@
+---
+title: "Getting Started"
+---
+
+# Getting Started
+
+Let's go through the process of installing Rust on your system and being able to compile your first program.
+
+
+## Installation
+
+Head over to [Rust's homepage](http://www.rust-lang.org/) and download the nightly version of Rust for your operating system. This should be a simple, one-click install.
+
+## Using It
+
+Now that Rust is installed, you'll have access to the `rustc` executable. That's the Rust compiler.
+
+Let's create a new file called `hello_world.rs`. The Rust file extension, if you didn't know already, is `rs`.
+
+``` {.rust}
+// hello_world.rs
+fn main() {
+  println!("Hello World!");
+}
+```
+
+Now you can compile it with:
+
+```bash
+$ rustc hello_world.rs -o helloworld
+```
+
+Let's run the hello world program written in Rust:
+
+```
+$ ./helloworld
+Hello World!
+```
\ No newline at end of file
diff --git a/src/doc/documentation/content/index.md b/src/doc/documentation/content/index.md
new file mode 100644
index 0000000000000..95d4c79907fd9
--- /dev/null
+++ b/src/doc/documentation/content/index.md
@@ -0,0 +1,8 @@
+---
+title: "Rust Documentation"
+---
+
+# Rust Documentation
+
+* [Introduction](/introduction/)
+* [Getting Started](/getting-started/)
diff --git a/src/doc/documentation/content/introduction.md b/src/doc/documentation/content/introduction.md
new file mode 100644
index 0000000000000..4a828b9558d8f
--- /dev/null
+++ b/src/doc/documentation/content/introduction.md
@@ -0,0 +1,441 @@
+---
+title: A 30-minute Introduction to Rust
+
+---
+
+# A 30-minute Introduction to Rust
+
+Rust is a systems programming language that combines strong compile-time correctness guarantees with fast performance.
+It improves upon the ideas of other systems languages like C++
+by providing guaranteed memory safety (no crashes, no data races) and complete control over the lifecycle of memory.
+Strong memory guarantees make writing correct concurrent Rust code easier than in other languages.
+This tutorial will give you an idea of what Rust is like in about thirty minutes.
+It expects that you're at least vaguely familiar with a previous 'curly brace' language,
+but does not require prior experience with systems programming.
+The concepts are more important than the syntax,
+so don't worry if you don't get every last detail:
+the [tutorial](tutorial.html) can help you out with that later.
+
+Let's talk about the most important concept in Rust, "ownership,"
+and its implications on a task that programmers usually find very difficult: concurrency.
+
+## The power of ownership
+
+Ownership is central to Rust,
+and is the feature from which many of Rust's powerful capabilities are derived.
+"Ownership" refers to which parts of your code are allowed read,
+write, and ultimately release, memory.
+Let's start by looking at some C++ code:
+
+```cpp
+int* dangling(void)
+{
+    int i = 1234;
+    return &i;
+}
+
+int add_one(void)
+{
+    int* num = dangling();
+    return *num + 1;
+}
+```
+
+
+**Note: obviously this is very simple and non-idiomatic C++.
+You wouldn't write it in practice; it is for illustrative purposes.**
+
+This function allocates an integer on the stack,
+and stores it in a variable, `i`.
+It then returns a reference to the variable `i`.
+There's just one problem:
+stack memory becomes invalid when the function returns.
+This means that in the second line of `add_one`,
+`num` points to some garbage values,
+and we won't get the effect that we want.
+While this is a trivial example,
+it can happen quite often in C++ code.
+There's a similar problem when memory on the heap is allocated with `malloc` (or `new`),
+then freed with `free` (or `delete`),
+yet your code attempts to do something with the pointer to that memory.
+This problem is called a 'dangling pointer,'
+and it's not possible to write Rust code that has it.
+Let's try writing it in Rust:
+
+``` {.rust .dontcheck}
+fn dangling() -> &int {
+    let i = 1234;
+    return &i;
+}
+
+fn add_one() -> int {
+    let num = dangling();
+    return *num + 1;
+}
+
+fn main() {
+    add_one();
+}
+```
+
+
+Save this program as `dangling.rs`. When you try to compile this program with `rustc dangling.rs`, you'll get an interesting (and long) error message:
+
+```bash
+dangling.rs:3:12: 3:14 error: `i` does not live long enough
+dangling.rs:3     return &i;
+                         ^~
+dangling.rs:1:23: 4:2 note: reference must be valid for the anonymous lifetime #1 defined on the block at 1:22...
+dangling.rs:1 fn dangling() -> &int {
+dangling.rs:2     let i = 1234;
+dangling.rs:3     return &i;
+dangling.rs:4 }
+dangling.rs:1:23: 4:2 note: ...but borrowed value is only valid for the block at 1:22
+dangling.rs:1 fn dangling() -> &int {
+dangling.rs:2     let i = 1234;
+dangling.rs:3     return &i;
+dangling.rs:4 }
+error: aborting due to previous error
+```
+
+In order to fully understand this error message,
+we need to talk about what it means to "own" something.
+So for now,
+let's just accept that Rust will not allow us to write code with a dangling pointer,
+and we'll come back to this code once we understand ownership.
+
+Let's forget about programming for a second and talk about books.
+I like to read physical books,
+and sometimes I really like one and tell my friends they should read it.
+While I'm reading my book, I own it: the book is in my possession.
+When I loan the book out to someone else for a while, they "borrow" it from me.
+And when you borrow a book, it's yours for a certain period of time,
+and then you give it back to me, and I own it again. Right?
+
+This concept applies directly to Rust code as well:
+some code "owns" a particular pointer to memory.
+It's the sole owner of that pointer.
+It can also lend that memory out to some other code for a while:
+that code "borrows" the memory,
+and it borrows it for a precise period of time,
+called a "lifetime."
+
+That's all there is to it.
+That doesn't seem so hard, right?
+Let's go back to that error message:
+`error: 'i' does not live long enough`.
+We tried to loan out a particular variable, `i`,
+using a reference (the `&` operator) but Rust knew that the variable would be invalid after the function returns,
+and so it tells us that:
+`reference must be valid for the anonymous lifetime #1...`.
+Neat!
+
+That's a great example for stack memory,
+but what about heap memory?
+Rust has a second kind of pointer,
+an 'owned box',
+that you can create with the `box` operator.
+Check it out:
+
+``` {.rust .dontcheck}
+fn dangling() -> Box<int> {
+    let i = box 1234;
+    return i;
+}
+
+fn add_one() -> int {
+    let num = dangling();
+    return *num + 1;
+}
+```
+
+Now instead of a stack allocated `1234`,
+we have a heap allocated `box 1234`.
+Whereas `&` borrows a pointer to existing memory,
+creating an owned box allocates memory on the heap and places a value in it,
+giving you the sole pointer to that memory.
+You can roughly compare these two lines:
+
+``` {.rust .dontcheck}
+// Rust
+let i = box 1234;
+```
+
+```cpp
+// C++
+int *i = new int;
+*i = 1234;
+```
+
+Rust infers the correct type,
+allocates the correct amount of memory and sets it to the value you asked for.
+This means that it's impossible to allocate uninitialized memory:
+*Rust does not have the concept of null*.
+Hooray!
+There's one other difference between this line of Rust and the C++:
+The Rust compiler also figures out the lifetime of `i`,
+and then inserts a corresponding `free` call after it's invalid,
+like a destructor in C++.
+You get all of the benefits of manually allocated heap memory without having to do all the bookkeeping yourself.
+Furthermore, all of this checking is done at compile time,
+so there's no runtime overhead.
+You'll get (basically) the exact same code that you'd get if you wrote the correct C++,
+but it's impossible to write the incorrect version, thanks to the compiler.
+
+You've seen one way that ownership and borrowing are useful to prevent code that would normally be dangerous in a less-strict language,
+but let's talk about another: concurrency.
+
+## Owning concurrency
+
+Concurrency is an incredibly hot topic in the software world right now.
+It's always been an interesting area of study for computer scientists,
+but as usage of the Internet explodes,
+people are looking to improve the number of users a given service can handle.
+Concurrency is one way of achieving this goal.
+There is a pretty big drawback to concurrent code, though:
+it can be hard to reason about, because it is non-deterministic.
+There are a few different approaches to writing good concurrent code,
+but let's talk about how Rust's notions of ownership and lifetimes contribute to correct but concurrent code.
+
+First, let's go over a simple concurrency example.
+Rust makes it easy to create "tasks",
+otherwise known as "threads".
+Typically, tasks do not share memory but instead communicate amongst each other with 'channels', like this:
+
+``` {.rust}
+fn main() {
+    let numbers = ~[1,2,3];
+
+    let (tx, rx)  = channel();
+    tx.send(numbers);
+
+    spawn(proc() {
+        let numbers = rx.recv();
+        println!("{}", numbers[0]);
+    })
+}
+```
+
+In this example, we create a boxed array of numbers.
+We then make a 'channel',
+Rust's primary means of passing messages between tasks.
+The `channel` function returns two different ends of the channel:
+a `Sender` and `Receiver` (commonly abbreviated `tx` and `rx`).
+The `spawn` function spins up a new task,
+given a *heap allocated closure* to run.
+As you can see in the code,
+we call `tx.send()` from the original task,
+passing in our boxed array,
+and we call `rx.recv()` (short for 'receive') inside of the new task:
+values given to the `Sender` via the `send` method come out the other end via the `recv` method on the `Receiver`.
+
+Now here's the exciting part:
+because `numbers` is an owned type,
+when it is sent across the channel,
+it is actually *moved*,
+transferring ownership of `numbers` between tasks.
+This ownership transfer is *very fast* -
+in this case simply copying a pointer -
+while also ensuring that the original owning task cannot create data races by continuing to read or write to `numbers` in parallel with the new owner.
+
+To prove that Rust performs the ownership transfer,
+try to modify the previous example to continue using the variable `numbers`:
+
+``` {.rust .dontcheck}
+fn main() {
+    let numbers = ~[1,2,3];
+
+    let (tx, rx)  = channel();
+    tx.send(numbers);
+
+    spawn(proc() {
+        let numbers = rx.recv();
+        println!("{}", numbers[0]);
+    });
+
+    // Try to print a number from the original task
+    println!("{}", numbers[0]);
+}
+```
+
+This will result an error indicating that the value is no longer in scope:
+
+```bash
+concurrency.rs:12:20: 12:27 error: use of moved value: 'numbers'
+concurrency.rs:12     println!("{}", numbers[0]);
+                                     ^~~~~~~
+```
+
+Since only one task can own a boxed array at a time,
+if instead of distributing our `numbers` array to a single task we wanted to distribute it to many tasks,
+we would need to copy the array for each.
+Let's see an example that uses the `clone` method to create copies of the data:
+
+``` {.rust}
+fn main() {
+    let numbers = ~[1,2,3];
+
+    for num in range(0, 3) {
+        let (tx, rx)  = channel();
+        // Use "clone" to send a *copy* of the array
+        tx.send(numbers.clone());
+
+        spawn(proc() {
+            let numbers = rx.recv();
+            println!("{:d}", numbers[num as uint]);
+        });
+    }
+}
+```
+
+This is similar to the code we had before,
+except now we loop three times,
+making three tasks,
+and *cloning* `numbers` before sending it.
+
+However, if we're making a lot of tasks,
+or if our data is very large,
+creating a copy for each task requires a lot of work and a lot of extra memory for little benefit.
+In practice, we might not want to do this because of the cost.
+Enter `Arc`,
+an atomically reference counted box ("A.R.C." == "atomically reference counted").
+`Arc` is the most common way to *share* data between tasks.
+Here's some code:
+
+``` {.rust}
+extern crate sync;
+use sync::Arc;
+
+fn main() {
+    let numbers = ~[1,2,3];
+    let numbers = Arc::new(numbers);
+
+    for num in range(0, 3) {
+        let (tx, rx)  = channel();
+        tx.send(numbers.clone());
+
+        spawn(proc() {
+            let numbers = rx.recv();
+            println!("{:d}", numbers[num as uint]);
+        })
+    }
+}
+```
+
+This is almost exactly the same,
+except that this time `numbers` is first put into an `Arc`.
+`Arc::new` creates the `Arc`,
+`.clone()` makes another `Arc` that refers to the same contents.
+So we clone the `Arc` for each task,
+send that clone down the channel,
+and then use it to print out a number.
+Now instead of copying an entire array to send it to our multiple tasks we are just copying a pointer (the `Arc`) and *sharing* the array.
+
+How can this work though?
+Surely if we're sharing data then can't we cause data races if one task writes to the array while others read?
+
+Well, Rust is super-smart and will only let you put data into an `Arc` that is provably safe to share.
+In this case, it's safe to share the array *as long as it's immutable*,
+i.e. many tasks may read the data in parallel as long as none can write.
+So for this type and many others `Arc` will only give you an immutable view of the data.
+
+Arcs are great for immutable data,
+but what about mutable data?
+Shared mutable state is the bane of the concurrent programmer:
+you can use a mutex to protect shared mutable state,
+but if you forget to acquire the mutex, bad things can happen, including crashes.
+Rust provides mutexes but makes it impossible to use them in a way that subverts memory safety.
+
+Let's take the same example yet again,
+and modify it to mutate the shared state:
+
+``` {.rust}
+extern crate sync;
+use sync::{Arc, Mutex};
+
+fn main() {
+    let numbers = ~[1,2,3];
+    let numbers_lock = Arc::new(Mutex::new(numbers));
+
+    for num in range(0, 3) {
+        let (tx, rx)  = channel();
+        tx.send(numbers_lock.clone());
+
+        spawn(proc() {
+            let numbers_lock = rx.recv();
+
+            // Take the lock, along with exclusive access to the underlying array
+            let mut numbers = numbers_lock.lock();
+            numbers[num as uint] += 1;
+
+            println!("{}", numbers[num as uint]);
+
+            // When `numbers` goes out of scope the lock is dropped
+        })
+    }
+}
+```
+
+This example is starting to get more subtle,
+but it hints at the powerful composability of Rust's concurrent types.
+This time we've put our array of numbers inside a `Mutex` and then put *that* inside the `Arc`.
+Like immutable data,
+`Mutex`es are sharable,
+but unlike immutable data,
+data inside a `Mutex` may be mutated as long as the mutex is locked.
+
+The `lock` method here returns not your original array or a pointer thereof,
+but a `MutexGuard`,
+a type that is responsible for releasing the lock when it goes out of scope.
+This same `MutexGuard` can transparently be treated as if it were the value the `Mutex` contains,
+as you can see in the subsequent indexing operation that performs the mutation.
+
+OK, let's stop there before we get too deep.
+
+## A footnote: unsafe
+
+The Rust compiler and libraries are entirely written in Rust;
+we say that Rust is "self-hosting".
+If Rust makes it impossible to unsafely share data between threads,
+and Rust is written in Rust,
+then how does it implement concurrent types like `Arc` and `Mutex`?
+The answer: `unsafe`.
+
+You see, while the Rust compiler is very smart,
+and saves you from making mistakes you might normally make,
+it's not an artificial intelligence.
+Because we're smarter than the compiler -
+sometimes - we need to over-ride this safe behavior.
+For this purpose, Rust has an `unsafe` keyword.
+Within an `unsafe` block,
+Rust turns off many of its safety checks.
+If something bad happens to your program,
+you only have to audit what you've done inside `unsafe`,
+and not the entire program itself.
+
+If one of the major goals of Rust was safety,
+why allow that safety to be turned off?
+Well, there are really only three main reasons to do it:
+interfacing with external code,
+such as doing FFI into a C library;
+performance (in certain cases);
+and to provide a safe abstraction around operations that normally would not be safe.
+Our `Arc`s are an example of this last purpose.
+We can safely hand out multiple pointers to the contents of the `Arc`,
+because we are sure the data is safe to share.
+But the Rust compiler can't know that we've made these choices,
+so _inside_ the implementation of the Arcs,
+we use `unsafe` blocks to do (normally) dangerous things.
+But we expose a safe interface,
+which means that the `Arc`s are impossible to use incorrectly.
+
+This is how Rust's type system prevents you from making some of the mistakes that make concurrent programming difficult,
+yet get the efficiency of languages such as C++.
+
+## That's all, folks
+
+I hope that this taste of Rust has given you an idea if Rust is the right language for you.
+
+<div class="next">
+Next Up: [Getting Started](/getting-started/)
+</div>
diff --git a/src/doc/documentation/content/irc.md b/src/doc/documentation/content/irc.md
new file mode 100644
index 0000000000000..4cd6bbb41ed04
--- /dev/null
+++ b/src/doc/documentation/content/irc.md
@@ -0,0 +1,12 @@
+---
+title: "Rust IRC"
+---
+
+# IRC
+
+All Rust channels are on the mozilla irc network (`irc.mozilla.org`).
+
+* `#rust`
+* `#rust-gamedev`
+* `#rust-branding`
+* `#rust-internals`
\ No newline at end of file
diff --git a/src/doc/documentation/lib/default.rb b/src/doc/documentation/lib/default.rb
new file mode 100644
index 0000000000000..a4df0ccb71576
--- /dev/null
+++ b/src/doc/documentation/lib/default.rb
@@ -0,0 +1,2 @@
+# All files in the 'lib' directory will be loaded
+# before nanoc starts compiling.
diff --git a/src/doc/documentation/nanoc.yaml b/src/doc/documentation/nanoc.yaml
new file mode 100644
index 0000000000000..67fd9a5bd173f
--- /dev/null
+++ b/src/doc/documentation/nanoc.yaml
@@ -0,0 +1,62 @@
+# A list of file extensions that nanoc will consider to be textual rather than
+# binary. If an item with an extension not in this list is found,  the file
+# will be considered as binary.
+text_extensions: [ 'coffee', 'css', 'erb', 'haml', 'handlebars', 'hb', 'htm', 'html', 'js', 'less', 'markdown', 'md', 'ms', 'mustache', 'php', 'rb', 'sass', 'scss', 'txt', 'xhtml', 'xml' ]
+
+# The path to the directory where all generated files will be written to. This
+# can be an absolute path starting with a slash, but it can also be path
+# relative to the site directory.
+output_dir: public
+
+# A list of index filenames, i.e. names of files that will be served by a web
+# server when a directory is requested. Usually, index files are named
+# “index.html”, but depending on the web server, this may be something else,
+# such as “default.htm”. This list is used by nanoc to generate pretty URLs.
+index_filenames: [ 'index.html' ]
+
+# Whether or not to generate a diff of the compiled content when compiling a
+# site. The diff will contain the differences between the compiled content
+# before and after the last site compilation.
+enable_output_diff: false
+
+prune:
+  # Whether to automatically remove files not managed by nanoc from the output
+  # directory. For safety reasons, this is turned off by default.
+  auto_prune: false
+
+  # Which files and directories you want to exclude from pruning. If you version
+  # your output directory, you should probably exclude VCS directories such as
+  # .git, .svn etc.
+  exclude: [ '.git', '.hg', '.svn', 'CVS' ]
+
+# The data sources where nanoc loads its data from. This is an array of
+# hashes; each array element represents a single data source. By default,
+# there is only a single data source that reads data from the “content/” and
+# “layout/” directories in the site directory.
+data_sources:
+  -
+    # The type is the identifier of the data source. By default, this will be
+    # `filesystem_unified`.
+    type: filesystem_unified
+
+    # The path where items should be mounted (comparable to mount points in
+    # Unix-like systems). This is “/” by default, meaning that items will have
+    # “/” prefixed to their identifiers. If the items root were “/en/”
+    # instead, an item at content/about.html would have an identifier of
+    # “/en/about/” instead of just “/about/”.
+    items_root: /
+
+    # The path where layouts should be mounted. The layouts root behaves the
+    # same as the items root, but applies to layouts rather than items.
+    layouts_root: /
+
+    # Whether to allow periods in identifiers. When turned off, everything
+    # past the first period is considered to be the extension, and when
+    # turned on, only the characters past the last period are considered to
+    # be the extension. For example,  a file named “content/about.html.erb”
+    # will have the identifier “/about/” when turned off, but when turned on
+    # it will become “/about.html/” instead.
+    allow_periods_in_identifiers: false
+  -
+    type: static
+    items_root: /static
diff --git a/src/doc/documentation/static/css/index.css b/src/doc/documentation/static/css/index.css
new file mode 100644
index 0000000000000..fce4e1a3e94f3
--- /dev/null
+++ b/src/doc/documentation/static/css/index.css
@@ -0,0 +1,232 @@
+* {
+  margin: 0;
+  padding: 0;
+
+  font-family: Georgia, Palatino, serif;
+}
+
+body {
+  background: #fff;
+  font-size: 1.2rem;
+}
+
+a {
+  text-decoration: none;
+}
+
+strong {
+  font-weight: 600;
+  line-height: 1.7;
+  font-family: Arial;
+  color: #444;
+}
+
+a:link,
+a:visited {
+  color: #d8714d;
+}
+
+a:hover {
+  color: #f90;
+}
+
+.container {
+  position: relative;
+  width: 80%;
+  margin: 40px auto;
+}
+
+.container h1 {
+  color: #333;
+  font-weight: normal;
+  line-height: 40px;
+  border-bottom: 2px dashed #eee;
+  padding-bottom: 13px;
+  letter-spacing: -1px;
+}
+
+.container .content h2 {
+  font-size: 1.7rem;
+  color: #000;
+  font-weight: 500;
+  margin: 40px 0 25px 0;
+  border-bottom: 1px solid #eaeaea;
+  padding-bottom: 16px;
+}
+
+.container p {
+  font-size: 1.1rem;
+  margin: 20px 0;
+  line-height: 1.7;
+}
+
+.container ul, .container ol {
+  margin: 20px;
+}
+
+.container li {
+  font-size: 1rem;
+  line-height: 1.6;
+}
+
+.container .content ul li {
+  list-style-type: square;
+}
+
+.container .content {
+  margin-left: 260px;
+  min-width: 400px;
+}
+
+.sidebar {
+  position: fixed;
+  width: 200px;
+
+  padding: 20px 20px 0 0;
+
+  border-right: 1px solid #ccc;
+
+  text-align: right;
+}
+
+.sidebar h2 {
+  text-transform: uppercase;
+
+  font-size: 1rem;
+
+  color: #333;
+
+  letter-spacing: 1px;
+
+  line-height: 1.5;
+}
+
+.sidebar ul {
+  list-style: none;
+
+  margin: 20px 0;
+}
+
+.sidebar li {
+  list-style: none;
+  font-size: 1rem;
+  line-height: 1.6;
+}
+
+.next {
+  width: 70%;
+  background: #4d8bd8;
+  color: #fff;
+  padding: 20px;
+  border-radius: 6px;
+}
+
+.next a {
+  color: #fff;
+  padding-bottom: 3px;
+  border-bottom: 1px dashed #eee;
+}
+
+/* Code */
+code,
+pre {
+  font-family: 'Source Code Pro', monospace;
+}
+code {
+  border-radius: 3px;
+  background: #edf6fa;
+  padding: 2px 5px;
+  font-family: 'Source Code Pro', monospace;
+}
+
+pre {
+  display: block;
+  margin-top: 0;
+  margin-bottom: 1rem;
+  padding: 1rem;
+  line-height: 1.4;
+  white-space: pre;
+  white-space: pre-wrap;
+  word-break: break-all;
+  word-wrap: break-word;
+  background-color: #f9f9f9;
+}
+
+pre code {
+  padding: 0;
+  font-size: 1.1rem;
+  color: inherit;
+  background-color: transparent;
+}
+
+pre code span {
+  font-family: 'Source Code Pro', monospace;
+}
+
+.hll { background-color: #ffffcc }
+ /*{ background: #f0f3f3; }*/
+.c, .co { color: #999; } /* Comment */
+.err { color: #AA0000; background-color: #FFAAAA } /* Error */
+.k, .keyword, .kw { color: #4667d3; } /* Keyword */
+.o { color: #555555 } /* Operator */
+.n { color: #6c6c6c;} /* Variable */
+.cm { color: #999; font-style: italic } /* Comment.Multiline */
+.cp { color: #4b6688 } /* Comment.Preproc */
+.c1 { color: #999; } /* Comment.Single */
+.cs { color: #999; } /* Comment.Special */
+.gd { background-color: #FFCCCC; border: 1px solid #CC0000 } /* Generic.Deleted */
+.ge { font-style: italic } /* Generic.Emph */
+.gr { color: #FF0000 } /* Generic.Error */
+.gh { color: #003300; } /* Generic.Heading */
+.gi { background-color: #CCFFCC; border: 1px solid #00CC00 } /* Generic.Inserted */
+.go { color: #AAAAAA } /* Generic.Output */
+.gp { color: #000099; } /* Generic.Prompt */
+.gs { } /* Generic.Strong */
+.gu { color: #003300; } /* Generic.Subheading */
+.gt { color: #99CC66 } /* Generic.Traceback */
+.kc { color: #006699; } /* Keyword.Constant */
+.kd { color: #006699; } /* Keyword.Declaration */
+.kn { color: #006699; } /* Keyword.Namespace */
+.kp { color: #006699 } /* Keyword.Pseudo */
+.kr { color: #006699; } /* Keyword.Reserved */
+.kt, .predefined-type, .dt, .directive { color: #536bcf; } /* Keyword.Type */
+.m { color: #ed4e4e } /* Literal.Number */
+.s, .st { color: #d44950 } /* Literal.String */
+.na { color: #4f9fcf } /* Name.Attribute */
+.nb { color: #336666 } /* Name.Builtin */
+.nc { color: #00AA88; } /* Name.Class */
+.no { color: #336600 } /* Name.Constant */
+.nd { color: #9999FF } /* Name.Decorator */
+.ni { color: #999999; } /* Name.Entity */
+.ne { color: #CC0000; } /* Name.Exception */
+.nf { color: #8f4dd2; } /* Name.Function */
+.nl { color: #9999FF } /* Name.Label */
+.nn { color: #00CCFF; } /* Name.Namespace */
+.nt { color: #2f6f9f; } /* Name.Tag */
+.nv { color: #003333 } /* Name.Variable */
+.ow { color: #000000; } /* Operator.Word */
+.w { color: #bbbbbb } /* Text.Whitespace */
+.mf { color: #FF6600 } /* Literal.Number.Float */
+.mh { color: #FF6600 } /* Literal.Number.Hex */
+.mi, .integer, .dv { color: #ed4e4e } /* Literal.Number.Integer */
+.mo { color: #FF6600 } /* Literal.Number.Oct */
+.sb { color: #CC3300 } /* Literal.String.Backtick */
+.sc { color: #CC3300 } /* Literal.String.Char */
+.sd { color: #CC3300; font-style: italic } /* Literal.String.Doc */
+.s2 { color: #CC3300 } /* Literal.String.Double */
+.se { color: #CC3300; } /* Literal.String.Escape */
+.sh { color: #CC3300 } /* Literal.String.Heredoc */
+.si { color: #AA0000 } /* Literal.String.Interpol */
+.sx { color: #CC3300 } /* Literal.String.Other */
+.sr { color: #33AAAA } /* Literal.String.Regex */
+.s1 { color: #CC3300 } /* Literal.String.Single */
+.ss { color: #FFCC33 } /* Literal.String.Symbol */
+.bp { color: #336666 } /* Name.Builtin.Pseudo */
+.vc { color: #003333 } /* Name.Variable.Class */
+.vg { color: #003333 } /* Name.Variable.Global */
+.vi { color: #003333 } /* Name.Variable.Instance */
+.il { color: #FF6600 } /* Literal.Number.Integer.Long */
+
+.css .o,
+.css .o + .nt,
+.css .nt + .nt { color: #999; }
diff --git a/src/doc/documentation/validator/bin.rs b/src/doc/documentation/validator/bin.rs
new file mode 100644
index 0000000000000..9b9f737fb651e
--- /dev/null
+++ b/src/doc/documentation/validator/bin.rs
@@ -0,0 +1,172 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_id = "validator"]
+#![crate_type = "bin"]
+#![feature(phase)]
+#![allow(unused_must_use)]
+
+extern crate core;
+extern crate regex;
+extern crate native;
+#[phase(syntax)] extern crate regex_macros;
+
+use std::io::{TempDir, IoResult};
+use std::io::fs::File;
+use std::path::posix::Path;
+use std::io::process::{Process,ProcessConfig,ProcessOutput,InheritFd,CreatePipe};
+use regex::{Regex,Captures};
+use std::os;
+use std::io::fs;
+
+pub struct Compiler {
+    input: ~str,
+    args: Vec<~str>,
+    process: Option<Process>
+}
+
+impl Compiler {
+    pub fn new(input: ~str) -> Compiler {
+        Compiler {
+            input: input,
+            args: vec![],
+            process: None
+        }
+    }
+
+    pub fn config<'a>(&'a self) -> ProcessConfig<'a> {
+        let mut config = ProcessConfig::new();
+
+        config.program = "rustc";
+        config.args = self.args.as_slice();
+
+        config
+    }
+
+
+    pub fn exec(&mut self) -> Result<(), ~str>{
+        // Create a tmp directory to stash all the files.
+        let tmp = TempDir::new("exec_compiler").unwrap();
+
+        // Save the path to that directory.
+        let path = tmp.path();
+
+        // Join a path for the block.rs file.
+        let block_path = path.join("block.rs");
+
+        // Create a new file with the previous path.
+        let mut file = File::create(&block_path).unwrap();
+
+        match file.write(self.input.as_bytes()) {
+            Ok(r) => {},
+            Err(err) => fail!("Oops: {}", err)
+        }
+
+        let f = File::open(&block_path);
+
+        self.args.push(block_path.as_str().unwrap().to_owned());
+        self.args.push("--out-dir".to_owned());
+        self.args.push(path.as_str().unwrap().to_owned());
+
+        let mut config = self.config();
+
+        config.stdout = InheritFd(1);
+        config.stderr = InheritFd(2);
+
+        let mut process = Process::configure(config).unwrap();
+        let exit = process.wait().unwrap();
+
+        if exit.success() {
+            Ok(())
+        } else {
+            let msg = format!("Could not execute process `{}`", exit);
+            Err(msg)
+        }
+    }
+}
+
+pub struct Block<'a> {
+    file: &'a Path,
+    input: &'a str,
+    start: uint,
+    end: uint
+}
+
+impl<'a> Block<'a> {
+    pub fn new(file: &'a Path, input: &'a str, start: uint, end: uint) -> Block<'a> {
+        Block {
+            file: file,
+            input: input,
+            start: start,
+            end: end
+        }
+    }
+
+    pub fn compile(&self) -> Result<(), ~str> {
+        let mut compiler = Compiler::new(self.input.to_owned());
+        compiler.exec()
+    }
+}
+
+pub struct Page<'a, 'r, 't> {
+    input: ~str,
+    path: &'a Path,
+    blocks: Vec<Block<'a>>
+}
+
+impl<'a, 'r, 't> Page<'a, 'r, 't> {
+    pub fn new(path: &'a Path) -> Page<'a, 'r, 't> {
+        let mut file = File::open(path).unwrap();
+
+        Page {
+            input: file.read_to_str().unwrap(),
+            path: path,
+            blocks: Vec::new()
+        }
+    }
+
+    pub fn compile(&'t self, regex: &'r Regex) -> Result<uint, ~str> {
+        let mut iter = regex.captures_iter(self.input);
+        let mut count = 0;
+
+        for capture in iter {
+            count = count + 1;
+            let (start, end) = capture.pos(1).unwrap();
+            let block = Block::new(self.path, capture.at(1), start, end);
+            try!(block.compile());
+        }
+
+        Ok(count)
+    }
+}
+
+fn main() {
+    // Skip a line to not crowd things.
+    println!("");
+
+    let mut args  = os::args();
+    let dir       = args.pop().unwrap();
+    let dir_path  = Path::new(StrBuf::from_owned_str(dir));
+
+    let re = regex!(r"``` \{\.rust\}\n([^`]+)\n");
+
+    let mut files = fs::walk_dir(&dir_path).unwrap();
+
+    for file in files {
+        let page = Page::new(&file);
+        match page.compile(&re) {
+            Ok(count) => println!(
+                "Successfully compiled {} blocks from: {}", count,
+                file.display()
+            ),
+            Err(err) => fail!("{}", err)
+        }
+    }
+}
\ No newline at end of file