diff --git a/docs/concepts/schemas.md b/docs/concepts/schemas.md
deleted file mode 100644
index d46899052..000000000
--- a/docs/concepts/schemas.md
+++ /dev/null
@@ -1,36 +0,0 @@
-
-# Schemas
-
-Every Slate editor has a "schema" associated with it, which contains information about the structure of its content. It lets you specify how to render each different type of node. And for more advanced use cases it lets you enforce rules about what the content of the editor can and cannot be.
-
-
-## Rules
-
-Slate schemas are built up of a set of rules. Every rule has a few properties:
-
-```js
-{
-  match: Function || Object,
-  render: Component || Function || Object || String,
-  decorate: Function,
-  validate: Function || Object,
-  change: Function
-}
-```
-
-Each of the properties will add certain functionality to the schema. For example,
-
-
-## Matches
-
-For any schema rule to be applied, it has to match a node in the editor's content. The most basic way to do this is to match by `kind` and `type`. For example:
-
-```js
-
-
-
-## Components
-
-The most basic use of a schema is to define which React components should be rendered for each node in the editor. For example, you might want to
-
-```
diff --git a/docs/guides/changes.md b/docs/guides/changes.md
index 7ab1a8598..35991c14a 100644
--- a/docs/guides/changes.md
+++ b/docs/guides/changes.md
@@ -120,27 +120,24 @@ The `editor.change()` method will create a new [`Change`](../reference/slate/cha
 
 ### 3. From Schema Rules
 
-The third place you may perform change operations—for more complex use cases—is from inside a custom [rule](../references/slate/schema.md#rules) in your editor's [`Schema`](../references/slate/schema.md). For example...
+The third place you may perform change operations—for more complex use cases—is from inside a custom normalization rule in your editor's [`Schema`](../references/slate/schema.md). For example...
 
 ```js
 {
-  match(obj) {
-    return obj.kind == 'block' && obj.type == 'quote',
-  },
-  validate(quote) {
-    const invalidChildren = quote.nodes.filter(n => n.kind != 'block')
-    if (!invalidChildren.size) return
-    return invalidChildren
-  },
-  normalize(change, quote, invalidChildren) {
-    invalidChildren.forEach((node) => {
-      change.removeNodeByKey(node.key)
-    })
-  },
+  blocks: {
+    list: {
+      nodes: [{ types: ['item'] }],
+      normalize: (change, reason, context) => {
+        if (reason == 'child_type_invalid') {
+          change.wrapBlockByKey(context.child.key, 'item')
+        }
+      }
+    }
+  }
 }
 ```
 
-When a rule's validation fails, Slate passes a [`Change`](../reference/slate/change.md) object to the `normalize()` method on the rule. You can use this object to apply the changes necessary to make your document valid on the next normalization pass.
+When a rule's validation fails, Slate passes a [`Change`](../reference/slate/change.md) object to the `normalize` function of the rule, if one exists. You can use this object to apply the changes necessary to make your document valid on the next normalization pass.
 
 ### 4. From Outside Slate
 
diff --git a/docs/reference/slate-react/plugins.md b/docs/reference/slate-react/plugins.md
index df25a7ec0..457266f92 100644
--- a/docs/reference/slate-react/plugins.md
+++ b/docs/reference/slate-react/plugins.md
@@ -127,4 +127,4 @@ The `render` property allows you to define higher-order-component-like behavior.
 ### `schema`
 `Object`
 
-The `schema` property allows you to define a set of rules that will be added to the editor's schema. The rules from each of the schemas returned by the plugins are collected into a single schema for the editor, and the rules are applied in the same order as the plugin stack.
+The `schema` property allows you to define a set of rules that will be added to the editor's schema. The rules from each of the schemas returned by the plugins are collected into a single schema for the editor.
diff --git a/docs/reference/slate/schema.md b/docs/reference/slate/schema.md
index a8f1a2cd2..6c91d951a 100644
--- a/docs/reference/slate/schema.md
+++ b/docs/reference/slate/schema.md
@@ -1,189 +1,303 @@
 
 # `Schema`
 
-Every Slate editor has a "schema" associated with it, which contains information about the structure of its content. It lets you specify how to render each different type of node. And for more advanced use cases it lets you enforce rules about what the content of the editor can and cannot be.
+Every Slate editor has a "schema" associated with it, which contains information about the structure of its content. For the most basic cases, you'll just rely on Slate's default core schema. But for advanced use cases you can enforce rules about what the content of a Slate document can contain.
 
 
 ## Properties
 
 ```js
 {
-  nodes: Object,
-  marks: Object,
-  rules: Array
+  document: Object,
+  blocks: Object,
+  inlines: Object,
 }
 ```
 
-The top-level properties of a schema all give you a way to define `rules` that the schema enforces. The `nodes` and `marks` properties are just convenient ways to define the most common set of rules.
+The top-level properties of a schema all give you a way to define validation "rules" that the schema enforces.
 
-### `marks`
-`Object type: Component || Function || Object || String`
+### `document`
+`Object`
 
 ```js
 {
-  bold: props => <strong>{props.children}</strong>
-}
-```
-```js
-{
-  bold: {
-    fontWeight: 'bold'
-  }
-}
-```
-```js
-{
-  bold: 'my-bold-class-name'
-}
-```
-
-An object that defines the [`Marks`](./mark.md) in the schema by `type`. Each key in the object refers to a mark by its `type`. The value defines how Slate will render the mark, and can either be a React component, an object of styles, or a class name.
-
-### `nodes`
-`Object<type, Component || Function>` <br/>
-`Object<type, Rule>`
-
-```js
-{
-  quote: props => <blockquote {...props.attributes}>{props.children}</blockquote>
-}
-```
-```js
-{
-  code: {
-    render: props => <pre {...props.attributes}><code>{props.children}</code></pre>,
-    decorate: myCodeHighlighter
+  document: {
+    nodes: [{ types: ['paragraph'] }]
   }
 }
 ```
 
-An object that defines the [`Block`](./block.md) and [`Inline`](./inline.md) nodes in the schema by `type`. Each key in the object refers to a node by its `type`. The values defines how Slate will render the node, and can optionally define any other property of a schema `Rule`.
+A set of validation rules that apply to the top-level document.
 
-### `rules`
-`Array<Rule>`
+### `blocks`
+`Object`
 
 ```js
-[
-  {
-    match: { kind: 'block', type: 'code' },
-    render: props => <pre {...props.attributes}><code>{props.children}</code></pre>,
-    decorate: myCodeHighlighter
+{
+  blocks: {
+    list: {
+      nodes: [{ types: ['item'] }]
+    },
+    item: {
+      parent: { types: ['list'] }
+    },
   }
-]
+}
 ```
 
-An array of rules that define the schema's behavior. Each of the rules are evaluated in order to determine a match.
+A dictionary of blocks by type, each with its own set of validation rules.
 
-Internally, the `marks` and `nodes` properties of a schema are simply converted into `rules`.
+### `inlines`
+`Object`
+
+```js
+{
+  inlines: {
+    emoji: {
+      isVoid: true,
+      nodes: [{ kinds: ['text'] }]
+    },
+  }
+}
+```
+
+A dictionary of inlines by type, each with its own set of validation rules.
 
 
 ## Rule Properties
 
 ```js
 {
-  match: Function,
-  decorate: Function,
+  data: Object,
+  isVoid: Boolean,
+  nodes: Array,
   normalize: Function,
-  placeholder: Component || Function,
-  render: Component || Function || Object || String,
-  validate: Function
+  parent: Object,
+  text: RegExp,
 }
 ```
 
-Slate schemas are built up of a set of rules. Each of the properties will add certain functionality to the schema, based on the properties it defines. 
+Slate schemas are built up of a set of validation rules. Each of the properties will validate certain pieces of the document based on the properties it defines. 
 
-### `match`
-`Function match(object: Node || Mark)`
+### `data`
+`Object`
 
 ```js
 {
-  match: (object) => object.kind == 'block' && object.type == 'code'
-}
-```
-
-The `match` property is the only required property of a rule. It determines which objects the rule applies to. 
-
-### `decorate`
-`Function decorate(node: Node) => List<Range>|Array<Object>`
-
-```js
-{
-  decorate: (node) => {
-    const text = node.getFirstText()
-
-    return [{
-      anchorKey: text.key,
-      anchorOffset: 0,
-      focusKey: text.key,
-      focusOffset: 1,
-      marks: [{ type: 'bold' }]
-    }]
+  data: {
+    href: v => isUrl(v),
   }
 }
 ```
 
-The `decorate` property allows you define a function that will apply extra marks to ranges of text inside a node. It is called with a [`Node`](./node.md). It should return a list of [`Range`](./range.md) objects with the desired marks, which will then be added to the text before rendering.
+A dictionary of 
+
+### `isVoid`
+`Boolean`
+
+```js
+{
+  isVoid: true,
+}
+```
+
+Will validate a node's `isVoid` property.
+
+### `nodes`
+`Array`
+
+```js
+{
+  nodes: [
+    { types: ['image', 'video'], min: 1, max: 3 },
+    { types: ['paragraph'], min: 0 },
+  ]
+}
+```
+
+Will validate a node's children. The node definitions can declare the `kinds`, `types`, `min` and `max` properties.
 
 ### `normalize`
-`Function normalize(change: Change, object: Node, failure: Any) => Change`
+`normalize(change: Change, reason: String, context: Object) => Void`
 
 ```js
 {
-  normalize: (change, node, invalidChildren) => {
-    invalidChildren.forEach((child) => {
-      change.removeNodeByKey(child.key)
-    })
-
-    return change
+  normalize: (change, reason, context) => {
+    case 'child_kind_invalid':
+      change.wrapBlockByKey(context.child.key, 'paragraph')
+      return
+    case 'child_type_invalid':
+      change.setNodeByKey(context.child.key, 'paragraph')
+      return
   }
 }
 ```
 
-The `normalize` property is a function to run that recovers the editor's state after the `validate` property of a rule has determined that an object is invalid. It is passed a [`Change`](./change.md) that it can use to make modifications. It is also passed the return value of the `validate` function, which makes it easy to quickly determine the failure reason from the validation.
+A function that can be provided to override the default behavior in the case of a rule being invalid. By default Slate will do what it can, but since it doesn't know much about your schema, it will often remove invalid nodes. If you want to override this behavior, and "fix" the node instead of removing it, pass a custom `normalize` function.
 
-### `placeholder`
-`Component` <br/>
-`Function`
+For more information on the arguments passed to `normalize`, see the [Invalid Reasons](#invalid-reasons) reference.
+
+### `parent`
+`Array`
 
 ```js
 {
-  placeholder: (props) => <span>{props.editor.props.placeholder}</span>
+  parent: { types: ['list'] }
 }
 ```
 
-The `placeholder` property determines which React component Slate will use to render a placeholder for the editor.
+Will validate a node's parent. The parent definition can declare the `kinds` and/or `types` properties.
 
-### `render`
-`Component` <br/>
-`Function` <br/>
-`Object` <br/>
-`String`
+### `text`
+`Array`
 
 ```js
 {
-  render: (props) => <pre {...props.attributes}><code>{props.children}</code></pre>
+  text: /^\w+$/
 }
 ```
 
-The `render` property determines which React component Slate will use to render a [`Node`](./node.md) or [`Mark`](./mark.md). Mark renderers can also be defined as an object of styles or a class name string for convenience.
+Will validate a node's text.
 
-### `validate`
-`Function validate(object: Node) => Any || Void`
-
-```js
-{
-  validate: (node) => {
-    const invalidChildren = node.nodes.filter(child => child.kind == 'block')
-    return invalidChildren.size ? invalidChildren : null
-  }
-}
-```
-
-The `validate` property allows you to define a constraint that the matching object must abide by. It should return either `Void` if the object is valid, or any non-void value if it is invalid. This makes it easy to return the exact reason that the object is invalid, which makes it simple to recover from the invalid state with the `normalize` property.
 
 ## Static Methods
 
+### `Schema.create`
+`Schema.create(properties: Object) => Schema`
+
+Create a new `Schema` instance with `properties`.
+
+### `Schema.fromJSON`
+`Schema.fromJSON(object: Object) => Schema`
+
+Create a schema from a JSON `object`.
+
 ### `Schema.isSchema`
 `Schema.isSchema(maybeSchema: Any) => Boolean`
 
 Returns a boolean if the passed in argument is a `Schema`.
+
+
+## Instance Methods
+
+### `toJSON`
+`toJSON() => Object`
+
+Returns a JSON representation of the schema.
+
+
+## Invalid Reasons
+
+When supplying your own `normalize` property for a schema rule, it will be called with `(change, reason, context)`. The `reason` will be one of a set of reasons, and `context` will vary depending on the reason. Here's the full set:
+
+### `child_kind_invalid`
+
+```js
+{
+  child: Node,
+  index: Number,
+  node: Node,
+  rule: Object,
+}
+```
+
+### `child_required`
+
+```js
+{
+  index: Number,
+  node: Node,
+  rule: Object,
+}
+```
+
+### `child_type_invalid`
+
+```js
+{
+  child: Node,
+  index: Number,
+  node: Node,
+  rule: Object,
+}
+```
+
+### `child_unknown`
+
+```js
+{
+  child: Node,
+  index: Number,
+  node: Node,
+  rule: Object,
+}
+```
+
+### `node_data_invalid`
+
+```js
+{
+  key: String,
+  node: Node,
+  rule: Object,
+  value: Mixed,
+}
+```
+
+### `node_is_void_invalid`
+
+```js
+{
+  node: Node,
+  rule: Object,
+}
+```
+
+### `node_kind_invalid`
+
+```js
+{
+  node: Node,
+  rule: Object,
+}
+```
+
+### `node_mark_invalid`
+
+```js
+{
+  mark: Mark,
+  node: Node,
+  rule: Object,
+}
+```
+
+### `node_text_invalid`
+
+```js
+{
+  text: String,
+  node: Node,
+  rule: Object,
+}
+```
+
+### `parent_kind_invalid`
+
+```js
+{
+  node: Node,
+  parent: Node,
+  rule: Object,
+}
+```
+
+### `parent_type_invalid`
+
+```js
+{
+  node: Node,
+  parent: Node,
+  rule: Object,
+}
+```
diff --git a/docs/walkthroughs/applying-custom-formatting.md b/docs/walkthroughs/applying-custom-formatting.md
index 7f5e7668d..a47a38c61 100644
--- a/docs/walkthroughs/applying-custom-formatting.md
+++ b/docs/walkthroughs/applying-custom-formatting.md
@@ -16,11 +16,6 @@ class App extends React.Component {
 
   state = {
     state: initialState,
-    schema: {
-      nodes: {
-        code: CodeNode
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -40,12 +35,18 @@ class App extends React.Component {
     return (
       <Editor
         state={this.state.state}
-        schema={this.state.schema}
         onChange={this.onChange}
         onKeyDown={this.onKeyDown}
+        renderNode={this.renderNode}
       />
     )
   }
+  
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'code': return <CodeNode {...props} />
+    }
+  }
 
 }
 ```
@@ -57,11 +58,6 @@ class App extends React.Component {
 
   state = {
     state: initialState,
-    schema: {
-      nodes: {
-        code: CodeNode
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -92,13 +88,19 @@ class App extends React.Component {
   render() {
     return (
       <Editor
-        schema={this.state.schema}
         state={this.state.state}
         onChange={this.onChange}
         onKeyDown={this.onKeyDown}
+        renderNode={this.renderNode}
       />
     )
   }
+  
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'code': return <CodeNode {...props} />
+    }
+  }
 
 }
 ```
@@ -116,9 +118,7 @@ function BoldMark(props) {
 
 Pretty simple, right?
 
-And now, let's tell Slate about that mark.
-To do that, we'll add it to the `schema` object under a `marks` property.
-Also, let's allow our mark to be toggled by changing `addMark` to `toggleMark`.
+And now, let's tell Slate about that mark. To do that, we'll pass in the `renderMark` prop to our editor. Also, let's allow our mark to be toggled by changing `addMark` to `toggleMark`.
 
 ```js
 function BoldMark(props) {
@@ -129,15 +129,6 @@ class App extends React.Component {
 
   state = {
     state: initialState,
-    schema: {
-      nodes: {
-        code: CodeNode
-      },
-      // Add our "bold" mark to the schema...
-      marks: {
-        bold: BoldMark
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -165,13 +156,28 @@ class App extends React.Component {
   render() {
     return (
       <Editor
-        schema={this.state.schema}
         state={this.state.state}
         onChange={this.onChange}
         onKeyDown={this.onKeyDown}
+        renderNode={this.renderNode}
+        // Add the `renderMark` prop...
+        renderMark={this.renderMark}
       />
     )
   }
+  
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'code': return <CodeNode {...props} />
+    }
+  }
+
+  // Add a `renderMark` method to render marks.
+  renderMark = (props) => {
+    switch (props.mark.type) {
+      case 'bold': return <BoldMark {...props} />
+    }
+  }
 
 }
 ```
diff --git a/docs/walkthroughs/defining-custom-block-nodes.md b/docs/walkthroughs/defining-custom-block-nodes.md
index 4ac01092d..521428dd3 100644
--- a/docs/walkthroughs/defining-custom-block-nodes.md
+++ b/docs/walkthroughs/defining-custom-block-nodes.md
@@ -72,12 +72,6 @@ class App extends React.Component {
 
   state = {
     state: initialState,
-    // Add a "schema" to our app's state that we can pass to the Editor.
-    schema: {
-      nodes: {
-        code: CodeNode
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -93,16 +87,23 @@ class App extends React.Component {
 
   render() {
     return (
-      // Pass in the `schema` property...
+      // Pass in the `renderNode` prop...
       <Editor
-        schema={this.state.schema}
         state={this.state.state}
         onChange={this.onChange}
         onKeyDown={this.onKeyDown}
+        renderNode={this.renderNode}
       />
     )
   }
 
+  // Add a `renderNode` method to render a `CodeNode` for code blocks.
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'code': return <CodeNode {...props} />
+    }
+  }
+
 }
 ```
 
@@ -117,11 +118,6 @@ class App extends React.Component {
 
   state = {
     state: initialState,
-    schema: {
-      nodes: {
-        code: CodeNode
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -143,14 +139,20 @@ class App extends React.Component {
   render() {
     return (
       <Editor
-        schema={this.state.schema}
         state={this.state.state}
         onChange={this.onChange}
         onKeyDown={this.onKeyDown}
+        renderNode={this.renderNode}
       />
     )
   }
 
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'code': return <CodeNode {...props} />
+    }
+  }
+
 }
 ```
 
@@ -167,11 +169,6 @@ class App extends React.Component {
 
   state = {
     state: initialState,
-    schema: {
-      nodes: {
-        code: CodeNode
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -194,13 +191,19 @@ class App extends React.Component {
   render() {
     return (
       <Editor
-        schema={this.state.schema}
         state={this.state.state}
         onChange={this.onChange}
         onKeyDown={this.onKeyDown}
+        renderNode={this.renderNode}
       />
     )
   }
+  
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'code': return <CodeNode {...props} />
+    }
+  }
 
 }
 ```
diff --git a/docs/walkthroughs/saving-and-loading-html-content.md b/docs/walkthroughs/saving-and-loading-html-content.md
index f64b665e7..d93f5e69f 100644
--- a/docs/walkthroughs/saving-and-loading-html-content.md
+++ b/docs/walkthroughs/saving-and-loading-html-content.md
@@ -219,19 +219,6 @@ class App extends React.Component {
 
   state = {
     state: html.deserialize(initialState),
-    // Add a schema with our nodes and marks...
-    schema: {
-      nodes: {
-        code: props => <pre {...props.attributes}>{props.children}</pre>,
-        paragraph: props => <p {...props.attributes}>{props.children}</p>,
-        quote: props => <blockquote {...props.attributes}>{props.children}</blockquote>,
-      },
-      marks: {
-        bold: props => <strong>{props.children}</strong>,
-        italic: props => <em>{props.children}</em>,
-        underline: props => <u>{props.children}</u>,
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -247,12 +234,31 @@ class App extends React.Component {
   render() {
     return (
       <Editor
-        schema={this.state.schema}
         state={this.state.state}
         onChange={this.onChange}
+        // Add the ability to render our nodes and marks...
+        renderNode={this.renderNode}
+        renderMark={this.renderMark}
       />
     )
   }
+  
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'code': return <pre {...props.attributes}><code>{props.children}</code></pre>
+      case 'code': return <p {...props.attributes}>{props.children}</p>
+      case 'quote': return <blockquote {...props.attributes}>{props.children}</blockquote>
+    }
+  }
+
+  // Add a `renderMark` method to render marks.
+  renderMark = (props) => {
+    switch (props.mark.type) {
+      case 'bold': return <strong>{props.children}</strong>
+      case 'italic': return <em>{props.children}</em>
+      case 'underline': return <u>{props.children}</u>
+    }
+  }
 
 }
 ```
diff --git a/docs/walkthroughs/using-plugins.md b/docs/walkthroughs/using-plugins.md
index 3aae1825e..8dc5d0abb 100644
--- a/docs/walkthroughs/using-plugins.md
+++ b/docs/walkthroughs/using-plugins.md
@@ -18,11 +18,6 @@ class App extends React.Component {
 
   state = {
     state: initialState,
-    schema: {
-      marks: {
-        bold: props => <strong>{props.children}</strong>
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -39,14 +34,20 @@ class App extends React.Component {
   render() {
     return (
       <Editor
-        schema={this.state.schema}
         state={this.state.state}
         onChange={this.onChange}
         onKeyDown={this.onKeyDown}
+        renderMark={this.renderMark}
       />
     )
   }
 
+  renderMark = (props) => {
+    switch (props.mark.type) {
+      case 'bold': return <strong>{props.children}</strong>
+    }
+  }
+
 }
 ```
 
@@ -106,11 +107,6 @@ class App extends React.Component {
 
   state = {
     state: initialState,
-    schema: {
-      marks: {
-        bold: props => <strong>{props.children}</strong>
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -122,12 +118,18 @@ class App extends React.Component {
       // Add the `plugins` property to the editor, and remove `onKeyDown`.
       <Editor
         plugins={plugins}
-        schema={this.state.schema}
         state={this.state.state}
         onChange={this.onChange}
+        renderMark={this.renderMark}
       />
     )
   }
+  
+  renderMark = (props) => {
+    switch (props.mark.type) {
+      case 'bold': return <strong>{props.children}</strong>
+    }
+  }
 
 }
 ```
@@ -150,16 +152,6 @@ class App extends React.Component {
 
   state = {
     state: initialState,
-    schema: {
-      marks: {
-        bold: props => <strong>{props.children}</strong>,
-        // Add our new mark renderers...
-        code: props => <code>{props.children}</code>,
-        italic: props => <em>{props.children}</em>,
-        strikethrough: props => <del>{props.children}</del>,
-        underline: props => <u>{props.children}</u>,
-      }
-    }
   }
 
   onChange = ({ state }) => {
@@ -170,12 +162,23 @@ class App extends React.Component {
     return (
       <Editor
         plugins={plugins}
-        schema={this.state.schema}
         state={this.state.state}
         onChange={this.onChange}
+        renderMark={this.renderMark}
       />
     )
   }
+  
+  renderMark = (props) => {
+    switch (props.mark.type) {
+      case 'bold': return <strong>{props.children}</strong>
+      // Add our new mark renderers...
+      case 'code': return <code>{props.children}</code>
+      case 'italic': return <em>{props.children}</em>
+      case 'strikethrough': return <del>{props.children}</del>
+      case 'underline': return <u>{props.children}</u>
+    }
+  }
 
 }
 ```
diff --git a/examples/check-lists/index.js b/examples/check-lists/index.js
index 78e04cf6f..fa8e16721 100644
--- a/examples/check-lists/index.js
+++ b/examples/check-lists/index.js
@@ -57,18 +57,6 @@ class CheckListItem extends React.Component {
 
 }
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    'check-list-item': CheckListItem,
-  },
-}
-
 /**
  * The rich text example.
  *
@@ -146,16 +134,29 @@ class CheckLists extends React.Component {
           <Editor
             spellCheck
             placeholder="Get to work..."
-            schema={schema}
             state={this.state.state}
             onChange={this.onChange}
             onKeyDown={this.onKeyDown}
+            renderNode={this.renderNode}
           />
         </div>
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'check-list-item': return <CheckListItem {...props} />
+    }
+  }
+
 }
 
 /**
diff --git a/examples/code-highlighting/index.js b/examples/code-highlighting/index.js
index acf170e45..d4f6a5c5b 100644
--- a/examples/code-highlighting/index.js
+++ b/examples/code-highlighting/index.js
@@ -46,94 +46,6 @@ function CodeBlockLine(props) {
   )
 }
 
-/**
- * Define a Prism.js decorator for code blocks.
- *
- * @param {Block} block
- * @return {Array}
- */
-
-function codeBlockDecorator(block) {
-  const language = block.data.get('language')
-  const texts = block.getTexts().toArray()
-  const string = texts.map(t => t.text).join('\n')
-  const grammar = Prism.languages[language]
-  const tokens = Prism.tokenize(string, grammar)
-  const decorations = []
-  let startText = texts.shift()
-  let endText = startText
-  let startOffset = 0
-  let endOffset = 0
-  let start = 0
-
-  for (const token of tokens) {
-    startText = endText
-    startOffset = endOffset
-
-    const content = typeof token == 'string' ? token : token.content
-    const newlines = content.split('\n').length - 1
-    const length = content.length - newlines
-    const end = start + length
-
-    let available = startText.text.length - startOffset
-    let remaining = length
-
-    endOffset = startOffset + remaining
-
-    while (available < remaining) {
-      endText = texts.shift()
-      remaining = length - available
-      available = endText.text.length
-      endOffset = remaining
-    }
-
-    if (typeof token != 'string') {
-      const range = {
-        anchorKey: startText.key,
-        anchorOffset: startOffset,
-        focusKey: endText.key,
-        focusOffset: endOffset,
-        marks: [{ type: `highlight-${token.type}` }],
-      }
-
-      decorations.push(range)
-    }
-
-    start = end
-  }
-
-  return decorations
-}
-
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    code: {
-      render: CodeBlock,
-      decorate: codeBlockDecorator,
-    },
-    code_line: {
-      render: CodeBlockLine,
-    },
-  },
-  marks: {
-    'highlight-comment': {
-      opacity: '0.33'
-    },
-    'highlight-keyword': {
-      fontWeight: 'bold'
-    },
-    'highlight-punctuation': {
-      opacity: '0.75'
-    }
-  }
-}
-
 /**
  * The code highlighting example.
  *
@@ -186,20 +98,113 @@ class CodeHighlighting extends React.Component {
    * @return {Component}
    */
 
-  render() {
+  render = () => {
     return (
       <div className="editor">
         <Editor
           placeholder="Write some code..."
-          schema={schema}
           state={this.state.state}
-          onKeyDown={this.onKeyDown}
           onChange={this.onChange}
+          onKeyDown={this.onKeyDown}
+          renderNode={this.renderNode}
+          renderMark={this.renderMark}
+          decorateNode={this.decorateNode}
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'code': return <CodeBlock {...props} />
+      case 'code_line': return <CodeBlockLine {...props} />
+    }
+  }
+
+  /**
+   * Render a Slate mark.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderMark = (props) => {
+    const { children, mark } = props
+    switch (mark.type) {
+      case 'comment': return <span style={{ opacity: '0.33' }}>{children}</span>
+      case 'keyword': return <span style={{ fontWeight: 'bold' }}>{children}</span>
+      case 'punctuation': return <span style={{ opacity: '0.75' }}>{children}</span>
+    }
+  }
+
+  /**
+   * Decorate code blocks with Prism.js highlighting.
+   *
+   * @param {Node} node
+   * @return {Array}
+   */
+
+  decorateNode = (node) => {
+    if (node.type != 'code') return
+
+    const language = node.data.get('language')
+    const texts = node.getTexts().toArray()
+    const string = texts.map(t => t.text).join('\n')
+    const grammar = Prism.languages[language]
+    const tokens = Prism.tokenize(string, grammar)
+    const decorations = []
+    let startText = texts.shift()
+    let endText = startText
+    let startOffset = 0
+    let endOffset = 0
+    let start = 0
+
+    for (const token of tokens) {
+      startText = endText
+      startOffset = endOffset
+
+      const content = typeof token == 'string' ? token : token.content
+      const newlines = content.split('\n').length - 1
+      const length = content.length - newlines
+      const end = start + length
+
+      let available = startText.text.length - startOffset
+      let remaining = length
+
+      endOffset = startOffset + remaining
+
+      while (available < remaining) {
+        endText = texts.shift()
+        remaining = length - available
+        available = endText.text.length
+        endOffset = remaining
+      }
+
+      if (typeof token != 'string') {
+        const range = {
+          anchorKey: startText.key,
+          anchorOffset: startOffset,
+          focusKey: endText.key,
+          focusOffset: endOffset,
+          marks: [{ type: token.type }],
+        }
+
+        decorations.push(range)
+      }
+
+      start = end
+    }
+
+    return decorations
+  }
+
 }
 
 /**
diff --git a/examples/embeds/index.js b/examples/embeds/index.js
index aaaa4f682..823dea2c8 100644
--- a/examples/embeds/index.js
+++ b/examples/embeds/index.js
@@ -6,18 +6,6 @@ import React from 'react'
 import Video from './video'
 import initialState from './state.json'
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    video: Video
-  }
-}
-
 /**
  * The images example.
  *
@@ -57,14 +45,27 @@ class Embeds extends React.Component {
       <div className="editor">
         <Editor
           placeholder="Enter some text..."
-          schema={schema}
           state={this.state.state}
           onChange={this.onChange}
+          renderNode={this.renderNode}
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    switch (props.node.type) {
+      case 'video': return <Video {...props} />
+    }
+  }
+
 }
 
 /**
diff --git a/examples/emojis/index.js b/examples/emojis/index.js
index a9a42b450..b6e6d39de 100644
--- a/examples/emojis/index.js
+++ b/examples/emojis/index.js
@@ -17,24 +17,6 @@ const EMOJIS = [
   '🙏', '👻', '🍔', '🍑', '🍆', '🔑',
 ]
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    paragraph: props => <p {...props.attributes}>{props.children}</p>,
-    emoji: (props) => {
-      const { isSelected, node } = props
-      const { data } = node
-      const code = data.get('code')
-      return <span className={`emoji ${isSelected ? 'selected' : ''}`} {...props.attributes} contentEditable={false}>{code}</span>
-    }
-  }
-}
-
 /**
  * The links example.
  *
@@ -130,14 +112,35 @@ class Emojis extends React.Component {
       <div className="editor">
         <Editor
           placeholder="Write some 😍👋🎉..."
-          schema={schema}
           state={this.state.state}
           onChange={this.onChange}
+          renderNode={this.renderNode}
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, children, node, isSelected } = props
+    switch (node.type) {
+      case 'paragraph': {
+        return <p {...attributes}>{children}</p>
+      }
+      case 'emoji': {
+        const { data } = node
+        const code = data.get('code')
+        return <span className={`emoji ${isSelected ? 'selected' : ''}`} {...props.attributes} contentEditable={false}>{code}</span>
+      }
+    }
+  }
+
 }
 
 /**
diff --git a/examples/forced-layout/index.js b/examples/forced-layout/index.js
index 00da19483..198c541ca 100644
--- a/examples/forced-layout/index.js
+++ b/examples/forced-layout/index.js
@@ -5,6 +5,32 @@ import { Block, State } from 'slate'
 import React from 'react'
 import initialState from './state.json'
 
+/**
+ * A simple schema to enforce the nodes in the Slate document.
+ *
+ * @type {Object}
+ */
+
+const schema = {
+  document: {
+    nodes: [
+      { types: ['title'], min: 1, max: 1 },
+      { types: ['paragraph'], min: 1 },
+    ],
+    normalize: (change, reason, { node, child, index }) => {
+      switch (reason) {
+        case 'child_type_invalid': {
+          return change.setNodeByKey(child.key, index == 0 ? 'title' : 'paragraph')
+        }
+        case 'child_required': {
+          const block = Block.create(index == 0 ? 'title' : 'paragraph')
+          return change.insertNodeByKey(node.key, index, block)
+        }
+      }
+    }
+  }
+}
+
 /**
  * The Forced Layout example.
  *
@@ -21,65 +47,6 @@ class ForcedLayout extends React.Component {
 
   state = {
     state: State.fromJSON(initialState),
-    schema: {
-      nodes: {
-        title: props => <h2 {...props.attrs}>{props.children}</h2>,
-        paragraph: props => <p {...props.attrs}>{props.children}</p>,
-      },
-      rules: [
-        /* Rule that always makes the first block a title, normalizes by inserting one if no children, or setting the top to be a title */
-
-        {
-          match: (object) => {
-            return object.kind == 'document'
-          },
-          validate: (document) => {
-            return !document.nodes.size || document.nodes.first().type != 'title' ? document.nodes : null
-          },
-          normalize: (change, document, nodes) => {
-            if (!nodes.size) {
-              const title = Block.create({ type: 'title', data: {}})
-              change.insertNodeByKey(document.key, 0, title)
-              return
-            }
-
-            change.setNodeByKey(nodes.first().key, 'title')
-          }
-        },
-
-        /* Rule that only allows for one title, normalizes by making titles paragraphs */
-
-        {
-          match: (object) => {
-            return object.kind == 'document'
-          },
-          validate: (document) => {
-            const invalidChildren = document.nodes.filter((child, index) => child.type == 'title' && index != 0)
-            return invalidChildren.size ? invalidChildren : null
-          },
-          normalize: (change, document, invalidChildren) => {
-            invalidChildren.forEach((child) => {
-              change.setNodeByKey(child.key, 'paragraph')
-            })
-          }
-        },
-
-        /* Rule that forces at least one paragraph, normalizes by inserting an empty paragraph */
-
-        {
-          match: (object) => {
-            return object.kind == 'document'
-          },
-          validate: (document) => {
-            return document.nodes.size < 2 ? true : null
-          },
-          normalize: (change, document) => {
-            const paragraph = Block.create({ type: 'paragraph', data: {}})
-            change.insertNodeByKey(document.key, 1, paragraph)
-          }
-        }
-      ]
-    }
   }
 
   /**
@@ -100,15 +67,34 @@ class ForcedLayout extends React.Component {
 
   render() {
     return (
-      <Editor
-        placeholder="Enter a title..."
-        state={this.state.state}
-        schema={this.state.schema}
-        onChange={this.onChange}
-      />
+      <div className="editor">
+        <Editor
+          placeholder="Enter a title..."
+          state={this.state.state}
+          schema={schema}
+          onChange={this.onChange}
+          renderNode={this.renderNode}
+          validateNode={this.validateNode}
+        />
+      </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, children, node } = props
+    switch (node.type) {
+      case 'title': return <h2 {...attributes}>{children}</h2>
+      case 'paragraph': return <p {...attributes}>{children}</p>
+    }
+  }
+
 }
 
 /**
diff --git a/examples/hovering-menu/index.js b/examples/hovering-menu/index.js
index fc8cf54db..c48256ffe 100644
--- a/examples/hovering-menu/index.js
+++ b/examples/hovering-menu/index.js
@@ -8,21 +8,6 @@ import initialState from './state.json'
 
 const root = window.document.querySelector('main')
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  marks: {
-    bold: props => <strong>{props.children}</strong>,
-    code: props => <code>{props.children}</code>,
-    italic: props => <em>{props.children}</em>,
-    underlined: props => <u>{props.children}</u>,
-  }
-}
-
 /**
  * The menu.
  *
@@ -129,6 +114,28 @@ class HoveringMenu extends React.Component {
     this.updateMenu()
   }
 
+  /**
+   * Update the menu's absolute position.
+   */
+
+  updateMenu = () => {
+    const { state } = this.state
+    const menu = this.menu
+    if (!menu) return
+
+    if (state.isBlurred || state.isEmpty) {
+      menu.removeAttribute('style')
+      return
+    }
+
+    const selection = window.getSelection()
+    const range = selection.getRangeAt(0)
+    const rect = range.getBoundingClientRect()
+    menu.style.opacity = 1
+    menu.style.top = `${rect.top + window.scrollY - menu.offsetHeight}px`
+    menu.style.left = `${rect.left + window.scrollX - menu.offsetWidth / 2 + rect.width / 2}px`
+  }
+
   /**
    * On change.
    *
@@ -166,9 +173,9 @@ class HoveringMenu extends React.Component {
         <div className="editor">
           <Editor
             placeholder="Enter some text..."
-            schema={schema}
             state={this.state.state}
             onChange={this.onChange}
+            renderMark={this.renderMark}
           />
         </div>
       </div>
@@ -176,25 +183,20 @@ class HoveringMenu extends React.Component {
   }
 
   /**
-   * Update the menu's absolute position.
+   * Render a Slate mark.
+   *
+   * @param {Object} props
+   * @return {Element}
    */
 
-  updateMenu = () => {
-    const { state } = this.state
-    const menu = this.menu
-    if (!menu) return
-
-    if (state.isBlurred || state.isEmpty) {
-      menu.removeAttribute('style')
-      return
+  renderMark = (props) => {
+    const { children, mark } = props
+    switch (mark.type) {
+      case 'bold': return <strong>{children}</strong>
+      case 'code': return <code>{children}</code>
+      case 'italic': return <em>{children}</em>
+      case 'underlined': return <u>{children}</u>
     }
-
-    const selection = window.getSelection()
-    const range = selection.getRangeAt(0)
-    const rect = range.getBoundingClientRect()
-    menu.style.opacity = 1
-    menu.style.top = `${rect.top + window.scrollY - menu.offsetHeight}px`
-    menu.style.left = `${rect.left + window.scrollX - menu.offsetWidth / 2 + rect.width / 2}px`
   }
 
 }
diff --git a/examples/huge-document/index.js b/examples/huge-document/index.js
index 3b399a067..458bb8da1 100644
--- a/examples/huge-document/index.js
+++ b/examples/huge-document/index.js
@@ -35,36 +35,6 @@ for (let h = 0; h < HEADINGS; h++) {
   }
 }
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    'heading': props => <h1 {...props.attributes}>{props.children}</h1>,
-    'paragraph': props => <p {...props.attributes} style={{ marginBottom: 20 }}>{props.children}</p>,
-  },
-  marks: {
-    bold: {
-      fontWeight: 'bold'
-    },
-    code: {
-      fontFamily: 'monospace',
-      backgroundColor: '#eee',
-      padding: '3px',
-      borderRadius: '4px'
-    },
-    italic: {
-      fontStyle: 'italic'
-    },
-    underlined: {
-      textDecoration: 'underline'
-    }
-  }
-}
-
 /**
  * The huge document example.
  *
@@ -104,17 +74,51 @@ class HugeDocument extends React.Component {
 
   render() {
     return (
-      <Editor
-        placeholder="Enter some text..."
-        schema={schema}
-        spellCheck={false}
-        state={this.state.state}
-        onChange={this.onChange}
-        onKeyDown={this.onKeyDown}
-      />
+      <div className="editor">
+        <Editor
+          placeholder="Enter some text..."
+          spellCheck={false}
+          state={this.state.state}
+          onChange={this.onChange}
+          onKeyDown={this.onKeyDown}
+          renderNode={this.renderNode}
+          renderMark={this.renderMark}
+        />
+      </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, children, node } = props
+    switch (node.type) {
+      case 'heading': return <h1 {...attributes}>{children}</h1>
+    }
+  }
+
+  /**
+   * Render a Slate mark.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderMark = (props) => {
+    const { children, mark } = props
+    switch (mark.type) {
+      case 'bold': return <strong>{children}</strong>
+      case 'code': return <code>{children}</code>
+      case 'italic': return <em>{children}</em>
+      case 'underlined': return <u>{children}</u>
+    }
+  }
+
 }
 
 /**
diff --git a/examples/images/index.js b/examples/images/index.js
index 4d807fb50..07381b305 100644
--- a/examples/images/index.js
+++ b/examples/images/index.js
@@ -7,72 +7,6 @@ import initialState from './state.json'
 import isImage from 'is-image'
 import isUrl from 'is-url'
 
-/**
- * Default block to be inserted when the document is empty,
- * and after an image is the last node in the document.
- *
- * @type {Object}
- */
-
-const defaultBlock = {
-  type: 'paragraph',
-  isVoid: false,
-  data: {}
-}
-
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    image: (props) => {
-      const { node, isSelected } = props
-      const src = node.data.get('src')
-      const className = isSelected ? 'active' : null
-      const style = { display: 'block' }
-      return (
-        <img src={src} className={className} style={style} {...props.attributes} />
-      )
-    },
-    paragraph: (props) => {
-      return <p {...props.attributes}>{props.children}</p>
-    }
-  },
-  rules: [
-    // Rule to insert a paragraph block if the document is empty.
-    {
-      match: (node) => {
-        return node.kind == 'document'
-      },
-      validate: (document) => {
-        return document.nodes.size ? null : true
-      },
-      normalize: (change, document) => {
-        const block = Block.create(defaultBlock)
-        change.insertNodeByKey(document.key, 0, block)
-      }
-    },
-    // Rule to insert a paragraph below a void node (the image) if that node is
-    // the last one in the document.
-    {
-      match: (node) => {
-        return node.kind == 'document'
-      },
-      validate: (document) => {
-        const lastNode = document.nodes.last()
-        return lastNode && lastNode.isVoid ? true : null
-      },
-      normalize: (change, document) => {
-        const block = Block.create(defaultBlock)
-        change.insertNodeByKey(document.key, document.nodes.size, block)
-      }
-    }
-  ]
-}
-
 /**
  * A change function to standardize inserting images.
  *
@@ -153,16 +87,56 @@ class Images extends React.Component {
       <div className="editor">
         <Editor
           placeholder="Enter some text..."
-          schema={schema}
           state={this.state.state}
           onChange={this.onChange}
           onDrop={this.onDrop}
           onPaste={this.onPaste}
+          renderNode={this.renderNode}
+          validateNode={this.validateNode}
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, node, isSelected } = props
+    switch (node.type) {
+      case 'image': {
+        const src = node.data.get('src')
+        const className = isSelected ? 'active' : null
+        const style = { display: 'block' }
+        return (
+          <img src={src} className={className} style={style} {...attributes} />
+        )
+      }
+    }
+  }
+
+  /**
+   * Perform node validation on the document.
+   *
+   * @param {Node} node
+   * @return {Function|Void}
+   */
+
+  validateNode = (node) => {
+    if (node.kind != 'document') return
+    const last = node.nodes.last()
+
+    if (!last || last.type != 'paragraph') {
+      const index = node.nodes.size
+      const paragraph = Block.create('paragraph')
+      return change => change.insertNodeByKey(node.key, index, paragraph)
+    }
+  }
+
   /**
    * On change.
    *
diff --git a/examples/index.css b/examples/index.css
index f70d752fa..7501cc72f 100644
--- a/examples/index.css
+++ b/examples/index.css
@@ -22,6 +22,7 @@ pre {
 }
 
 :not(pre) > code {
+  font-family: monospace;
   background-color: #eee;
   padding: 3px;
 }
diff --git a/examples/links/index.js b/examples/links/index.js
index fc857f570..1dc322196 100644
--- a/examples/links/index.js
+++ b/examples/links/index.js
@@ -6,23 +6,6 @@ import React from 'react'
 import initialState from './state.json'
 import isUrl from 'is-url'
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    paragraph: props => <p>{props.children}</p>,
-    link: (props) => {
-      const { data } = props.node
-      const href = data.get('href')
-      return <a {...props.attributes} href={href}>{props.children}</a>
-    }
-  }
-}
-
 /**
  * A change helper to standardize wrapping links.
  *
@@ -65,7 +48,7 @@ class Links extends React.Component {
 
   state = {
     state: State.fromJSON(initialState)
-  };
+  }
 
   /**
    * Check whether the current selection has a link in it.
@@ -188,15 +171,33 @@ class Links extends React.Component {
       <div className="editor">
         <Editor
           placeholder="Enter some text..."
-          schema={schema}
           state={this.state.state}
           onChange={this.onChange}
           onPaste={this.onPaste}
+          renderNode={this.renderNode}
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, children, node } = props
+    switch (node.type) {
+      case 'link': {
+        const { data } = node
+        const href = data.get('href')
+        return <a {...attributes} href={href}>{children}</a>
+      }
+    }
+  }
+
 }
 
 /**
diff --git a/examples/markdown-preview/index.js b/examples/markdown-preview/index.js
index d5633c26f..a1e492fef 100644
--- a/examples/markdown-preview/index.js
+++ b/examples/markdown-preview/index.js
@@ -12,120 +12,6 @@ import React from 'react'
 // eslint-disable-next-line
 Prism.languages.markdown=Prism.languages.extend("markup",{}),Prism.languages.insertBefore("markdown","prolog",{blockquote:{pattern:/^>(?:[\t ]*>)*/m,alias:"punctuation"},code:[{pattern:/^(?: {4}|\t).+/m,alias:"keyword"},{pattern:/``.+?``|`[^`\n]+`/,alias:"keyword"}],title:[{pattern:/\w+.*(?:\r?\n|\r)(?:==+|--+)/,alias:"important",inside:{punctuation:/==+$|--+$/}},{pattern:/(^\s*)#+.+/m,lookbehind:!0,alias:"important",inside:{punctuation:/^#+|#+$/}}],hr:{pattern:/(^\s*)([*-])([\t ]*\2){2,}(?=\s*$)/m,lookbehind:!0,alias:"punctuation"},list:{pattern:/(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,lookbehind:!0,alias:"punctuation"},"url-reference":{pattern:/!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,inside:{variable:{pattern:/^(!?\[)[^\]]+/,lookbehind:!0},string:/(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,punctuation:/^[\[\]!:]|[<>]/},alias:"url"},bold:{pattern:/(^|[^\\])(\*\*|__)(?:(?:\r?\n|\r)(?!\r?\n|\r)|.)+?\2/,lookbehind:!0,inside:{punctuation:/^\*\*|^__|\*\*$|__$/}},italic:{pattern:/(^|[^\\])([*_])(?:(?:\r?\n|\r)(?!\r?\n|\r)|.)+?\2/,lookbehind:!0,inside:{punctuation:/^[*_]|[*_]$/}},url:{pattern:/!?\[[^\]]+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)| ?\[[^\]\n]*\])/,inside:{variable:{pattern:/(!?\[)[^\]]+(?=\]$)/,lookbehind:!0},string:{pattern:/"(?:\\.|[^"\\])*"(?=\)$)/}}}}),Prism.languages.markdown.bold.inside.url=Prism.util.clone(Prism.languages.markdown.url),Prism.languages.markdown.italic.inside.url=Prism.util.clone(Prism.languages.markdown.url),Prism.languages.markdown.bold.inside.italic=Prism.util.clone(Prism.languages.markdown.italic),Prism.languages.markdown.italic.inside.bold=Prism.util.clone(Prism.languages.markdown.bold);
 
-/**
- * Define a decorator for markdown styles.
- *
- * @param {Block} block
- * @return {Array}
- */
-
-function markdownDecorator(block) {
-  const string = block.text
-  const texts = block.getTexts().toArray()
-  const grammar = Prism.languages.markdown
-  const tokens = Prism.tokenize(string, grammar)
-  const decorations = []
-  let startText = texts.shift()
-  let endText = startText
-  let startOffset = 0
-  let endOffset = 0
-  let start = 0
-
-  function getLength(token) {
-    if (typeof token == 'string') {
-      return token.length
-    } else if (typeof token.content == 'string') {
-      return token.content.length
-    } else {
-      return token.content.reduce((l, t) => l + getLength(t), 0)
-    }
-  }
-
-  for (const token of tokens) {
-    startText = endText
-    startOffset = endOffset
-
-    const length = getLength(token)
-    const end = start + length
-
-    let available = startText.text.length - startOffset
-    let remaining = length
-
-    endOffset = startOffset + remaining
-
-    while (available < remaining) {
-      endText = texts.shift()
-      remaining = length - available
-      available = endText.text.length
-      endOffset = remaining
-    }
-
-    if (typeof token != 'string') {
-      const range = {
-        anchorKey: startText.key,
-        anchorOffset: startOffset,
-        focusKey: endText.key,
-        focusOffset: endOffset,
-        marks: [{ type: token.type }],
-      }
-
-      decorations.push(range)
-    }
-
-
-    start = end
-  }
-
-  return decorations
-}
-
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  marks: {
-    'title': {
-      fontWeight: 'bold',
-      fontSize: '20px',
-      margin: '20px 0 10px 0',
-      display: 'inline-block'
-    },
-    'bold': {
-      fontWeight: 'bold'
-    },
-    'italic': {
-      fontStyle: 'italic'
-    },
-    'punctuation': {
-      opacity: 0.2
-    },
-    'code': {
-      fontFamily: 'monospace',
-      display: 'inline-block',
-      padding: '2px 1px',
-    },
-    'list': {
-      paddingLeft: '10px',
-      lineHeight: '10px',
-      fontSize: '20px'
-    },
-    'hr': {
-      borderBottom: '2px solid #000',
-      display: 'block',
-      opacity: 0.2
-    }
-  },
-  rules: [
-    {
-      match: object => object.kind == 'block',
-      decorate: markdownDecorator,
-    }
-  ]
-}
-
 /**
  * The markdown preview example.
  *
@@ -144,6 +30,16 @@ class MarkdownPreview extends React.Component {
     state: Plain.deserialize('Slate is flexible enough to add **decorators** that can format text based on its content. For example, this editor has **Markdown** preview decorators on it, to make it _dead_ simple to make an editor with built-in Markdown previewing.\n## Try it out!\nTry it out for yourself!')
   }
 
+  /**
+   * On change.
+   *
+   * @param {Change} change
+   */
+
+  onChange = ({ state }) => {
+    this.setState({ state })
+  }
+
   /**
    *
    * Render the example.
@@ -156,22 +52,127 @@ class MarkdownPreview extends React.Component {
       <div className="editor">
         <Editor
           placeholder="Write some markdown..."
-          schema={schema}
           state={this.state.state}
           onChange={this.onChange}
+          renderMark={this.renderMark}
+          decorateNode={this.decorateNode}
         />
       </div>
     )
   }
 
   /**
-   * On change.
+   * Render a Slate mark.
    *
-   * @param {Change} change
+   * @param {Object} props
+   * @return {Element}
    */
 
-  onChange = ({ state }) => {
-    this.setState({ state })
+  renderMark = (props) => {
+    const { children, mark } = props
+    switch (mark.type) {
+      case 'bold': return <strong>{children}</strong>
+      case 'code': return <code>{children}</code>
+      case 'italic': return <em>{children}</em>
+      case 'underlined': return <u>{children}</u>
+      case 'title': {
+        return (
+          <span style={{ fontWeight: 'bold', fontSize: '20px', margin: '20px 0 10px 0', display: 'inline-block' }}>
+            {children}
+          </span>
+        )
+      }
+      case 'punctuation': {
+        return (
+          <span style={{ opacity: 0.2 }}>
+            {children}
+          </span>
+        )
+      }
+      case 'list': {
+        return (
+          <span style={{ paddingLeft: '10px', lineHeight: '10px', fontSize: '20px' }}>
+            {children}
+          </span>
+        )
+      }
+      case 'hr': {
+        return (
+          <span style={{ borderBottom: '2px solid #000', display: 'block', opacity: 0.2 }}>
+            {children}
+          </span>
+        )
+      }
+    }
+  }
+
+  /**
+   * Define a decorator for markdown styles.
+   *
+   * @param {Node} node
+   * @return {Array}
+   */
+
+  decorateNode(node) {
+    if (node.kind != 'block') return
+
+    const string = node.text
+    const texts = node.getTexts().toArray()
+    const grammar = Prism.languages.markdown
+    const tokens = Prism.tokenize(string, grammar)
+    const decorations = []
+    let startText = texts.shift()
+    let endText = startText
+    let startOffset = 0
+    let endOffset = 0
+    let start = 0
+
+    function getLength(token) {
+      if (typeof token == 'string') {
+        return token.length
+      } else if (typeof token.content == 'string') {
+        return token.content.length
+      } else {
+        return token.content.reduce((l, t) => l + getLength(t), 0)
+      }
+    }
+
+    for (const token of tokens) {
+      startText = endText
+      startOffset = endOffset
+
+      const length = getLength(token)
+      const end = start + length
+
+      let available = startText.text.length - startOffset
+      let remaining = length
+
+      endOffset = startOffset + remaining
+
+      while (available < remaining) {
+        endText = texts.shift()
+        remaining = length - available
+        available = endText.text.length
+        endOffset = remaining
+      }
+
+      if (typeof token != 'string') {
+        const range = {
+          anchorKey: startText.key,
+          anchorOffset: startOffset,
+          focusKey: endText.key,
+          focusOffset: endOffset,
+          marks: [{ type: token.type }],
+        }
+
+        decorations.push(range)
+      }
+
+
+      start = end
+    }
+
+    return decorations
   }
 
 }
diff --git a/examples/markdown-shortcuts/index.js b/examples/markdown-shortcuts/index.js
index d13016836..1f573a2a5 100644
--- a/examples/markdown-shortcuts/index.js
+++ b/examples/markdown-shortcuts/index.js
@@ -5,26 +5,6 @@ import { State } from 'slate'
 import React from 'react'
 import initialState from './state.json'
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    'block-quote': props => <blockquote>{props.children}</blockquote>,
-    'bulleted-list': props => <ul>{props.children}</ul>,
-    'heading-one': props => <h1>{props.children}</h1>,
-    'heading-two': props => <h2>{props.children}</h2>,
-    'heading-three': props => <h3>{props.children}</h3>,
-    'heading-four': props => <h4>{props.children}</h4>,
-    'heading-five': props => <h5>{props.children}</h5>,
-    'heading-six': props => <h6>{props.children}</h6>,
-    'list-item': props => <li>{props.children}</li>,
-  }
-}
-
 /**
  * The auto-markdown example.
  *
@@ -78,15 +58,37 @@ class MarkdownShortcuts extends React.Component {
       <div className="editor">
         <Editor
           placeholder="Write some markdown..."
-          schema={schema}
           state={this.state.state}
           onChange={this.onChange}
           onKeyDown={this.onKeyDown}
+          renderNode={this.renderNode}
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, children, node } = props
+    switch (node.type) {
+      case 'block-quote': return <blockquote {...attributes}>{children}</blockquote>
+      case 'bulleted-list': return <ul {...attributes}>{children}</ul>
+      case 'heading-one': return <h1 {...attributes}>{children}</h1>
+      case 'heading-two': return <h2 {...attributes}>{children}</h2>
+      case 'heading-three': return <h3 {...attributes}>{children}</h3>
+      case 'heading-four': return <h4 {...attributes}>{children}</h4>
+      case 'heading-five': return <h5 {...attributes}>{children}</h5>
+      case 'heading-six': return <h6 {...attributes}>{children}</h6>
+      case 'list-item': return <li {...attributes}>{children}</li>
+    }
+  }
+
   /**
    * On change.
    *
diff --git a/examples/paste-html/index.js b/examples/paste-html/index.js
index 060f7e835..f846e99b9 100644
--- a/examples/paste-html/index.js
+++ b/examples/paste-html/index.js
@@ -6,39 +6,6 @@ import { State } from 'slate'
 import React from 'react'
 import initialState from './state.json'
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    'bulleted-list': props => <ul {...props.attributes}>{props.children}</ul>,
-    'code': props => <pre><code {...props.attributes}>{props.children}</code></pre>,
-    'heading-one': props => <h1 {...props.attributes}>{props.children}</h1>,
-    'heading-two': props => <h2 {...props.attributes}>{props.children}</h2>,
-    'heading-three': props => <h3 {...props.attributes}>{props.children}</h3>,
-    'heading-four': props => <h4 {...props.attributes}>{props.children}</h4>,
-    'heading-five': props => <h5 {...props.attributes}>{props.children}</h5>,
-    'heading-six': props => <h6 {...props.attributes}>{props.children}</h6>,
-    'list-item': props => <li {...props.attributes}>{props.children}</li>,
-    'numbered-list': props => <ol {...props.attributes}>{props.children}</ol>,
-    'quote': props => <blockquote {...props.attributes}>{props.children}</blockquote>,
-    'link': (props) => {
-      const { data } = props.node
-      const href = data.get('href')
-      return <a href={href} {...props.attributes}>{props.children}</a>
-    }
-  },
-  marks: {
-    bold: props => <strong>{props.children}</strong>,
-    code: props => <code>{props.children}</code>,
-    italic: props => <em>{props.children}</em>,
-    underlined: props => <u>{props.children}</u>,
-  }
-}
-
 /**
  * Tags to blocks.
  *
@@ -197,15 +164,62 @@ class PasteHtml extends React.Component {
       <div className="editor">
         <Editor
           placeholder="Paste in some HTML..."
-          schema={schema}
           state={this.state.state}
           onPaste={this.onPaste}
           onChange={this.onChange}
+          renderNode={this.renderNode}
+          renderMark={this.renderMark}
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, children, node } = props
+    switch (node.type) {
+      case 'quote': return <blockquote {...attributes}>{children}</blockquote>
+      case 'code': return <pre><code {...attributes}>{children}</code></pre>
+      case 'bulleted-list': return <ul {...attributes}>{children}</ul>
+      case 'heading-one': return <h1 {...attributes}>{children}</h1>
+      case 'heading-two': return <h2 {...attributes}>{children}</h2>
+      case 'heading-three': return <h3 {...attributes}>{children}</h3>
+      case 'heading-four': return <h4 {...attributes}>{children}</h4>
+      case 'heading-five': return <h5 {...attributes}>{children}</h5>
+      case 'heading-six': return <h6 {...attributes}>{children}</h6>
+      case 'list-item': return <li {...attributes}>{children}</li>
+      case 'numbered-list': return <ol {...attributes}>{children}</ol>
+      case 'link': {
+        const { data } = node
+        const href = data.get('href')
+        return <a href={href} {...attributes}>{children}</a>
+      }
+    }
+  }
+
+  /**
+   * Render a Slate mark.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderMark = (props) => {
+    const { children, mark } = props
+    switch (mark.type) {
+      case 'bold': return <strong>{children}</strong>
+      case 'code': return <code>{children}</code>
+      case 'italic': return <em>{children}</em>
+      case 'underlined': return <u>{children}</u>
+    }
+  }
+
 }
 
 /**
diff --git a/examples/plain-text/index.js b/examples/plain-text/index.js
index 1349befce..333d7c594 100644
--- a/examples/plain-text/index.js
+++ b/examples/plain-text/index.js
@@ -40,11 +40,13 @@ class PlainText extends React.Component {
 
   render() {
     return (
-      <Editor
-        placeholder="Enter some plain text..."
-        state={this.state.state}
-        onChange={this.onChange}
-      />
+      <div className="editor">
+        <Editor
+          placeholder="Enter some plain text..."
+          state={this.state.state}
+          onChange={this.onChange}
+        />
+      </div>
     )
   }
 
diff --git a/examples/plugins/index.js b/examples/plugins/index.js
index ff8158e53..13a7195fc 100644
--- a/examples/plugins/index.js
+++ b/examples/plugins/index.js
@@ -82,12 +82,14 @@ The third is an example of using the plugin.render property to create a higher-o
 
   render() {
     return (
-      <Editor
-        placeholder="Enter some text..."
-        plugins={plugins}
-        state={this.state.state}
-        onChange={this.onChange}
-      />
+      <div className="editor">
+        <Editor
+          placeholder="Enter some text..."
+          plugins={plugins}
+          state={this.state.state}
+          onChange={this.onChange}
+        />
+      </div>
     )
   }
 
diff --git a/examples/read-only/index.js b/examples/read-only/index.js
index a149be8e2..9d6f4c0b8 100644
--- a/examples/read-only/index.js
+++ b/examples/read-only/index.js
@@ -40,12 +40,14 @@ class ReadOnly extends React.Component {
 
   render() {
     return (
-      <Editor
-        readOnly
-        placeholder="Enter some text..."
-        state={this.state.state}
-        onChange={this.onChange}
-      />
+      <div className="editor">
+        <Editor
+          readOnly
+          placeholder="Enter some text..."
+          state={this.state.state}
+          onChange={this.onChange}
+        />
+      </div>
     )
   }
 
diff --git a/examples/rich-text/index.js b/examples/rich-text/index.js
index bb5673a90..5ab49e4d5 100644
--- a/examples/rich-text/index.js
+++ b/examples/rich-text/index.js
@@ -15,7 +15,7 @@ import { isKeyHotkey } from 'is-hotkey'
 const DEFAULT_NODE = 'paragraph'
 
 /**
- * Hotkey matchers.
+ * Define hotkey matchers.
  *
  * @type {Function}
  */
@@ -25,40 +25,6 @@ const isItalicHotkey = isKeyHotkey('mod+i')
 const isUnderlinedHotkey = isKeyHotkey('mod+u')
 const isCodeHotkey = isKeyHotkey('mod+`')
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    'block-quote': props => <blockquote {...props.attributes}>{props.children}</blockquote>,
-    'bulleted-list': props => <ul {...props.attributes}>{props.children}</ul>,
-    'heading-one': props => <h1 {...props.attributes}>{props.children}</h1>,
-    'heading-two': props => <h2 {...props.attributes}>{props.children}</h2>,
-    'list-item': props => <li {...props.attributes}>{props.children}</li>,
-    'numbered-list': props => <ol {...props.attributes}>{props.children}</ol>,
-  },
-  marks: {
-    bold: {
-      fontWeight: 'bold'
-    },
-    code: {
-      fontFamily: 'monospace',
-      backgroundColor: '#eee',
-      padding: '3px',
-      borderRadius: '4px'
-    },
-    italic: {
-      fontStyle: 'italic'
-    },
-    underlined: {
-      textDecoration: 'underline'
-    }
-  }
-}
-
 /**
  * The rich text example.
  *
@@ -296,16 +262,53 @@ class RichTextExample extends React.Component {
       <div className="editor">
         <Editor
           placeholder="Enter some rich text..."
-          schema={schema}
-          spellCheck
           state={this.state.state}
           onChange={this.onChange}
           onKeyDown={this.onKeyDown}
+          renderNode={this.renderNode}
+          renderMark={this.renderMark}
+          spellCheck
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, children, node } = props
+    switch (node.type) {
+      case 'block-quote': return <blockquote {...attributes}>{children}</blockquote>
+      case 'bulleted-list': return <ul {...attributes}>{children}</ul>
+      case 'heading-one': return <h1 {...attributes}>{children}</h1>
+      case 'heading-two': return <h2 {...attributes}>{children}</h2>
+      case 'list-item': return <li {...attributes}>{children}</li>
+      case 'numbered-list': return <ol {...attributes}>{children}</ol>
+    }
+  }
+
+  /**
+   * Render a Slate mark.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderMark = (props) => {
+    const { children, mark } = props
+    switch (mark.type) {
+      case 'bold': return <strong>{children}</strong>
+      case 'code': return <code>{children}</code>
+      case 'italic': return <em>{children}</em>
+      case 'underlined': return <u>{children}</u>
+    }
+  }
+
 }
 
 /**
diff --git a/examples/rtl/index.js b/examples/rtl/index.js
index 2a32addfd..5ef9a7fe2 100644
--- a/examples/rtl/index.js
+++ b/examples/rtl/index.js
@@ -5,25 +5,13 @@ import { State } from 'slate'
 import React from 'react'
 import initialState from './state.json'
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    'block-quote': props => <blockquote {...props.attributes}>{props.children}</blockquote>,
-  }
-}
-
 /**
  * The plain text example.
  *
  * @type {Component}
  */
 
-class PlainText extends React.Component {
+class RTL extends React.Component {
 
   /**
    * Deserialize the initial editor state.
@@ -68,20 +56,36 @@ class PlainText extends React.Component {
 
   render() {
     return (
-      <Editor
-        placeholder="Enter some plain text..."
-        schema={schema}
-        state={this.state.state}
-        onChange={this.onChange}
-        onKeyDown={this.onKeyDown}
-      />
+      <div className="editor">
+        <Editor
+          placeholder="Enter some plain text..."
+          state={this.state.state}
+          onChange={this.onChange}
+          onKeyDown={this.onKeyDown}
+          renderNode={this.renderNode}
+        />
+      </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, children, node } = props
+    switch (node.type) {
+      case 'block-quote': return <blockquote {...attributes}>{children}</blockquote>
+    }
+  }
+
 }
 
 /**
  * Export.
  */
 
-export default PlainText
+export default RTL
diff --git a/examples/search-highlighting/index.js b/examples/search-highlighting/index.js
index a5735f1ea..6ad2a1f31 100644
--- a/examples/search-highlighting/index.js
+++ b/examples/search-highlighting/index.js
@@ -5,20 +5,6 @@ import { State } from 'slate'
 import React from 'react'
 import initialState from './state.json'
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  marks: {
-    highlight: {
-      backgroundColor: '#ffeeba'
-    }
-  }
-}
-
 /**
  * The rich text example.
  *
@@ -130,16 +116,30 @@ class SearchHighlighting extends React.Component {
     return (
       <div className="editor">
         <Editor
+          placeholder="Enter some rich text..."
           state={this.state.state}
           onChange={this.onChange}
-          schema={schema}
-          placeholder="Enter some rich text..."
+          renderMark={this.renderMark}
           spellCheck
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate mark.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderMark = (props) => {
+    const { children, mark } = props
+    switch (mark.type) {
+      case 'highlight': return <span style={{ backgroundColor: '#ffeeba' }}>{children}</span>
+    }
+  }
+
 }
 
 /**
diff --git a/examples/syncing-operations/index.js b/examples/syncing-operations/index.js
index e080b7212..82e457520 100644
--- a/examples/syncing-operations/index.js
+++ b/examples/syncing-operations/index.js
@@ -17,32 +17,6 @@ const isItalicHotkey = isKeyHotkey('mod+i')
 const isUnderlinedHotkey = isKeyHotkey('mod+u')
 const isCodeHotkey = isKeyHotkey('mod+`')
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  marks: {
-    bold: {
-      fontWeight: 'bold'
-    },
-    code: {
-      fontFamily: 'monospace',
-      backgroundColor: '#eee',
-      padding: '3px',
-      borderRadius: '4px'
-    },
-    italic: {
-      fontStyle: 'italic'
-    },
-    underlined: {
-      textDecoration: 'underline'
-    }
-  }
-}
-
 /**
  * A simple editor component to demo syncing with.
  *
@@ -205,17 +179,34 @@ class SyncingEditor extends React.Component {
     return (
       <div className="editor">
         <Editor
+          placeholder="Enter some text..."
           state={this.state.state}
           onChange={this.onChange}
           onKeyDown={this.onKeyDown}
-          schema={schema}
-          placeholder="Enter some text..."
+          renderMark={this.renderMark}
           spellCheck
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate mark.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderMark = (props) => {
+    const { children, mark } = props
+    switch (mark.type) {
+      case 'bold': return <strong>{children}</strong>
+      case 'code': return <code>{children}</code>
+      case 'italic': return <em>{children}</em>
+      case 'underlined': return <u>{children}</u>
+    }
+  }
+
 }
 
 /**
diff --git a/examples/tables/index.js b/examples/tables/index.js
index 20601fa43..3e17f4354 100644
--- a/examples/tables/index.js
+++ b/examples/tables/index.js
@@ -5,23 +5,6 @@ import { State } from 'slate'
 import React from 'react'
 import initialState from './state.json'
 
-/**
- * Define a schema.
- *
- * @type {Object}
- */
-
-const schema = {
-  nodes: {
-    'table': props => <table><tbody {...props.attributes}>{props.children}</tbody></table>,
-    'table-row': props => <tr {...props.attributes}>{props.children}</tr>,
-    'table-cell': props => <td {...props.attributes}>{props.children}</td>,
-  },
-  marks: {
-    'bold': props => <strong>{props.children}</strong>
-  }
-}
-
 /**
  * The tables example.
  *
@@ -38,7 +21,7 @@ class Tables extends React.Component {
 
   state = {
     state: State.fromJSON(initialState)
-  };
+  }
 
   /**
    * On backspace, do nothing if at the start of a table cell.
@@ -135,15 +118,46 @@ class Tables extends React.Component {
       <div className="editor">
         <Editor
           placeholder="Enter some text..."
-          schema={schema}
           state={this.state.state}
-          onKeyDown={this.onKeyDown}
           onChange={this.onChange}
+          onKeyDown={this.onKeyDown}
+          renderNode={this.renderNode}
+          renderMark={this.renderMark}
         />
       </div>
     )
   }
 
+  /**
+   * Render a Slate node.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderNode = (props) => {
+    const { attributes, children, node } = props
+    switch (node.type) {
+      case 'table': return <table><tbody {...attributes}>{children}</tbody></table>
+      case 'table-row': return <tr {...attributes}>{children}</tr>
+      case 'table-cell': return <td {...attributes}>{children}</td>
+    }
+  }
+
+  /**
+   * Render a Slate mark.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  renderMark = (props) => {
+    const { children, mark } = props
+    switch (mark.type) {
+      case 'bold': return <strong>{children}</strong>
+    }
+  }
+
 }
 
 /**
diff --git a/packages/slate-react/src/components/content.js b/packages/slate-react/src/components/content.js
index 1ab26638b..24f9cde9f 100644
--- a/packages/slate-react/src/components/content.js
+++ b/packages/slate-react/src/components/content.js
@@ -435,7 +435,8 @@ class Content extends React.Component {
   renderNode = (child, isSelected) => {
     const { editor, readOnly, schema, state } = this.props
     const { document, decorations } = state
-    let decs = document.getDecorations(schema)
+    const stack = editor.getStack()
+    let decs = document.getDecorations(stack)
     if (decorations) decs = decorations.concat(decs)
     return (
       <Node
diff --git a/packages/slate-react/src/components/default-node.js b/packages/slate-react/src/components/default-node.js
deleted file mode 100644
index c672e79bb..000000000
--- a/packages/slate-react/src/components/default-node.js
+++ /dev/null
@@ -1,51 +0,0 @@
-
-import React from 'react'
-import SlateTypes from 'slate-prop-types'
-import Types from 'prop-types'
-
-/**
- * Default node.
- *
- * @type {Component}
- */
-
-class DefaultNode extends React.Component {
-
-  /**
-   * Prop types.
-   *
-   * @type {Object}
-   */
-
-  static propTypes = {
-    attributes: Types.object.isRequired,
-    editor: Types.object.isRequired,
-    isSelected: Types.bool.isRequired,
-    node: SlateTypes.node.isRequired,
-    parent: SlateTypes.node.isRequired,
-    readOnly: Types.bool.isRequired,
-    state: SlateTypes.state.isRequired,
-  }
-
-  /**
-   * Render.
-   *
-   * @return {Element}
-   */
-
-  render() {
-    const { attributes, children, node } = this.props
-    const Tag = node.kind == 'block' ? 'div' : 'span'
-    const style = { position: 'relative' }
-    return <Tag {...attributes} style={style}>{children}</Tag>
-  }
-
-}
-
-/**
- * Export.
- *
- * @type {Component}
- */
-
-export default DefaultNode
diff --git a/packages/slate-react/src/components/default-placeholder.js b/packages/slate-react/src/components/default-placeholder.js
deleted file mode 100644
index ad3e041c9..000000000
--- a/packages/slate-react/src/components/default-placeholder.js
+++ /dev/null
@@ -1,64 +0,0 @@
-
-import React from 'react'
-import SlateTypes from 'slate-prop-types'
-import Types from 'prop-types'
-
-/**
- * Default placeholder.
- *
- * @type {Component}
- */
-
-class DefaultPlaceholder extends React.Component {
-
-  /**
-   * Property types.
-   *
-   * @type {Object}
-   */
-
-  static propTypes = {
-    editor: Types.object.isRequired,
-    isSelected: Types.bool.isRequired,
-    node: SlateTypes.node.isRequired,
-    parent: SlateTypes.node.isRequired,
-    readOnly: Types.bool.isRequired,
-    state: SlateTypes.state.isRequired,
-  }
-
-  /**
-   * Render.
-   *
-   * @return {Element}
-   */
-
-  render() {
-    const { editor, state } = this.props
-    if (!editor.props.placeholder) return null
-    if (state.document.getBlocks().size > 1) return null
-
-    const style = {
-      pointerEvents: 'none',
-      display: 'inline-block',
-      width: '0',
-      maxWidth: '100%',
-      whiteSpace: 'nowrap',
-      opacity: '0.333',
-    }
-
-    return (
-      <span contentEditable={false} style={style}>
-        {editor.props.placeholder}
-      </span>
-    )
-  }
-
-}
-
-/**
- * Export.
- *
- * @type {Component}
- */
-
-export default DefaultPlaceholder
diff --git a/packages/slate-react/src/components/editor.js b/packages/slate-react/src/components/editor.js
index 07da9fd30..53f428ee2 100644
--- a/packages/slate-react/src/components/editor.js
+++ b/packages/slate-react/src/components/editor.js
@@ -5,7 +5,7 @@ import React from 'react'
 import SlateTypes from 'slate-prop-types'
 import Types from 'prop-types'
 import logger from 'slate-dev-logger'
-import { Stack, State } from 'slate'
+import { Schema, Stack, State } from 'slate'
 
 import EVENT_HANDLERS from '../constants/event-handlers'
 import AfterPlugin from '../plugins/after'
@@ -53,7 +53,6 @@ class Editor extends React.Component {
     autoCorrect: Types.bool,
     autoFocus: Types.bool,
     className: Types.string,
-    onBeforeChange: Types.func,
     onChange: Types.func,
     placeholder: Types.any,
     placeholderClassName: Types.string,
@@ -85,7 +84,7 @@ class Editor extends React.Component {
   }
 
   /**
-   * When constructed, create a new `Stack` and run `onBeforeChange`.
+   * Constructor.
    *
    * @param {Object} props
    */
@@ -99,12 +98,14 @@ class Editor extends React.Component {
     // special significance on the editor itself.
     const plugins = resolvePlugins(props)
     const stack = Stack.create({ plugins })
+    const schema = Schema.create({ plugins })
+    this.state.schema = schema
     this.state.stack = stack
 
-    // Run `onBeforeChange` on the passed-in state because we need to ensure
-    // that it is normalized, and queue the resulting change.
+    // Run `onChange` on the passed-in state because we need to ensure that it
+    // is normalized, and queue the resulting change.
     const change = props.state.change()
-    stack.handle('onBeforeChange', change, this)
+    stack.run('onChange', change, this)
     const { state } = change
     this.queueChange(change)
     this.cacheState(state)
@@ -128,28 +129,37 @@ class Editor extends React.Component {
 
   /**
    * When the `props` are updated, create a new `Stack` if necessary and run
-   * `onBeforeChange` to ensure the state is normalized.
+   * `onChange` to ensure the state is normalized.
    *
    * @param {Object} props
    */
 
   componentWillReceiveProps = (props) => {
-    let { stack } = this.state
+    let { state } = props
+    let { schema, stack } = this.state
+    let isNew = false
 
-    // If any plugin-related properties will change, create a new `Stack`.
+    // Check to see if any plugin-related properœties have changed.
     for (let i = 0; i < PLUGINS_PROPS.length; i++) {
       const prop = PLUGINS_PROPS[i]
       if (props[prop] == this.props[prop]) continue
-      const plugins = resolvePlugins(props)
-      stack = Stack.create({ plugins })
-      this.setState({ stack })
+      isNew = true
+      break
     }
 
-    // Run `onBeforeChange` on the passed-in state because we need to ensure
-    // that it is normalized, and queue the resulting change.
-    const change = props.state.change()
-    stack.handle('onBeforeChange', change, this)
-    const { state } = change
+    // If any plugin-related properties will change, create a new `Stack`.
+    if (isNew) {
+      const plugins = resolvePlugins(props)
+      stack = Stack.create({ plugins })
+      schema = Schema.create({ plugins })
+      this.setState({ schema, stack })
+    }
+
+    // Run `onChange` on the passed-in state because we need to ensure that it
+    // is normalized, and queue the resulting change.
+    const change = state.change()
+    stack.run('onChange', change, this)
+    state = change.state
     this.queueChange(change)
     this.cacheState(state)
     this.setState({ state })
@@ -208,8 +218,10 @@ class Editor extends React.Component {
 
     if (change) {
       debug('flushChange', { change })
-      this.props.onChange(change)
-      delete this.tmp.change
+      window.requestAnimationFrame(() => {
+        delete this.tmp.change
+        this.props.onChange(change)
+      })
     }
   }
 
@@ -236,7 +248,17 @@ class Editor extends React.Component {
    */
 
   getSchema = () => {
-    return this.state.stack.schema
+    return this.state.schema
+  }
+
+  /**
+   * Get the editor's current stack.
+   *
+   * @return {Stack}
+   */
+
+  getStack = () => {
+    return this.state.stack
   }
 
   /**
@@ -258,7 +280,6 @@ class Editor extends React.Component {
   change = (...args) => {
     const { state } = this.state
     const change = state.change().call(...args)
-    debug('change', { change })
     this.onChange(change)
   }
 
@@ -266,13 +287,13 @@ class Editor extends React.Component {
    * On event.
    *
    * @param {String} handler
-   * @param {Mixed} ...args
+   * @param {Event} event
    */
 
-  onEvent = (handler, ...args) => {
+  onEvent = (handler, event) => {
     const { stack, state } = this.state
     const change = state.change()
-    stack.handle(handler, change, this, ...args)
+    stack.run(handler, event, change, this)
     this.onChange(change)
   }
 
@@ -283,22 +304,19 @@ class Editor extends React.Component {
    */
 
   onChange = (change) => {
+    debug('onChange', { change })
+
     if (State.isState(change)) {
       throw new Error('As of slate@0.22.0 the `editor.onChange` method must be passed a `Change` object not a `State` object.')
     }
 
     const { stack } = this.state
-
-    stack.handle('onBeforeChange', change, this)
-    stack.handle('onChange', change, this)
-
+    stack.run('onChange', change, this)
     const { state } = change
     const { document, selection } = this.tmp
     const { onChange, onDocumentChange, onSelectionChange } = this.props
 
     if (state == this.state.state) return
-
-    debug('onChange', { change })
     onChange(change)
     if (onDocumentChange && state.document != document) onDocumentChange(state.document, change)
     if (onSelectionChange && state.selection != selection) onSelectionChange(state.selection, change)
@@ -311,19 +329,15 @@ class Editor extends React.Component {
    */
 
   render() {
-    const { props, state } = this
-    const { stack } = state
+    debug('render', this)
+
+    const { stack, state } = this.state
     const children = stack
-      .renderPortal(state.state, this)
+      .map('renderPortal', state, this)
       .map((child, i) => <Portal key={i} isOpened>{child}</Portal>)
 
-    debug('render', { props, state })
-
-    const tree = stack.render(state.state, this, {
-      ...props,
-      children,
-    })
-
+    const props = { ...this.props, children }
+    const tree = stack.render('renderEditor', props, state, this)
     return tree
   }
 
diff --git a/packages/slate-react/src/components/leaf.js b/packages/slate-react/src/components/leaf.js
index 3d69390af..0cb5976b6 100644
--- a/packages/slate-react/src/components/leaf.js
+++ b/packages/slate-react/src/components/leaf.js
@@ -84,18 +84,17 @@ class Leaf extends React.Component {
    */
 
   render() {
-    const { props } = this
-    const { node, index } = props
+    this.debug('render', this)
+
+    const { node, index } = this.props
     const offsetKey = OffsetKey.stringify({
       key: node.key,
       index
     })
 
-    this.debug('render', { props })
-
     return (
       <span data-offset-key={offsetKey}>
-        {this.renderMarks(props)}
+        {this.renderMarks()}
       </span>
     )
   }
@@ -103,43 +102,29 @@ class Leaf extends React.Component {
   /**
    * Render all of the leaf's mark components.
    *
-   * @param {Object} props
    * @return {Element}
    */
 
-  renderMarks(props) {
-    const { marks, schema, node, offset, text, state, editor } = props
-    const children = this.renderText(props)
+  renderMarks() {
+    const { marks, schema, node, offset, text, state, editor } = this.props
+    const stack = editor.getStack()
+    const leaf = this.renderText()
 
-    return marks.reduce((memo, mark) => {
-      const Component = mark.getComponent(schema)
-      if (!Component) return memo
-      return (
-        <Component
-          editor={editor}
-          mark={mark}
-          marks={marks}
-          node={node}
-          offset={offset}
-          schema={schema}
-          state={state}
-          text={text}
-        >
-          {memo}
-        </Component>
-      )
-    }, children)
+    return marks.reduce((children, mark) => {
+      const props = { editor, mark, marks, node, offset, schema, state, text, children }
+      const element = stack.find('renderMark', props)
+      return element || children
+    }, leaf)
   }
 
   /**
    * Render the text content of the leaf, accounting for browsers.
    *
-   * @param {Object} props
    * @return {Element}
    */
 
-  renderText(props) {
-    const { block, node, parent, text, index, leaves } = props
+  renderText() {
+    const { block, node, parent, text, index, leaves } = this.props
 
     // COMPAT: If the text is empty and it's the only child, we need to render a
     // <br/> to get the block to have the proper height.
diff --git a/packages/slate-react/src/components/node.js b/packages/slate-react/src/components/node.js
index 8469c17a6..e1bd41d7b 100644
--- a/packages/slate-react/src/components/node.js
+++ b/packages/slate-react/src/components/node.js
@@ -43,20 +43,6 @@ class Node extends React.Component {
     state: SlateTypes.state.isRequired,
   }
 
-  /**
-   * Constructor.
-   *
-   * @param {Object} props
-   */
-
-  constructor(props) {
-    super(props)
-    const { node, schema } = props
-    this.state = {}
-    this.state.Component = node.getComponent(schema)
-    this.state.Placeholder = node.getPlaceholder(schema)
-  }
-
   /**
    * Debug.
    *
@@ -70,19 +56,6 @@ class Node extends React.Component {
     debug(message, `${key} (${type})`, ...args)
   }
 
-  /**
-   * On receiving new props, update the `Component` renderer.
-   *
-   * @param {Object} props
-   */
-
-  componentWillReceiveProps = (props) => {
-    if (props.node == this.props.node) return
-    const Component = props.node.getComponent(props.schema)
-    const Placeholder = props.node.getPlaceholder(props.schema)
-    this.setState({ Component, Placeholder })
-  }
-
   /**
    * Should the node update?
    *
@@ -93,24 +66,15 @@ class Node extends React.Component {
 
   shouldComponentUpdate = (nextProps) => {
     const { props } = this
-    const { Component } = this.state
+    const stack = props.editor.getStack()
+    const shouldUpdate = stack.find('shouldNodeComponentUpdate', props, nextProps)
     const n = nextProps
     const p = props
 
-    // If the `Component` has enabled suppression of update checking, always
-    // return true so that it can deal with update checking itself.
-    if (Component && Component.suppressShouldComponentUpdate) {
-      logger.deprecate('2.2.0', 'The `suppressShouldComponentUpdate` property is deprecated because it led to an important performance loss, use `shouldNodeComponentUpdate` instead.')
-      return true
-    }
-
     // If the `Component` has a custom logic to determine whether the component
-    // needs to be updated or not, return true if it returns true.
-    // If it returns false, we still want to benefit from the
-    // performance gain of the rest of the logic.
-    if (Component && Component.shouldNodeComponentUpdate) {
-      const shouldUpdate = Component.shouldNodeComponentUpdate(p, n)
-
+    // needs to be updated or not, return true if it returns true. If it returns
+    // false, we need to ignore it, because it shouldn't be allowed it.
+    if (shouldUpdate != null) {
       if (shouldUpdate) {
         return true
       }
@@ -151,15 +115,13 @@ class Node extends React.Component {
    */
 
   render() {
-    const { props } = this
+    this.debug('render', this)
 
-    this.debug('render', { props })
-
-    const { editor, isSelected, node, parent, readOnly, state } = props
-    const { Component, Placeholder } = this.state
+    const { editor, isSelected, node, parent, readOnly, state } = this.props
     const { selection } = state
+    const stack = editor.getStack()
     const indexes = node.getSelectionIndexes(selection, isSelected)
-    const children = node.nodes.toArray().map((child, i) => {
+    let children = node.nodes.toArray().map((child, i) => {
       const isChildSelected = !!indexes && indexes.start <= i && i < indexes.end
       return this.renderNode(child, isChildSelected)
     })
@@ -175,22 +137,24 @@ class Node extends React.Component {
       if (direction == 'rtl') attributes.dir = 'rtl'
     }
 
-    const p = {
+    const props = {
+      key: node.key,
       editor,
       isSelected,
-      key: node.key,
       node,
       parent,
       readOnly,
       state
     }
 
-    const element = (
-      <Component {...p} attributes={attributes}>
-        {Placeholder && <Placeholder {...p} />}
-        {children}
-      </Component>
-    )
+    let placeholder = stack.find('renderPlaceholder', props)
+
+    if (placeholder) {
+      placeholder = React.cloneElement(placeholder, { key: `${node.key}-placeholder` })
+      children = [placeholder, ...children]
+    }
+
+    const element = stack.find('renderNode', { ...props, attributes, children })
 
     return node.isVoid
       ? <Void {...this.props}>{element}</Void>
@@ -207,8 +171,9 @@ class Node extends React.Component {
 
   renderNode = (child, isSelected) => {
     const { block, decorations, editor, node, readOnly, schema, state } = this.props
-    const Component = child.kind === 'text' ? Text : Node
-    const decs = decorations.concat(node.getDecorations(schema))
+    const Component = child.kind == 'text' ? Text : Node
+    const stack = editor.getStack()
+    const decs = decorations.concat(node.getDecorations(stack))
     return (
       <Component
         block={node.kind == 'block' ? node : block}
diff --git a/packages/slate-react/src/plugins/after.js b/packages/slate-react/src/plugins/after.js
index 39115a405..e4f97c5b3 100644
--- a/packages/slate-react/src/plugins/after.js
+++ b/packages/slate-react/src/plugins/after.js
@@ -4,13 +4,11 @@ import Debug from 'debug'
 import Plain from 'slate-plain-serializer'
 import React from 'react'
 import getWindow from 'get-window'
-import { Block, Inline, Text, coreSchema } from 'slate'
+import { Block, Inline, Text } from 'slate'
 
 import EVENT_HANDLERS from '../constants/event-handlers'
 import HOTKEYS from '../constants/hotkeys'
 import Content from '../components/content'
-import DefaultNode from '../components/default-node'
-import DefaultPlaceholder from '../components/default-placeholder'
 import findDOMNode from '../utils/find-dom-node'
 import findNode from '../utils/find-node'
 import findPoint from '../utils/find-point'
@@ -38,28 +36,6 @@ const debug = Debug('slate:core:after')
 function AfterPlugin(options = {}) {
   let isDraggingInternally = null
 
-  /**
-   * On before change, enforce the editor's schema.
-   *
-   * @param {Change} change
-   * @param {Editor} editor
-   */
-
-  function onBeforeChange(change, editor) {
-    const { state } = change
-    const schema = editor.getSchema()
-    const prevState = editor.getState()
-
-    // PERF: Skip normalizing if the document hasn't changed, since schemas only
-    // normalize changes to the document, not selection.
-    if (prevState && state.document == prevState.document) return
-
-    debug('onBeforeChange')
-
-    change.normalize(coreSchema)
-    change.normalize(schema)
-  }
-
   /**
    * On before input, correct any browser inconsistencies.
    *
@@ -684,7 +660,7 @@ function AfterPlugin(options = {}) {
   }
 
   /**
-   * Render.
+   * Render editor.
    *
    * @param {Object} props
    * @param {State} state
@@ -692,7 +668,7 @@ function AfterPlugin(options = {}) {
    * @return {Object}
    */
 
-  function render(props, state, editor) {
+  function renderEditor(props, state, editor) {
     const handlers = EVENT_HANDLERS.reduce((obj, handler) => {
       obj[handler] = editor[handler]
       return obj
@@ -719,22 +695,48 @@ function AfterPlugin(options = {}) {
   }
 
   /**
-   * Add default rendering rules to the schema.
+   * Render node.
    *
-   * @type {Object}
+   * @param {Object} props
+   * @return {Element}
    */
 
-  const schema = {
-    rules: [
-      {
-        match: obj => obj.kind == 'block' || obj.kind == 'inline',
-        render: DefaultNode,
-      },
-      {
-        match: obj => obj.kind == 'block' && Text.isTextList(obj.nodes) && obj.text == '',
-        placeholder: DefaultPlaceholder,
-      },
-    ]
+  function renderNode(props) {
+    const { attributes, children, node } = props
+    if (node.kind != 'block' && node.kind != 'inline') return
+    const Tag = node.kind == 'block' ? 'div' : 'span'
+    const style = { position: 'relative' }
+    return <Tag {...attributes} style={style}>{children}</Tag>
+  }
+
+  /**
+   * Render placeholder.
+   *
+   * @param {Object} props
+   * @return {Element}
+   */
+
+  function renderPlaceholder(props) {
+    const { editor, node, state } = props
+    if (node.kind != 'block') return
+    if (!Text.isTextList(node.nodes)) return
+    if (node.text != '') return
+    if (state.document.getBlocks().size > 1) return
+
+    const style = {
+      pointerEvents: 'none',
+      display: 'inline-block',
+      width: '0',
+      maxWidth: '100%',
+      whiteSpace: 'nowrap',
+      opacity: '0.333',
+    }
+
+    return (
+      <span contentEditable={false} style={style}>
+        {editor.props.placeholder}
+      </span>
+    )
   }
 
   /**
@@ -744,7 +746,6 @@ function AfterPlugin(options = {}) {
    */
 
   return {
-    onBeforeChange,
     onBeforeInput,
     onBlur,
     onClick,
@@ -758,8 +759,9 @@ function AfterPlugin(options = {}) {
     onKeyDown,
     onPaste,
     onSelect,
-    render,
-    schema,
+    renderEditor,
+    renderNode,
+    renderPlaceholder,
   }
 }
 
diff --git a/packages/slate-react/src/plugins/before.js b/packages/slate-react/src/plugins/before.js
index 0dd00ddd9..b264ece03 100644
--- a/packages/slate-react/src/plugins/before.js
+++ b/packages/slate-react/src/plugins/before.js
@@ -90,6 +90,27 @@ function BeforePlugin() {
     debug('onBlur', { event })
   }
 
+  /**
+   * On change.
+   *
+   * @param {Change} change
+   * @param {Editor} editor
+   */
+
+  function onChange(change, editor) {
+    const { state } = change
+    const schema = editor.getSchema()
+
+    // If the state's schema isn't the editor's schema, update it.
+    if (state.schema != schema) {
+      change
+        .setState({ schema })
+        .normalize()
+    }
+
+    debug('onChange')
+  }
+
   /**
    * On composition end.
    *
@@ -377,6 +398,7 @@ function BeforePlugin() {
   return {
     onBeforeInput,
     onBlur,
+    onChange,
     onCompositionEnd,
     onCompositionStart,
     onCopy,
diff --git a/packages/slate-react/test/rendering/fixtures/custom-block-multiple.js b/packages/slate-react/test/rendering/fixtures/custom-block-multiple.js
index f31a3155b..df8415738 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-block-multiple.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-block-multiple.js
@@ -3,18 +3,24 @@
 import React from 'react'
 import h from '../../helpers/h'
 
-export const schema = {
-  nodes: {
-    code: (props) => {
-      return (
-        React.createElement('pre', props.attributes,
-          React.createElement('code', {}, props.children)
-        )
-      )
-    }
+function Code(props) {
+  return (
+    React.createElement('pre', props.attributes,
+      React.createElement('code', {}, props.children)
+    )
+  )
+}
+
+function renderNode(props) {
+  switch (props.node.type) {
+    case 'code': return Code(props)
   }
 }
 
+export const props = {
+  renderNode,
+}
+
 export const state = (
   <state>
     <document>
diff --git a/packages/slate-react/test/rendering/fixtures/custom-block-void.js b/packages/slate-react/test/rendering/fixtures/custom-block-void.js
index 8ec3274e6..5ef58a18b 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-block-void.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-block-void.js
@@ -3,16 +3,22 @@
 import React from 'react'
 import h from '../../helpers/h'
 
-export const schema = {
-  nodes: {
-    image: (props) => {
-      return (
-        React.createElement('img', { src: props.node.data.get('src'), ...props.attributes })
-      )
-    }
+function Image(props) {
+  return (
+    React.createElement('img', { src: props.node.data.get('src'), ...props.attributes })
+  )
+}
+
+function renderNode(props) {
+  switch (props.node.type) {
+    case 'image': return Image(props)
   }
 }
 
+export const props = {
+  renderNode,
+}
+
 export const state = (
   <state>
     <document>
diff --git a/packages/slate-react/test/rendering/fixtures/custom-block.js b/packages/slate-react/test/rendering/fixtures/custom-block.js
index 95bc912af..d5260cdab 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-block.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-block.js
@@ -3,14 +3,18 @@
 import React from 'react'
 import h from '../../helpers/h'
 
-export const schema = {
-  nodes: {
-    code: (props) => {
-      return (
-        React.createElement('pre', props.attributes,
-          React.createElement('code', {}, props.children)
-        )
-      )
+function Code(props) {
+  return (
+    React.createElement('pre', props.attributes,
+      React.createElement('code', {}, props.children)
+    )
+  )
+}
+
+export const props = {
+  renderNode(p) {
+    switch (p.node.type) {
+      case 'code': return Code(p)
     }
   }
 }
diff --git a/packages/slate-react/test/rendering/fixtures/custom-decorator.js b/packages/slate-react/test/rendering/fixtures/custom-decorator.js
index bdf306d1b..1b244d702 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-decorator.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-decorator.js
@@ -1,29 +1,34 @@
 /** @jsx h */
 
+import React from 'react'
 import h from '../../helpers/h'
 
-export const schema = {
-  nodes: {
-    paragraph: {
-      decorate(block) {
-        const text = block.getFirstText()
-        return [{
-          anchorKey: text.key,
-          anchorOffset: 1,
-          focusKey: text.key,
-          focusOffset: 2,
-          marks: [{ type: 'bold' }]
-        }]
-      }
-    }
-  },
-  marks: {
-    bold: {
-      fontWeight: 'bold',
-    }
+function decorateNode(block) {
+  const text = block.getFirstText()
+  return [{
+    anchorKey: text.key,
+    anchorOffset: 1,
+    focusKey: text.key,
+    focusOffset: 2,
+    marks: [{ type: 'bold' }]
+  }]
+}
+
+function Bold(props) {
+  return React.createElement('strong', null, props.children)
+}
+
+function renderMark(props) {
+  switch (props.mark.type) {
+    case 'bold': return Bold(props)
   }
 }
 
+export const props = {
+  decorateNode,
+  renderMark,
+}
+
 export const state = (
   <state>
     <document>
@@ -39,7 +44,7 @@ export const output = `
   <div style="position:relative">
     <span>
       <span>o</span>
-      <span><span style="font-weight:bold">n</span></span>
+      <span><strong>n</strong></span>
       <span>e</span>
     </span>
   </div>
diff --git a/packages/slate-react/test/rendering/fixtures/custom-inline-multiple.js b/packages/slate-react/test/rendering/fixtures/custom-inline-multiple.js
index 4ccab05c2..8b0a1993d 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-inline-multiple.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-inline-multiple.js
@@ -3,16 +3,22 @@
 import React from 'react'
 import h from '../../helpers/h'
 
-export const schema = {
-  nodes: {
-    link: (props) => {
-      return (
-        React.createElement('a', { href: props.node.data.get('href'), ...props.attributes }, props.children)
-      )
-    }
+function Link(props) {
+  return (
+    React.createElement('a', { href: props.node.data.get('href'), ...props.attributes }, props.children)
+  )
+}
+
+function renderNode(props) {
+  switch (props.node.type) {
+    case 'link': return Link(props)
   }
 }
 
+export const props = {
+  renderNode,
+}
+
 export const state = (
   <state>
     <document>
diff --git a/packages/slate-react/test/rendering/fixtures/custom-inline-void.js b/packages/slate-react/test/rendering/fixtures/custom-inline-void.js
index 8bdf49f40..ebeda406c 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-inline-void.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-inline-void.js
@@ -3,16 +3,22 @@
 import React from 'react'
 import h from '../../helpers/h'
 
-export const schema = {
-  nodes: {
-    emoji: (props) => {
-      return (
-        React.createElement('img', props.attributes)
-      )
-    }
+function Emoji(props) {
+  return (
+    React.createElement('img', props.attributes)
+  )
+}
+
+function renderNode(props) {
+  switch (props.node.type) {
+    case 'emoji': return Emoji(props)
   }
 }
 
+export const props = {
+  renderNode,
+}
+
 export const state = (
   <state>
     <document>
diff --git a/packages/slate-react/test/rendering/fixtures/custom-inline.js b/packages/slate-react/test/rendering/fixtures/custom-inline.js
index c50cad041..96e8e94f2 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-inline.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-inline.js
@@ -3,16 +3,22 @@
 import React from 'react'
 import h from '../../helpers/h'
 
-export const schema = {
-  nodes: {
-    link: (props) => {
-      return (
-        React.createElement('a', { href: props.node.data.get('href'), ...props.attributes }, props.children)
-      )
-    }
+function Link(props) {
+  return (
+    React.createElement('a', { href: props.node.data.get('href'), ...props.attributes }, props.children)
+  )
+}
+
+function renderNode(props) {
+  switch (props.node.type) {
+    case 'link': return Link(props)
   }
 }
 
+export const props = {
+  renderNode,
+}
+
 export const state = (
   <state>
     <document>
diff --git a/packages/slate-react/test/rendering/fixtures/custom-mark-as-function.js b/packages/slate-react/test/rendering/fixtures/custom-mark-as-function.js
deleted file mode 100644
index 87d30db98..000000000
--- a/packages/slate-react/test/rendering/fixtures/custom-mark-as-function.js
+++ /dev/null
@@ -1,36 +0,0 @@
-/** @jsx h */
-
-import React from 'react'
-import h from '../../helpers/h'
-
-export const schema = {
-  marks: {
-    bold: (props) => {
-      return (
-        React.createElement('strong', {}, props.children)
-      )
-    }
-  }
-}
-
-export const state = (
-  <state>
-    <document>
-      <paragraph>
-        one<b>two</b>three
-      </paragraph>
-    </document>
-  </state>
-)
-
-export const output = `
-<div data-slate-editor="true" contenteditable="true" role="textbox">
-  <div style="position:relative">
-    <span>
-      <span>one</span>
-      <span><strong>two</strong></span>
-      <span>three</span>
-    </span>
-  </div>
-</div>
-`.trim()
diff --git a/packages/slate-react/test/rendering/fixtures/custom-mark-as-object.js b/packages/slate-react/test/rendering/fixtures/custom-mark-as-object.js
deleted file mode 100644
index bace25646..000000000
--- a/packages/slate-react/test/rendering/fixtures/custom-mark-as-object.js
+++ /dev/null
@@ -1,33 +0,0 @@
-/** @jsx h */
-
-import h from '../../helpers/h'
-
-export const schema = {
-  marks: {
-    bold: {
-      fontWeight: 'bold'
-    }
-  }
-}
-
-export const state = (
-  <state>
-    <document>
-      <paragraph>
-        one<b>two</b>three
-      </paragraph>
-    </document>
-  </state>
-)
-
-export const output = `
-<div data-slate-editor="true" contenteditable="true" role="textbox">
-  <div style="position:relative">
-    <span>
-      <span>one</span>
-      <span><span style="font-weight:bold">two</span></span>
-      <span>three</span>
-    </span>
-  </div>
-</div>
-`.trim()
diff --git a/packages/slate-react/test/rendering/fixtures/custom-mark-as-string.js b/packages/slate-react/test/rendering/fixtures/custom-mark-as-string.js
deleted file mode 100644
index e835f31cd..000000000
--- a/packages/slate-react/test/rendering/fixtures/custom-mark-as-string.js
+++ /dev/null
@@ -1,31 +0,0 @@
-/** @jsx h */
-
-import h from '../../helpers/h'
-
-export const schema = {
-  marks: {
-    bold: 'bold',
-  }
-}
-
-export const state = (
-  <state>
-    <document>
-      <paragraph>
-        one<b>two</b>three
-      </paragraph>
-    </document>
-  </state>
-)
-
-export const output = `
-<div data-slate-editor="true" contenteditable="true" role="textbox">
-  <div style="position:relative">
-    <span>
-      <span>one</span>
-      <span><span class="bold">two</span></span>
-      <span>three</span>
-    </span>
-  </div>
-</div>
-`.trim()
diff --git a/packages/slate-react/test/rendering/fixtures/custom-mark-as-component.js b/packages/slate-react/test/rendering/fixtures/custom-mark.js
similarity index 69%
rename from packages/slate-react/test/rendering/fixtures/custom-mark-as-component.js
rename to packages/slate-react/test/rendering/fixtures/custom-mark.js
index ba21aced8..f46bdc23d 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-mark-as-component.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-mark.js
@@ -3,22 +3,20 @@
 import React from 'react'
 import h from '../../helpers/h'
 
-class Bold extends React.Component {
-
-  render() {
-    return (
-      React.createElement('strong', {}, this.props.children)
-    )
-  }
-
+function Bold(props) {
+  return React.createElement('strong', null, props.children)
 }
 
-export const schema = {
-  marks: {
-    bold: Bold,
+function renderMark(props) {
+  switch (props.mark.type) {
+    case 'bold': return Bold(props)
   }
 }
 
+export const props = {
+  renderMark,
+}
+
 export const state = (
   <state>
     <document>
diff --git a/packages/slate-react/test/rendering/fixtures/default-block-with-inline.js b/packages/slate-react/test/rendering/fixtures/default-block-with-inline.js
index 833f628b7..8a4b4d1ef 100644
--- a/packages/slate-react/test/rendering/fixtures/default-block-with-inline.js
+++ b/packages/slate-react/test/rendering/fixtures/default-block-with-inline.js
@@ -2,7 +2,7 @@
 
 import h from '../../helpers/h'
 
-export const schema = {}
+export const props = {}
 
 export const state = (
   <state>
diff --git a/packages/slate-react/test/rendering/fixtures/default-block.js b/packages/slate-react/test/rendering/fixtures/default-block.js
index cf5b8b693..d672d7391 100644
--- a/packages/slate-react/test/rendering/fixtures/default-block.js
+++ b/packages/slate-react/test/rendering/fixtures/default-block.js
@@ -2,7 +2,7 @@
 
 import h from '../../helpers/h'
 
-export const schema = {}
+export const props = {}
 
 export const state = (
   <state>
diff --git a/packages/slate-react/test/rendering/fixtures/empty-block-with-inline.js b/packages/slate-react/test/rendering/fixtures/empty-block-with-inline.js
index be70099c3..ce996f858 100644
--- a/packages/slate-react/test/rendering/fixtures/empty-block-with-inline.js
+++ b/packages/slate-react/test/rendering/fixtures/empty-block-with-inline.js
@@ -2,7 +2,7 @@
 
 import h from '../../helpers/h'
 
-export const schema = {}
+export const props = {}
 
 export const state = (
   <state>
@@ -17,6 +17,7 @@ export const state = (
 export const output = `
 <div data-slate-editor="true" contenteditable="true" role="textbox">
   <div style="position:relative">
+    <span contenteditable="false" style="pointer-events:none;display:inline-block;width:0;max-width:100%;white-space:nowrap;opacity:0.333"></span>
     <span>
       <span><br></span>
     </span>
diff --git a/packages/slate-react/test/rendering/fixtures/empty-block.js b/packages/slate-react/test/rendering/fixtures/empty-block.js
index 29972734b..4541c4097 100644
--- a/packages/slate-react/test/rendering/fixtures/empty-block.js
+++ b/packages/slate-react/test/rendering/fixtures/empty-block.js
@@ -2,7 +2,7 @@
 
 import h from '../../helpers/h'
 
-export const schema = {}
+export const props = {}
 
 export const state = (
   <state>
@@ -15,6 +15,7 @@ export const state = (
 export const output = `
 <div data-slate-editor="true" contenteditable="true" role="textbox">
   <div style="position:relative">
+    <span contenteditable="false" style="pointer-events:none;display:inline-block;width:0;max-width:100%;white-space:nowrap;opacity:0.333"></span>
     <span>
       <span><br></span>
     </span>
diff --git a/packages/slate-react/test/rendering/fixtures/nested-text-direction.js b/packages/slate-react/test/rendering/fixtures/nested-text-direction.js
index f73943cd3..d3e363036 100644
--- a/packages/slate-react/test/rendering/fixtures/nested-text-direction.js
+++ b/packages/slate-react/test/rendering/fixtures/nested-text-direction.js
@@ -2,7 +2,7 @@
 
 import h from '../../helpers/h'
 
-export const schema = {}
+export const props = {}
 
 export const state = (
   <state>
diff --git a/packages/slate-react/test/rendering/fixtures/readonly-custom-block-void.js b/packages/slate-react/test/rendering/fixtures/readonly-custom-block-void.js
index bbf489800..4d7c845a8 100644
--- a/packages/slate-react/test/rendering/fixtures/readonly-custom-block-void.js
+++ b/packages/slate-react/test/rendering/fixtures/readonly-custom-block-void.js
@@ -3,18 +3,19 @@
 import React from 'react'
 import h from '../../helpers/h'
 
-export const schema = {
-  nodes: {
-    image: (props) => {
-      return (
-        React.createElement('img', { src: props.node.data.get('src'), ...props.attributes })
-      )
-    }
+function Image(props) {
+  return React.createElement('img', { src: props.node.data.get('src'), ...props.attributes })
+}
+
+function renderNode(props) {
+  switch (props.node.type) {
+    case 'image': return Image(props)
   }
 }
 
 export const props = {
   readOnly: true,
+  renderNode,
 }
 
 export const state = (
diff --git a/packages/slate-react/test/rendering/fixtures/readonly-custom-inline-void.js b/packages/slate-react/test/rendering/fixtures/readonly-custom-inline-void.js
index fdca540fb..fe1a669f2 100644
--- a/packages/slate-react/test/rendering/fixtures/readonly-custom-inline-void.js
+++ b/packages/slate-react/test/rendering/fixtures/readonly-custom-inline-void.js
@@ -3,18 +3,21 @@
 import React from 'react'
 import h from '../../helpers/h'
 
-export const schema = {
-  nodes: {
-    emoji: (props) => {
-      return (
-        React.createElement('img', props.attributes)
-      )
-    }
+function Emoji(props) {
+  return (
+    React.createElement('img', props.attributes)
+  )
+}
+
+function renderNode(props) {
+  switch (props.node.type) {
+    case 'emoji': return Emoji(props)
   }
 }
 
 export const props = {
   readOnly: true,
+  renderNode,
 }
 
 export const state = (
diff --git a/packages/slate-react/test/rendering/fixtures/text-direction.js b/packages/slate-react/test/rendering/fixtures/text-direction.js
index 6a9643667..a64b56220 100644
--- a/packages/slate-react/test/rendering/fixtures/text-direction.js
+++ b/packages/slate-react/test/rendering/fixtures/text-direction.js
@@ -2,7 +2,7 @@
 
 import h from '../../helpers/h'
 
-export const schema = {}
+export const props = {}
 
 export const state = (
   <state>
diff --git a/packages/slate-react/test/rendering/index.js b/packages/slate-react/test/rendering/index.js
index 93372ea40..19f475982 100644
--- a/packages/slate-react/test/rendering/index.js
+++ b/packages/slate-react/test/rendering/index.js
@@ -19,10 +19,9 @@ describe('rendering', () => {
   for (const test of tests) {
     it(test, async () => {
       const module = require(resolve(dir, test))
-      const { state, schema, output, props } = module
+      const { state, output, props } = module
       const p = {
         state,
-        schema,
         onChange() {},
         ...(props || {}),
       }
diff --git a/packages/slate/benchmark/changes/normalize.js b/packages/slate/benchmark/changes/normalize.js
index c60593a08..9ae0c58e4 100644
--- a/packages/slate/benchmark/changes/normalize.js
+++ b/packages/slate/benchmark/changes/normalize.js
@@ -2,12 +2,11 @@
 /* eslint-disable react/jsx-key */
 
 import h from '../../test/helpers/h'
-import SCHEMA from '../../lib/schemas/core'
 
 export default function (state) {
   state
     .change()
-    .normalize(SCHEMA)
+    .normalize()
 }
 
 export const input = (
diff --git a/packages/slate/src/changes/at-range.js b/packages/slate/src/changes/at-range.js
index ad4741c8a..cbfffa758 100644
--- a/packages/slate/src/changes/at-range.js
+++ b/packages/slate/src/changes/at-range.js
@@ -6,7 +6,6 @@ import Inline from '../models/inline'
 import Mark from '../models/mark'
 import Node from '../models/node'
 import String from '../utils/string'
-import SCHEMA from '../schemas/core'
 
 /**
  * Changes.
@@ -242,7 +241,7 @@ Changes.deleteAtRange = (change, range, options = {}) => {
 
     // If we should normalize, do it now after everything.
     if (normalize) {
-      change.normalizeNodeByKey(ancestor.key, SCHEMA)
+      change.normalizeNodeByKey(ancestor.key)
     }
   }
 }
@@ -667,7 +666,7 @@ Changes.insertBlockAtRange = (change, range, block, options = {}) => {
   }
 
   if (normalize) {
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -780,7 +779,7 @@ Changes.insertFragmentAtRange = (change, range, fragment, options = {}) => {
 
   // Normalize if requested.
   if (normalize) {
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -816,7 +815,7 @@ Changes.insertInlineAtRange = (change, range, inline, options = {}) => {
   change.insertNodeByKey(parent.key, index + 1, inline, { normalize: false })
 
   if (normalize) {
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -1111,7 +1110,7 @@ Changes.unwrapBlockAtRange = (change, range, properties, options = {}) => {
 
   // TODO: optmize to only normalize the right block
   if (normalize) {
-    change.normalizeDocument(SCHEMA)
+    change.normalizeDocument()
   }
 }
 
@@ -1157,7 +1156,7 @@ Changes.unwrapInlineAtRange = (change, range, properties, options = {}) => {
 
   // TODO: optmize to only normalize the right block
   if (normalize) {
-    change.normalizeDocument(SCHEMA)
+    change.normalizeDocument()
   }
 }
 
@@ -1228,7 +1227,7 @@ Changes.wrapBlockAtRange = (change, range, block, options = {}) => {
   })
 
   if (normalize) {
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -1300,7 +1299,7 @@ Changes.wrapInlineAtRange = (change, range, inline, options = {}) => {
     })
 
     if (normalize) {
-      change.normalizeNodeByKey(startBlock.key, SCHEMA)
+      change.normalizeNodeByKey(startBlock.key)
     }
   }
 
@@ -1323,8 +1322,8 @@ Changes.wrapInlineAtRange = (change, range, inline, options = {}) => {
 
     if (normalize) {
       change
-        .normalizeNodeByKey(startBlock.key, SCHEMA)
-        .normalizeNodeByKey(endBlock.key, SCHEMA)
+        .normalizeNodeByKey(startBlock.key)
+        .normalizeNodeByKey(endBlock.key)
     }
 
     blocks.slice(1, -1).forEach((block) => {
@@ -1336,7 +1335,7 @@ Changes.wrapInlineAtRange = (change, range, inline, options = {}) => {
       })
 
       if (normalize) {
-        change.normalizeNodeByKey(block.key, SCHEMA)
+        change.normalizeNodeByKey(block.key)
       }
     })
   }
diff --git a/packages/slate/src/changes/by-key.js b/packages/slate/src/changes/by-key.js
index e005af91a..e98354c29 100644
--- a/packages/slate/src/changes/by-key.js
+++ b/packages/slate/src/changes/by-key.js
@@ -3,7 +3,6 @@ import Block from '../models/block'
 import Inline from '../models/inline'
 import Mark from '../models/mark'
 import Node from '../models/node'
-import SCHEMA from '../schemas/core'
 
 /**
  * Changes.
@@ -68,7 +67,7 @@ Changes.addMarkByKey = (change, key, offset, length, mark, options = {}) => {
 
   if (normalize) {
     const parent = document.getParent(key)
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -91,7 +90,7 @@ Changes.insertFragmentByKey = (change, key, index, fragment, options = {}) => {
   })
 
   if (normalize) {
-    change.normalizeNodeByKey(key, SCHEMA)
+    change.normalizeNodeByKey(key)
   }
 }
 
@@ -119,7 +118,7 @@ Changes.insertNodeByKey = (change, key, index, node, options = {}) => {
   })
 
   if (normalize) {
-    change.normalizeNodeByKey(key, SCHEMA)
+    change.normalizeNodeByKey(key)
   }
 }
 
@@ -153,7 +152,7 @@ Changes.insertTextByKey = (change, key, offset, text, marks, options = {}) => {
 
   if (normalize) {
     const parent = document.getParent(key)
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -187,7 +186,7 @@ Changes.mergeNodeByKey = (change, key, options = {}) => {
 
   if (normalize) {
     const parent = document.getParent(key)
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -218,7 +217,7 @@ Changes.moveNodeByKey = (change, key, newKey, newIndex, options = {}) => {
 
   if (normalize) {
     const parent = document.getCommonAncestor(key, newKey)
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -277,7 +276,7 @@ Changes.removeMarkByKey = (change, key, offset, length, mark, options = {}) => {
 
   if (normalize) {
     const parent = document.getParent(key)
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -305,7 +304,7 @@ Changes.removeNodeByKey = (change, key, options = {}) => {
 
   if (normalize) {
     const parent = document.getParent(key)
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -362,7 +361,7 @@ Changes.removeTextByKey = (change, key, offset, length, options = {}) => {
 
   if (normalize) {
     const block = document.getClosestBlock(key)
-    change.normalizeNodeByKey(block.key, SCHEMA)
+    change.normalizeNodeByKey(block.key)
   }
 }
 
@@ -387,7 +386,7 @@ Changes.replaceNodeByKey = (change, key, newNode, options = {}) => {
   change.removeNodeByKey(key, { normalize: false })
   change.insertNodeByKey(parent.key, index, newNode, options)
   if (normalize) {
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -422,7 +421,7 @@ Changes.setMarkByKey = (change, key, offset, length, mark, properties, options =
 
   if (normalize) {
     const parent = document.getParent(key)
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -452,7 +451,7 @@ Changes.setNodeByKey = (change, key, properties, options = {}) => {
   })
 
   if (normalize) {
-    change.normalizeNodeByKey(node.key, SCHEMA)
+    change.normalizeNodeByKey(node.key)
   }
 }
 
@@ -481,7 +480,7 @@ Changes.splitNodeByKey = (change, key, position, options = {}) => {
 
   if (normalize) {
     const parent = document.getParent(key)
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -520,7 +519,7 @@ Changes.splitDescendantsByKey = (change, key, textKey, textOffset, options = {})
 
   if (normalize) {
     const parent = document.getParent(key)
-    change.normalizeNodeByKey(parent.key, SCHEMA)
+    change.normalizeNodeByKey(parent.key)
   }
 }
 
@@ -614,34 +613,11 @@ Changes.unwrapNodeByKey = (change, key, options = {}) => {
     change.moveNodeByKey(key, parentParent.key, parentIndex + 1, { normalize: false })
 
     if (normalize) {
-      change.normalizeNodeByKey(parentParent.key, SCHEMA)
+      change.normalizeNodeByKey(parentParent.key)
     }
   }
 }
 
-/**
- * Wrap a node in an inline with `properties`.
- *
- * @param {Change} change
- * @param {String} key The node to wrap
- * @param {Block|Object|String} inline The wrapping inline (its children are discarded)
- * @param {Object} options
- *   @property {Boolean} normalize
- */
-
-Changes.wrapInlineByKey = (change, key, inline, options) => {
-  inline = Inline.create(inline)
-  inline = inline.set('nodes', inline.nodes.clear())
-
-  const { document } = change.state
-  const node = document.assertDescendant(key)
-  const parent = document.getParent(node.key)
-  const index = parent.nodes.indexOf(node)
-
-  change.insertNodeByKey(parent.key, index, inline, { normalize: false })
-  change.moveNodeByKey(node.key, inline.key, 0, options)
-}
-
 /**
  * Wrap a node in a block with `properties`.
  *
@@ -665,6 +641,53 @@ Changes.wrapBlockByKey = (change, key, block, options) => {
   change.moveNodeByKey(node.key, block.key, 0, options)
 }
 
+/**
+ * Wrap a node in an inline with `properties`.
+ *
+ * @param {Change} change
+ * @param {String} key The node to wrap
+ * @param {Block|Object|String} inline The wrapping inline (its children are discarded)
+ * @param {Object} options
+ *   @property {Boolean} normalize
+ */
+
+Changes.wrapInlineByKey = (change, key, inline, options) => {
+  inline = Inline.create(inline)
+  inline = inline.set('nodes', inline.nodes.clear())
+
+  const { document } = change.state
+  const node = document.assertDescendant(key)
+  const parent = document.getParent(node.key)
+  const index = parent.nodes.indexOf(node)
+
+  change.insertNodeByKey(parent.key, index, inline, { normalize: false })
+  change.moveNodeByKey(node.key, inline.key, 0, options)
+}
+
+/**
+ * Wrap a node by `key` with `parent`.
+ *
+ * @param {Change} change
+ * @param {String} key
+ * @param {Node|Object} parent
+ * @param {Object} options
+ */
+
+Changes.wrapNodeByKey = (change, key, parent) => {
+  parent = Node.create(parent)
+  parent = parent.set('nodes', parent.nodes.clear())
+
+  if (parent.kind == 'block') {
+    change.wrapBlockByKey(key, parent)
+    return
+  }
+
+  if (parent.kind == 'inline') {
+    change.wrapInlineByKey(key, parent)
+    return
+  }
+}
+
 /**
  * Export.
  *
diff --git a/packages/slate/src/changes/index.js b/packages/slate/src/changes/index.js
index 712dbb780..3f3cf8a35 100644
--- a/packages/slate/src/changes/index.js
+++ b/packages/slate/src/changes/index.js
@@ -2,10 +2,10 @@
 import AtCurrentRange from './at-current-range'
 import AtRange from './at-range'
 import ByKey from './by-key'
-import Normalize from './normalize'
 import OnHistory from './on-history'
 import OnSelection from './on-selection'
 import OnState from './on-state'
+import WithSchema from './with-schema'
 
 /**
  * Export.
@@ -17,8 +17,8 @@ export default {
   ...AtCurrentRange,
   ...AtRange,
   ...ByKey,
-  ...Normalize,
   ...OnHistory,
   ...OnSelection,
   ...OnState,
+  ...WithSchema,
 }
diff --git a/packages/slate/src/changes/normalize.js b/packages/slate/src/changes/with-schema.js
similarity index 73%
rename from packages/slate/src/changes/normalize.js
rename to packages/slate/src/changes/with-schema.js
index 923f6f6e4..80eb9bfc1 100644
--- a/packages/slate/src/changes/normalize.js
+++ b/packages/slate/src/changes/with-schema.js
@@ -1,8 +1,6 @@
 
 import { Set } from 'immutable'
 
-import Schema from '../models/schema'
-
 /**
  * Changes.
  *
@@ -12,45 +10,37 @@ import Schema from '../models/schema'
 const Changes = {}
 
 /**
- * Normalize the document and selection with a `schema`.
+ * Normalize the state with its schema.
  *
  * @param {Change} change
- * @param {Schema} schema
  */
 
-Changes.normalize = (change, schema) => {
-  change.normalizeDocument(schema)
+Changes.normalize = (change) => {
+  change.normalizeDocument()
 }
 
 /**
- * Normalize the document with a `schema`.
+ * Normalize the document with the state's schema.
  *
  * @param {Change} change
- * @param {Schema} schema
  */
 
-Changes.normalizeDocument = (change, schema) => {
+Changes.normalizeDocument = (change) => {
   const { state } = change
   const { document } = state
-  change.normalizeNodeByKey(document.key, schema)
+  change.normalizeNodeByKey(document.key)
 }
 
 /**
- * Normalize a `node` and its children with a `schema`.
+ * Normalize a `node` and its children with the state's schema.
  *
  * @param {Change} change
  * @param {Node|String} key
- * @param {Schema} schema
  */
 
-Changes.normalizeNodeByKey = (change, key, schema) => {
-  assertSchema(schema)
-
-  // If the schema has no validation rules, there's nothing to normalize.
-  if (!schema.hasValidators) return
-
+Changes.normalizeNodeByKey = (change, key) => {
   const { state } = change
-  const { document } = state
+  const { document, schema } = state
   const node = document.assertNode(key)
   normalizeNodeAndChildren(change, node, schema)
 }
@@ -139,20 +129,19 @@ function refindNode(change, node) {
  */
 
 function normalizeNode(change, node, schema) {
-  const max = schema.rules.length
+  const max = schema.stack.plugins.length + 1
   let iterations = 0
 
-  function iterate(t, n) {
-    const failure = n.validate(schema)
-    if (!failure) return
+  function iterate(c, n) {
+    const normalize = n.validate(schema)
+    if (!normalize) return
 
-    // Run the `normalize` function for the rule with the invalid value.
-    const { value, rule } = failure
-    rule.normalize(t, n, value)
+    // Run the `normalize` function to fix the node.
+    normalize(c)
 
     // Re-find the node reference, in case it was updated. If the node no longer
     // exists, we're done for this branch.
-    n = refindNode(t, n)
+    n = refindNode(c, n)
     if (!n) return
 
     // Increment the iterations counter, and check to make sure that we haven't
@@ -166,28 +155,12 @@ function normalizeNode(change, node, schema) {
     }
 
     // Otherwise, iterate again.
-    iterate(t, n)
+    iterate(c, n)
   }
 
   iterate(change, node)
 }
 
-/**
- * Assert that a `schema` exists.
- *
- * @param {Schema} schema
- */
-
-function assertSchema(schema) {
-  if (Schema.isSchema(schema)) {
-    return
-  } else if (schema == null) {
-    throw new Error('You must pass a `schema` object.')
-  } else {
-    throw new Error(`You passed an invalid \`schema\` object: ${schema}.`)
-  }
-}
-
 /**
  * Export.
  *
diff --git a/packages/slate/src/constants/core-schema-rules.js b/packages/slate/src/constants/core-schema-rules.js
new file mode 100644
index 000000000..746abfd00
--- /dev/null
+++ b/packages/slate/src/constants/core-schema-rules.js
@@ -0,0 +1,281 @@
+
+import { List } from 'immutable'
+
+import Text from '../models/text'
+
+/**
+ * Define the core schema rules, order-sensitive.
+ *
+ * @type {Array}
+ */
+
+const CORE_SCHEMA_RULES = [
+
+  /**
+   * Only allow block nodes in documents.
+   *
+   * @type {Object}
+   */
+
+  {
+    validateNode(node) {
+      if (node.kind != 'document') return
+      const invalids = node.nodes.filter(n => n.kind != 'block')
+      if (!invalids.size) return
+
+      return (change) => {
+        invalids.forEach((child) => {
+          change.removeNodeByKey(child.key, { normalize: false })
+        })
+      }
+    }
+  },
+
+  /**
+   * Only allow block nodes or inline and text nodes in blocks.
+   *
+   * @type {Object}
+   */
+
+  {
+    validateNode(node) {
+      if (node.kind != 'block') return
+      const first = node.nodes.first()
+      if (!first) return
+      const kinds = first.kind == 'block' ? ['block'] : ['inline', 'text']
+      const invalids = node.nodes.filter(n => !kinds.includes(n.kind))
+      if (!invalids.size) return
+
+      return (change) => {
+        invalids.forEach((child) => {
+          change.removeNodeByKey(child.key, { normalize: false })
+        })
+      }
+    }
+  },
+
+  /**
+   * Only allow inline and text nodes in inlines.
+   *
+   * @type {Object}
+   */
+
+  {
+    validateNode(node) {
+      if (node.kind != 'inline') return
+      const invalids = node.nodes.filter(n => n.kind != 'inline' && n.kind != 'text')
+      if (!invalids.size) return
+
+      return (change) => {
+        invalids.forEach((child) => {
+          change.removeNodeByKey(child.key, { normalize: false })
+        })
+      }
+    }
+  },
+
+  /**
+   * Ensure that block and inline nodes have at least one text child.
+   *
+   * @type {Object}
+   */
+
+  {
+    validateNode(node) {
+      if (node.kind != 'block' && node.kind != 'inline') return
+      if (node.nodes.size > 0) return
+
+      return (change) => {
+        const text = Text.create()
+        change.insertNodeByKey(node.key, 0, text, { normalize: false })
+      }
+    }
+  },
+
+  /**
+   * Ensure that void nodes contain a text node with a single space of text.
+   *
+   * @type {Object}
+   */
+
+  {
+    validateNode(node) {
+      if (!node.isVoid) return
+      if (node.kind != 'block' && node.kind != 'inline') return
+      if (node.text == ' ' && node.nodes.size == 1) return
+
+      return (change) => {
+        const text = Text.create(' ')
+        const index = node.nodes.size
+
+        change.insertNodeByKey(node.key, index, text, { normalize: false })
+
+        node.nodes.forEach((child) => {
+          change.removeNodeByKey(child.key, { normalize: false })
+        })
+      }
+    }
+  },
+
+  /**
+   * Ensure that inline nodes are never empty.
+   *
+   * This rule is applied to all blocks, because when they contain an empty
+   * inline, we need to remove the inline from that parent block. If `validate`
+   * was to be memoized, it should be against the parent node, not the inline
+   * themselves.
+   *
+   * @type {Object}
+   */
+
+  {
+    validateNode(node) {
+      if (node.kind != 'block') return
+      const invalids = node.nodes.filter(n => n.kind == 'inline' && n.text == '')
+      if (!invalids.size) return
+
+      return (change) => {
+        // If all of the block's nodes are invalid, insert an empty text node so
+        // that the selection will be preserved when they are all removed.
+        if (node.nodes.size == invalids.size) {
+          const text = Text.create()
+          change.insertNodeByKey(node.key, 1, text, { normalize: false })
+        }
+
+        invalids.forEach((child) => {
+          change.removeNodeByKey(child.key, { normalize: false })
+        })
+      }
+    }
+  },
+
+  /**
+   * Ensure that inline void nodes are surrounded by text nodes, by adding extra
+   * blank text nodes if necessary.
+   *
+   * @type {Object}
+   */
+
+  {
+    validateNode(node) {
+      if (node.kind != 'block' && node.kind != 'inline') return
+
+      const invalids = node.nodes.reduce((list, child, index) => {
+        if (child.kind !== 'inline') return list
+
+        const prev = index > 0 ? node.nodes.get(index - 1) : null
+        const next = node.nodes.get(index + 1)
+        // We don't test if "prev" is inline, since it has already been processed in the loop
+        const insertBefore = !prev
+        const insertAfter = !next || (next.kind == 'inline')
+
+        if (insertAfter || insertBefore) {
+          list = list.push({ insertAfter, insertBefore, index })
+        }
+
+        return list
+      }, new List())
+
+      if (!invalids.size) return
+
+      return (change) => {
+        // Shift for every text node inserted previously.
+        let shift = 0
+
+        invalids.forEach(({ index, insertAfter, insertBefore }) => {
+          if (insertBefore) {
+            change.insertNodeByKey(node.key, shift + index, Text.create(), { normalize: false })
+            shift++
+          }
+
+          if (insertAfter) {
+            change.insertNodeByKey(node.key, shift + index + 1, Text.create(), { normalize: false })
+            shift++
+          }
+        })
+      }
+    }
+  },
+
+  /**
+   * Merge adjacent text nodes.
+   *
+   * @type {Object}
+   */
+
+  {
+    validateNode(node) {
+      if (node.kind != 'block' && node.kind != 'inline') return
+
+      const invalids = node.nodes
+        .map((child, i) => {
+          const next = node.nodes.get(i + 1)
+          if (child.kind != 'text') return
+          if (!next || next.kind != 'text') return
+          return next
+        })
+        .filter(Boolean)
+
+      if (!invalids.size) return
+
+      return (change) => {
+        // Reverse the list to handle consecutive merges, since the earlier nodes
+        // will always exist after each merge.
+        invalids.reverse().forEach((n) => {
+          change.mergeNodeByKey(n.key, { normalize: false })
+        })
+      }
+    }
+  },
+
+  /**
+   * Prevent extra empty text nodes, except when adjacent to inline void nodes.
+   *
+   * @type {Object}
+   */
+
+  {
+    validateNode(node) {
+      if (node.kind != 'block' && node.kind != 'inline') return
+      const { nodes } = node
+      if (nodes.size <= 1) return
+
+      const invalids = nodes.filter((desc, i) => {
+        if (desc.kind != 'text') return
+        if (desc.text.length > 0) return
+
+        const prev = i > 0 ? nodes.get(i - 1) : null
+        const next = nodes.get(i + 1)
+
+        // If it's the first node, and the next is a void, preserve it.
+        if (!prev && next.kind == 'inline') return
+
+        // It it's the last node, and the previous is an inline, preserve it.
+        if (!next && prev.kind == 'inline') return
+
+        // If it's surrounded by inlines, preserve it.
+        if (next && prev && next.kind == 'inline' && prev.kind == 'inline') return
+
+        // Otherwise, remove it.
+        return true
+      })
+
+      if (!invalids.size) return
+
+      return (change) => {
+        invalids.forEach((text) => {
+          change.removeNodeByKey(text.key, { normalize: false })
+        })
+      }
+    }
+  }
+
+]
+
+/**
+ * Export.
+ *
+ * @type {Array}
+ */
+
+export default CORE_SCHEMA_RULES
diff --git a/packages/slate/src/index.js b/packages/slate/src/index.js
index 8f82e03e1..ecac2bb69 100644
--- a/packages/slate/src/index.js
+++ b/packages/slate/src/index.js
@@ -16,7 +16,6 @@ import Selection from './models/selection'
 import Stack from './models/stack'
 import State from './models/state'
 import Text from './models/text'
-import coreSchema from './schemas/core'
 import { resetKeyGenerator, setKeyGenerator } from './utils/generate-key'
 
 /**
@@ -43,7 +42,6 @@ export {
   Stack,
   State,
   Text,
-  coreSchema,
   resetKeyGenerator,
   setKeyGenerator,
 }
@@ -66,7 +64,6 @@ export default {
   Stack,
   State,
   Text,
-  coreSchema,
   resetKeyGenerator,
   setKeyGenerator,
 }
diff --git a/packages/slate/src/models/node.js b/packages/slate/src/models/node.js
index 43d93d8a5..28169693c 100644
--- a/packages/slate/src/models/node.js
+++ b/packages/slate/src/models/node.js
@@ -8,6 +8,7 @@ import Block from './block'
 import Data from './data'
 import Document from './document'
 import Inline from './inline'
+import Range from './range'
 import Text from './text'
 import generateKey from '../utils/generate-key'
 import isIndexInRange from '../utils/is-index-in-range'
@@ -585,25 +586,16 @@ class Node {
   }
 
   /**
-   * Get the component for the node from a `schema`.
+   * Get the decorations for the node from a `stack`.
    *
-   * @param {Schema} schema
-   * @return {Component|Void}
+   * @param {Stack} stack
+   * @return {List}
    */
 
-  getComponent(schema) {
-    return schema.__getComponent(this)
-  }
-
-  /**
-   * Get the decorations for the node from a `schema`.
-   *
-   * @param {Schema} schema
-   * @return {Array}
-   */
-
-  getDecorations(schema) {
-    return schema.__getDecorations(this)
+  getDecorations(stack) {
+    const decorations = stack.find('decorateNode', this)
+    const list = Range.createList(decorations || [])
+    return list
   }
 
   /**
@@ -1894,11 +1886,11 @@ class Node {
    * Validate the node against a `schema`.
    *
    * @param {Schema} schema
-   * @return {Object|Null}
+   * @return {Function|Null}
    */
 
   validate(schema) {
-    return schema.__validate(this)
+    return schema.validateNode(this)
   }
 
   /**
@@ -2124,7 +2116,6 @@ memoize(Node.prototype, [
   'getClosestInline',
   'getClosestVoid',
   'getCommonAncestor',
-  'getComponent',
   'getDecorations',
   'getDepth',
   'getDescendant',
diff --git a/packages/slate/src/models/schema.js b/packages/slate/src/models/schema.js
index d248e0702..f4448e66c 100644
--- a/packages/slate/src/models/schema.js
+++ b/packages/slate/src/models/schema.js
@@ -1,14 +1,38 @@
 
-import React from 'react'
-import find from 'lodash/find'
+import Debug from 'debug'
 import isPlainObject from 'is-plain-object'
-import logger from 'slate-dev-logger'
-import typeOf from 'type-of'
+import mergeWith from 'lodash/mergeWith'
 import { Record } from 'immutable'
 
+import CORE_SCHEMA_RULES from '../constants/core-schema-rules'
 import MODEL_TYPES from '../constants/model-types'
-import Range from '../models/range'
-import isReactComponent from '../utils/is-react-component'
+import Stack from './stack'
+import memoize from '../utils/memoize'
+
+/**
+ * Validation failure reasons.
+ *
+ * @type {Object}
+ */
+
+const CHILD_KIND_INVALID = 'child_kind_invalid'
+const CHILD_REQUIRED = 'child_required'
+const CHILD_TYPE_INVALID = 'child_type_invalid'
+const CHILD_UNKNOWN = 'child_unknown'
+const NODE_DATA_INVALID = 'node_data_invalid'
+const NODE_IS_VOID_INVALID = 'node_is_void_invalid'
+const NODE_MARK_INVALID = 'node_mark_invalid'
+const NODE_TEXT_INVALID = 'node_text_invalid'
+const PARENT_KIND_INVALID = 'parent_kind_invalid'
+const PARENT_TYPE_INVALID = 'parent_type_invalid'
+
+/**
+ * Debug.
+ *
+ * @type {Function}
+ */
+
+const debug = Debug('slate:schema')
 
 /**
  * Default properties.
@@ -17,7 +41,10 @@ import isReactComponent from '../utils/is-react-component'
  */
 
 const DEFAULTS = {
-  rules: [],
+  stack: Stack.create(),
+  document: {},
+  blocks: {},
+  inlines: {},
 }
 
 /**
@@ -47,6 +74,44 @@ class Schema extends Record(DEFAULTS) {
     throw new Error(`\`Schema.create\` only accepts objects or schemas, but you passed it: ${attrs}`)
   }
 
+  /**
+   * Create a `Schema` from a JSON `object`.
+   *
+   * @param {Object} object
+   * @return {Schema}
+   */
+
+  static fromJSON(object) {
+    if (Schema.isSchema(object)) {
+      return object
+    }
+
+    let { plugins } = object
+
+    if (object.rules) {
+      throw new Error('Schemas in Slate have changed! They are no longer accept a `rules` property.')
+    }
+
+    if (object.nodes) {
+      throw new Error('Schemas in Slate have changed! They are no longer accept a `nodes` property.')
+    }
+
+    if (!plugins) {
+      plugins = [{ schema: object }]
+    }
+
+    const schema = resolveSchema(plugins)
+    const stack = Stack.create({ plugins: [ ...CORE_SCHEMA_RULES, ...plugins ] })
+    const ret = new Schema({ ...schema, stack })
+    return ret
+  }
+
+  /**
+   * Alias `fromJS`.
+   */
+
+  static fromJS = Schema.fromJSON
+
   /**
    * Check if a `value` is a `Schema`.
    *
@@ -58,25 +123,6 @@ class Schema extends Record(DEFAULTS) {
     return !!(value && value[MODEL_TYPES.SCHEMA])
   }
 
-  /**
-   * Create a `Schema` from a JSON `object`.
-   *
-   * @param {Object} object
-   * @return {Schema}
-   */
-
-  static fromJSON(object) {
-    object = normalizeProperties(object)
-    const schema = new Schema(object)
-    return schema
-  }
-
-  /**
-   * Alias `fromJS`.
-   */
-
-  static fromJS = Schema.fromJSON
-
   /**
    * Get the kind.
    *
@@ -88,225 +134,359 @@ class Schema extends Record(DEFAULTS) {
   }
 
   /**
-   * Return true if one rule can normalize the document
-   *
-   * @return {Boolean}
-   */
-
-  get hasValidators() {
-    const { rules } = this
-    return rules.some(rule => rule.validate)
-  }
-
-  /**
-   * Return true if one rule can decorate text nodes
-   *
-   * @return {Boolean}
-   */
-
-  get hasDecorators() {
-    const { rules } = this
-    return rules.some(rule => rule.decorate)
-  }
-
-  /**
-   * Return the component for an `object`.
-   *
-   * This method is private, because it should always be called on one of the
-   * often-changing immutable objects instead, since it will be memoized for
-   * much better performance.
+   * Get the rule for an `object`.
    *
    * @param {Mixed} object
-   * @return {Component|Null}
+   * @return {Object}
    */
 
-  __getComponent(object) {
-    const match = find(this.rules, rule => rule.render && rule.match(object))
-    if (!match) return null
-    return match.render
-  }
-
-  /**
-   * Return the placeholder for an `object`.
-   *
-   * This method is private, because it should always be called on one of the
-   * often-changing immutable objects instead, since it will be memoized for
-   * much better performance.
-   *
-   * @param {Mixed} object
-   * @return {Component|Null}
-   */
-
-  __getPlaceholder(object) {
-    const match = find(this.rules, rule => rule.placeholder && rule.match(object))
-    if (!match) return null
-    return match.placeholder
-  }
-
-  /**
-   * Return the decorations for an `object`.
-   *
-   * This method is private, because it should always be called on one of the
-   * often-changing immutable objects instead, since it will be memoized for
-   * much better performance.
-   *
-   * @param {Mixed} object
-   * @return {List<Range>}
-   */
-
-  __getDecorations(object) {
-    const array = []
-
-    this.rules.forEach((rule) => {
-      if (!rule.decorate) return
-      if (!rule.match(object)) return
-
-      const decorations = rule.decorate(object)
-      if (!decorations.length) return
-
-      decorations.forEach((dec) => {
-        array.push(dec)
-      })
-    })
-
-    const list = Range.createList(array)
-    return list
-  }
-
-  /**
-   * Validate an `object` against the schema, returning the failing rule and
-   * value if the object is invalid, or void if it's valid.
-   *
-   * This method is private, because it should always be called on one of the
-   * often-changing immutable objects instead, since it will be memoized for
-   * much better performance.
-   *
-   * @param {Mixed} object
-   * @return {Object|Void}
-   */
-
-  __validate(object) {
-    let value
-
-    const match = find(this.rules, (rule) => {
-      if (!rule.validate) return
-      if (!rule.match(object)) return
-
-      value = rule.validate(object)
-      return value
-    })
-
-    if (!value) return
-
-    return {
-      rule: match,
-      value,
+  getRule(object) {
+    switch (object.kind) {
+      case 'document': return this.document
+      case 'block': return this.blocks[object.type]
+      case 'inline': return this.inlines[object.type]
     }
   }
 
+  /**
+   * Get a dictionary of the parent rule validations by child type.
+   *
+   * @return {Object|Null}
+   */
+
+  getParentRules() {
+    const { blocks, inlines } = this
+    const parents = {}
+
+    for (const key in blocks) {
+      const rule = blocks[key]
+      if (rule.parent == null) continue
+      parents[key] = rule
+    }
+
+    for (const key in inlines) {
+      const rule = inlines[key]
+      if (rule.parent == null) continue
+      parents[key] = rule
+    }
+
+    return Object.keys(parents).length == 0 ? null : parents
+  }
+
+  /**
+   * Fail validation by returning a normalizing change function.
+   *
+   * @param {String} reason
+   * @param {Object} context
+   * @return {Function}
+   */
+
+  fail(reason, context) {
+    return (change) => {
+      debug(`normalizing`, { reason, context })
+      const { rule } = context
+      const count = change.operations.length
+      if (rule.normalize) rule.normalize(change, reason, context)
+      if (change.operations.length > count) return
+      this.normalize(change, reason, context)
+    }
+  }
+
+  /**
+   * Normalize an invalid state with `reason` and `context`.
+   *
+   * @param {Change} change
+   * @param {String} reason
+   * @param {Mixed} context
+   */
+
+  normalize(change, reason, context) {
+    switch (reason) {
+      case CHILD_KIND_INVALID:
+      case CHILD_TYPE_INVALID:
+      case CHILD_UNKNOWN: {
+        const { child, node } = context
+        return child.kind == 'text' && node.kind == 'block' && node.nodes.size == 1
+          ? change.removeNodeByKey(node.key)
+          : change.removeNodeByKey(child.key)
+      }
+
+      case CHILD_REQUIRED:
+      case NODE_TEXT_INVALID:
+      case PARENT_KIND_INVALID:
+      case PARENT_TYPE_INVALID: {
+        const { node } = context
+        return node.kind == 'document'
+          ? node.nodes.forEach(child => change.removeNodeByKey(child.key))
+          : change.removeNodeByKey(node.key)
+      }
+
+      case NODE_DATA_INVALID: {
+        const { node, key } = context
+        return node.data.get(key) === undefined && node.kind != 'document'
+          ? change.removeNodeByKey(node.key)
+          : change.setNodeByKey(node.key, { data: node.data.delete(key) })
+      }
+
+      case NODE_IS_VOID_INVALID: {
+        const { node } = context
+        return change.setNodeByKey(node.key, { isVoid: !node.isVoid })
+      }
+
+      case NODE_MARK_INVALID: {
+        const { node, mark } = context
+        return node.getTexts().forEach(t => change.removeMarkByKey(t.key, 0, t.text.length, mark))
+      }
+    }
+  }
+
+  /**
+   * Validate a `node` with the schema, returning a function that will fix the
+   * invalid node, or void if the node is valid.
+   *
+   * @param {Node} node
+   * @return {Function|Void}
+   */
+
+  validateNode(node) {
+    const ret = this.stack.find('validateNode', node)
+    if (ret) return ret
+
+    if (node.kind == 'text') return
+
+    const rule = this.getRule(node) || {}
+    const parents = this.getParentRules()
+    const ctx = { node, rule }
+
+    if (rule.isVoid != null) {
+      if (node.isVoid != rule.isVoid) {
+        return this.fail(NODE_IS_VOID_INVALID, ctx)
+      }
+    }
+
+    if (rule.data != null) {
+      for (const key in rule.data) {
+        const fn = rule.data[key]
+        const value = node.data.get(key)
+
+        if (!fn(value)) {
+          return this.fail(NODE_DATA_INVALID, { ...ctx, key, value })
+        }
+      }
+    }
+
+    if (rule.marks != null) {
+      const marks = node.getMarks().toArray()
+
+      for (const mark of marks) {
+        for (const def of rule.marks) {
+          if (def.type != mark.type) {
+            return this.fail(NODE_MARK_INVALID, { ...ctx, mark })
+          }
+        }
+      }
+    }
+
+    if (rule.text != null) {
+      const { text } = node
+
+      if (!rule.text.test(text)) {
+        return this.fail(NODE_TEXT_INVALID, { ...ctx, text })
+      }
+    }
+
+    if (rule.nodes != null || parents != null) {
+      const children = node.nodes.toArray()
+      const defs = rule.nodes != null ? rule.nodes.slice() : []
+
+      let offset
+      let min
+      let index
+      let def
+      let max
+      let child
+
+      function nextDef() {
+        offset = offset == null ? null : 0
+        def = defs.shift()
+        min = def && (def.min == null ? 0 : def.min)
+        max = def && (def.max == null ? Infinity : def.max)
+        return !!def
+      }
+
+      function nextChild() {
+        index = index == null ? 0 : index + 1
+        offset = offset == null ? 0 : offset + 1
+        child = children[index]
+        if (max != null && offset == max) nextDef()
+        return !!child
+      }
+
+      if (rule.nodes != null) {
+        nextDef()
+      }
+
+      while (nextChild()) {
+        if (parents != null && child.kind != 'text' && child.type in parents) {
+          const r = parents[child.type]
+
+          if (r.parent.kinds != null && !r.parent.kinds.includes(node.kind)) {
+            return this.fail(PARENT_KIND_INVALID, { node: child, parent: node, rule: r })
+          }
+
+          if (r.parent.types != null && !r.parent.types.includes(node.type)) {
+            return this.fail(PARENT_TYPE_INVALID, { node: child, parent: node, rule: r })
+          }
+        }
+
+        if (rule.nodes != null) {
+          if (!def) {
+            return this.fail(CHILD_UNKNOWN, { ...ctx, child, index })
+          }
+
+          if (def.kinds != null && !def.kinds.includes(child.kind)) {
+            if (offset >= min && nextDef()) continue
+            return this.fail(CHILD_KIND_INVALID, { ...ctx, child, index })
+          }
+
+          if (def.types != null && !def.types.includes(child.type)) {
+            if (offset >= min && nextDef()) continue
+            return this.fail(CHILD_TYPE_INVALID, { ...ctx, child, index })
+          }
+        }
+      }
+
+      if (rule.nodes != null) {
+        while (min != null) {
+          if (offset < min) {
+            return this.fail(CHILD_REQUIRED, { ...ctx, index })
+          }
+
+          nextDef()
+        }
+      }
+    }
+  }
+
+  /**
+   * Return a JSON representation of the schema.
+   *
+   * @return {Object}
+   */
+
+  toJSON() {
+    const object = {
+      kind: this.kind,
+      document: this.document,
+      blocks: this.blocks,
+      inlines: this.inlines,
+    }
+
+    return object
+  }
+
+  /**
+   * Alias `toJS`.
+   */
+
+  toJS() {
+    return this.toJSON()
+  }
+
 }
 
 /**
- * Normalize the `properties` of a schema.
+ * Resolve a set of schema rules from an array of `plugins`.
  *
- * @param {Object} properties
+ * @param {Array} plugins
  * @return {Object}
  */
 
-function normalizeProperties(properties) {
-  let { rules = [], nodes, marks } = properties
-
-  if (nodes) {
-    const array = normalizeNodes(nodes)
-    rules = rules.concat(array)
+function resolveSchema(plugins = []) {
+  const schema = {
+    document: {},
+    blocks: {},
+    inlines: {},
   }
 
-  if (marks) {
-    const array = normalizeMarks(marks)
-    rules = rules.concat(array)
-  }
+  plugins.slice().reverse().forEach((plugin) => {
+    if (!plugin.schema) return
 
-  if (properties.transform) {
-    logger.deprecate('0.22.0', 'The `schema.transform` property has been deprecated in favor of `schema.change`.')
-    properties.change = properties.transform
-    delete properties.transform
-  }
+    if (plugin.schema.rules) {
+      throw new Error('Schemas in Slate have changed! They are no longer accept a `rules` property.')
+    }
 
-  return { rules }
+    if (plugin.schema.nodes) {
+      throw new Error('Schemas in Slate have changed! They are no longer accept a `nodes` property.')
+    }
+
+    const { document = {}, blocks = {}, inlines = {}} = plugin.schema
+    const d = resolveDocumentRule(document)
+    const bs = {}
+    const is = {}
+
+    for (const key in blocks) {
+      bs[key] = resolveNodeRule('block', key, blocks[key])
+    }
+
+    for (const key in inlines) {
+      is[key] = resolveNodeRule('inline', key, inlines[key])
+    }
+
+    mergeWith(schema.document, d, customizer)
+    mergeWith(schema.blocks, bs, customizer)
+    mergeWith(schema.inlines, is, customizer)
+  })
+
+  return schema
 }
 
 /**
- * Normalize a `nodes` shorthand argument.
+ * Resolve a document rule `obj`.
  *
- * @param {Object} nodes
- * @return {Array}
+ * @param {Object} obj
+ * @return {Object}
  */
 
-function normalizeNodes(nodes) {
-  const rules = []
-
-  for (const key in nodes) {
-    let rule = nodes[key]
-
-    if (typeOf(rule) == 'function' || isReactComponent(rule)) {
-      rule = { render: rule }
-    }
-
-    rule.match = (object) => {
-      return (
-        (object.kind == 'block' || object.kind == 'inline') &&
-        object.type == key
-      )
-    }
-
-    rules.push(rule)
+function resolveDocumentRule(obj) {
+  return {
+    data: {},
+    nodes: null,
+    ...obj,
   }
-
-  return rules
 }
 
 /**
- * Normalize a `marks` shorthand argument.
+ * Resolve a node rule with `type` from `obj`.
  *
- * @param {Object} marks
- * @return {Array}
+ * @param {String} kind
+ * @param {String} type
+ * @param {Object} obj
+ * @return {Object}
  */
 
-function normalizeMarks(marks) {
-  const rules = []
-
-  for (const key in marks) {
-    let rule = marks[key]
-
-    if (!rule.render && !rule.decorator && !rule.validate) {
-      rule = { render: rule }
-    }
-
-    rule.render = normalizeMarkComponent(rule.render)
-    rule.match = object => object.kind == 'mark' && object.type == key
-    rules.push(rule)
+function resolveNodeRule(kind, type, obj) {
+  return {
+    data: {},
+    isVoid: null,
+    nodes: null,
+    parent: null,
+    text: null,
+    ...obj,
   }
-
-  return rules
 }
 
 /**
- * Normalize a mark `render` property.
+ * A Lodash customizer for merging `kinds` and `types` arrays.
  *
- * @param {Component|Function|Object|String} render
- * @return {Component}
+ * @param {Mixed} target
+ * @param {Mixed} source
+ * @return {Array|Void}
  */
 
-function normalizeMarkComponent(render) {
-  if (isReactComponent(render)) return render
-
-  switch (typeOf(render)) {
-    case 'function':
-      return render
-    case 'object':
-      return props => <span style={render}>{props.children}</span>
-    case 'string':
-      return props => <span className={render}>{props.children}</span>
+function customizer(target, source, key) {
+  if (key == 'kinds' || key == 'types') {
+    return target == null ? source : target.concat(source)
   }
 }
 
@@ -316,6 +496,16 @@ function normalizeMarkComponent(render) {
 
 Schema.prototype[MODEL_TYPES.SCHEMA] = true
 
+/**
+ * Memoize read methods.
+ */
+
+memoize(Schema.prototype, [
+  'getParentRules',
+], {
+  takesArguments: true,
+})
+
 /**
  * Export.
  *
diff --git a/packages/slate/src/models/stack.js b/packages/slate/src/models/stack.js
index c3d225bc7..a52b21e23 100644
--- a/packages/slate/src/models/stack.js
+++ b/packages/slate/src/models/stack.js
@@ -1,17 +1,8 @@
 
-import Debug from 'debug'
 import { Record } from 'immutable'
 
 import MODEL_TYPES from '../constants/model-types'
-import Schema from './schema'
-
-/**
- * Debug.
- *
- * @type {Function}
- */
-
-const debug = Debug('slate:stack')
+import memoize from '../utils/memoize'
 
 /**
  * Default properties.
@@ -21,7 +12,6 @@ const debug = Debug('slate:stack')
 
 const DEFAULTS = {
   plugins: [],
-  schema: new Schema(),
 }
 
 /**
@@ -36,15 +26,11 @@ class Stack extends Record(DEFAULTS) {
    * Constructor.
    *
    * @param {Object} attrs
-   *   @property {Array} plugins
-   *   @property {Schema|Object} schema
-   *   @property {Function} ...handlers
    */
 
   static create(attrs = {}) {
-    const { plugins } = attrs
-    const schema = resolveSchema(plugins)
-    const stack = new Stack({ plugins, schema })
+    const { plugins = [] } = attrs
+    const stack = new Stack({ plugins })
     return stack
   }
 
@@ -70,72 +56,91 @@ class Stack extends Record(DEFAULTS) {
   }
 
   /**
-   * Invoke an event `handler` on all of the plugins, until one of them decides
-   * to stop propagation.
+   * Get all plugins with `property`.
    *
-   * @param {String} handler
-   * @param {Change} change
-   * @param {Editor} editor
-   * @param {Mixed} ...args
-   */
-
-  handle(handler, change, editor, ...args) {
-    debug(handler)
-
-    for (let k = 0; k < this.plugins.length; k++) {
-      const plugin = this.plugins[k]
-      if (!plugin[handler]) continue
-      const next = plugin[handler](...args, change, editor)
-      if (next != null) break
-    }
-  }
-
-  /**
-   * Invoke `render` on all of the plugins in reverse, building up a tree of
-   * higher-order components.
-   *
-   * @param {State} state
-   * @param {Editor} editor
-   * @param {Object} children
-   * @param {Object} props
-   * @return {Component}
-   */
-
-  render(state, editor, props) {
-    debug('render')
-    const plugins = this.plugins.slice().reverse()
-    let children
-
-    for (let i = 0; i < plugins.length; i++) {
-      const plugin = plugins[i]
-      if (!plugin.render) continue
-      children = plugin.render(props, state, editor)
-      props.children = children
-    }
-
-    return children
-  }
-
-  /**
-   * Invoke `renderPortal` on all of the plugins, building a list of portals.
-   *
-   * @param {State} state
-   * @param {Editor} editor
+   * @param {String} property
    * @return {Array}
    */
 
-  renderPortal(state, editor) {
-    debug('renderPortal')
-    const portals = []
+  getPluginsWith(property) {
+    return this.plugins.filter(plugin => plugin[property] != null)
+  }
 
-    for (let i = 0; i < this.plugins.length; i++) {
-      const plugin = this.plugins[i]
-      if (!plugin.renderPortal) continue
-      const portal = plugin.renderPortal(state, editor)
-      if (portal) portals.push(portal)
+  /**
+   * Iterate the plugins with `property`, returning the first non-null value.
+   *
+   * @param {String} property
+   * @param {Any} ...args
+   */
+
+  find(property, ...args) {
+    const plugins = this.getPluginsWith(property)
+
+    for (let i = 0; i < plugins.length; i++) {
+      const plugin = plugins[i]
+      const ret = plugin[property](...args)
+      if (ret != null) return ret
+    }
+  }
+
+  /**
+   * Iterate the plugins with `property`, returning all the non-null values.
+   *
+   * @param {String} property
+   * @param {Any} ...args
+   * @return {Array}
+   */
+
+  map(property, ...args) {
+    const plugins = this.getPluginsWith(property)
+    const array = []
+
+    for (let i = 0; i < plugins.length; i++) {
+      const plugin = plugins[i]
+      const value = plugin[property](...args)
+      if (value != null) array.push(value)
     }
 
-    return portals
+    return array
+  }
+
+  /**
+   * Iterate the plugins with `property`, breaking on any a non-null values.
+   *
+   * @param {String} property
+   * @param {Any} ...args
+   */
+
+  run(property, ...args) {
+    const plugins = this.getPluginsWith(property)
+
+    for (let i = 0; i < plugins.length; i++) {
+      const plugin = plugins[i]
+      const ret = plugin[property](...args)
+      if (ret != null) return
+    }
+  }
+
+  /**
+   * Iterate the plugins with `property`, reducing to a set of React children.
+   *
+   * @param {String} property
+   * @param {Object} props
+   * @param {Any} ...args
+   */
+
+  render(property, props, ...args) {
+    const plugins = this.getPluginsWith(property).reverse()
+    let { children = null } = props
+
+    for (let i = 0; i < plugins.length; i++) {
+      const plugin = plugins[i]
+      const value = plugin[property](props, ...args)
+      if (value == null) continue
+      props.children = children = value
+    }
+
+    return children
   }
 
 }
@@ -147,25 +152,14 @@ class Stack extends Record(DEFAULTS) {
 Stack.prototype[MODEL_TYPES.STACK] = true
 
 /**
- * Resolve a schema from a set of `plugins`.
- *
- * @param {Array} plugins
- * @return {Schema}
+ * Memoize read methods.
  */
 
-function resolveSchema(plugins) {
-  let rules = []
-
-  for (let i = 0; i < plugins.length; i++) {
-    const plugin = plugins[i]
-    if (plugin.schema == null) continue
-    const schema = Schema.create(plugin.schema)
-    rules = rules.concat(schema.rules)
-  }
-
-  const schema = Schema.create({ rules })
-  return schema
-}
+memoize(Stack.prototype, [
+  'getPluginsWith',
+], {
+  takesArguments: true,
+})
 
 /**
  * Export.
diff --git a/packages/slate/src/models/state.js b/packages/slate/src/models/state.js
index 59b314c37..9ba3b217e 100644
--- a/packages/slate/src/models/state.js
+++ b/packages/slate/src/models/state.js
@@ -4,11 +4,11 @@ import logger from 'slate-dev-logger'
 import { Record, Set, List, Map } from 'immutable'
 
 import MODEL_TYPES from '../constants/model-types'
-import SCHEMA from '../schemas/core'
 import Data from './data'
 import Document from './document'
 import History from './history'
 import Range from './range'
+import Schema from './schema'
 
 /**
  * Default properties.
@@ -17,11 +17,12 @@ import Range from './range'
  */
 
 const DEFAULTS = {
-  document: Document.create(),
-  selection: Range.create(),
-  history: History.create(),
   data: new Map(),
   decorations: null,
+  document: Document.create(),
+  history: History.create(),
+  schema: Schema.create(),
+  selection: Range.create(),
 }
 
 /**
@@ -64,6 +65,7 @@ class State extends Record(DEFAULTS) {
       return {
         data: attrs.data,
         decorations: attrs.decorations,
+        schema: attrs.schema,
       }
     }
 
@@ -71,6 +73,7 @@ class State extends Record(DEFAULTS) {
       const props = {}
       if ('data' in attrs) props.data = Data.create(attrs.data)
       if ('decorations' in attrs) props.decorations = Range.createList(attrs.decorations)
+      if ('schema' in attrs) props.schema = Schema.create(attrs.schema)
       return props
     }
 
@@ -91,12 +94,14 @@ class State extends Record(DEFAULTS) {
     let {
       document = {},
       selection = {},
+      schema = {},
     } = object
 
     let data = new Map()
 
     document = Document.fromJSON(document)
     selection = Range.fromJSON(selection)
+    schema = Schema.fromJSON(schema)
 
     // Allow plugins to set a default value for `data`.
     if (options.plugins) {
@@ -119,14 +124,11 @@ class State extends Record(DEFAULTS) {
       data,
       document,
       selection,
+      schema,
     })
 
-
     if (options.normalize !== false) {
-      state = state
-        .change({ save: false })
-        .normalize(SCHEMA)
-        .state
+      state = state.change({ save: false }).normalize().state
     }
 
     return state
@@ -640,10 +642,11 @@ class State extends Record(DEFAULTS) {
     const object = {
       kind: this.kind,
       data: this.data.toJSON(),
-      document: this.document.toJSON(options),
-      selection: this.selection.toJSON(),
       decorations: this.decorations ? this.decorations.toArray().map(d => d.toJSON()) : null,
+      document: this.document.toJSON(options),
       history: this.history.toJSON(),
+      selection: this.selection.toJSON(),
+      schema: this.schema.toJSON(),
     }
 
     if ('preserveStateData' in options) {
@@ -667,6 +670,10 @@ class State extends Record(DEFAULTS) {
       delete object.selection
     }
 
+    if (!options.preserveSchema) {
+      delete object.schema
+    }
+
     if (options.preserveSelection && !options.preserveKeys) {
       const { document, selection } = this
       object.selection.anchorPath = selection.isSet ? document.getPath(selection.anchorKey) : null
diff --git a/packages/slate/src/models/text.js b/packages/slate/src/models/text.js
index ece39a8f6..e1259ff0e 100644
--- a/packages/slate/src/models/text.js
+++ b/packages/slate/src/models/text.js
@@ -514,7 +514,7 @@ class Text extends Record(DEFAULTS) {
    */
 
   validate(schema) {
-    return schema.__validate(this)
+    return schema.validateNode(this)
   }
 
   /**
diff --git a/packages/slate/src/schemas/Readme.md b/packages/slate/src/schemas/Readme.md
deleted file mode 100644
index 9e2443e75..000000000
--- a/packages/slate/src/schemas/Readme.md
+++ /dev/null
@@ -1,2 +0,0 @@
-
-This directory contains the core schema that ships with Slate by default, which controls all of the "core" document and selection validation logic. For example, it ensures that two adjacent text nodes are always mergeed, or that the top-level document only ever contains block nodes. It is not exposed by default, since it is only needed internally.
diff --git a/packages/slate/src/schemas/core.js b/packages/slate/src/schemas/core.js
deleted file mode 100644
index 839865581..000000000
--- a/packages/slate/src/schemas/core.js
+++ /dev/null
@@ -1,311 +0,0 @@
-
-import { List } from 'immutable'
-
-import Schema from '../models/schema'
-import Text from '../models/text'
-
-/**
- * Options object with normalize set to `false`.
- *
- * @type {Object}
- */
-
-const OPTS = { normalize: false }
-
-/**
- * Define the core schema rules, order-sensitive.
- *
- * @type {Array}
- */
-
-const rules = [
-
-  /**
-   * Only allow block nodes in documents.
-   *
-   * @type {Object}
-   */
-
-  {
-    match: (node) => {
-      return node.kind == 'document'
-    },
-    validate: (document) => {
-      const invalids = document.nodes.filter(n => n.kind != 'block')
-      return invalids.size ? invalids : null
-    },
-    normalize: (change, document, invalids) => {
-      invalids.forEach((node) => {
-        change.removeNodeByKey(node.key, OPTS)
-      })
-    }
-  },
-
-  /**
-   * Only allow block nodes or inline and text nodes in blocks.
-   *
-   * @type {Object}
-   */
-
-  {
-    match: (node) => {
-      return node.kind == 'block'
-    },
-    validate: (block) => {
-      const first = block.nodes.first()
-      if (!first) return null
-
-      const kinds = first.kind == 'block'
-        ? ['block']
-        : ['inline', 'text']
-
-      const invalids = block.nodes.filter(n => !kinds.includes(n.kind))
-      return invalids.size ? invalids : null
-    },
-    normalize: (change, block, invalids) => {
-      invalids.forEach((node) => {
-        change.removeNodeByKey(node.key, OPTS)
-      })
-    }
-  },
-
-  /**
-   * Only allow inline and text nodes in inlines.
-   *
-   * @type {Object}
-   */
-
-  {
-    match: (object) => {
-      return object.kind == 'inline'
-    },
-    validate: (inline) => {
-      const invalids = inline.nodes.filter(n => n.kind != 'inline' && n.kind != 'text')
-      return invalids.size ? invalids : null
-    },
-    normalize: (change, inline, invalids) => {
-      invalids.forEach((node) => {
-        change.removeNodeByKey(node.key, OPTS)
-      })
-    }
-  },
-
-  /**
-   * Ensure that block and inline nodes have at least one text child.
-   *
-   * @type {Object}
-   */
-
-  {
-    match: (object) => {
-      return object.kind == 'block' || object.kind == 'inline'
-    },
-    validate: (node) => {
-      return node.nodes.size == 0
-    },
-    normalize: (change, node) => {
-      const text = Text.create()
-      change.insertNodeByKey(node.key, 0, text, OPTS)
-    }
-  },
-
-  /**
-   * Ensure that void nodes contain a text node with a single space of text.
-   *
-   * @type {Object}
-   */
-
-  {
-    match: (object) => {
-      return (
-        (object.kind == 'inline' || object.kind == 'block') &&
-        (object.isVoid)
-      )
-    },
-    validate: (node) => {
-      return node.text !== ' ' || node.nodes.size !== 1
-    },
-    normalize: (change, node, result) => {
-      const text = Text.create(' ')
-      const index = node.nodes.size
-
-      change.insertNodeByKey(node.key, index, text, OPTS)
-
-      node.nodes.forEach((child) => {
-        change.removeNodeByKey(child.key, OPTS)
-      })
-    }
-  },
-
-  /**
-   * Ensure that inline nodes are never empty.
-   *
-   * This rule is applied to all blocks, because when they contain an empty
-   * inline, we need to remove the inline from that parent block. If `validate`
-   * was to be memoized, it should be against the parent node, not the inline
-   * themselves.
-   *
-   * @type {Object}
-   */
-
-  {
-    match: (object) => {
-      return object.kind == 'block'
-    },
-    validate: (block) => {
-      const invalids = block.nodes.filter(n => n.kind == 'inline' && n.text == '')
-      return invalids.size ? invalids : null
-    },
-    normalize: (change, block, invalids) => {
-      // If all of the block's nodes are invalid, insert an empty text node so
-      // that the selection will be preserved when they are all removed.
-      if (block.nodes.size == invalids.size) {
-        const text = Text.create()
-        change.insertNodeByKey(block.key, 1, text, OPTS)
-      }
-
-      invalids.forEach((node) => {
-        change.removeNodeByKey(node.key, OPTS)
-      })
-    }
-  },
-
-  /**
-   * Ensure that inline void nodes are surrounded by text nodes, by adding extra
-   * blank text nodes if necessary.
-   *
-   * @type {Object}
-   */
-
-  {
-    match: (object) => {
-      return object.kind == 'block' || object.kind == 'inline'
-    },
-    validate: (node) => {
-      const invalids = node.nodes.reduce((list, child, index) => {
-        if (child.kind !== 'inline') return list
-
-        const prev = index > 0 ? node.nodes.get(index - 1) : null
-        const next = node.nodes.get(index + 1)
-        // We don't test if "prev" is inline, since it has already been processed in the loop
-        const insertBefore = !prev
-        const insertAfter = !next || (next.kind == 'inline')
-
-        if (insertAfter || insertBefore) {
-          list = list.push({ insertAfter, insertBefore, index })
-        }
-
-        return list
-      }, new List())
-
-      return invalids.size ? invalids : null
-    },
-    normalize: (change, block, invalids) => {
-      // Shift for every text node inserted previously.
-      let shift = 0
-
-      invalids.forEach(({ index, insertAfter, insertBefore }) => {
-        if (insertBefore) {
-          change.insertNodeByKey(block.key, shift + index, Text.create(), OPTS)
-          shift++
-        }
-
-        if (insertAfter) {
-          change.insertNodeByKey(block.key, shift + index + 1, Text.create(), OPTS)
-          shift++
-        }
-      })
-    }
-  },
-
-  /**
-   * Merge adjacent text nodes.
-   *
-   * @type {Object}
-   */
-
-  {
-    match: (object) => {
-      return object.kind == 'block' || object.kind == 'inline'
-    },
-    validate: (node) => {
-      const invalids = node.nodes
-        .map((child, i) => {
-          const next = node.nodes.get(i + 1)
-          if (child.kind != 'text') return
-          if (!next || next.kind != 'text') return
-          return next
-        })
-        .filter(Boolean)
-
-      return invalids.size ? invalids : null
-    },
-    normalize: (change, node, invalids) => {
-      // Reverse the list to handle consecutive merges, since the earlier nodes
-      // will always exist after each merge.
-      invalids.reverse().forEach((n) => {
-        change.mergeNodeByKey(n.key, OPTS)
-      })
-    }
-  },
-
-  /**
-   * Prevent extra empty text nodes, except when adjacent to inline void nodes.
-   *
-   * @type {Object}
-   */
-
-  {
-    match: (object) => {
-      return object.kind == 'block' || object.kind == 'inline'
-    },
-    validate: (node) => {
-      const { nodes } = node
-      if (nodes.size <= 1) return
-
-      const invalids = nodes.filter((desc, i) => {
-        if (desc.kind != 'text') return
-        if (desc.text.length > 0) return
-
-        const prev = i > 0 ? nodes.get(i - 1) : null
-        const next = nodes.get(i + 1)
-
-        // If it's the first node, and the next is a void, preserve it.
-        if (!prev && next.kind == 'inline') return
-
-        // It it's the last node, and the previous is an inline, preserve it.
-        if (!next && prev.kind == 'inline') return
-
-        // If it's surrounded by inlines, preserve it.
-        if (next && prev && next.kind == 'inline' && prev.kind == 'inline') return
-
-        // Otherwise, remove it.
-        return true
-      })
-
-      return invalids.size ? invalids : null
-    },
-    normalize: (change, node, invalids) => {
-      invalids.forEach((text) => {
-        change.removeNodeByKey(text.key, OPTS)
-      })
-    }
-  }
-
-]
-
-/**
- * Create the core schema.
- *
- * @type {Schema}
- */
-
-const SCHEMA = Schema.create({ rules })
-
-/**
- * Export.
- *
- * @type {Schema}
- */
-
-export default SCHEMA
diff --git a/packages/slate/test/helpers/h.js b/packages/slate/test/helpers/h.js
index a126d5ebb..938dd381d 100644
--- a/packages/slate/test/helpers/h.js
+++ b/packages/slate/test/helpers/h.js
@@ -13,6 +13,8 @@ const h = createHyperscript({
     paragraph: 'paragraph',
     quote: 'quote',
     code: 'code',
+    list: 'list',
+    item: 'item',
     image: {
       type: 'image',
       isVoid: true,
diff --git a/packages/slate/test/index.js b/packages/slate/test/index.js
index a70aab60b..27495f1cf 100644
--- a/packages/slate/test/index.js
+++ b/packages/slate/test/index.js
@@ -17,7 +17,7 @@ import { resetKeyGenerator } from '..'
 
 describe('slate', () => {
   require('./serializers')
-  require('./schemas')
+  require('./schema')
   require('./changes')
   require('./history')
 })
diff --git a/packages/slate/test/schemas/core/block-create-text.js b/packages/slate/test/schema/core/block-create-text.js
similarity index 100%
rename from packages/slate/test/schemas/core/block-create-text.js
rename to packages/slate/test/schema/core/block-create-text.js
diff --git a/packages/slate/test/schemas/core/document-no-inline-children.js b/packages/slate/test/schema/core/document-no-inline-children.js
similarity index 100%
rename from packages/slate/test/schemas/core/document-no-inline-children.js
rename to packages/slate/test/schema/core/document-no-inline-children.js
diff --git a/packages/slate/test/schemas/core/document-no-text-children.js b/packages/slate/test/schema/core/document-no-text-children.js
similarity index 100%
rename from packages/slate/test/schemas/core/document-no-text-children.js
rename to packages/slate/test/schema/core/document-no-text-children.js
diff --git a/packages/slate/test/schemas/core/inline-no-block-children.js b/packages/slate/test/schema/core/inline-no-block-children.js
similarity index 100%
rename from packages/slate/test/schemas/core/inline-no-block-children.js
rename to packages/slate/test/schema/core/inline-no-block-children.js
diff --git a/packages/slate/test/schemas/core/inline-text-around.js b/packages/slate/test/schema/core/inline-text-around.js
similarity index 100%
rename from packages/slate/test/schemas/core/inline-text-around.js
rename to packages/slate/test/schema/core/inline-text-around.js
diff --git a/packages/slate/test/schemas/core/remove-empty-inline.js b/packages/slate/test/schema/core/remove-empty-inline.js
similarity index 100%
rename from packages/slate/test/schemas/core/remove-empty-inline.js
rename to packages/slate/test/schema/core/remove-empty-inline.js
diff --git a/packages/slate/test/schema/custom/child-kind-invalid-custom.js b/packages/slate/test/schema/custom/child-kind-invalid-custom.js
new file mode 100644
index 000000000..75bf810cb
--- /dev/null
+++ b/packages/slate/test/schema/custom/child-kind-invalid-custom.js
@@ -0,0 +1,41 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {},
+    quote: {
+      nodes: [
+        { kinds: ['block'] },
+      ],
+      normalize: (change, reason, { child }) => {
+        if (reason == 'child_kind_invalid') {
+          change.wrapBlockByKey(child.key, 'paragraph')
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <quote>
+        text
+      </quote>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <quote>
+        <paragraph>
+          text
+        </paragraph>
+      </quote>
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/child-kind-invalid-default.js b/packages/slate/test/schema/custom/child-kind-invalid-default.js
new file mode 100644
index 000000000..dfea71580
--- /dev/null
+++ b/packages/slate/test/schema/custom/child-kind-invalid-default.js
@@ -0,0 +1,32 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {},
+    quote: {
+      nodes: [
+        { kinds: ['text'] },
+      ]
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <quote>
+        <link>text</link>
+      </quote>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <quote />
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/child-required-custom.js b/packages/slate/test/schema/custom/child-required-custom.js
new file mode 100644
index 000000000..8619890e5
--- /dev/null
+++ b/packages/slate/test/schema/custom/child-required-custom.js
@@ -0,0 +1,40 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {},
+    quote: {
+      nodes: [
+        { types: ['paragraph'], min: 2 },
+      ],
+      normalize: (change, reason, { node, index }) => {
+        if (reason == 'child_required') {
+          change.insertNodeByKey(node.key, index, { kind: 'block', type: 'paragraph' })
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <quote>
+        <paragraph />
+      </quote>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <quote>
+        <paragraph />
+        <paragraph />
+      </quote>
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/child-required-default.js b/packages/slate/test/schema/custom/child-required-default.js
new file mode 100644
index 000000000..a075c0696
--- /dev/null
+++ b/packages/slate/test/schema/custom/child-required-default.js
@@ -0,0 +1,28 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {},
+    quote: {
+      nodes: [
+        { types: ['paragraph'], min: 1 },
+      ]
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <quote />
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document />
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/child-type-invalid-custom.js b/packages/slate/test/schema/custom/child-type-invalid-custom.js
new file mode 100644
index 000000000..0811a750f
--- /dev/null
+++ b/packages/slate/test/schema/custom/child-type-invalid-custom.js
@@ -0,0 +1,41 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {},
+    quote: {
+      nodes: [
+        { types: ['paragraph'] },
+      ],
+      normalize: (change, reason, { child }) => {
+        if (reason == 'child_type_invalid') {
+          change.wrapBlockByKey(child.key, 'paragraph')
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <quote>
+        <image />
+      </quote>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <quote>
+        <paragraph>
+          <image />
+        </paragraph>
+      </quote>
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/child-type-invalid-default.js b/packages/slate/test/schema/custom/child-type-invalid-default.js
new file mode 100644
index 000000000..c76c9bb1a
--- /dev/null
+++ b/packages/slate/test/schema/custom/child-type-invalid-default.js
@@ -0,0 +1,30 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {},
+    quote: {
+      nodes: [
+        { types: ['paragraph'] },
+      ]
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <quote>
+        <image />
+      </quote>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document />
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/child-unknown-custom.js b/packages/slate/test/schema/custom/child-unknown-custom.js
new file mode 100644
index 000000000..92f3dae9b
--- /dev/null
+++ b/packages/slate/test/schema/custom/child-unknown-custom.js
@@ -0,0 +1,49 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {},
+    quote: {
+      nodes: [
+        { types: ['paragraph'], max: 1 },
+      ],
+      normalize: (change, reason, { node, child, index }) => {
+        if (reason == 'child_unknown') {
+          const previous = node.getPreviousSibling(child.key)
+          const offset = previous.nodes.size
+          child.nodes.forEach((n, i) => change.moveNodeByKey(n.key, previous.key, offset + i, { normalize: false }))
+          change.removeNodeByKey(child.key)
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <quote>
+        <paragraph>
+          one
+        </paragraph>
+        <paragraph>
+          two
+        </paragraph>
+      </quote>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <quote>
+        <paragraph>
+          onetwo
+        </paragraph>
+      </quote>
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/child-unknown-default.js b/packages/slate/test/schema/custom/child-unknown-default.js
new file mode 100644
index 000000000..3f9ac15ca
--- /dev/null
+++ b/packages/slate/test/schema/custom/child-unknown-default.js
@@ -0,0 +1,41 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {},
+    quote: {
+      nodes: [
+        { types: ['paragraph'], max: 1 },
+      ]
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <quote>
+        <paragraph>
+          one
+        </paragraph>
+        <paragraph>
+          two
+        </paragraph>
+      </quote>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <quote>
+        <paragraph>
+          one
+        </paragraph>
+      </quote>
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/node-data-invalid-custom.js b/packages/slate/test/schema/custom/node-data-invalid-custom.js
new file mode 100644
index 000000000..a11e6b4d8
--- /dev/null
+++ b/packages/slate/test/schema/custom/node-data-invalid-custom.js
@@ -0,0 +1,34 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {
+      data: {
+        thing: v => v == 'value'
+      },
+      normalize: (change, reason, { node, key }) => {
+        if (reason == 'node_data_invalid') {
+          change.setNodeByKey(node.key, { data: { thing: 'value' }})
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph />
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph thing="value" />
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/node-data-invalid-default-undefined.js b/packages/slate/test/schema/custom/node-data-invalid-default-undefined.js
new file mode 100644
index 000000000..60b9fb0c1
--- /dev/null
+++ b/packages/slate/test/schema/custom/node-data-invalid-default-undefined.js
@@ -0,0 +1,27 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {
+      data: {
+        thing: v => v == 'value'
+      },
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph />
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document />
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/node-data-invalid-default.js b/packages/slate/test/schema/custom/node-data-invalid-default.js
new file mode 100644
index 000000000..7ffc0bc4d
--- /dev/null
+++ b/packages/slate/test/schema/custom/node-data-invalid-default.js
@@ -0,0 +1,29 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {
+      data: {
+        thing: v => v == null || v == 'value'
+      },
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph thing="invalid" />
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph />
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/node-is-void-invalid-custom.js b/packages/slate/test/schema/custom/node-is-void-invalid-custom.js
new file mode 100644
index 000000000..d3ce966bc
--- /dev/null
+++ b/packages/slate/test/schema/custom/node-is-void-invalid-custom.js
@@ -0,0 +1,30 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {
+      isVoid: false,
+      normalize: (change, reason, { node }) => {
+        if (reason == 'node_is_void_invalid') {
+          change.removeNodeByKey(node.key, 'paragraph')
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <block type="paragraph" isVoid />
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document />
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/node-is-void-invalid-default.js b/packages/slate/test/schema/custom/node-is-void-invalid-default.js
new file mode 100644
index 000000000..7d637392d
--- /dev/null
+++ b/packages/slate/test/schema/custom/node-is-void-invalid-default.js
@@ -0,0 +1,29 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {
+      isVoid: false,
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <block type="paragraph" isVoid />
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph>
+        {' '}
+      </paragraph>
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/node-mark-invalid-custom.js b/packages/slate/test/schema/custom/node-mark-invalid-custom.js
new file mode 100644
index 000000000..a9f47c508
--- /dev/null
+++ b/packages/slate/test/schema/custom/node-mark-invalid-custom.js
@@ -0,0 +1,34 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {
+      marks: ['bold'],
+      normalize: (change, reason, { node }) => {
+        if (reason == 'node_mark_invalid') {
+          node.nodes.forEach(n => change.removeNodeByKey(n.key))
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph>
+        one <i>two</i> three
+      </paragraph>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph />
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/node-mark-invalid-default.js b/packages/slate/test/schema/custom/node-mark-invalid-default.js
new file mode 100644
index 000000000..4d8d36436
--- /dev/null
+++ b/packages/slate/test/schema/custom/node-mark-invalid-default.js
@@ -0,0 +1,31 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {
+      marks: ['bold'],
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph>
+        one <i>two</i> three
+      </paragraph>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph>
+        one two three
+      </paragraph>
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/node-text-invalid-custom.js b/packages/slate/test/schema/custom/node-text-invalid-custom.js
new file mode 100644
index 000000000..caa949fa6
--- /dev/null
+++ b/packages/slate/test/schema/custom/node-text-invalid-custom.js
@@ -0,0 +1,34 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {
+      text: /^\d*$/,
+      normalize: (change, reason, { node }) => {
+        if (reason == 'node_text_invalid') {
+          node.nodes.forEach(n => change.removeNodeByKey(n.key))
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph>
+        invalid
+      </paragraph>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph />
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/node-text-invalid-default.js b/packages/slate/test/schema/custom/node-text-invalid-default.js
new file mode 100644
index 000000000..843bddbbc
--- /dev/null
+++ b/packages/slate/test/schema/custom/node-text-invalid-default.js
@@ -0,0 +1,27 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    paragraph: {
+      text: /^\d*$/,
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph>
+        invalid
+      </paragraph>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document />
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/parent-kind-invalid-custom.js b/packages/slate/test/schema/custom/parent-kind-invalid-custom.js
new file mode 100644
index 000000000..e00172110
--- /dev/null
+++ b/packages/slate/test/schema/custom/parent-kind-invalid-custom.js
@@ -0,0 +1,36 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  inlines: {
+    link: {
+      parent: { kinds: ['block'] },
+      normalize: (change, reason, { node }) => {
+        if (reason == 'parent_kind_invalid') {
+          change.unwrapNodeByKey(node.key)
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph>
+        <link><link>one</link></link>
+      </paragraph>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph>
+        <link>one</link>
+      </paragraph>
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/parent-kind-invalid-default.js b/packages/slate/test/schema/custom/parent-kind-invalid-default.js
new file mode 100644
index 000000000..e62820345
--- /dev/null
+++ b/packages/slate/test/schema/custom/parent-kind-invalid-default.js
@@ -0,0 +1,29 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  inlines: {
+    link: {
+      parent: { kinds: ['block'] },
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph>
+        <link><link>one</link></link>
+      </paragraph>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph />
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/parent-type-invalid-custom.js b/packages/slate/test/schema/custom/parent-type-invalid-custom.js
new file mode 100644
index 000000000..97e8d319c
--- /dev/null
+++ b/packages/slate/test/schema/custom/parent-type-invalid-custom.js
@@ -0,0 +1,39 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    list: {},
+    item: {
+      parent: { types: ['list'] },
+      normalize: (change, reason, { node }) => {
+        if (reason == 'parent_type_invalid') {
+          change.wrapBlockByKey(node.key, 'list')
+        }
+      }
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph>
+        <item />
+      </paragraph>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph>
+        <list>
+          <item />
+        </list>
+      </paragraph>
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/custom/parent-type-invalid-default.js b/packages/slate/test/schema/custom/parent-type-invalid-default.js
new file mode 100644
index 000000000..6dc540a31
--- /dev/null
+++ b/packages/slate/test/schema/custom/parent-type-invalid-default.js
@@ -0,0 +1,30 @@
+/** @jsx h */
+
+import h from '../../helpers/h'
+
+export const schema = {
+  blocks: {
+    list: {},
+    item: {
+      parent: { types: ['list'] },
+    }
+  }
+}
+
+export const input = (
+  <state>
+    <document>
+      <paragraph>
+        <item />
+      </paragraph>
+    </document>
+  </state>
+)
+
+export const output = (
+  <state>
+    <document>
+      <paragraph />
+    </document>
+  </state>
+)
diff --git a/packages/slate/test/schema/index.js b/packages/slate/test/schema/index.js
new file mode 100644
index 000000000..5811513cf
--- /dev/null
+++ b/packages/slate/test/schema/index.js
@@ -0,0 +1,53 @@
+
+import assert from 'assert'
+import fs from 'fs'
+import { Schema } from '../..'
+import { basename, extname, resolve } from 'path'
+
+/**
+ * Tests.
+ */
+
+describe('schema', () => {
+  describe('core', () => {
+    const testsDir = resolve(__dirname, 'core')
+    const tests = fs.readdirSync(testsDir).filter(t => t[0] != '.').map(t => basename(t, extname(t)))
+
+    for (const test of tests) {
+      it(test, async () => {
+        const module = require(resolve(testsDir, test))
+        const { input, output, schema } = module
+        const s = Schema.create(schema)
+        const expected = output
+        const actual = input
+          .change()
+          .setState({ schema: s })
+          .normalize()
+          .state.toJSON()
+
+        assert.deepEqual(actual, expected)
+      })
+    }
+  })
+
+  describe('custom', () => {
+    const testsDir = resolve(__dirname, 'custom')
+    const tests = fs.readdirSync(testsDir).filter(t => t[0] != '.').map(t => basename(t, extname(t)))
+
+    for (const test of tests) {
+      it(test, async () => {
+        const module = require(resolve(testsDir, test))
+        const { input, output, schema } = module
+        const s = Schema.create(schema)
+        const expected = output.toJSON()
+        const actual = input
+          .change()
+          .setState({ schema: s })
+          .normalize()
+          .state.toJSON()
+
+        assert.deepEqual(actual, expected)
+      })
+    }
+  })
+})
diff --git a/packages/slate/test/schemas/index.js b/packages/slate/test/schemas/index.js
deleted file mode 100644
index 05a43b8b6..000000000
--- a/packages/slate/test/schemas/index.js
+++ /dev/null
@@ -1,27 +0,0 @@
-
-import assert from 'assert'
-import fs from 'fs'
-import { Schema } from '../..'
-import { basename, extname, resolve } from 'path'
-
-/**
- * Tests.
- */
-
-describe('schemas', () => {
-  describe('core', () => {
-    const innerDir = resolve(__dirname, 'core')
-    const tests = fs.readdirSync(innerDir).filter(t => t[0] != '.').map(t => basename(t, extname(t)))
-
-    for (const test of tests) {
-      it(test, async () => {
-        const module = require(resolve(innerDir, test))
-        const { input, output, schema } = module
-        const s = Schema.create(schema)
-        const actual = input.change().normalize(s).state.toJSON()
-        const expected = output
-        assert.deepEqual(actual, expected)
-      })
-    }
-  })
-})