diff --git a/docs/0.7/Get started.md.hbs b/docs/0.7/Get started.md.hbs
index 1249d40..119ec9b 100755
--- a/docs/0.7/Get started.md.hbs	
+++ b/docs/0.7/Get started.md.hbs	
@@ -4,7 +4,7 @@ title: Get started
 
 Welcome! These pages aim to provide all the information you need to master Ractive.
 
-If you see something wrong, out of date, or missing from this documentation, please [raise an issue on GitHub](https://github.com/ractivejs/docs.ractivejs.org/issues) or - even better - submit a pull request. Your fellow Ractive users will thank you!
+If you see something wrong, out of date, or missing from this documentation, please check out our {{{createLink 'Known issues, FAQs, and Tips' 'known issues and FAQs'}}}, [raise an issue on GitHub](https://github.com/ractivejs/docs.ractivejs.org/issues) or - even better - submit a pull request. Your fellow Ractive users will thank you!
 
 Using Ractive is very simple. An instance is created using `new Ractive({...})`
 with the desired options:
diff --git a/docs/edge/Tips.md.hbs b/docs/0.7/Known issues, FAQs, and Tips.md.hbs
similarity index 65%
rename from docs/edge/Tips.md.hbs
rename to docs/0.7/Known issues, FAQs, and Tips.md.hbs
index 2fde34a..e8dfc43 100644
--- a/docs/edge/Tips.md.hbs
+++ b/docs/0.7/Known issues, FAQs, and Tips.md.hbs	
@@ -1,8 +1,22 @@
 ---
-title: Tips
+title: Known issues, FAQs, and Tips
 ---
-Using Ractive with...
----------------------
+
+## Known Issues
+
+### Memory and crashing issues with Safari on iOS 9
+
+It seems that Apple has introduced some memory management _feature_ with Safari in iOS 9 that causes large templates to crash Safari during parsing. Fortunately, this can be worked around by splitting your templates into smaller partials or, more efficiently, by pre-parsing your templates and serving them as a JS object. You can use {{{createLink 'Ractive.parse()'}}} to create the JS object as a build step or when the page is being served.
+
+Since there isn't _really_ any browser for iOS other than Safari, all browser on iOS 9 are affected by this issue. iOS 8 seems to remain unaffected.
+
+## FAQs
+
+__Coming Soon!™__
+
+## Tips
+
+### Using Ractive with...
 
 * {{{createLink 'using-ractive-with-backbone' '...Backbone'}}}
 * {{{createLink 'using-ractive-with-requirejs' '...RequireJS'}}}
@@ -12,8 +26,7 @@ Using Ractive with...
 * {{{createLink 'using-ractive-with-jquery-mobile' '...jQuery Mobile'}}}
 <!-- TODO * [...Underscore (and other utility libraries)](using-ractive-with-underscore) -->
 
-Building an app with Ractive
-----------------------------
+### Building an app with Ractive
 
 Ractive can take care of your UI, and for simple applications it can take care of your *application state* as well. But if you're building a complex app you'll likely have other things to worry about as well - routing and history management, fetching and saving data to and from a server, validating data, handling realtime communication, user authentication, and all the other fun stuff that goes into a web app.
 
diff --git a/docs/0.7/Tips.md.hbs b/docs/0.7/Tips.md.hbs
index 2fde34a..5e9b446 100644
--- a/docs/0.7/Tips.md.hbs
+++ b/docs/0.7/Tips.md.hbs
@@ -1,8 +1,22 @@
 ---
-title: Tips
+title: Known issues, FAQs, and Tips
 ---
-Using Ractive with...
----------------------
+
+## Known Issues
+
+### Memory and crashing issues with Safari on iOS 9
+
+It seems that Apple has introduced some memory management _feature_ with Safari in iOS 9 that causes large templates to crash Safari during parsing. Fortunately, this can be worked around by splitting your templates into smaller partials or, more efficiently, by pre-parsing your templates and serving them as a JS object. You can use {{{createLink 'Ractive.parse()'}}} to create the JS object as a build step or when the page is being served.
+
+iOS 8 seems to remain unaffected.
+
+## FAQs
+
+__Coming Soon!&tmp;__
+
+## Tips
+
+### Using Ractive with...
 
 * {{{createLink 'using-ractive-with-backbone' '...Backbone'}}}
 * {{{createLink 'using-ractive-with-requirejs' '...RequireJS'}}}
@@ -12,8 +26,7 @@ Using Ractive with...
 * {{{createLink 'using-ractive-with-jquery-mobile' '...jQuery Mobile'}}}
 <!-- TODO * [...Underscore (and other utility libraries)](using-ractive-with-underscore) -->
 
-Building an app with Ractive
-----------------------------
+### Building an app with Ractive
 
 Ractive can take care of your UI, and for simple applications it can take care of your *application state* as well. But if you're building a complex app you'll likely have other things to worry about as well - routing and history management, fetching and saving data to and from a server, validating data, handling realtime communication, user authentication, and all the other fun stuff that goes into a web app.
 
diff --git a/docs/edge/Get started.md.hbs b/docs/edge/Get started.md.hbs
index 9d506ed..26f99da 100755
--- a/docs/edge/Get started.md.hbs	
+++ b/docs/edge/Get started.md.hbs	
@@ -4,7 +4,7 @@ title: Get started
 
 Welcome! These pages aim to provide all the information you need to master Ractive.
 
-If you see something wrong, out of date, or missing from this documentation, please [raise an issue on GitHub](https://github.com/ractivejs/docs.ractivejs.org/issues) or - even better - submit a pull request. Your fellow Ractive users will thank you!
+If you see something wrong, out of date, or missing from this documentation, please check out our {{{createLink 'Known issues, FAQs, and Tips' 'known issues and FAQs'}}}, [raise an issue on GitHub](https://github.com/ractivejs/docs.ractivejs.org/issues) or - even better - submit a pull request. Your fellow Ractive users will thank you!
 
 Using Ractive is very simple. An instance is created using `new Ractive({...})`
 with the desired options:
diff --git a/docs/edge/Keypaths.md.hbs b/docs/edge/Keypaths.md.hbs
index fc4a23b..93c9f88 100644
--- a/docs/edge/Keypaths.md.hbs
+++ b/docs/edge/Keypaths.md.hbs
@@ -66,4 +66,8 @@ ractive = new Ractive({
 });
 
 ractive.get( 'letters[0]' ); // returns undefined
-```
\ No newline at end of file
+```
+
+## Escaping
+
+While not ideal, sometimes properties of objects have `.`s in name e.g. `foo['bar.baz']`. Note that while numbers are supported in array notation, strings are not. To access a peypath with a literal `.` in one of the keys, you can escape it with a `\` e.g. `foo.bar\.baz`. Any keys accessible in the template will be unescaped, so if you're trying to use them with simple string concatenation to access a keypath with a `.` in it, you'll need to make sure you escape it first.
diff --git a/docs/edge/Known issues, FAQs, and Tips.md.hbs b/docs/edge/Known issues, FAQs, and Tips.md.hbs
new file mode 100644
index 0000000..e8dfc43
--- /dev/null
+++ b/docs/edge/Known issues, FAQs, and Tips.md.hbs	
@@ -0,0 +1,37 @@
+---
+title: Known issues, FAQs, and Tips
+---
+
+## Known Issues
+
+### Memory and crashing issues with Safari on iOS 9
+
+It seems that Apple has introduced some memory management _feature_ with Safari in iOS 9 that causes large templates to crash Safari during parsing. Fortunately, this can be worked around by splitting your templates into smaller partials or, more efficiently, by pre-parsing your templates and serving them as a JS object. You can use {{{createLink 'Ractive.parse()'}}} to create the JS object as a build step or when the page is being served.
+
+Since there isn't _really_ any browser for iOS other than Safari, all browser on iOS 9 are affected by this issue. iOS 8 seems to remain unaffected.
+
+## FAQs
+
+__Coming Soon!™__
+
+## Tips
+
+### Using Ractive with...
+
+* {{{createLink 'using-ractive-with-backbone' '...Backbone'}}}
+* {{{createLink 'using-ractive-with-requirejs' '...RequireJS'}}}
+* {{{createLink 'using-ractive-with-browserify' '...Browserify'}}}
+* {{{createLink 'using-ractive-with-yeoman' '...Yeoman'}}}
+* {{{createLink 'Promises' '...built-in Promise support'}}}
+* {{{createLink 'using-ractive-with-jquery-mobile' '...jQuery Mobile'}}}
+<!-- TODO * [...Underscore (and other utility libraries)](using-ractive-with-underscore) -->
+
+### Building an app with Ractive
+
+Ractive can take care of your UI, and for simple applications it can take care of your *application state* as well. But if you're building a complex app you'll likely have other things to worry about as well - routing and history management, fetching and saving data to and from a server, validating data, handling realtime communication, user authentication, and all the other fun stuff that goes into a web app.
+
+Unlike mega-frameworks like Angular and Ember, Ractive doesn't have an opinion about these things - you're encouraged to build your app from loosely coupled modules. It means you're not beholden to a particular framework's way of doing things, and you can swap out (for example) your routing library for something better later on, but it does mean that you're now responsible for making those decisions.
+
+This section is designed to help with that, by collecting tips and advice. If you think your experience can help other developers, please add it to the wiki!
+
+* {{{createLink 'Routing'}}}
diff --git a/docs/edge/Migrating.md.hbs b/docs/edge/Migrating.md.hbs
index 20e103a..e099ca7 100644
--- a/docs/edge/Migrating.md.hbs
+++ b/docs/edge/Migrating.md.hbs
@@ -8,10 +8,48 @@ These migration notes are cribbed from the [CHANGELOG](https://github.com/ractiv
 
 ### What's new
 
-*Nothing yet*
+Ractive's data handling has been completely rewritten to use a full viewmodel hierarchy as opposed to the previous hashmap-like implementation. This has made the code much easier to reason about, and it should also eliminate many data-related bugs. It also has made large swaths of Ractive considerably faster.
+
+Spread arguments (`...arguments`) and `arguments` access is now available for method event handlers. Individual arguments are available using array notation (`arguments[n]`), dot notation (`arguments.0`), or `1`-based dollar vars, like regular expression matches (`$1`, `$2`, etc).
+
+There is now support for linking data to extra keypaths in the model. This is particularly handy for master-detail scenarios where you have a complex list of objects and you want to focus on a single one at a time. A keypath like `'foo.bar.bazzes.0'` can be linked to `'baz'` so that the detail section doesn't have to worry about a non-bindable expressions or copying objects around. Both sides of the link are automatically kept in sync. See {{{createLink 'ractive.link()'}}}.
+
+You can now use ES2015 object literal shorthand in templates e.g. `{ foo }` is equivalent to `{ foo: foo }`.
+
+If you have object keys with `.`s in them, you can now escape them with a `\`. So if you have a `bar` object with a `foo.baz` property, it can be accessed with `bar.foo\.baz`. Keypaths in the template are given as escaped paths so that they can be used directly with Ractive methods. There are also a few new static methods on `Ractive` to deal with escaping, unescaping, splitting, and joining keypaths.
+
+`<textarea>`s now handle HTML content as plain text to match what happens in browsers. They can now also set up two-way binding with a single interpolator as content instead of using the value attribute e.g. `<textarea>\{{someBinding}}</textarea>` is equivalent to `<textarea value="\{{someBinding}}"></textarea>`.
+
+Progressive enhancement is now supported with a few limitations. If you pass `enhance: true` when creating your Ractive instance, it will not discard the contents of its target element and will instead try to reuse elements and nodes as it builds the virtual DOM from its template. This option is incompatible with the `append` option.
+
+The `Object`, `String`, and `Boolean` globals are now accessible from within templates.
+
+You can now set up aliases with context and iterative mustache sections that can be used to clarify templates and avoid issues with object-literal context sections and two-way binding. For context sections, use `\{{#with someExpressionOrRef as alias1, some.deeply.nested[reference].expression as alias2}}...\{{/with}}` to set up as many aliases as you need. For iterative sections, you can alias the context with the iteration (the current item) by using `\{{#each some.list as item}}...\{{/each}}`. Partial contexts also support aliasing, since partial context is just a shortcut for `\{{#with context}}\{{>partial}}\{{/with}}`, as `\{{>somePartial some.path as alias1, some.other[expression](arg1, arg2) as alias2}}`.
+
+There is a new CSP-compatible parsing mode that collects all of the expressions in the template at the end of the parse and stores them as `function`s on the template root. At render-time, any expressions look for a corresponding pre-built function before using `new Function(...)` to create one. Templates parsed in this way are no longer JSON compatible. To enable this mode, pass `csp: true` when pre-parsing your template.
+
+If your environment supports it, you can now use Unicode characters from the Supplementary Multilingual Plane and the Supplemental Idiographic Plane in your templates.
+
+There are two new special references available on your templates for access to the current Ractive instance and your environment's global object. `@ractive` will resolve to the nearest Ractive instance in the template, which includes components should the template belong to one. `@global` resolves to `window` in most browsers and `global` in Node.js. Both special references are also available outside of the template so that Ractive can be notified of changes outside the template easily.
+
+Keywords can now be used as references, so you can now use `new`, `if`, `while`, etc as references.
+
+Keypaths within components are now adjusted to be relative to the component. If you need to access the path to the data relative to the root instance, you can use the new special reference `@rootpath`.
+
+Partials defined in `<script>` tags can now contain top-level inline partial definitions that will get added to the instance along with the scripte-defined partial.
+
+You can now retrieve the CSS for a Ractive instance with a new `toCSS` method. You can also get the CSS for all instances with a new static Ractive method of the same name.
 
 ### Breaking changes and deprecation
 
+* Names in partial mustaches have been further relaxed to allow `/`s. They can also now handle relative contexts because partial name expressions no longer support spaces around the `.` delimiters in object paths. `\{{> foo.bar.baz .bat}}` before this change would have parsed as a single expression to get the partial name from `foo.bar.baz.bat`. It will now get the name from `foo.bar.baz` and have a context provided from `.bat`.
+
+* Other elements are no longer allowed within `<option>` elements.
+
+* Integer literals in interpolators are now considered to be integer literal expressions rather than references. They were considered references before so that you could access array members by index within a context. If you need to access an array member within a context section, you can still do so with `\{{this.0}}`.
+
+* The private `_ractive` tracking data added to Ractive controlled DOM nodes has changed significantly. The format of `Ractive.getNodeInfo` objects is still compatible.
+
 * `\{{#with obj}}` to not render if `obj` is falsey (https://github.com/ractivejs/ractive/issues/1856)
 
 ## Migrating from 0.6.x
diff --git a/docs/edge/Mustaches.md.hbs b/docs/edge/Mustaches.md.hbs
index 34f5190..bb66959 100644
--- a/docs/edge/Mustaches.md.hbs
+++ b/docs/edge/Mustaches.md.hbs
@@ -473,58 +473,43 @@ In this example, clicking the button gets a "random" coin flip result, sets it i
 <a name="aliasing"></a>
 ### Aliasing
 
-Since a section with a non-falsy value uses the value as its context, an object expression can be used to create an arbitrary context within a section. Any currently visible context keypaths can be referenced within the new context object, which allows you to keep keypaths available that would otherwise be unreachable.
-
-```html
-\{{# { id: '10t' } }}
-  Error: \{{id}}
-\{{/}}
-```
-
-Output:
-```html
-Error: 10t
-```
-
-Using a section with an object expression to keep references accessible or convenient:
-
-```html
-<ul>
-\{{#things:outerIndex}}
-  \{{# { thing: ., i: outerIndex } }}
-    \{{#colors:j}}
-      <li>\{{i}}-\{{j}} \{{.}} \{{thing}}</li>
-    \{{/}}
-  \{{/}}
-\{{/}}
-</ul>
-```
-
-**Note** `i` as `outerIndex` is not required, `outerIndex` is still accessible within the `\{{#colors}}` section.
-
-Data:
+Any section (or `\{{#with}}` section) provides its own context to the template that falls within it, and any references within the section will be resolved against the section context. Ambiguous references are resolved up the model hierarchy _and_ the context hierarchy. Given a data structure that looks like
 ```js
 {
-  colors: ['Purple', 'Orange', 'Green'],
-  things: ['People-Eater', 'Orange', 'Hornet']
+  foo: {
+    baz: 99,
+    bar: {
+      baz: 42
+    }
+  },
+  list: [
+    baz: 198,
+    bar: {
+      baz: 84
+    }
+  ]
 }
 ```
-
-Output:
+and a template
 ```html
-<ul>
-  <li>0-0 Purple People-Eater</li>
-  <li>0-1 Orange People-Eater</li>
-  <li>0-2 Green People-Eater</li>
-  <li>1-0 Purple Orange</li>
-  <li>1-1 Orange Orange</li>
-  <li>1-2 Green Orange</li>
-  <li>2-0 Purple Hornet</li>
-  <li>2-1 Orange Hornet</li>
-  <li>2-2 Green Hornet</li>
-</ul>
+\{{#each list}}
+  explicit 1: \{{.bar.baz}}
+  \{{#with .bar}}
+    implicit 1: \{{baz}}
+    \{{#with ~/foo}}
+      explicit 2: \{{.bar.baz}}
+      implicit 2: \{{baz}}
+    \{{/with}}
+  \{{/with}}
+\{{/each}}
 ```
+there is no way to reference `~/list.0.baz` from the second implicit site because the site has a different context (`~/foo`) and using an ambiguous reference (`baz`) results in `~/foo.baz`  being used. Aliasing offers an escape hatch for similarly complex scenarios where ambiguity can cause the wrong reference to be used or performance issues to arise, because ambiguity is expensive.
+
+Alias block use the existing `\{{#with}}` mustache, but instead of setting a context, they set names for one or more keypaths. Aliases follow the form `destination as alias`, where destination is any valid reference at that point in the template e.g. `\{{#with .foo as myFoo, @key as someKey, 10 * @index + ~/offset as someCalculation, .baz.bat as lastOne}}`. Because plain reference aliases, like the `myFoo` and `lastOne` aliases in the example, refer to exactly one non-computed keypath, they can also be used for two-way binding deeper in the template. For example, `<input value="\{{myFoo}}" />` as a child of the alias block would bind to `.foo` in the context where the alias block is defined.
+
+Aliasing is also extended to `\{{#each}}` blocks so that the iterated item can be named rather than just referred to as `this` or `.`. For instance, `\{{#each list as item}}` would make `item` equivalent to `this` directly within the `each` block, but `item` would still refer to same value in further nested contexts. Index and key aliases can still be used with an aliased iteration e.g. `\{{#each object as item: key, index}}`.
 
+Finally, partials can also be used with alias shorthand in much the same way that they can be passed context e.g. `\{{>somePartial .foo.bar as myBar, 20 * @index + baz as myComp}}`.
 
 <a name="static"></a>
 ### Static mustaches
diff --git a/docs/edge/Overview.md.hbs b/docs/edge/Overview.md.hbs
new file mode 100644
index 0000000..df00031
--- /dev/null
+++ b/docs/edge/Overview.md.hbs
@@ -0,0 +1,83 @@
+---
+title: Overview
+---
+
+## Welcome!
+
+Thanks for swinging by to have a look at Ractive.js! This document is here to try to give you the slightly-closer-than-mile-high overview of what Ractive is and what it does while also providing links to more detailed sections of the documentation. Since you're here, you probably have a pretty good idea of what Ractive does, but in case you don't: Ractive is a relatively unopinionated library that makes creating interactive and reactive views for your data easy. Technically speaking, Ractive is a Model-View-Viewmodel library where you supply data for the Model and a template for the View, and Ractive handles the rest of it for you.
+
+## Init - or - getting an instance
+
+Before you can do anything with Ractive, you need to create a Ractive instance. There are a number of different ways to do so that will be addressed later, but the simplest is to use `new` and pass in whatever options you like. The most common options are `el`, `data`, and `template`. `el` is the target element on the page where your Ractive instance should render. It can be an actual reference to a DOM element or a CSS selector string. `data` and `template` will be addressed shortly, so for now, consider this to be the basis of all further mention of your Ractive instance: `var ractive = new Ractive({ el: '#someElement' });`.
+
+## Data - or - the Model
+
+There are two places that you can place your data in Ractive. Now, "your data" in this case is any JavaScript thing that you want it to be. You can stick to just JSON-compatible objects, or you can create heavy objects with methods, properties, and prototypes out of ES2015 classes, or anything in between and hand them to Ractive to use when binding a template. Data can be hierarchical, naturally, and Ractive uses keypaths to access parts or your data that are deeper than the root level. If you have special data, like Backbone models, Ractive allows you to supply adaptors that let it read and write whatever you may need.
+
+The first place for your data in Ractive is in a Ractive instance's data registry. Every Ractive instance has a data registry that defaults to an empty object `{}` and roughly correlates to the data that you pass to other templating libraries. Note that with more complex setups, as will be discussed further on, data can also be inherited from parent instances, so each data registry behaves somewhat as a prototype for any children it may have. The data registry is the default place that Ractive looks to resolve any keypaths you hand it, so it's the best place to store data that your templates will be binding to and working with. Anything that you can assign to a variable in JavaScript can be placed into a data registry, so primitives, objects, arrays, and even functions can be used as data in Ractive.
+
+The second place for your data is just about anywhere else. Ractive supports accessing properties of the Ractive instance and your environment's global object from both templates and API methods, so you can keep things like helper functions and other more globally scoped things outside of your data registry if you like. Note that Ractive won't know if you change anything outside of its data registry unless you tell it, so unless you use the Ractive API to make the change, you'll have to specifically tell Ractive what changed in order to have the changes propagate. That's why things that don't often change are better candidates for external storage than the data you work with directly in your templates.
+
+### Keypaths
+
+A keypath is simply a string of object keys separated by `.`s that is used to access some nested part of your data. If you had chunk of data that looked like `{ foo: { bar: { baz: 'hello' } } }`, the keypath to the `'hello'` string would be `'foo.bar.baz'`. If you happen to have object keys that contain a `.`, you can still use them in a keypath by escaping the `.` with a `\`. So switching out the `'baz'` key for `'bip.bop'`, the keypath would become `'foo.bar.bip\.bop'`.
+
+Keypaths and arrays are a slightly odd combination because normally you'd use `path.to.array[0]` to access the first element of the given array, but with Ractive, that keypath would be represented as `'path.to.array.0'`. Ractive will parse array-style paths, but they are always converted to dot notation.
+
+### Manipulation
+
+Once your data has been initialized, you generally should not modify it directly, because doing so will not notify your Ractive instance that your data has changed. To modify data, Ractive instances provide a `set` method that takes a keypath and a value and updates the targeted property in the data registry. If you had a chunk of data that looked like `{ foo: { bar: { baz: 'hello' } } }`, you could update the `'hello'` string with `ractive.set( 'foo.bar.baz', 'goodbye' )`. You can also use `get` to retrieve data at a given keypath e.g. `ractive.get( 'foo.bar.baz' )` after the set would return `'goodbye'`. `set` can also take a map of keypaths with values to update multiple keypaths in one operation e.g. `set({ 'foo.bar.baz': 'hello', 'foo.bar.bat': 'goodbye' })` would update `'foo.bar.baz'` and create a new property `'bat'` on `'foo.bar'`.
+
+There are also a number of helpful method supplied for interacting with data from your Ractive instance. `toggle` will take a truthy value at the given keypath and make it false and vice-versa. `add` will add the given number, which defaults to `1`, to the given keypath. `subtract` will subtract the given number, which also defaults to `1`, from the given keypath. `splice`, `shift`, `unshift`, `push`, and `pop` are special handlers that will perform the same operations as their JavaScript analogues, but in a more performant way with regards to the DOM updates that may go along with them.
+
+Any keypaths that don't exist when set will automatically have objects added as necessary to create them, so with an empty data registry, `set( 'foo.bar.baz', 'hello' )` will create an object `{ bar: { baz: 'hello' } }` and assign it to the `'foo'` property on the root of the registry. Similarly, `get`ting a keypath that doesn't exist will not throw, but will instead return `undefined`.
+
+Now that you have your data and know how to work with it, let's see what we can do with the view.
+
+## Templates - or - the View
+
+Ractive uses it's own flavor of Mustache with a strong influence from Handlebars as its template language because Mustache templates are fairly easy to grasp for anyone with any experience with HTML and any sort of templating. Unlike Mustache and Handlebars, Ractive does not operate on templates at the string level. Instead, it creates a virtual DOM from your template and uses it to keep the browser DOM in sync with your data. Since the templates aren't string-based, there are certain things that you can do with Mustaches that you can't do with Ractive, with the main one being conditionally closing one element and opening another. For instance `<div>Some stuff...\{{#if condition}}</div><div>\{{/if}}... some other stuff</div>` is not possible in Ractive because there's no way to represent an element that may become two elements in DOM. That's the main corner case that differentiates Ractive's Mustache flavor from others.
+
+### Interpolators
+
+The simplest interesting unit of template in Ractive is the interpolator, which takes some expression and renders it into the DOM. Ractive supports four distinct but closely related forms of interpolator that are differentiated by their mustache delimiters. Plain mustaches `\{{ ... }}` will safely render their content as a string, escaping any HTML out as entity references. Triple mustaches `\{{{ ... }}}` do the same except they do not escape any HTML in their content. Static mustaches `[[ ... ]]` behave like plain mustaches except that they only bind once, which means that they aren't kept up to date with their source data. Triple static mustaches `[[[ ... ]]]` don't escape HTML and only bind once.
+
+Mustache delimiters can be set globally using `Ractive.defaults`, per instance using an option, or inline in the template using the Mustache syntax e.g. `\{{=<% %>=}}` to use `<% ... %>` as a plain mustache. The option names for the various delimiters are	`delimiters` for plain mustaches, `tripleDelimiters` for triples, `staticDelimiters` for static mustaches, and `staticTripleDelimiters` for static triples. Values for each of those options should be an array with the start and end delimiter e.g. `[ '<%', '%>' ]`.
+
+### References
+
+To bind data into your template using an interpolator, you would use its keypath as a reference in the interpolator. If you had data that looked like `{ foo: { bar: { baz: 'world' } } }`, you could bind it into your template with `{{ foo.bar.baz }}`. Since `'foo.bar.baz'` is a keypath that resolves to data in your registry, and it is also a non-static mustache, any time you `set` `'foo.bar.baz'` in some way, the interpolator that references it will be updated.
+
+You can also use a variable in array notation to access keypaths dynamically using what Ractive calls a reference expression. Reference expressions look like `foo[bar].baz` in a template, where `'bar'` is a separate reference that should resolve to a key on `'foo'`. Any time `'bar'` or `'foo'` or the value at the combined keypath changes, the reference expression will be notified and update as well.
+
+### Expressions
+
+Beyond references, you can also use many valid JavaScript expressions in your templates to perform computations with your data. Among the support expressions are any literals (object, array, number, boolean, etc), function calls, ternary conditionals, and binary operators.
+
+#### Aliases
+
+### Conditionals
+
+### Iteration
+
+### Special references
+
+### Partials
+
+## Interactivity
+
+### Two-way binding
+
+### Events
+
+## More complex structures
+
+### Components
+
+### Decorators
+
+### Transitions
+
+## Deployment
+
+### Templates
diff --git a/docs/edge/Partials.md.hbs b/docs/edge/Partials.md.hbs
index 79a715d..b9bb170 100644
--- a/docs/edge/Partials.md.hbs
+++ b/docs/edge/Partials.md.hbs
@@ -198,10 +198,10 @@ Partials may be named with the same rules as any other identifier in Ractive or
 Partial sections may be given explicit context by adding an expression after the name in the form of `\{{>[name expression] [context expression]}}`. The partial will then be executed with the given context instead of the context in which the partial section appears. This has the same effect as wrapping the partial section in a `#with` section.
 
 ```html
-\{{#list}}\{{>somePartial { item: ., magicNumber: 42 }}}\{{/}}
+\{{#list}}\{{>somePartial .foo.bar }}\{{/}}
 ```
 
-In this example, `\{{item}}` in `somePartial` will resolve to the current item in `list` and `magicNumber` will resolve to `42`. Ancestor references, members, object literals, and any other expressions that resolve to an object may be used as a context expression.
+In this example, `\{{this}}` of `\{{.}}` in `somePartial` will resolve to the `.foo.bar` path of the current item in `list`. Ancestor references, members, object literals, and any other expressions that resolve to an object may be used as a context expression. Aliases may also be established for use in a partial e.g. `\{{>somePartial .foo.bar as item, 42 as magicNumber}}`, and in the case of `item`, as a plain referece, can still be used for two-way binding.
 
 
 <a name="recursion"></a>
diff --git a/docs/edge/Ractive.escapeKey().md.hbs b/docs/edge/Ractive.escapeKey().md.hbs
new file mode 100644
index 0000000..d02641b
--- /dev/null
+++ b/docs/edge/Ractive.escapeKey().md.hbs
@@ -0,0 +1,12 @@
+---
+title: Ractive.escapeKey()
+---
+
+Escapes the given key so that it can be concatenated with a keypath string e.g. `foo.bar` => `foo\.bar`.
+
+> ### Ractive.escapeKey( key )
+> Returns the properly escaped key.
+
+> > ### **key** *`String`*
+> > The key to escape.
+
diff --git a/docs/edge/Ractive.joinKeys().md.hbs b/docs/edge/Ractive.joinKeys().md.hbs
new file mode 100644
index 0000000..db409d4
--- /dev/null
+++ b/docs/edge/Ractive.joinKeys().md.hbs
@@ -0,0 +1,12 @@
+---
+title: Ractive.joinKeys()
+---
+
+Joins the given keys into a properly escaped keypath e.g. `Ractive.joinKeys( 'foo', 'bar.baz' )` => `'foo.bar\.baz'`.
+
+> ### Ractive.joinKeys( ...keys )
+> Returns the properly joined and escaped keypath.
+
+> > ### **keys** *`Strings`*
+> > The keys to join into an escaped keypath.
+
diff --git a/docs/edge/Ractive.splitKeypath().md.hbs b/docs/edge/Ractive.splitKeypath().md.hbs
new file mode 100644
index 0000000..4ea1659
--- /dev/null
+++ b/docs/edge/Ractive.splitKeypath().md.hbs
@@ -0,0 +1,13 @@
+---
+title: Ractive.splitKeypath()
+---
+
+Splits the given keypath into an array of unescaped keys e.g. `Ractive.splitKeypath( 'foo.bar\.baz' )` => `[ 'foo', 'bar.baz' ]`.
+
+> ### Ractive.splitKeypath( keypath )
+> Returns an array of unescaped keys.
+
+> > ### **keypath** *`String`*
+> > The keypath to split into keys.
+
+
diff --git a/docs/edge/Ractive.unescapeKey().md.hbs b/docs/edge/Ractive.unescapeKey().md.hbs
new file mode 100644
index 0000000..7d853bf
--- /dev/null
+++ b/docs/edge/Ractive.unescapeKey().md.hbs
@@ -0,0 +1,12 @@
+---
+title: Ractive.unescapeKey()
+---
+
+Unescapes the given key e.g. `foo\.bar` => `foo.bar`.
+
+> ### Ractive.unescapeKey( key )
+> Returns the properly unescaped key.
+
+> > ### **key** *`String`*
+> > The key to unescape.
+
diff --git a/docs/edge/References.md.hbs b/docs/edge/References.md.hbs
index 5ea5e79..fad94be 100644
--- a/docs/edge/References.md.hbs
+++ b/docs/edge/References.md.hbs
@@ -7,14 +7,15 @@ By themselves, references are useless - they must *resolve* to a *{{{createLink
 
 The resolution algorithm looks like this:
 
-1. If the context stack is empty, skip to (6).
-2. Find the innermost context on the current context stack.
-3. See if the keypath which is `context + '.' + reference` points to a value
-4. If so, resolve with that keypath
-5. Otherwise, remove the innermost context from the stack. Repeat (1-5).
-6. See if `reference` is a valid keypath by itself. If so, resolve.
-7. If we couldn't resolve the reference, add it to the 'pending resolution' pile. Each time the data changes, repeat steps (1-7).
-
+1. Is the reference a special ref? If so, resolve with the appropriate special keypath.
+2. If the reference is explicit or matches a path in the current context exactly, resolve with that keypath.
+3. Grab the current virtual node from the template hierarchy.
+4. If there are any aliases, index, or key mapping defined that match, resolve with that keypath.
+5. If this is a component and there are any matching mappings, resolve with that keypath.
+6. If this node has context and there is a matching path, resolve with that keypath.
+7. Otherwise, remove the innermost context from the stack. Repeat (3-7).
+8. See if `reference` is a valid keypath by itself. If so, resolve with that keypath.
+9. If the reference is still unresolved, add it to the 'pending resolution' pile. Each time potentially matching keypaths are updated, resolution will be attempted for the unresolved reference.
 
 ## Huh?
 
@@ -179,3 +180,20 @@ The above example could also use a root reference:
 </ul>
 ```
 
+## Special references
+
+There are a few things that can be useful to reference from the template that don't really exist in your data. For instance, the current iteration index of a repeated section. These special references can be used just like any other data reference, excepting two-way binding. Here's the list of specials and their resolutions:
+
+1. `@index` - the current iteration index of the containing repeated section e.g. `\{{#each list}}\{{@index}}\{{/each}}`
+2. `@key` - the current key name of the containing object iteration section e.g. `\{{#each someObj}}\{{@key}}\{{/each}}`
+3. `@keypath` - the keypath to the current context e.g. `foo.bar.baz` in `\{{#foo}}\{{#with bar.baz}}\{{@keypath}}\{{/with}}\{{/}}`. If the current context happens to be a mapping in a component, the keypath will be adjusted relative to the mapping.
+3. `@rootpath` - the same as keypath, except not adjusted for component mappings.
+4. `@global` - the current global object for this environment e.g. `window` in a browser or `global` in node. This reference can be used with two-way binding, but note that if something outside of Ractive changes a value, Ractive won't know unless you tell it to `update`.
+5. `@ractive` - the current Ractive instance e.g. the current component or the Ractive root. You can access any properties or methods available on a Ractive instance with this, and due to the way capture works, you can also use `@ractive.get('...')` in a binding and it will update with the target keypath.
+
+## Summary of prefixes
+
+* `~/` means at the current instance root.
+* `.` means the current context. When more path follows, it follows the path from the current context.
+* `../` means the parent of the current context and may also be stacked and have a following path.
+* `@` means this is a special reference that has meaning specified by where it exists in the template e.g. `@index` means the current iteration index of the containing repeated section.
diff --git a/docs/edge/ractive.link().md.hbs b/docs/edge/ractive.link().md.hbs
new file mode 100644
index 0000000..cd5574e
--- /dev/null
+++ b/docs/edge/ractive.link().md.hbs
@@ -0,0 +1,35 @@
+---
+title: ractive.link()
+---
+
+Creates a link between two {{{createLink 'keypath' 'keypaths'}}} that keeps them in sync. Since Ractive can't always watch the contents of objects, copying an object to two different keypaths in your data usually leads to one or both of them getting out of sync. `link` creates a sort of symlink between the two paths so that Ractive knows they are actually the same object. This is particularly useful for master/detail scenarios where you have a complex list of data and you want to be able to select an item to edit in a detail form.
+
+```js
+ractive.link( 'some.nested.0.list.25.item', 'current' );
+ractive.set( 'current.name', 'Rich' ); // some.nested.0.list.25.item.name is also updated to be 'Rich'
+```
+
+This can be used to great effect with method events and the `@keypath` special ref:
+```html
+\{{#each some.nested}}
+  \{{#each list}}
+    \{{#with item}}
+      \{{.name}}
+      <button on-click="link(@keypath, 'current')">Select</button>
+    \{{/with}}
+  \{{/each}}
+\{{/each}}
+
+Name: <input value="\{{~/current.name}}" />
+```
+
+> ### ractive.link( source, destination )
+> Returns a `Promise` (see {{{createLink 'Promises'}}})
+
+> > ### **source** *`String`*
+> > The keypath of the source item.
+
+> > ### **destination** *`String`*
+> > The keypath to use as the destination - or where you'd like the data 'copied'.
+
+Links can be removed using {{{createLink 'ractive.unlink()'}}}.
diff --git a/docs/edge/ractive.unlink.md.hbs b/docs/edge/ractive.unlink.md.hbs
new file mode 100644
index 0000000..b341f84
--- /dev/null
+++ b/docs/edge/ractive.unlink.md.hbs
@@ -0,0 +1,12 @@
+---
+title: ractive.unlink()
+---
+
+Removes a link set up by {{{createLink 'ractive.link()'}}}.
+
+> ### ractive.unlink( destination )
+> Returns a `Promise` (see {{{createLink 'Promises'}}})
+
+> > ### **destination** *`String`*
+> > The destination supplied to `link`.
+
diff --git a/package.json b/package.json
index 47302fb..b123f58 100644
--- a/package.json
+++ b/package.json
@@ -18,6 +18,7 @@
   "scripts": {
     "build": "grunt build",
     "predeploy": "npm run build",
-    "deploy": "surge build docs.ractivejs.org"
+    "deploy": "surge build docs.ractivejs.org",
+    "grunt": "./node_modules/.bin/grunt"
   }
 }
diff --git a/shared/scss/code.scss b/shared/scss/code.scss
index 40d0c9a..5f48804 100644
--- a/shared/scss/code.scss
+++ b/shared/scss/code.scss
@@ -45,7 +45,7 @@ code {
 	border: 1px solid #eee;
 	border-radius: 0.2em;
 	background-color: $light-green;
-	color: #444;
+	color: #000;
 	font-weight: normal;
 	font-size: 0.8em;
 	padding: 0.15em 0.3em;
@@ -57,7 +57,7 @@ pre code {
 	border: none;
 	border-radius: 0;
 	background-color: transparent;
-	color: inherit;
+	color: #000;
 	font-weight: inherit;
 	font-size: inherit;
 	padding: 0;
diff --git a/templates/0.7/partials/left-nav.md.hbs b/templates/0.7/partials/left-nav.md.hbs
index c403db8..6c84f0a 100644
--- a/templates/0.7/partials/left-nav.md.hbs
+++ b/templates/0.7/partials/left-nav.md.hbs
@@ -2,7 +2,7 @@
 	<h1>Introduction</h1>
 	<ul>
 		<li>{{{createLink 'Get started'}}}</li>
-		<li>{{{createLink 'Tips'}}}</li>
+		<li>{{{createLink 'Known issues, FAQs, and Tips'}}}</li>
 		<li>{{{createLink 'Get support'}}}</li>
 		<li>{{{createLink 'Contributing'}}}</li>
 		<li>{{{createLink 'Get started with node.js'}}}</li>
diff --git a/templates/edge/partials/left-nav.md.hbs b/templates/edge/partials/left-nav.md.hbs
index 44ee73c..4c6c288 100644
--- a/templates/edge/partials/left-nav.md.hbs
+++ b/templates/edge/partials/left-nav.md.hbs
@@ -2,12 +2,12 @@
 	<h1>Introduction</h1>
 	<ul>
 		<li>{{{createLink 'Get started'}}}</li>
-		<li>{{{createLink 'Tips'}}}</li>
+		<li>{{{createLink 'Overview'}}}</li>
+		<li>{{{createLink 'Known issues, FAQs, and Tips'}}}</li>
 		<li>{{{createLink 'Get support'}}}</li>
 		<li>{{{createLink 'Contributing'}}}</li>
 		<li>{{{createLink 'Get started with node.js'}}}</li>
 		<li>{{{createLink 'Migrating' 'Migrating from previous versions'}}}</li>
-		<li>{{{createLink 'CSP'}}}</li>
 	</ul>
 </section>
 
@@ -83,6 +83,7 @@
 		<li>{{{createLink 'ractive.fire()'}}}</li>
 		<li>{{{createLink 'ractive.get()'}}}</li>
 		<li>{{{createLink 'ractive.insert()'}}}</li>
+		<li>{{{createLink 'ractive.link()'}}}</li>
 		<li>{{{createLink 'ractive.merge()'}}}</li>
 		<li>{{{createLink 'ractive.observe()'}}}</li>
 		<li>{{{createLink 'ractive.observeOnce()'}}}</li>
@@ -101,6 +102,7 @@
 		<li>{{{createLink 'ractive.teardown()'}}}</li>
 		<li>{{{createLink 'ractive.toggle()'}}}</li>
 		<li>{{{createLink 'ractive.toHTML()'}}}</li>
+		<li>{{{createLink 'ractive.unlink()'}}}</li>
 		<li>{{{createLink 'ractive.unrender()'}}}</li>
 		<li>{{{createLink 'ractive.unshift()'}}}</li>
 		<li>{{{createLink 'ractive.update()'}}}</li>
@@ -117,9 +119,13 @@
 	</ul>
 	<h2>Static methods</h2>
 	<ul>
+		<li>{{{createLink 'Ractive.escapeKey()'}}}</li>
 		<li>{{{createLink 'Ractive.extend()'}}}</li>
 		<li>{{{createLink 'Ractive.getNodeInfo()'}}}</li>
+		<li>{{{createLink 'Ractive.joinKeys()'}}}</li>
 		<li>{{{createLink 'Ractive.parse()'}}}</li>
+		<li>{{{createLink 'Ractive.splitKeypath()'}}}</li>
+		<li>{{{createLink 'Ractive.unescapeKey()'}}}</li>
 	</ul>
 	<h2>Static properties</h2>
 	<ul>