diff --git a/docs/source/embedding.md b/docs/source/embedding.md
index d2936b5437..e21fc9845f 100644
--- a/docs/source/embedding.md
+++ b/docs/source/embedding.md
@@ -30,58 +30,7 @@ This HTML snippet is composed of multiple `<script>` tags:
  - The second script tag contains the state of all the widget models currently
    in use. It has the mime type `application/vnd.jupyter.widget-state+json`.
 
-   The JSON schema for the content of that script tag is:
-
-    ```json
-    {
-        "$schema": "http://json-schema.org/draft-04/schema#",
-        "description": "Jupyter Interactive Widget State JSON schema.",
-        "type": "object",
-        "properties" : {
-            "version_major" : {
-                "description": "Format version (major)",
-                "type": "number",
-                "minimum": 1,
-                "maximum": 1
-            },
-            "version_minor" : {
-                "description": "Format version (minor)",
-                "type": "number"
-            },
-            "state": {
-                "description": "Model State for All Widget Models",
-                "type": "object",
-                "additionalProperties": true,
-                "additionalProperties" : {
-                    "type": "object",
-                    "properties": {
-                        "model_name": {
-                            "description" : "Name of the JavaScript class holding the model implementation",
-                            "type": "string"
-                        },
-                        "model_module": {
-                            "description" : "Name of the JavaScript module holding the model implementation",
-                            "type": "string"
-                        },
-                        "model_module_version": {
-                            "description" : "Semver range for the JavaScript module holding the model implementation",
-                            "type": "string"
-                        },
-                        "state": {
-                            "description" : "Serialized state of the model",
-                            "type": "object",
-                            "additional_properties": true
-                        }
-                    },
-                    "required": [ "model_name", "model_module", "state" ],
-                    "additionalProperties": false
-                }
-            }
-        },
-        "required": [ "version_major", "version_minor", "state" ],
-        "additionalProperties": false
-    }
-    ```
+   The JSON schema for the content of that script tag is found in the jupyter-widgets-schema npm package.
 
 - The following script tags correspond to the views which you want to display
   in the web page. They have the mime type `application/vnd.jupyter.widget-view+json`.
@@ -89,33 +38,7 @@ This HTML snippet is composed of multiple `<script>` tags:
   The *Embed Widgets* action currently creates such a tag for each view
   displayed in the notebook at this time.
 
-  The JSON schema for the content of that script tag is:
-
-    ```json
-    {
-        "$schema": "http://json-schema.org/draft-04/schema#",
-        "description": "Jupyter Interactive Widget View JSON schema.",
-        "type": "object",
-        "properties" : {
-            "version_major" : {
-                "description": "Format version (major)",
-                "type": "number",
-                "minimum": 1,
-                "maximum": 1
-            },
-            "version_minor" : {
-                "description": "Format version (minor)",
-                "type": "number"
-            },
-            "model_id": {
-                "description": "Unique identifier of the widget model to be displayed",
-                "type": "string"
-            },
-            "required": [ "model_id" ]
-        },
-        "additionalProperties": false
-    }
-    ```
+  The JSON schema for the content of that script tag is found in the jupyter-widgets-schema npm package.
 
   If you want to lay out these script tags in a custom fashion or only keep
   some of them, you can change their location in the DOM when including the
diff --git a/ipywidgets/state.schema.json b/ipywidgets/state.schema.json
index 5accca0bd2..85d3865552 100644
--- a/ipywidgets/state.schema.json
+++ b/ipywidgets/state.schema.json
@@ -6,17 +6,18 @@
         "version_major" : {
             "description": "Format version (major)",
             "type": "number",
-            "minimum": 1,
-            "maximum": 1
+            "minimum": 2,
+            "maximum": 2
         },
         "version_minor" : {
             "description": "Format version (minor)",
-            "type": "number"
+            "type": "number",
+            "minimum": 0,
+            "maximum": 0
         },
         "state": {
-            "description": "Model State for All Widget Models",
+            "description": "Model State for All Widget Models - keys are model ids, values are model state",
             "type": "object",
-            "additionalProperties": true,
             "additionalProperties" : {
                 "type": "object",
                 "properties": {
@@ -34,15 +35,44 @@
                     },
                     "state": {
                         "description" : "Serialized state of the model",
-                        "type": "object",
-                        "additional_properties": true
+                        "type": "object"
+                    },
+                    "buffers": {
+                        "description": "Binary buffers in the state",
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "path": {
+                                    "description": "A path for a binary buffer value.",
+                                    "type": "array",
+                                    "items": {
+                                        "description": "An object key or array index",
+                                        "type": ["string", "number"]
+                                    }
+                                },
+                                "data": {
+                                    "description" : "A binary buffer encoded as specified in the 'encoding' property",
+                                    "type": "string"
+                                },
+                                "encoding": {
+                                    "description": "The encoding of the buffer data",
+                                    "type": "string",
+                                    "oneOf": [
+                                        {"enum": ["hex"], "description": "Base 16 encoding, as specified in RFC 4648, section 8 (https://tools.ietf.org/html/rfc4648#section-8)"},
+                                        {"enum": ["base64"], "description": "Base 64 encoding, as specified in RFC 4648, section 4 (https://tools.ietf.org/html/rfc4648#section-4)"}
+
+                                    ]
+                                }
+
+                            },
+                            "required": ["path", "data", "encoding"]
+                        }
                     }
                 },
-                "required": [ "model_name", "model_module", "state" ],
-                "additionalProperties": false
+                "required": [ "model_name", "model_module", "state" ]
             }
         }
     },
-    "required": [ "version_major", "version_minor", "state" ],
-    "additionalProperties": false
+    "required": [ "version_major", "version_minor", "state" ]
 }
diff --git a/ipywidgets/widgets/widget.py b/ipywidgets/widgets/widget.py
index 7c9121616b..030ffc55ee 100644
--- a/ipywidgets/widgets/widget.py
+++ b/ipywidgets/widgets/widget.py
@@ -16,6 +16,8 @@
 from ipython_genutils.py3compat import string_types, PY3
 from IPython.display import display
 
+from base64 import standard_b64decode, standard_b64encode
+
 from .._version import __protocol_version__
 
 
@@ -279,17 +281,26 @@ def handle_comm_opened(comm, msg):
 
     @staticmethod
     def get_manager_state(drop_defaults=False):
-        return dict(version_major=1, version_minor=0, state={
-            k: {
-                'model_name': Widget.widgets[k]._model_name,
-                'model_module': Widget.widgets[k]._model_module,
-                'model_module_version': Widget.widgets[k]._model_module_version,
-                'state': Widget.widgets[k].get_state(drop_defaults=drop_defaults)
-            } for k in Widget.widgets
-        })
+        manager_state = {}
+        for model_id, model in Widget.widgets.items():
+            state = {
+                'model_name': model._model_name,
+                'model_module': model.model_module,
+                'model_module_version': model._model_module_version
+            }
+            model_state, buffer_paths, buffers = _remove_buffers(model.get_state(drop_defaults=drop_defaults))
+            state['state'] = model_state
+            if len(buffers) > 0:
+                state['buffers'] = {
+                    'buffers': [{'path': p, 'data': standard_b64encode(d).decode('ascii')}
+                                for p, d in zip(buffer_paths, buffers)],
+                    'encoding': 'base64'
+                }
+            manager_state[model_id] = state
+        return {'version_major': 2, 'version_minor': 0, 'state': manager_state}
 
     def get_view_spec(self):
-        return dict(version_major=1, version_minor=0, model_id=self._model_id)
+        return dict(version_major=2, version_minor=0, model_id=self._model_id)
 
     #-------------------------------------------------------------------------
     # Traits
@@ -619,6 +630,8 @@ def _ipython_display_(self, **kwargs):
             data = {
                 'text/plain': "A Jupyter Widget",
                 'application/vnd.jupyter.widget-view+json': {
+                    'version_major': '2',
+                    'version_minor': '0',
                     'model_id': self._model_id
                 }
             }
diff --git a/jupyter-js-widgets/package.json b/jupyter-js-widgets/package.json
index 965b2672ad..74bdef87af 100644
--- a/jupyter-js-widgets/package.json
+++ b/jupyter-js-widgets/package.json
@@ -91,11 +91,12 @@
     "@types/semver": "^5.3.30",
     "ajv": "^4.9.0",
     "backbone": "1.2.0",
+    "base64-js": "1.2.0",
     "d3-format": "^0.5.1",
     "font-awesome": "^4.5.0",
     "jquery": "^3.1.1",
     "jquery-ui": "^1.12.1",
-    "jupyter-widgets-schema": "^0.1.1",
+    "jupyter-widgets-schema": "^0.3.0-beta.2",
     "lolex": "^1.4.0",
     "scriptjs": "^2.5.8",
     "semver": "^5.1.0",
diff --git a/jupyter-js-widgets/src-embed/embed-webpack.ts b/jupyter-js-widgets/src-embed/embed-webpack.ts
index ce5f4416e9..2351920cb3 100644
--- a/jupyter-js-widgets/src-embed/embed-webpack.ts
+++ b/jupyter-js-widgets/src-embed/embed-webpack.ts
@@ -19,8 +19,8 @@ require('../css/widgets.css');
 
 // Load json schema validator
 var Ajv = require('ajv');
-var widget_state_schema = require('jupyter-widgets-schema').v1.state;
-var widget_view_schema = require('jupyter-widgets-schema').v1.view;
+var widget_state_schema = require('jupyter-widgets-schema').v2.state;
+var widget_view_schema = require('jupyter-widgets-schema').v2.view;
 
 // Magic global widget rendering function:
 import * as widgets from '../../jupyter-js-widgets/lib/index';
@@ -90,7 +90,7 @@ function renderManager(element, tag) {
         console.log(model_validate.errors);
     }
     var manager = new embed.EmbedManager();
-    manager.set_state(widgetStateObject.state, {}).then(function(models) {
+    manager.set_state(widgetStateObject, {}).then(function(models) {
         var tags = element.querySelectorAll('script[type="application/vnd.jupyter.widget-view+json"]');
         for (var i=0; i!=tags.length; ++i) {
             // TODO: validate view schema
diff --git a/jupyter-js-widgets/src/manager-base.ts b/jupyter-js-widgets/src/manager-base.ts
index 04a6be326d..c05595815c 100644
--- a/jupyter-js-widgets/src/manager-base.ts
+++ b/jupyter-js-widgets/src/manager-base.ts
@@ -19,7 +19,6 @@ import {
     shims
 } from './services-shim';
 
-
 /**
  * The options for a model.
  *
@@ -186,8 +185,17 @@ abstract class ManagerBase<T> {
      * Handle when a comm is opened.
      */
     handle_comm_open(comm: shims.services.Comm, msg: services.KernelMessage.ICommOpenMsg): Promise<Backbone.Model> {
-        var data = (msg.content.data as any);
-        utils.put_buffers(data.state, data.buffer_paths, msg.buffers)
+        let data = (msg.content.data as any);
+        let buffer_paths = data.buffer_paths || [];
+        // Make sure the buffers are DataViews
+        let buffers = (msg.buffers || []).map(b => {
+            if (b instanceof DataView) {
+                return b;
+            } else {
+                return new DataView(b instanceof ArrayBuffer ? b : b.buffer);
+            }
+        });
+        utils.put_buffers(data.state, buffer_paths, buffers);
         return this.new_model({
             model_name: data.state['_model_name'],
             model_module: data.state['_model_module'],
@@ -369,49 +377,73 @@ abstract class ManagerBase<T> {
     /**
      * Asynchronously get the state of the widget manager.
      *
-     * This includes all of the widget models.
+     * This includes all of the widget models, and follows the format given in
+     * the jupyter-widgets-schema package.
      *
      * @param options - The options for what state to return.
      * @returns Promise for a state dictionary
      */
     get_state(options: StateOptions): Promise<any> {
-        var that = this;
-        return utils.resolvePromisesDict(this._models).then(function(models) {
-            var state = {};
-            for (var model_id in models) {
-                if (models.hasOwnProperty(model_id)) {
-                    var model = models[model_id];
-                    state[model_id] = utils.resolvePromisesDict({
-                        model_name: model.name,
-                        model_module: model.module,
-                        model_module_version: model.get('_model_module_version'),
-                        state: model.constructor._serialize_state(model.get_state(options.drop_defaults), that)
-                    });
+        return utils.resolvePromisesDict(this._models).then((models) => {
+            let state = {};
+            Object.keys(models).forEach(model_id => {
+                let model = models[model_id];
+                let split = utils.remove_buffers(model.serialize(model.get_state(options.drop_defaults)));
+                let buffers = split.buffers.map((buffer, index) => {
+                    return {data: utils.bufferToBase64(buffer), path: split.buffer_paths[index], encoding: 'base64'};
+                });
+                state[model_id] = {
+                    model_name: model.name,
+                    model_module: model.module,
+                    model_module_version: model.get('_model_module_version'),
+                    state: split.state
+                };
+                // To save space, only include the buffer key if we have buffers
+                if (buffers.length > 0) {
+                    state[model_id].buffers = buffers;
                 }
-            }
-            return utils.resolvePromisesDict(state);
+            });
+            return {version_major: 2, version_minor: 0, state: state};
         }).catch(utils.reject('Could not get state of widget manager', true));
     };
 
     /**
      * Set the widget manager state.
      *
+     * @param state - a Javascript object conforming to the application/vnd.jupyter.widget-state+json spec.
+     *
      * Reconstructs all of the widget models in the state, merges that with the
      * current manager state, and then attempts to redisplay the widgets in the
      * state.
      */
     set_state(state, displayOptions) {
-        var that = this;
 
+        // Check to make sure that it's the same version we are parsing.
+        if (!(state.version_major && state.version_major <= 2)) {
+            throw "Unsupported widget state format";
+        }
+        let models = state.state;
         // Recreate all the widget models for the given widget manager state.
-        var all_models = that._get_comm_info().then(function(live_comms) {
-            return Promise.all(_.map(Object.keys(state), function (model_id) {
+        let all_models = this._get_comm_info().then(live_comms => {
+            return Promise.all(Object.keys(models).map(model_id => {
+
+                // First put back the binary buffers
+                let decode: { [s: string]: (s: string) => ArrayBuffer; } = {'base64': utils.base64ToBuffer, 'hex': utils.hexToBuffer};
+                let model = models[model_id];
+                let modelState = model.state;
+                if (model.buffers) {
+                    let bufferPaths = model.buffers.map(b => b.path);
+                    // put_buffers expects buffers to be DataViews
+                    let buffers = model.buffers.map(b => new DataView(decode[b.encoding](b.data)));
+                    utils.put_buffers(model.state, bufferPaths, buffers);
+                }
 
-                // If the model has already been created, set it's state and then
+                // If the model has already been created, set its state and then
                 // return it.
-                if (that._models[model_id]) {
-                    return that._models[model_id].then(function(model) {
-                        return model.constructor._deserialize_state(state[model_id].state || {}, that).then(function(attributes) {
+                if (this._models[model_id]) {
+                    return this._models[model_id].then(model => {
+                        // deserialize state
+                        return model.constructor._deserialize_state(modelState || {}, this).then(attributes => {
                             model.set_state(attributes);
                             return model;
                         });
@@ -419,21 +451,21 @@ abstract class ManagerBase<T> {
                 }
 
                 if (live_comms.hasOwnProperty(model_id)) {  // live comm
-                    return that._create_comm(that.comm_target_name, model_id).then(function(new_comm) {
-                        return that.new_model({
+                    return this._create_comm(this.comm_target_name, model_id).then(new_comm => {
+                        return this.new_model({
                             comm: new_comm,
-                            model_name: state[model_id].model_name,
-                            model_module: state[model_id].model_module,
-                            model_module_version: state[model_id].model_module_version
+                            model_name: models[model_id].model_name,
+                            model_module: models[model_id].model_module,
+                            model_module_version: models[model_id].model_module_version
                         });
                     });
                 } else {                                    // dead comm
-                    return that.new_model({
+                    return this.new_model({
                         model_id: model_id,
-                        model_name: state[model_id].model_name,
-                        model_module: state[model_id].model_module,
-                        model_module_version: state[model_id].model_module_version
-                    }, state[model_id].state);
+                        model_name: models[model_id].model_name,
+                        model_module: models[model_id].model_module,
+                        model_module_version: models[model_id].model_module_version
+                    }, modelState);
                 }
             }));
         });
diff --git a/jupyter-js-widgets/src/utils.ts b/jupyter-js-widgets/src/utils.ts
index fd5de01ca8..a42fdee45c 100644
--- a/jupyter-js-widgets/src/utils.ts
+++ b/jupyter-js-widgets/src/utils.ts
@@ -3,8 +3,9 @@
 
 import * as _ from 'underscore';
 
-// TODO: ATTEMPT TO KILL THIS MODULE USING THIRD PARTY LIBRARIES WHEN IPYWIDGETS
-// IS CONVERTED TO NODE COMMONJS.
+import {
+    toByteArray, fromByteArray
+} from 'base64-js';
 
 /**
  * http://www.ietf.org/rfc/rfc4122.txt
@@ -182,7 +183,7 @@ function escape_html(text: string): string {
  * Will lead to {a: 1, b: {data: array1}, c: [0, array2]}
  */
 export
-function put_buffers(state, buffer_paths, buffers) {
+function put_buffers(state, buffer_paths: (string | number)[][], buffers: DataView[]) {
     for (let i=0; i<buffer_paths.length; i++) {
         let buffer_path = buffer_paths[i];
          // say we want to set state[x][y][z] = buffers[i]
@@ -204,9 +205,9 @@ function put_buffers(state, buffer_paths, buffers) {
  * and the buffers associated to those paths (.buffers).
  */
 export
-function remove_buffers(state) {
-    let buffers = [];
-    let buffer_paths = [];
+function remove_buffers(state): {state: any, buffers: ArrayBuffer[], buffer_paths: (string | number)[][]} {
+    let buffers: ArrayBuffer[] = [];
+    let buffer_paths: (string | number)[][] = [];
     // if we need to remove an object from a list, we need to clone that list, otherwise we may modify
     // the internal state of the widget model
     // however, we do not want to clone everything, for performance
@@ -226,7 +227,7 @@ function remove_buffers(state) {
                             obj = _.clone(obj);
                             is_cloned = true;
                         }
-                        buffers.push(value);
+                        buffers.push(value instanceof ArrayBuffer ? value : value.buffer);
                         buffer_paths.push(path.concat([i]));
                         // easier to just keep the array, but clear the entry, otherwise we have to think
                         // about array length, much easier this way
@@ -255,7 +256,7 @@ function remove_buffers(state) {
                                 obj = _.clone(obj);
                                 is_cloned = true;
                             }
-                            buffers.push(value);
+                            buffers.push(value instanceof ArrayBuffer ? value : value.buffer);
                             buffer_paths.push(path.concat([key]));
                             delete obj[key]; // for objects/dicts we just delete them
                         }
@@ -279,3 +280,63 @@ function remove_buffers(state) {
     let new_state = remove(state, []);
     return {state: new_state, buffers: buffers, buffer_paths: buffer_paths}
 }
+
+let hexTable = [
+    '00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '0A', '0B', '0C', '0D', '0E', '0F',
+    '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '1A', '1B', '1C', '1D', '1E', '1F',
+    '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '2A', '2B', '2C', '2D', '2E', '2F',
+    '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '3A', '3B', '3C', '3D', '3E', '3F',
+    '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '4A', '4B', '4C', '4D', '4E', '4F',
+    '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '5A', '5B', '5C', '5D', '5E', '5F',
+    '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '6A', '6B', '6C', '6D', '6E', '6F',
+    '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '7A', '7B', '7C', '7D', '7E', '7F',
+    '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '8A', '8B', '8C', '8D', '8E', '8F',
+    '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '9A', '9B', '9C', '9D', '9E', '9F',
+    'A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9', 'AA', 'AB', 'AC', 'AD', 'AE', 'AF',
+    'B0', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B9', 'BA', 'BB', 'BC', 'BD', 'BE', 'BF',
+    'C0', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'CA', 'CB', 'CC', 'CD', 'CE', 'CF',
+    'D0', 'D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D7', 'D8', 'D9', 'DA', 'DB', 'DC', 'DD', 'DE', 'DF',
+    'E0', 'E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7', 'E8', 'E9', 'EA', 'EB', 'EC', 'ED', 'EE', 'EF',
+    'F0', 'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'FA', 'FB', 'FC', 'FD', 'FE', 'FF'
+];
+
+/**
+ * Convert an ArrayBuffer to a hex string.
+ */
+export
+function bufferToHex(buffer: ArrayBuffer): string {
+    let x = new Uint8Array(buffer);
+    let s = [];
+    for (let i = 0; i < x.length; i++) {
+        s.push(hexTable[x[i]]);
+    }
+    return s.join('');
+}
+
+/**
+ * Convert a hex string to an ArrayBuffer.
+ */
+export
+function hexToBuffer(hex: string): ArrayBuffer {
+    let x = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        x[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+    }
+    return x.buffer;
+}
+
+/**
+ * Convert an ArrayBuffer to a base64 string.
+ */
+export
+function bufferToBase64(buffer: ArrayBuffer): string {
+    return fromByteArray(new Uint8Array(buffer));
+}
+
+/**
+ * Convert a base64 string to an ArrayBuffer.
+ */
+export
+function base64ToBuffer(base64: string): ArrayBuffer {
+    return toByteArray(base64).buffer;
+}
diff --git a/jupyter-js-widgets/src/widget.ts b/jupyter-js-widgets/src/widget.ts
index 172ce2c7de..c04f982889 100644
--- a/jupyter-js-widgets/src/widget.ts
+++ b/jupyter-js-widgets/src/widget.ts
@@ -172,9 +172,17 @@ class WidgetModel extends Backbone.Model {
                 this.state_change = this.state_change
                     .then(() => {
                         // see Widget.open/_split_state_buffers about why we need state_with_buffers
-                        var state = msg.content.data.state;
-                        var buffer_paths = msg.content.data.buffer_paths || [];
-                        var buffers = msg.buffers || [];
+                        let state = msg.content.data.state;
+                        let buffer_paths = msg.content.data.buffer_paths || [];
+                        // Make sure the buffers are DataViews
+                        let buffers = (msg.buffers || []).map(b => {
+                            if (b instanceof DataView) {
+                                return b;
+                            } else {
+                                return new DataView(b instanceof ArrayBuffer ? b : b.buffer);
+                            }
+                        });
+
                         utils.put_buffers(state, buffer_paths, buffers);
                         return (this.constructor as typeof WidgetModel)._deserialize_state(state, this.widget_manager);
                     }).then((state) => {
diff --git a/jupyter-widgets-schema/index.js b/jupyter-widgets-schema/index.js
index 2e79c5e99b..50c27b55ac 100644
--- a/jupyter-widgets-schema/index.js
+++ b/jupyter-widgets-schema/index.js
@@ -2,5 +2,9 @@ module.exports = {
     v1: {
         state: require('./v1/state.schema.json'),
         view: require('./v1/view.schema.json')
-    }
+    },
+    v2: {
+        state: require('./v2/state.schema.json'),
+        view: require('./v2/view.schema.json')
+    },
 };
diff --git a/jupyter-widgets-schema/package.json b/jupyter-widgets-schema/package.json
index 9a47ac1bd0..1ffc5dc715 100644
--- a/jupyter-widgets-schema/package.json
+++ b/jupyter-widgets-schema/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jupyter-widgets-schema",
-  "version": "0.1.1",
+  "version": "0.3.0-beta.2",
   "description": "Schemas for the Jupyter interactive Widgets",
   "main": "index.js",
   "scripts": {
diff --git a/jupyter-widgets-schema/v2/state.schema.json b/jupyter-widgets-schema/v2/state.schema.json
new file mode 100644
index 0000000000..85d3865552
--- /dev/null
+++ b/jupyter-widgets-schema/v2/state.schema.json
@@ -0,0 +1,78 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Jupyter Interactive Widget State JSON schema.",
+    "type": "object",
+    "properties" : {
+        "version_major" : {
+            "description": "Format version (major)",
+            "type": "number",
+            "minimum": 2,
+            "maximum": 2
+        },
+        "version_minor" : {
+            "description": "Format version (minor)",
+            "type": "number",
+            "minimum": 0,
+            "maximum": 0
+        },
+        "state": {
+            "description": "Model State for All Widget Models - keys are model ids, values are model state",
+            "type": "object",
+            "additionalProperties" : {
+                "type": "object",
+                "properties": {
+                    "model_name": {
+                        "description" : "Name of the JavaScript class holding the model implementation",
+                        "type": "string"
+                    },
+                    "model_module": {
+                        "description" : "Name of the JavaScript module holding the model implementation",
+                        "type": "string"
+                    },
+                    "model_module_version": {
+                        "description" : "Semver range for the JavaScript module holding the model implementation",
+                        "type": "string"
+                    },
+                    "state": {
+                        "description" : "Serialized state of the model",
+                        "type": "object"
+                    },
+                    "buffers": {
+                        "description": "Binary buffers in the state",
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "path": {
+                                    "description": "A path for a binary buffer value.",
+                                    "type": "array",
+                                    "items": {
+                                        "description": "An object key or array index",
+                                        "type": ["string", "number"]
+                                    }
+                                },
+                                "data": {
+                                    "description" : "A binary buffer encoded as specified in the 'encoding' property",
+                                    "type": "string"
+                                },
+                                "encoding": {
+                                    "description": "The encoding of the buffer data",
+                                    "type": "string",
+                                    "oneOf": [
+                                        {"enum": ["hex"], "description": "Base 16 encoding, as specified in RFC 4648, section 8 (https://tools.ietf.org/html/rfc4648#section-8)"},
+                                        {"enum": ["base64"], "description": "Base 64 encoding, as specified in RFC 4648, section 4 (https://tools.ietf.org/html/rfc4648#section-4)"}
+
+                                    ]
+                                }
+
+                            },
+                            "required": ["path", "data", "encoding"]
+                        }
+                    }
+                },
+                "required": [ "model_name", "model_module", "state" ]
+            }
+        }
+    },
+    "required": [ "version_major", "version_minor", "state" ]
+}
diff --git a/jupyter-widgets-schema/v2/view.schema.json b/jupyter-widgets-schema/v2/view.schema.json
new file mode 100644
index 0000000000..66ae922296
--- /dev/null
+++ b/jupyter-widgets-schema/v2/view.schema.json
@@ -0,0 +1,22 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Jupyter Interactive Widget View JSON schema.",
+    "type": "object",
+    "properties" : {
+        "version_major" : {
+            "description": "Format version (major)",
+            "type": "number",
+            "minimum": 2,
+            "maximum": 2
+        },
+        "version_minor" : {
+            "description": "Format version (minor)",
+            "type": "number"
+        },
+        "model_id": {
+            "description": "Unique identifier of the widget model to be displayed",
+            "type": "string"
+        }
+    },
+    "required": [ "model_id" ]
+}
diff --git a/widgetsnbextension/src/embed_widgets.js b/widgetsnbextension/src/embed_widgets.js
index 1ea2a71dbc..22d8bacf7f 100644
--- a/widgetsnbextension/src/embed_widgets.js
+++ b/widgetsnbextension/src/embed_widgets.js
@@ -12,11 +12,7 @@ var embed_widgets = function() {
             Jupyter.WidgetManager._managers[0].get_state({
                 'drop_defaults': true
             }).then(function(state) {
-                var data = JSON.stringify({
-                    version_major: 1,
-                    version_minor: 0,
-                    state: state
-                }, null, '    ');
+                var data = JSON.stringify(state, null, '    ');
                 var value = '<script src="https://unpkg.com/jupyter-js-widgets@~' + widgets.version + '/dist/embed.js"></script>\n' +
                             '<script type="application/vnd.jupyter.widget-state+json">\n' + data + '\n</script>';
 
@@ -27,7 +23,7 @@ var embed_widgets = function() {
                         cell.output_area.outputs.forEach(function (output) {
                             if (output.data
                                 && output.data[VIEW_MIME_TYPE]
-                                && state[output.data[VIEW_MIME_TYPE].model_id]) {
+                                && state.state[output.data[VIEW_MIME_TYPE].model_id]) {
                                 views.push(('\n<script type="'+VIEW_MIME_TYPE+'">\n'
                                     + JSON.stringify(output.data[VIEW_MIME_TYPE], null, '    ')
                                     + '\n</script>'));
diff --git a/widgetsnbextension/src/manager.js b/widgetsnbextension/src/manager.js
index 402ef74936..ce394bc662 100644
--- a/widgetsnbextension/src/manager.js
+++ b/widgetsnbextension/src/manager.js
@@ -163,11 +163,7 @@ WidgetManager.prototype._init_actions = function() {
                 drop_defaults: true
             }).then(function(state) {
                 Jupyter.notebook.metadata.widgets = {
-                    'application/vnd.jupyter.widget-state+json' : {
-                        version_major: 1,
-                        version_minor: 0,
-                        state: state
-                    }
+                    'application/vnd.jupyter.widget-state+json' : state
                 };
                 Jupyter.menubar.actions.get('jupyter-notebook:save-notebook').handler({
                     notebook: Jupyter.notebook