diff --git a/src/lib/coerce.js b/src/lib/coerce.js
index 26f15e57932..e6eba28261a 100644
--- a/src/lib/coerce.js
+++ b/src/lib/coerce.js
@@ -257,19 +257,56 @@ exports.valObjectMeta = {
             'An {array} of plot information.'
         ].join(' '),
         requiredOpts: ['items'],
-        otherOpts: ['dflt', 'freeLength'],
+        // set dimensions=2 for a 2D array
+        // `items` may be a single object instead of an array, in which case
+        // `freeLength` must be true.
+        otherOpts: ['dflt', 'freeLength', 'dimensions'],
         coerceFunction: function(v, propOut, dflt, opts) {
+
+            // simplified coerce function just for array items
+            function coercePart(v, opts, dflt) {
+                var out;
+                var propPart = {set: function(v) { out = v; }};
+
+                if(dflt === undefined) dflt = opts.dflt;
+
+                exports.valObjectMeta[opts.valType].coerceFunction(v, propPart, dflt, opts);
+
+                return out;
+            }
+
+            var twoD = opts.dimensions === 2;
+
             if(!Array.isArray(v)) {
                 propOut.set(dflt);
                 return;
             }
 
-            var items = opts.items,
-                vOut = [];
+            var items = opts.items;
+            var vOut = [];
+            var arrayItems = Array.isArray(items);
+            var len = arrayItems ? items.length : v.length;
+
+            var i, j, len2, vNew;
+
             dflt = Array.isArray(dflt) ? dflt : [];
 
-            for(var i = 0; i < items.length; i++) {
-                exports.coerce(v, vOut, items, '[' + i + ']', dflt[i]);
+            if(twoD) {
+                for(i = 0; i < len; i++) {
+                    vOut[i] = [];
+                    var row = Array.isArray(v[i]) ? v[i] : [];
+                    len2 = arrayItems ? items[i].length : row.length;
+                    for(j = 0; j < len2; j++) {
+                        vNew = coercePart(row[j], arrayItems ? items[i][j] : items, (dflt[i] || [])[j]);
+                        if(vNew !== undefined) vOut[i][j] = vNew;
+                    }
+                }
+            }
+            else {
+                for(i = 0; i < len; i++) {
+                    vNew = coercePart(v[i], arrayItems ? items[i] : items, dflt[i]);
+                    if(vNew !== undefined) vOut[i] = vNew;
+                }
             }
 
             propOut.set(vOut);
@@ -278,15 +315,25 @@ exports.valObjectMeta = {
             if(!Array.isArray(v)) return false;
 
             var items = opts.items;
+            var arrayItems = Array.isArray(items);
+            var twoD = opts.dimensions === 2;
 
             // when free length is off, input and declared lengths must match
             if(!opts.freeLength && v.length !== items.length) return false;
 
             // valid when all input items are valid
             for(var i = 0; i < v.length; i++) {
-                var isItemValid = exports.validate(v[i], opts.items[i]);
-
-                if(!isItemValid) return false;
+                if(twoD) {
+                    if(!Array.isArray(v[i]) || (!opts.freeLength && v[i].length !== items[i].length)) {
+                        return false;
+                    }
+                    for(var j = 0; j < v[i].length; j++) {
+                        if(!exports.validate(v[i][j], arrayItems ? items[i][j] : items)) {
+                            return false;
+                        }
+                    }
+                }
+                else if(!exports.validate(v[i], arrayItems ? items[i] : items)) return false;
             }
 
             return true;
diff --git a/src/lib/regex.js b/src/lib/regex.js
index 7ebeb0d971a..acfaff9d41b 100644
--- a/src/lib/regex.js
+++ b/src/lib/regex.js
@@ -8,16 +8,19 @@
 
 'use strict';
 
-// Simple helper functions
-// none of these need any external deps
-
 /*
  * make a regex for matching counter ids/names ie xaxis, xaxis2, xaxis10...
- *  eg: regexCounter('x')
- * tail is an optional piece after the id
- *  eg regexCounter('scene', '.annotations') for scene2.annotations etc.
+ *
+ * @param {string} head: the head of the pattern, eg 'x' matches 'x', 'x2', 'x10' etc.
+ *      'xy' is a special case for cartesian subplots: it matches 'x2y3' etc
+ * @param {Optional(string)} tail: a fixed piece after the id
+ *      eg counterRegex('scene', '.annotations') for scene2.annotations etc.
+ * @param {boolean} openEnded: if true, the string may continue past the match.
  */
 exports.counter = function(head, tail, openEnded) {
-    return new RegExp('^' + head + '([2-9]|[1-9][0-9]+)?' +
-        (tail || '') + (openEnded ? '' : '$'));
+    var fullTail = (tail || '') + (openEnded ? '' : '$');
+    if(head === 'xy') {
+        return new RegExp('^x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?' + fullTail);
+    }
+    return new RegExp('^' + head + '([2-9]|[1-9][0-9]+)?' + fullTail);
 };
diff --git a/src/lib/stats.js b/src/lib/stats.js
index 134c17559c2..9e48bc081b4 100644
--- a/src/lib/stats.js
+++ b/src/lib/stats.js
@@ -28,7 +28,7 @@ var isNumeric = require('fast-isnumeric');
 exports.aggNums = function(f, v, a, len) {
     var i,
         b;
-    if(!len) len = a.length;
+    if(!len || len > a.length) len = a.length;
     if(!isNumeric(v)) v = false;
     if(Array.isArray(a[0])) {
         b = new Array(len);
diff --git a/src/plot_api/plot_schema.js b/src/plot_api/plot_schema.js
index e3915e0297d..ef8261834c9 100644
--- a/src/plot_api/plot_schema.js
+++ b/src/plot_api/plot_schema.js
@@ -383,7 +383,8 @@ function recurseIntoValObject(valObject, parts, i) {
     }
 
     // now recurse as far as we can. Occasionally we have an attribute
-    // setting an internal part below what's
+    // setting an internal part below what's in the schema; just return
+    // the innermost schema item we find.
     for(; i < parts.length; i++) {
         var newValObject = valObject[parts[i]];
         if(Lib.isPlainObject(newValObject)) valObject = newValObject;
@@ -398,8 +399,23 @@ function recurseIntoValObject(valObject, parts, i) {
         else if(valObject.valType === 'info_array') {
             i++;
             var index = parts[i];
-            if(!isIndex(index) || index >= valObject.items.length) return false;
-            valObject = valObject.items[index];
+            if(!isIndex(index)) return false;
+
+            var items = valObject.items;
+            if(Array.isArray(items)) {
+                if(index >= items.length) return false;
+                if(valObject.dimensions === 2) {
+                    i++;
+                    if(parts.length === i) return valObject;
+                    var index2 = parts[i];
+                    if(!isIndex(index2)) return false;
+                    valObject = items[index][index2];
+                }
+                else valObject = items[index];
+            }
+            else {
+                valObject = items;
+            }
         }
     }
 
diff --git a/src/plot_api/validate.js b/src/plot_api/validate.js
index 8f163fb92c9..0b77146a4e1 100644
--- a/src/plot_api/validate.js
+++ b/src/plot_api/validate.js
@@ -164,9 +164,10 @@ function crawl(objIn, objOut, schema, list, base, path) {
         var valIn = objIn[k],
             valOut = objOut[k];
 
-        var nestedSchema = getNestedSchema(schema, k),
-            isInfoArray = (nestedSchema || {}).valType === 'info_array',
-            isColorscale = (nestedSchema || {}).valType === 'colorscale';
+        var nestedSchema = getNestedSchema(schema, k);
+        var isInfoArray = (nestedSchema || {}).valType === 'info_array';
+        var isColorscale = (nestedSchema || {}).valType === 'colorscale';
+        var items = (nestedSchema || {}).items;
 
         if(!isInSchema(schema, k)) {
             list.push(format('schema', base, p));
@@ -174,9 +175,54 @@ function crawl(objIn, objOut, schema, list, base, path) {
         else if(isPlainObject(valIn) && isPlainObject(valOut)) {
             crawl(valIn, valOut, nestedSchema, list, base, p);
         }
+        else if(isInfoArray && isArray(valIn)) {
+            if(valIn.length > valOut.length) {
+                list.push(format('unused', base, p.concat(valOut.length)));
+            }
+            var len = valOut.length;
+            var arrayItems = Array.isArray(items);
+            if(arrayItems) len = Math.min(len, items.length);
+            var m, n, item, valInPart, valOutPart;
+            if(nestedSchema.dimensions === 2) {
+                for(n = 0; n < len; n++) {
+                    if(isArray(valIn[n])) {
+                        if(valIn[n].length > valOut[n].length) {
+                            list.push(format('unused', base, p.concat(n, valOut[n].length)));
+                        }
+                        var len2 = valOut[n].length;
+                        for(m = 0; m < (arrayItems ? Math.min(len2, items[n].length) : len2); m++) {
+                            item = arrayItems ? items[n][m] : items;
+                            valInPart = valIn[n][m];
+                            valOutPart = valOut[n][m];
+                            if(!Lib.validate(valInPart, item)) {
+                                list.push(format('value', base, p.concat(n, m), valInPart));
+                            }
+                            else if(valOutPart !== valInPart && valOutPart !== +valInPart) {
+                                list.push(format('dynamic', base, p.concat(n, m), valInPart, valOutPart));
+                            }
+                        }
+                    }
+                    else {
+                        list.push(format('array', base, p.concat(n), valIn[n]));
+                    }
+                }
+            }
+            else {
+                for(n = 0; n < len; n++) {
+                    item = arrayItems ? items[n] : items;
+                    valInPart = valIn[n];
+                    valOutPart = valOut[n];
+                    if(!Lib.validate(valInPart, item)) {
+                        list.push(format('value', base, p.concat(n), valInPart));
+                    }
+                    else if(valOutPart !== valInPart && valOutPart !== +valInPart) {
+                        list.push(format('dynamic', base, p.concat(n), valInPart, valOutPart));
+                    }
+                }
+            }
+        }
         else if(nestedSchema.items && !isInfoArray && isArray(valIn)) {
-            var items = nestedSchema.items,
-                _nestedSchema = items[Object.keys(items)[0]],
+            var _nestedSchema = items[Object.keys(items)[0]],
                 indexList = [];
 
             var j, _p;
diff --git a/src/plots/cartesian/constants.js b/src/plots/cartesian/constants.js
index 818071ca864..a134bd71cf5 100644
--- a/src/plots/cartesian/constants.js
+++ b/src/plots/cartesian/constants.js
@@ -7,7 +7,7 @@
 */
 
 'use strict';
-var counterRegex = require('../../lib').counterRegex;
+var counterRegex = require('../../lib/regex').counter;
 
 
 module.exports = {
diff --git a/src/plots/cartesian/layout_attributes.js b/src/plots/cartesian/layout_attributes.js
index 225c409e249..64783e015ea 100644
--- a/src/plots/cartesian/layout_attributes.js
+++ b/src/plots/cartesian/layout_attributes.js
@@ -685,11 +685,11 @@ module.exports = {
         valType: 'info_array',
         role: 'info',
         items: [
-            {valType: 'number', min: 0, max: 1, editType: 'calc'},
-            {valType: 'number', min: 0, max: 1, editType: 'calc'}
+            {valType: 'number', min: 0, max: 1, editType: 'plot'},
+            {valType: 'number', min: 0, max: 1, editType: 'plot'}
         ],
         dflt: [0, 1],
-        editType: 'calc',
+        editType: 'plot',
         description: [
             'Sets the domain of this axis (in plot fraction).'
         ].join(' ')
diff --git a/src/plots/cartesian/layout_defaults.js b/src/plots/cartesian/layout_defaults.js
index 149bb203d1e..54cedf70d16 100644
--- a/src/plots/cartesian/layout_defaults.js
+++ b/src/plots/cartesian/layout_defaults.js
@@ -161,7 +161,8 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
         var positioningOptions = {
             letter: axLetter,
             counterAxes: counterAxes[axLetter],
-            overlayableAxes: overlayableAxes
+            overlayableAxes: overlayableAxes,
+            grid: layoutOut.grid
         };
 
         handlePositionDefaults(axLayoutIn, axLayoutOut, coerce, positioningOptions);
diff --git a/src/plots/cartesian/position_defaults.js b/src/plots/cartesian/position_defaults.js
index ebbe138e368..c6feadc14df 100644
--- a/src/plots/cartesian/position_defaults.js
+++ b/src/plots/cartesian/position_defaults.js
@@ -15,26 +15,43 @@ var Lib = require('../../lib');
 
 
 module.exports = function handlePositionDefaults(containerIn, containerOut, coerce, options) {
-    var counterAxes = options.counterAxes || [],
-        overlayableAxes = options.overlayableAxes || [],
-        letter = options.letter;
+    var counterAxes = options.counterAxes || [];
+    var overlayableAxes = options.overlayableAxes || [];
+    var letter = options.letter;
+    var grid = options.grid;
+
+    var dfltAnchor, dfltDomain, dfltSide, dfltPosition;
+
+    if(grid) {
+        dfltDomain = grid._domains[letter][grid._axisMap[containerOut._id]];
+        dfltAnchor = grid._anchors[containerOut._id];
+        if(dfltDomain) {
+            dfltSide = grid[letter + 'side'].split(' ')[0];
+            dfltPosition = grid.domain[letter][dfltSide === 'right' || dfltSide === 'top' ? 1 : 0];
+        }
+    }
+
+    // Even if there's a grid, this axis may not be in it - fall back on non-grid defaults
+    dfltDomain = dfltDomain || [0, 1];
+    dfltAnchor = dfltAnchor || (isNumeric(containerIn.position) ? 'free' : (counterAxes[0] || 'free'));
+    dfltSide = dfltSide || (letter === 'x' ? 'bottom' : 'left');
+    dfltPosition = dfltPosition || 0;
 
     var anchor = Lib.coerce(containerIn, containerOut, {
         anchor: {
             valType: 'enumerated',
             values: ['free'].concat(counterAxes),
-            dflt: isNumeric(containerIn.position) ? 'free' :
-                (counterAxes[0] || 'free')
+            dflt: dfltAnchor
         }
     }, 'anchor');
 
-    if(anchor === 'free') coerce('position');
+    if(anchor === 'free') coerce('position', dfltPosition);
 
     Lib.coerce(containerIn, containerOut, {
         side: {
             valType: 'enumerated',
             values: letter === 'x' ? ['bottom', 'top'] : ['left', 'right'],
-            dflt: letter === 'x' ? 'bottom' : 'left'
+            dflt: dfltSide
         }
     }, 'side');
 
@@ -54,9 +71,9 @@ module.exports = function handlePositionDefaults(containerIn, containerOut, coer
         // in ax.setscale()... but this means we still need (imperfect) logic
         // in the axes popover to hide domain for the overlaying axis.
         // perhaps I should make a private version _domain that all axes get???
-        var domain = coerce('domain');
-        if(domain[0] > domain[1] - 0.01) containerOut.domain = [0, 1];
-        Lib.noneOrAll(containerIn.domain, containerOut.domain, [0, 1]);
+        var domain = coerce('domain', dfltDomain);
+        if(domain[0] > domain[1] - 0.01) containerOut.domain = dfltDomain;
+        Lib.noneOrAll(containerIn.domain, containerOut.domain, dfltDomain);
     }
 
     coerce('layer');
diff --git a/src/plots/domain_attributes.js b/src/plots/domain.js
similarity index 51%
rename from src/plots/domain_attributes.js
rename to src/plots/domain.js
index d929be4f5c7..3c6dc828780 100644
--- a/src/plots/domain_attributes.js
+++ b/src/plots/domain.js
@@ -20,6 +20,8 @@ var extendFlat = require('../lib/extend').extendFlat;
  *     opts.trace: set to true for trace containers
  *   @param {string}
  *     opts.editType: editType for all pieces
+ *   @param {boolean}
+ *     opts.noGridCell: set to true to omit `row` and `column`
  *
  * @param {object} extra
  *   @param {string}
@@ -29,7 +31,7 @@ var extendFlat = require('../lib/extend').extendFlat;
  *
  * @return {object} attributes object containing {x,y} as specified
  */
-module.exports = function(opts, extra) {
+exports.attributes = function(opts, extra) {
     opts = opts || {};
     extra = extra || {};
 
@@ -48,7 +50,7 @@ module.exports = function(opts, extra) {
     var contPart = opts.trace ? 'trace ' : 'subplot ';
     var descPart = extra.description ? ' ' + extra.description : '';
 
-    return {
+    var out = {
         x: extendFlat({}, base, {
             description: [
                 'Sets the horizontal domain of this ',
@@ -69,4 +71,62 @@ module.exports = function(opts, extra) {
         }),
         editType: opts.editType
     };
+
+    if(!opts.noGridCell) {
+        out.row = {
+            valType: 'integer',
+            min: 0,
+            dflt: 0,
+            role: 'info',
+            editType: opts.editType,
+            description: [
+                'If there is a layout grid, use the domain ',
+                'for this row in the grid for this ',
+                namePart,
+                contPart,
+                '.',
+                descPart
+            ].join('')
+        };
+        out.column = {
+            valType: 'integer',
+            min: 0,
+            dflt: 0,
+            role: 'info',
+            editType: opts.editType,
+            description: [
+                'If there is a layout grid, use the domain ',
+                'for this column in the grid for this ',
+                namePart,
+                contPart,
+                '.',
+                descPart
+            ].join('')
+        };
+    }
+
+    return out;
+};
+
+exports.defaults = function(containerOut, layout, coerce, dfltDomains) {
+    var dfltX = (dfltDomains && dfltDomains.x) || [0, 1];
+    var dfltY = (dfltDomains && dfltDomains.y) || [0, 1];
+
+    var grid = layout.grid;
+    if(grid) {
+        var column = coerce('domain.column');
+        if(column !== undefined) {
+            if(column < grid.columns) dfltX = grid._domains.x[column];
+            else delete containerOut.domain.column;
+        }
+
+        var row = coerce('domain.row');
+        if(row !== undefined) {
+            if(row < grid.rows) dfltY = grid._domains.y[row];
+            else delete containerOut.domain.row;
+        }
+    }
+
+    coerce('domain.x', dfltX);
+    coerce('domain.y', dfltY);
 };
diff --git a/src/plots/geo/layout/layout_attributes.js b/src/plots/geo/layout/layout_attributes.js
index 4e15c3e680b..f326c816550 100644
--- a/src/plots/geo/layout/layout_attributes.js
+++ b/src/plots/geo/layout/layout_attributes.js
@@ -9,7 +9,7 @@
 'use strict';
 
 var colorAttrs = require('../../../components/color/attributes');
-var domainAttrs = require('../../domain_attributes');
+var domainAttrs = require('../../domain').attributes;
 var constants = require('../constants');
 var overrideAll = require('../../../plot_api/edit_types').overrideAll;
 
diff --git a/src/plots/gl3d/layout/layout_attributes.js b/src/plots/gl3d/layout/layout_attributes.js
index ec32f254c30..870eca0151c 100644
--- a/src/plots/gl3d/layout/layout_attributes.js
+++ b/src/plots/gl3d/layout/layout_attributes.js
@@ -10,7 +10,7 @@
 'use strict';
 
 var gl3dAxisAttrs = require('./axis_attributes');
-var domainAttrs = require('../../domain_attributes');
+var domainAttrs = require('../../domain').attributes;
 var extendFlat = require('../../../lib/extend').extendFlat;
 var counterRegex = require('../../../lib').counterRegex;
 
diff --git a/src/plots/grid.js b/src/plots/grid.js
new file mode 100644
index 00000000000..7e1f75722a6
--- /dev/null
+++ b/src/plots/grid.js
@@ -0,0 +1,399 @@
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+var Lib = require('../lib');
+var domainAttrs = require('./domain').attributes;
+var counterRegex = require('../lib/regex').counter;
+var cartesianIdRegex = require('./cartesian/constants').idRegex;
+
+
+var gridAttrs = exports.attributes = {
+    rows: {
+        valType: 'integer',
+        min: 1,
+        role: 'info',
+        editType: 'plot',
+        description: [
+            'The number of rows in the grid. If you provide a 2D `subplots`',
+            'array or a `yaxes` array, its length is used as the default.',
+            'But it\'s also possible to have a different length, if you',
+            'want to leave a row at the end for non-cartesian subplots.'
+        ].join(' ')
+    },
+    roworder: {
+        valType: 'enumerated',
+        values: ['top to bottom', 'bottom to top'],
+        dflt: 'top to bottom',
+        role: 'info',
+        editType: 'plot',
+        description: [
+            'Is the first row the top or the bottom? Note that columns',
+            'are always enumerated from left to right.'
+        ].join(' ')
+    },
+    columns: {
+        valType: 'integer',
+        min: 1,
+        role: 'info',
+        editType: 'plot',
+        description: [
+            'The number of columns in the grid. If you provide a 2D `subplots`',
+            'array, the length of its longest row is used as the default.',
+            'If you give an `xaxes` array, its length is used as the default.',
+            'But it\'s also possible to have a different length, if you',
+            'want to leave a row at the end for non-cartesian subplots.'
+        ].join(' ')
+    },
+    subplots: {
+        valType: 'info_array',
+        freeLength: true,
+        dimensions: 2,
+        items: {valType: 'enumerated', values: [counterRegex('xy').toString(), '']},
+        role: 'info',
+        editType: 'plot',
+        description: [
+            'Used for freeform grids, where some axes may be shared across subplots',
+            'but others are not. Each entry should be a cartesian subplot id, like',
+            '*xy* or *x3y2*, or ** to leave that cell empty. You may reuse x axes',
+            'within the same column, and y axes within the same row.',
+            'Non-cartesian subplots and traces that support `domain` can place themselves',
+            'in this grid separately using the `gridcell` attribute.'
+        ].join(' ')
+    },
+    xaxes: {
+        valType: 'info_array',
+        freeLength: true,
+        items: {valType: 'enumerated', values: [cartesianIdRegex.x.toString(), '']},
+        role: 'info',
+        editType: 'plot',
+        description: [
+            'Used with `yaxes` when the x and y axes are shared across columns and rows.',
+            'Each entry should be an x axis id like *x*, *x2*, etc., or ** to',
+            'not put an x axis in that column. Entries other than ** must be unique.',
+            'Ignored if `subplots` is present. If missing but `yaxes` is present,',
+            'will generate consecutive IDs.'
+        ].join(' ')
+    },
+    yaxes: {
+        valType: 'info_array',
+        freeLength: true,
+        items: {valType: 'enumerated', values: [cartesianIdRegex.y.toString(), '']},
+        role: 'info',
+        editType: 'plot',
+        description: [
+            'Used with `yaxes` when the x and y axes are shared across columns and rows.',
+            'Each entry should be an y axis id like *y*, *y2*, etc., or ** to',
+            'not put a y axis in that row. Entries other than ** must be unique.',
+            'Ignored if `subplots` is present. If missing but `xaxes` is present,',
+            'will generate consecutive IDs.'
+        ].join(' ')
+    },
+    pattern: {
+        valType: 'enumerated',
+        values: ['independent', 'coupled'],
+        dflt: 'coupled',
+        role: 'info',
+        editType: 'plot',
+        description: [
+            'If no `subplots`, `xaxes`, or `yaxes` are given but we do have `rows` and `columns`,',
+            'we can generate defaults using consecutive axis IDs, in two ways:',
+            '*coupled* gives one x axis per column and one y axis per row.',
+            '*independent* uses a new xy pair for each cell, left-to-right across each row',
+            'then iterating rows according to `roworder`.'
+        ].join(' ')
+    },
+    xgap: {
+        valType: 'number',
+        min: 0,
+        max: 1,
+        role: 'info',
+        editType: 'plot',
+        description: [
+            'Horizontal space between grid cells, expressed as a fraction',
+            'of the total width available to one cell. Defaults to 0.1',
+            'for coupled-axes grids and 0.2 for independent grids.'
+        ].join(' ')
+    },
+    ygap: {
+        valType: 'number',
+        min: 0,
+        max: 1,
+        role: 'info',
+        editType: 'plot',
+        description: [
+            'Vertical space between grid cells, expressed as a fraction',
+            'of the total height available to one cell. Defaults to 0.1',
+            'for coupled-axes grids and 0.3 for independent grids.'
+        ].join(' ')
+    },
+    domain: domainAttrs({name: 'grid', editType: 'plot', noGridCell: true}, {
+        description: [
+            'The first and last cells end exactly at the domain',
+            'edges, with no grout around the edges.'
+        ].join(' ')
+    }),
+    xside: {
+        valType: 'enumerated',
+        values: ['bottom', 'bottom plot', 'top plot', 'top'],
+        dflt: 'bottom plot',
+        role: 'info',
+        editType: 'ticks',
+        description: [
+            'Sets where the x axis labels and titles go. *bottom* means',
+            'the very bottom of the grid. *bottom plot* is the lowest plot',
+            'that each x axis is used in. *top* and *top plot* are similar.'
+        ].join(' ')
+    },
+    yside: {
+        valType: 'enumerated',
+        values: ['left', 'left plot', 'right plot', 'right'],
+        dflt: 'left plot',
+        role: 'info',
+        editType: 'ticks',
+        description: [
+            'Sets where the y axis labels and titles go. *left* means',
+            'the very left edge of the grid. *left plot* is the leftmost plot',
+            'that each y axis is used in. *right* and *right plot* are similar.'
+        ].join(' ')
+    },
+    editType: 'plot'
+};
+
+// the shape of the grid - this needs to be done BEFORE supplyDataDefaults
+// so that non-subplot traces can place themselves in the grid
+exports.sizeDefaults = function(layoutIn, layoutOut) {
+    var gridIn = layoutIn.grid;
+    if(!gridIn) return;
+
+    var hasSubplotGrid = Array.isArray(gridIn.subplots) && Array.isArray(gridIn.subplots[0]);
+    var hasXaxes = Array.isArray(gridIn.xaxes);
+    var hasYaxes = Array.isArray(gridIn.yaxes);
+
+    var dfltRows, dfltColumns;
+
+    if(hasSubplotGrid) {
+        dfltRows = gridIn.subplots.length;
+        dfltColumns = gridIn.subplots[0].length;
+    }
+    else {
+        if(hasYaxes) dfltRows = gridIn.yaxes.length;
+        if(hasXaxes) dfltColumns = gridIn.xaxes.length;
+    }
+
+    var gridOut = layoutOut.grid = {};
+
+    function coerce(attr, dflt) {
+        return Lib.coerce(gridIn, gridOut, gridAttrs, attr, dflt);
+    }
+
+    var rows = coerce('rows', dfltRows);
+    var columns = coerce('columns', dfltColumns);
+
+    if(!(rows * columns > 1)) return;
+
+    if(!hasSubplotGrid && !hasXaxes && !hasYaxes) {
+        var useDefaultSubplots = coerce('pattern') === 'independent';
+        if(useDefaultSubplots) hasSubplotGrid = true;
+    }
+    gridOut._hasSubplotGrid = hasSubplotGrid;
+
+    var rowOrder = coerce('roworder');
+    var reversed = rowOrder === 'top to bottom';
+
+    gridOut._domains = {
+        x: fillGridPositions('x', coerce, hasSubplotGrid ? 0.2 : 0.1, columns),
+        y: fillGridPositions('y', coerce, hasSubplotGrid ? 0.3 : 0.1, rows, reversed)
+    };
+};
+
+// coerce x or y sizing attributes and return an array of domains for this direction
+function fillGridPositions(axLetter, coerce, dfltGap, len, reversed) {
+    var dirGap = coerce(axLetter + 'gap', dfltGap);
+    var domain = coerce('domain.' + axLetter);
+    coerce(axLetter + 'side');
+
+    var out = new Array(len);
+    var start = domain[0];
+    var step = (domain[1] - start) / (len - dirGap);
+    var cellDomain = step * (1 - dirGap);
+    for(var i = 0; i < len; i++) {
+        var cellStart = start + step * i;
+        out[reversed ? (len - 1 - i) : i] = [cellStart, cellStart + cellDomain];
+    }
+    return out;
+}
+
+// the (cartesian) contents of the grid - this needs to happen AFTER supplyDataDefaults
+// so that we know what cartesian subplots are available
+exports.contentDefaults = function(layoutIn, layoutOut) {
+    var gridOut = layoutOut.grid;
+    // make sure we got to the end of handleGridSizing
+    if(!gridOut || !gridOut._domains) return;
+
+    var gridIn = layoutIn.grid;
+    var subplots = layoutOut._subplots;
+    var hasSubplotGrid = gridOut._hasSubplotGrid;
+    var rows = gridOut.rows;
+    var columns = gridOut.columns;
+    var useDefaultSubplots = gridOut.pattern === 'independent';
+
+    var i, j, xId, yId, subplotId, subplotsOut, yPos;
+
+    var axisMap = gridOut._axisMap = {};
+
+    if(hasSubplotGrid) {
+        var subplotsIn = gridIn.subplots || [];
+        subplotsOut = gridOut.subplots = new Array(rows);
+        var index = 1;
+
+        for(i = 0; i < rows; i++) {
+            var rowOut = subplotsOut[i] = new Array(columns);
+            var rowIn = subplotsIn[i] || [];
+            for(j = 0; j < columns; j++) {
+                if(useDefaultSubplots) {
+                    subplotId = (index === 1) ? 'xy' : ('x' + index + 'y' + index);
+                    index++;
+                }
+                else subplotId = rowIn[j];
+
+                rowOut[j] = '';
+
+                if(subplots.cartesian.indexOf(subplotId) !== -1) {
+                    yPos = subplotId.indexOf('y');
+                    xId = subplotId.slice(0, yPos);
+                    yId = subplotId.slice(yPos);
+                    if((axisMap[xId] !== undefined && axisMap[xId] !== j) ||
+                        (axisMap[yId] !== undefined && axisMap[yId] !== i)
+                    ) {
+                        continue;
+                    }
+
+                    rowOut[j] = subplotId;
+                    axisMap[xId] = j;
+                    axisMap[yId] = i;
+                }
+            }
+        }
+    }
+    else {
+        gridOut.xaxes = fillGridAxes(gridIn.xaxes, subplots.xaxis, columns, axisMap, 'x');
+        gridOut.yaxes = fillGridAxes(gridIn.yaxes, subplots.yaxis, rows, axisMap, 'y');
+    }
+
+    var anchors = gridOut._anchors = {};
+    var reversed = gridOut.roworder === 'top to bottom';
+
+    for(var axisId in axisMap) {
+        var axLetter = axisId.charAt(0);
+        var side = gridOut[axLetter + 'side'];
+
+        var i0, inc, iFinal;
+
+        if(side.length < 8) {
+            // grid edge -  ie not "* plot" - make these as free axes
+            // since we're not guaranteed to have a subplot there at all
+            anchors[axisId] = 'free';
+        }
+        else if(axLetter === 'x') {
+            if((side.charAt(0) === 't') === reversed) {
+                i0 = 0;
+                inc = 1;
+                iFinal = rows;
+            }
+            else {
+                i0 = rows - 1;
+                inc = -1;
+                iFinal = -1;
+            }
+            if(hasSubplotGrid) {
+                var column = axisMap[axisId];
+                for(i = i0; i !== iFinal; i += inc) {
+                    subplotId = subplotsOut[i][column];
+                    if(!subplotId) continue;
+                    yPos = subplotId.indexOf('y');
+                    if(subplotId.slice(0, yPos) === axisId) {
+                        anchors[axisId] = subplotId.slice(yPos);
+                        break;
+                    }
+                }
+            }
+            else {
+                for(i = i0; i !== iFinal; i += inc) {
+                    yId = gridOut.yaxes[i];
+                    if(subplots.cartesian.indexOf(axisId + yId) !== -1) {
+                        anchors[axisId] = yId;
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            if((side.charAt(0) === 'l')) {
+                i0 = 0;
+                inc = 1;
+                iFinal = columns;
+            }
+            else {
+                i0 = columns - 1;
+                inc = -1;
+                iFinal = -1;
+            }
+            if(hasSubplotGrid) {
+                var row = axisMap[axisId];
+                for(i = i0; i !== iFinal; i += inc) {
+                    subplotId = subplotsOut[row][i];
+                    if(!subplotId) continue;
+                    yPos = subplotId.indexOf('y');
+                    if(subplotId.slice(yPos) === axisId) {
+                        anchors[axisId] = subplotId.slice(0, yPos);
+                        break;
+                    }
+                }
+            }
+            else {
+                for(i = i0; i !== iFinal; i += inc) {
+                    xId = gridOut.xaxes[i];
+                    if(subplots.cartesian.indexOf(xId + axisId) !== -1) {
+                        anchors[axisId] = xId;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+};
+
+function fillGridAxes(axesIn, axesAllowed, len, axisMap, axLetter) {
+    var out = new Array(len);
+    var i;
+
+    function fillOneAxis(i, axisId) {
+        if(axesAllowed.indexOf(axisId) !== -1 && axisMap[axisId] === undefined) {
+            out[i] = axisId;
+            axisMap[axisId] = i;
+        }
+        else out[i] = '';
+    }
+
+    if(Array.isArray(axesIn)) {
+        for(i = 0; i < len; i++) {
+            fillOneAxis(i, axesIn[i]);
+        }
+    }
+    else {
+        // default axis list is the first `len` axis ids
+        fillOneAxis(0, axLetter);
+        for(i = 1; i < len; i++) {
+            fillOneAxis(i, axLetter + (i + 1));
+        }
+    }
+
+    return out;
+}
diff --git a/src/plots/layout_attributes.js b/src/plots/layout_attributes.js
index 1dfee32e8f7..1e7e8e20bea 100644
--- a/src/plots/layout_attributes.js
+++ b/src/plots/layout_attributes.js
@@ -10,6 +10,7 @@
 
 var fontAttrs = require('./font_attributes');
 var colorAttrs = require('../components/color/attributes');
+var gridAttrs = require('./grid').attributes;
 
 var globalFont = fontAttrs({
     editType: 'calc',
@@ -195,5 +196,6 @@ module.exports = {
             'being treated as immutable, thus any data array with a',
             'different identity from its predecessor contains new data.'
         ].join(' ')
-    }
+    },
+    grid: gridAttrs
 };
diff --git a/src/plots/mapbox/layout_attributes.js b/src/plots/mapbox/layout_attributes.js
index b373105c29f..2306c8b4bcf 100644
--- a/src/plots/mapbox/layout_attributes.js
+++ b/src/plots/mapbox/layout_attributes.js
@@ -11,7 +11,7 @@
 
 var Lib = require('../../lib');
 var defaultLine = require('../../components/color').defaultLine;
-var domainAttrs = require('../domain_attributes');
+var domainAttrs = require('../domain').attributes;
 var fontAttrs = require('../font_attributes');
 var textposition = require('../../traces/scatter/attributes').textposition;
 var overrideAll = require('../../plot_api/edit_types').overrideAll;
diff --git a/src/plots/plots.js b/src/plots/plots.js
index ae049d78d5c..db80e30dfed 100644
--- a/src/plots/plots.js
+++ b/src/plots/plots.js
@@ -20,6 +20,7 @@ var Lib = require('../lib');
 var _ = Lib._;
 var Color = require('../components/color');
 var BADNUM = require('../constants/numerical').BADNUM;
+var Grid = require('./grid');
 
 var plots = module.exports = {};
 
@@ -1250,6 +1251,8 @@ plots.supplyLayoutGlobalDefaults = function(layoutIn, layoutOut, formatObj) {
 
     if(layoutIn.width && layoutIn.height) plots.sanitizeMargins(layoutOut);
 
+    Grid.sizeDefaults(layoutIn, layoutOut);
+
     coerce('paper_bgcolor');
 
     coerce('separators', formatObj.decimal + formatObj.thousands);
@@ -1387,6 +1390,7 @@ plots.supplyLayoutModuleDefaults = function(layoutIn, layoutOut, fullData, trans
 
     // ensure all cartesian axes have at least one subplot
     if(layoutOut._has('cartesian')) {
+        Grid.contentDefaults(layoutIn, layoutOut);
         Cartesian.finalizeSubplots(layoutIn, layoutOut);
     }
 
diff --git a/src/plots/polar/layout_attributes.js b/src/plots/polar/layout_attributes.js
index ff663ed518a..ba4d8fe25a6 100644
--- a/src/plots/polar/layout_attributes.js
+++ b/src/plots/polar/layout_attributes.js
@@ -10,7 +10,7 @@
 
 var colorAttrs = require('../../components/color/attributes');
 var axesAttrs = require('../cartesian/layout_attributes');
-var domainAttrs = require('../domain_attributes');
+var domainAttrs = require('../domain').attributes;
 var extendFlat = require('../../lib').extendFlat;
 var overrideAll = require('../../plot_api/edit_types').overrideAll;
 
diff --git a/src/plots/subplot_defaults.js b/src/plots/subplot_defaults.js
index 589017a1a9a..b8c229cc8a1 100644
--- a/src/plots/subplot_defaults.js
+++ b/src/plots/subplot_defaults.js
@@ -10,6 +10,7 @@
 'use strict';
 
 var Lib = require('../lib');
+var handleDomainDefaults = require('./domain').defaults;
 
 
 /**
@@ -63,8 +64,9 @@ module.exports = function handleSubplotDefaults(layoutIn, layoutOut, fullData, o
 
         layoutOut[id] = subplotLayoutOut = {};
 
-        coerce('domain.' + partition, [i / idsLength, (i + 1) / idsLength]);
-        coerce('domain.' + {x: 'y', y: 'x'}[partition]);
+        var dfltDomains = {};
+        dfltDomains[partition] = [i / idsLength, (i + 1) / idsLength];
+        handleDomainDefaults(subplotLayoutOut, layoutOut, coerce, dfltDomains);
 
         opts.id = id;
         handleDefaults(subplotLayoutIn, subplotLayoutOut, coerce, opts);
diff --git a/src/plots/ternary/layout/layout_attributes.js b/src/plots/ternary/layout/layout_attributes.js
index 10f59f289f8..77c06326974 100644
--- a/src/plots/ternary/layout/layout_attributes.js
+++ b/src/plots/ternary/layout/layout_attributes.js
@@ -9,7 +9,7 @@
 'use strict';
 
 var colorAttrs = require('../../../components/color/attributes');
-var domainAttrs = require('../../domain_attributes');
+var domainAttrs = require('../../domain').attributes;
 var ternaryAxesAttrs = require('./axis_attributes');
 var overrideAll = require('../../../plot_api/edit_types').overrideAll;
 
diff --git a/src/traces/parcoords/attributes.js b/src/traces/parcoords/attributes.js
index 1713b722d86..177a872b918 100644
--- a/src/traces/parcoords/attributes.js
+++ b/src/traces/parcoords/attributes.js
@@ -13,7 +13,7 @@ var colorbarAttrs = require('../../components/colorbar/attributes');
 var colorscales = require('../../components/colorscale/scales');
 var axesAttrs = require('../../plots/cartesian/layout_attributes');
 var fontAttrs = require('../../plots/font_attributes');
-var domainAttrs = require('../../plots/domain_attributes');
+var domainAttrs = require('../../plots/domain').attributes;
 
 var extend = require('../../lib/extend');
 var extendDeepAll = extend.extendDeepAll;
@@ -92,7 +92,6 @@ module.exports = {
         values: {
             valType: 'data_array',
             role: 'info',
-            dflt: [],
             editType: 'calc',
             description: [
                 'Dimension values. `values[n]` represents the value of the `n`th point in the dataset,',
diff --git a/src/traces/parcoords/calc.js b/src/traces/parcoords/calc.js
index c9f54b985cd..702862132c7 100644
--- a/src/traces/parcoords/calc.js
+++ b/src/traces/parcoords/calc.js
@@ -15,11 +15,11 @@ var wrap = require('../../lib/gup').wrap;
 
 module.exports = function calc(gd, trace) {
     var cs = !!trace.line.colorscale && Lib.isArray(trace.line.color);
-    var color = cs ? trace.line.color : Array.apply(0, Array(trace.dimensions.reduce(function(p, n) {return Math.max(p, n.values.length);}, 0))).map(function() {return 0.5;});
+    var color = cs ? trace.line.color : constHalf(trace._commonLength);
     var cscale = cs ? trace.line.colorscale : [[0, trace.line.color], [1, trace.line.color]];
 
     if(hasColorscale(trace, 'line')) {
-        calcColorscale(trace, trace.line.color, 'line', 'c');
+        calcColorscale(trace, color, 'line', 'c');
     }
 
     return wrap({
@@ -27,3 +27,11 @@ module.exports = function calc(gd, trace) {
         cscale: cscale
     });
 };
+
+function constHalf(len) {
+    var out = new Array(len);
+    for(var i = 0; i < len; i++) {
+        out[i] = 0.5;
+    }
+    return out;
+}
diff --git a/src/traces/parcoords/defaults.js b/src/traces/parcoords/defaults.js
index 13c6e8789c1..bbcdd63b475 100644
--- a/src/traces/parcoords/defaults.js
+++ b/src/traces/parcoords/defaults.js
@@ -13,17 +13,24 @@ var attributes = require('./attributes');
 var hasColorscale = require('../../components/colorscale/has_colorscale');
 var colorscaleDefaults = require('../../components/colorscale/defaults');
 var maxDimensionCount = require('./constants').maxDimensionCount;
+var handleDomainDefaults = require('../../plots/domain').defaults;
 
 function handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce) {
 
-    coerce('line.color', defaultColor);
+    var lineColor = coerce('line.color', defaultColor);
 
-    if(hasColorscale(traceIn, 'line') && Lib.isArray(traceIn.line.color)) {
-        coerce('line.colorscale');
-        colorscaleDefaults(traceIn, traceOut, layout, coerce, {prefix: 'line.', cLetter: 'c'});
-    }
-    else {
-        coerce('line.color', defaultColor);
+    if(hasColorscale(traceIn, 'line') && Lib.isArray(lineColor)) {
+        if(lineColor.length) {
+            coerce('line.colorscale');
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, {prefix: 'line.', cLetter: 'c'});
+            // TODO: I think it would be better to keep showing lines beyond the last line color
+            // but I'm not sure what color to give these lines - probably black or white
+            // depending on the background color?
+            traceOut._commonLength = Math.min(traceOut._commonLength, lineColor.length);
+        }
+        else {
+            traceOut.line.color = defaultColor;
+        }
     }
 }
 
@@ -52,7 +59,10 @@ function dimensionsDefaults(traceIn, traceOut) {
         }
 
         var values = coerce('values');
-        var visible = coerce('visible', values.length > 0);
+        var visible = coerce('visible');
+        if(!(values && values.length)) {
+            visible = dimensionOut.visible = false;
+        }
 
         if(visible) {
             coerce('label');
@@ -62,21 +72,14 @@ function dimensionsDefaults(traceIn, traceOut) {
             coerce('range');
             coerce('constraintrange');
 
-            commonLength = Math.min(commonLength, dimensionOut.values.length);
+            commonLength = Math.min(commonLength, values.length);
         }
 
         dimensionOut._index = i;
         dimensionsOut.push(dimensionOut);
     }
 
-    if(isFinite(commonLength)) {
-        for(i = 0; i < dimensionsOut.length; i++) {
-            dimensionOut = dimensionsOut[i];
-            if(dimensionOut.visible && dimensionOut.values.length > commonLength) {
-                dimensionOut.values = dimensionOut.values.slice(0, commonLength);
-            }
-        }
-    }
+    traceOut._commonLength = commonLength;
 
     return dimensionsOut;
 }
@@ -90,18 +93,24 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
 
     handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce);
 
-    coerce('domain.x');
-    coerce('domain.y');
+    handleDomainDefaults(traceOut, layout, coerce);
 
     if(!Array.isArray(dimensions) || !dimensions.length) {
         traceOut.visible = false;
     }
 
-    // make default font size 10px,
+    // since we're not slicing uneven arrays anymore, stash the length in each dimension
+    // but we can't do this in dimensionsDefaults (yet?) because line.color can also
+    // truncate
+    for(var i = 0; i < dimensions.length; i++) {
+        if(dimensions[i].visible) dimensions[i]._length = traceOut._commonLength;
+    }
+
+    // make default font size 10px (default is 12),
     // scale linearly with global font size
     var fontDflt = {
         family: layout.font.family,
-        size: Math.round(layout.font.size * (10 / 12)),
+        size: Math.round(layout.font.size / 1.2),
         color: layout.font.color
     };
 
diff --git a/src/traces/parcoords/parcoords.js b/src/traces/parcoords/parcoords.js
index 74f1a31f111..c622b2ae9af 100644
--- a/src/traces/parcoords/parcoords.js
+++ b/src/traces/parcoords/parcoords.js
@@ -21,8 +21,8 @@ function visible(dimension) {return !('visible' in dimension) || dimension.visib
 
 function dimensionExtent(dimension) {
 
-    var lo = dimension.range ? dimension.range[0] : d3.min(dimension.values);
-    var hi = dimension.range ? dimension.range[1] : d3.max(dimension.values);
+    var lo = dimension.range ? dimension.range[0] : Lib.aggNums(Math.min, null, dimension.values, dimension._length);
+    var hi = dimension.range ? dimension.range[1] : Lib.aggNums(Math.max, null, dimension.values, dimension._length);
 
     if(isNaN(lo) || !isFinite(lo)) {
         lo = 0;
@@ -139,7 +139,11 @@ function model(layout, d, i) {
         rangeFont = trace.rangefont;
 
     var lines = Lib.extendDeep({}, line, {
-        color: lineColor.map(domainToUnitScale({values: lineColor, range: [line.cmin, line.cmax]})),
+        color: lineColor.map(domainToUnitScale({
+            values: lineColor,
+            range: [line.cmin, line.cmax],
+            _length: trace._commonLength
+        })),
         blockLineCount: c.blockLineCount,
         canvasOverdrag: c.overdrag * c.canvasPixelRatio
     });
@@ -201,6 +205,12 @@ function viewModel(model) {
         var foundKey = uniqueKeys[dimension.label];
         uniqueKeys[dimension.label] = (foundKey || 0) + 1;
         var key = dimension.label + (foundKey ? '__' + foundKey : '');
+
+        var truncatedValues = dimension.values;
+        if(truncatedValues.length > dimension._length) {
+            truncatedValues = truncatedValues.slice(0, dimension._length);
+        }
+
         return {
             key: key,
             label: dimension.label,
@@ -213,8 +223,8 @@ function viewModel(model) {
             crossfilterDimensionIndex: i,
             visibleIndex: dimension._index,
             height: height,
-            values: dimension.values,
-            paddedUnitValues: dimension.values.map(domainToUnit).map(paddedUnitScale),
+            values: truncatedValues,
+            paddedUnitValues: truncatedValues.map(domainToUnit).map(paddedUnitScale),
             xScale: xScale,
             x: xScale(i),
             canvasX: xScale(i) * canvasPixelRatio,
diff --git a/src/traces/pie/attributes.js b/src/traces/pie/attributes.js
index cf6ae715d4f..9a901c61735 100644
--- a/src/traces/pie/attributes.js
+++ b/src/traces/pie/attributes.js
@@ -11,7 +11,7 @@
 var colorAttrs = require('../../components/color/attributes');
 var fontAttrs = require('../../plots/font_attributes');
 var plotAttrs = require('../../plots/attributes');
-var domainAttrs = require('../../plots/domain_attributes');
+var domainAttrs = require('../../plots/domain').attributes;
 
 var extendFlat = require('../../lib/extend').extendFlat;
 
diff --git a/src/traces/pie/defaults.js b/src/traces/pie/defaults.js
index a13e89497cc..9a1aa32551c 100644
--- a/src/traces/pie/defaults.js
+++ b/src/traces/pie/defaults.js
@@ -10,6 +10,7 @@
 
 var Lib = require('../../lib');
 var attributes = require('./attributes');
+var handleDomainDefaults = require('../../plots/domain').defaults;
 
 module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
     function coerce(attr, dflt) {
@@ -56,8 +57,7 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
         }
     }
 
-    coerce('domain.x');
-    coerce('domain.y');
+    handleDomainDefaults(traceOut, layout, coerce);
 
     coerce('hole');
 
diff --git a/src/traces/sankey/attributes.js b/src/traces/sankey/attributes.js
index 438f7912b63..4ca7d632c25 100644
--- a/src/traces/sankey/attributes.js
+++ b/src/traces/sankey/attributes.js
@@ -12,7 +12,7 @@ var fontAttrs = require('../../plots/font_attributes');
 var plotAttrs = require('../../plots/attributes');
 var colorAttrs = require('../../components/color/attributes');
 var fxAttrs = require('../../components/fx/attributes');
-var domainAttrs = require('../../plots/domain_attributes');
+var domainAttrs = require('../../plots/domain').attributes;
 
 var extendFlat = require('../../lib/extend').extendFlat;
 var overrideAll = require('../../plot_api/edit_types').overrideAll;
diff --git a/src/traces/sankey/defaults.js b/src/traces/sankey/defaults.js
index 5e33b9322a4..173c88dd100 100644
--- a/src/traces/sankey/defaults.js
+++ b/src/traces/sankey/defaults.js
@@ -12,6 +12,7 @@ var Lib = require('../../lib');
 var attributes = require('./attributes');
 var Color = require('../../components/color');
 var tinycolor = require('tinycolor2');
+var handleDomainDefaults = require('../../plots/domain').defaults;
 
 module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
     function coerce(attr, dflt) {
@@ -45,8 +46,8 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
             'rgba(0, 0, 0, 0.2)';
     }));
 
-    coerce('domain.x');
-    coerce('domain.y');
+    handleDomainDefaults(traceOut, layout, coerce);
+
     coerce('orientation');
     coerce('valueformat');
     coerce('valuesuffix');
diff --git a/src/traces/table/attributes.js b/src/traces/table/attributes.js
index 7dbfededbe0..feccc72501b 100644
--- a/src/traces/table/attributes.js
+++ b/src/traces/table/attributes.js
@@ -12,7 +12,7 @@ var annAttrs = require('../../components/annotations/attributes');
 var extendFlat = require('../../lib/extend').extendFlat;
 var overrideAll = require('../../plot_api/edit_types').overrideAll;
 var fontAttrs = require('../../plots/font_attributes');
-var domainAttrs = require('../../plots/domain_attributes');
+var domainAttrs = require('../../plots/domain').attributes;
 
 module.exports = overrideAll({
     domain: domainAttrs({name: 'table', trace: true}),
diff --git a/src/traces/table/defaults.js b/src/traces/table/defaults.js
index 58504670af8..989b435766d 100644
--- a/src/traces/table/defaults.js
+++ b/src/traces/table/defaults.js
@@ -10,6 +10,7 @@
 
 var Lib = require('../../lib');
 var attributes = require('./attributes');
+var handleDomainDefaults = require('../../plots/domain').defaults;
 
 function defaultColumnOrder(traceOut, coerce) {
     var specifiedColumnOrder = traceOut.columnorder || [];
@@ -28,8 +29,7 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
         return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
     }
 
-    coerce('domain.x');
-    coerce('domain.y');
+    handleDomainDefaults(traceOut, layout, coerce);
 
     coerce('columnwidth');
 
diff --git a/test/image/baselines/grid_subplot_types.png b/test/image/baselines/grid_subplot_types.png
new file mode 100644
index 00000000000..970b25cca38
Binary files /dev/null and b/test/image/baselines/grid_subplot_types.png differ
diff --git a/test/image/mocks/grid_subplot_types.json b/test/image/mocks/grid_subplot_types.json
new file mode 100644
index 00000000000..fbdf2fd7454
--- /dev/null
+++ b/test/image/mocks/grid_subplot_types.json
@@ -0,0 +1,32 @@
+{
+  "data": [
+    {"y": [1, 2, 3]},
+    {"y": [4, 6, 5], "xaxis": "x2"},
+    {"x": [1, 2, 3], "y": [8, 9, 7], "yaxis": "y2"},
+    {"type": "surface", "z": [[1, 2], [4, 1]], "showscale": false},
+    {"type": "pie", "labels": ["a", "b"], "values": [1, 6], "domain": {"row": 0, "column": 2}},
+    {"type": "scatterternary", "a": [1, 1, 3], "b": [1, 3, 1], "c": [3, 1, 1], "mode": "markers"},
+    {
+      "type": "table",
+      "header": {"values": ["a", "b"]},
+      "cells": {"values": [["c", "d"], ["e", "f"]]},
+      "domain": {"row": 2, "column": 0}
+    },
+    {"type": "scattergeo", "lon": [0, -75], "lat": [0, 45], "marker": {"size": [20, 30]}},
+    {"type": "heatmap", "z": [[1, 2], [4, 1]], "showscale": false, "xaxis": "x3", "yaxis": "y3"}
+  ],
+  "layout": {
+    "xaxis": {"title": "x"},
+    "xaxis2": {"title": "x2"},
+    "yaxis": {"title": "y"},
+    "yaxis2": {"title": "y2"},
+    "xaxis3": {"title": "x3"},
+    "yaxis3": {"title": "y3"},
+    "grid": {"rows": 3, "columns": 3, "xgap": 0.3, "ygap": 0.3},
+    "scene": {"domain": {"row": 1, "column": 1}},
+    "ternary": {"domain": {"row": 1, "column": 2}},
+    "geo": {"domain": {"row": 2, "column": 1}},
+    "width": 700,
+    "height": 700
+  }
+}
diff --git a/test/image/mocks/grouped_bar.json b/test/image/mocks/grouped_bar.json
index 7b513a7d3f3..04a3e9b8513 100644
--- a/test/image/mocks/grouped_bar.json
+++ b/test/image/mocks/grouped_bar.json
@@ -33,11 +33,6 @@
     "xaxis": {
       "type": "category"
     },
-    "barmode": "group",
-    "categories": [
-      "giraffes",
-      "orangutans",
-      "monkeys"
-    ]
+    "barmode": "group"
   }
 }
diff --git a/test/jasmine/tests/annotations_test.js b/test/jasmine/tests/annotations_test.js
index 9f7c323dab4..906e354654b 100644
--- a/test/jasmine/tests/annotations_test.js
+++ b/test/jasmine/tests/annotations_test.js
@@ -1208,7 +1208,10 @@ describe('annotation effects', function() {
         })
         .then(function() {
             expect(gd._fullLayout.annotations[0].x).toBe('2018-01-29 13:29:41.4857');
-            expect(gd._fullLayout.annotations[0].y).toBe('2017-02-02 06:36:46.8112');
+            // AJ loosened this test - expected '2017-02-02 06:36:46.8112'
+            // but when I run it I get '2017-02-02 06:28:39.9586'.
+            // must be different fonts altering autoranging
+            expect(gd._fullLayout.annotations[0].y.substr(0, 10)).toBe('2017-02-02');
         })
         .catch(failTest)
         .then(done);
diff --git a/test/jasmine/tests/gl3d_plot_interact_test.js b/test/jasmine/tests/gl3d_plot_interact_test.js
index 20837c9876c..d5f46bb8cbd 100644
--- a/test/jasmine/tests/gl3d_plot_interact_test.js
+++ b/test/jasmine/tests/gl3d_plot_interact_test.js
@@ -1020,8 +1020,8 @@ describe('@gl Test gl3d annotations', function() {
         camera.eye = {x: x, y: y, z: z};
         scene.setCamera(camera);
         // need a fairly long delay to let the camera update here
-        // 200 was not robust for me (AJ), 300 seems to be.
-        return delay(300)();
+        // 300 was not robust for me (AJ), 500 seems to be.
+        return delay(500)();
     }
 
     it('should move with camera', function(done) {
diff --git a/test/jasmine/tests/lib_test.js b/test/jasmine/tests/lib_test.js
index 7ade3bc8ffe..29ce0b65301 100644
--- a/test/jasmine/tests/lib_test.js
+++ b/test/jasmine/tests/lib_test.js
@@ -797,6 +797,77 @@ describe('Test lib.js:', function() {
                 expect(coerce({domain: [0, 0.5, 1]}, {}, infoArrayAttrs, 'domain'))
                     .toEqual([0, 0.5]);
             });
+
+            it('supports bounded freeLength attributes', function() {
+                var attrs = {
+                    x: {
+                        valType: 'info_array',
+                        freeLength: true,
+                        items: [
+                            {valType: 'integer', min: 0},
+                            {valType: 'integer', max: -1}
+                        ],
+                        dflt: [1, -2]
+                    },
+                };
+                expect(coerce({}, {}, attrs, 'x')).toEqual([1, -2]);
+                expect(coerce({x: []}, {}, attrs, 'x')).toEqual([1, -2]);
+                expect(coerce({x: [5]}, {}, attrs, 'x')).toEqual([5, -2]);
+                expect(coerce({x: [-5]}, {}, attrs, 'x')).toEqual([1, -2]);
+                expect(coerce({x: [5, -5]}, {}, attrs, 'x')).toEqual([5, -5]);
+                expect(coerce({x: [3, -3, 3]}, {}, attrs, 'x')).toEqual([3, -3]);
+            });
+
+            it('supports unbounded freeLength attributes', function() {
+                var attrs = {
+                    x: {
+                        valType: 'info_array',
+                        freeLength: true,
+                        items: {valType: 'integer', min: 0, dflt: 1}
+                    }
+                };
+                expect(coerce({}, {}, attrs, 'x')).toBeUndefined();
+                expect(coerce({x: []}, {}, attrs, 'x')).toEqual([]);
+                expect(coerce({x: [3]}, {}, attrs, 'x')).toEqual([3]);
+                expect(coerce({x: [-3]}, {}, attrs, 'x')).toEqual([1]);
+                expect(coerce({x: [-1, 4, 'hi', 5]}, {}, attrs, 'x'))
+                    .toEqual([1, 4, 1, 5]);
+            });
+
+            it('supports 2D fixed-size arrays', function() {
+                var attrs = {
+                    x: {
+                        valType: 'info_array',
+                        dimensions: 2,
+                        items: [
+                            [{valType: 'integer', min: 0, max: 2}, {valType: 'integer', min: 3, max: 5}],
+                            [{valType: 'integer', min: 6, max: 8}, {valType: 'integer', min: 9, max: 11}]
+                        ],
+                        dflt: [[1, 4], [7, 10]]
+                    }
+                };
+                expect(coerce({}, {}, attrs, 'x')).toEqual([[1, 4], [7, 10]]);
+                expect(coerce({x: []}, {}, attrs, 'x')).toEqual([[1, 4], [7, 10]]);
+                expect(coerce({x: [[0, 3], [8, 11]]}, {}, attrs, 'x'))
+                    .toEqual([[0, 3], [8, 11]]);
+                expect(coerce({x: [[10, 5, 10], [6], [1, 2, 3]]}, {}, attrs, 'x'))
+                    .toEqual([[1, 5], [6, 10]]);
+            });
+
+            it('supports unbounded 2D freeLength arrays', function() {
+                var attrs = {
+                    x: {
+                        valType: 'info_array',
+                        freeLength: true,
+                        dimensions: 2,
+                        items: {valType: 'integer', min: 0, dflt: 1}
+                    }
+                };
+                expect(coerce({}, {}, attrs, 'x')).toBeUndefined();
+                expect(coerce({x: []}, {}, attrs, 'x')).toEqual([]);
+                expect(coerce({x: [[], [0], [-1, 2], [5, 'a', 4, 6.6]]}, {}, attrs, 'x'))
+                    .toEqual([[], [0], [1, 2], [5, 1, 4, 1]]);
+            });
         });
 
         describe('subplotid valtype', function() {
diff --git a/test/jasmine/tests/parcoords_test.js b/test/jasmine/tests/parcoords_test.js
index a1dc36f1130..0adb306491b 100644
--- a/test/jasmine/tests/parcoords_test.js
+++ b/test/jasmine/tests/parcoords_test.js
@@ -118,7 +118,7 @@ describe('parcoords initialization tests', function() {
                     alienProperty: 'Alpha Centauri'
                 }]
             });
-            expect(fullTrace.dimensions).toEqual([{values: [1], visible: true, tickformat: '3s', _index: 0}]);
+            expect(fullTrace.dimensions).toEqual([{values: [1], visible: true, tickformat: '3s', _index: 0, _length: 1}]);
         });
 
         it('\'dimension.visible\' should be set to false, and other props just passed through if \'values\' is not provided', function() {
@@ -127,7 +127,7 @@ describe('parcoords initialization tests', function() {
                     alienProperty: 'Alpha Centauri'
                 }]
             });
-            expect(fullTrace.dimensions).toEqual([{visible: false, values: [], _index: 0}]);
+            expect(fullTrace.dimensions).toEqual([{visible: false, _index: 0}]);
         });
 
         it('\'dimension.visible\' should be set to false, and other props just passed through if \'values\' is an empty array', function() {
@@ -147,22 +147,17 @@ describe('parcoords initialization tests', function() {
                     alienProperty: 'Alpha Centauri'
                 }]
             });
-            expect(fullTrace.dimensions).toEqual([{visible: false, values: [], _index: 0}]);
+            expect(fullTrace.dimensions).toEqual([{visible: false, _index: 0}]);
         });
 
-        it('\'dimension.values\' should get truncated to a common shortest length', function() {
+        it('\'dimension.values\' should get truncated to a common shortest *nonzero* length', function() {
             var fullTrace = _supply({dimensions: [
                 {values: [321, 534, 542, 674]},
                 {values: [562, 124, 942]},
                 {values: [], visible: true},
-                {values: [1, 2], visible: false} // shouldn't be truncated to as false
+                {values: [1, 2], visible: false} // shouldn't be truncated to as visible: false
             ]});
-            expect(fullTrace.dimensions).toEqual([
-                {values: [], visible: true, tickformat: '3s', _index: 0},
-                {values: [], visible: true, tickformat: '3s', _index: 1},
-                {values: [], visible: true, tickformat: '3s', _index: 2},
-                {values: [1, 2], visible: false, _index: 3}
-            ]);
+            expect(fullTrace._commonLength).toBe(3);
         });
     });
 
@@ -272,9 +267,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[0].dimensions[1].range).toBeDefined();
                 expect(gd.data[0].dimensions[1].range).toEqual([0, 700000]);
                 expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined();
-
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('Do something sensible if there is no panel i.e. dimension count is less than 2', function(done) {
@@ -291,9 +286,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[0].dimensions[0].range).not.toBeDefined();
                 expect(gd.data[0].dimensions[0].constraintrange).toBeDefined();
                 expect(gd.data[0].dimensions[0].constraintrange).toEqual([200, 700]);
-
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('Does not error with zero dimensions', function(done) {
@@ -302,11 +297,13 @@ describe('@gl parcoords', function() {
             var gd = createGraphDiv();
 
             Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() {
+
                 expect(gd.data.length).toEqual(1);
                 expect(gd.data[0].dimensions.length).toEqual(0);
                 expect(document.querySelectorAll('.axis').length).toEqual(0);
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('Works with duplicate dimension labels', function(done) {
@@ -322,8 +319,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data.length).toEqual(1);
                 expect(gd.data[0].dimensions.length).toEqual(2);
                 expect(document.querySelectorAll('.axis').length).toEqual(2);
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('Works with a single line; also, use a longer color array than the number of lines', function(done) {
@@ -349,8 +347,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[0].dimensions.length).toEqual(2);
                 expect(document.querySelectorAll('.axis').length).toEqual(2);
                 expect(gd.data[0].dimensions[0].values.length).toEqual(1);
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('Does not raise an error with zero lines and no specified range', function(done) {
@@ -373,8 +372,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[0].dimensions.length).toEqual(2);
                 expect(document.querySelectorAll('.axis').length).toEqual(0);
                 expect(gd.data[0].dimensions[0].values.length).toEqual(0);
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('Works with non-finite `values` elements', function(done) {
@@ -401,8 +401,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[0].dimensions.length).toEqual(2);
                 expect(document.querySelectorAll('.axis').length).toEqual(2);
                 expect(gd.data[0].dimensions[0].values.length).toEqual(values[0].length);
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('@noCI Works with 60 dimensions', function(done) {
@@ -431,8 +432,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data.length).toEqual(1);
                 expect(gd.data[0].dimensions.length).toEqual(60);
                 expect(document.querySelectorAll('.axis').length).toEqual(60);
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('@noCI Truncates 60+ dimensions to 60', function(done) {
@@ -459,8 +461,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data.length).toEqual(1);
                 expect(gd.data[0].dimensions.length).toEqual(60);
                 expect(document.querySelectorAll('.axis').length).toEqual(60);
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('@noCI Truncates dimension values to the shortest array, retaining only 3 lines', function(done) {
@@ -488,11 +491,12 @@ describe('@gl parcoords', function() {
                 expect(gd.data.length).toEqual(1);
                 expect(gd.data[0].dimensions.length).toEqual(60);
                 expect(document.querySelectorAll('.axis').length).toEqual(60);
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
-        it('Skip dimensions which are not plain objects or whose `values` is not an array', function(done) {
+        it('@flaky Skip dimensions which are not plain objects or whose `values` is not an array', function(done) {
 
             var mockCopy = Lib.extendDeep({}, mock1);
             var newDimension, i, j;
@@ -521,8 +525,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data.length).toEqual(1);
                 expect(gd.data[0].dimensions.length).toEqual(5); // it's still five, but ...
                 expect(document.querySelectorAll('.axis').length).toEqual(3); // only 3 axes shown
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
 
@@ -539,7 +544,9 @@ describe('@gl parcoords', function() {
                 y: [0.05, 0.85]
             };
             gd = createGraphDiv();
-            Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(done);
+            Plotly.plot(gd, mockCopy.data, mockCopy.layout)
+            .catch(fail)
+            .then(done);
         });
 
         it('`Plotly.plot` should have proper fields on `gd.data` on initial rendering', function() {
@@ -584,9 +591,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[1].dimensions[1].constraintrange).not.toBeDefined();
 
                 expect(document.querySelectorAll('.axis').length).toEqual(20); // one dimension is `visible: false`
-
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
 
         });
 
@@ -604,9 +611,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[0].dimensions[0].constraintrange).toBeDefined();
                 expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]);
                 expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined();
-
-                done();
-            });
+            })
+            .catch(fail)
+            .then(done);
 
         });
 
@@ -632,6 +639,7 @@ describe('@gl parcoords', function() {
                 .then(restyleDimension('constraintrange', [[0, 1]]))
                 .then(restyleDimension('values', [[0, 0.1, 0.4, 1, 2, 0, 0.1, 0.4, 1, 2]]))
                 .then(restyleDimension('visible', false))
+                .catch(fail)
                 .then(done);
         });
 
@@ -652,11 +660,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[0].dimensions[0].constraintrange).toBeDefined();
                 expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]);
                 expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined();
-
-                done();
-            });
-
-
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('Should emit a \'plotly_restyle\' event', function(done) {
@@ -677,10 +683,11 @@ describe('@gl parcoords', function() {
 
             expect(tester.get()).toBe(false);
             Plotly.restyle(gd, 'line.colorscale', 'Viridis')
-                .then(window.setTimeout(function() {
-                    expect(tester.get()).toBe(true);
-                    done();
-                }, 0));
+            .then(function() {
+                expect(tester.get()).toBe(true);
+            })
+            .catch(fail)
+            .then(done);
 
         });
 
@@ -715,20 +722,24 @@ describe('@gl parcoords', function() {
             mouseEvent('mousemove', 315, 218);
             mouseEvent('mouseover', 315, 218);
 
-            window.setTimeout(function() {
+            new Promise(function(resolve) {
+                window.setTimeout(function() {
 
-                expect(hoverTester.get()).toBe(true);
+                    expect(hoverTester.get()).toBe(true);
 
-                mouseEvent('mousemove', 329, 153);
-                mouseEvent('mouseover', 329, 153);
+                    mouseEvent('mousemove', 329, 153);
+                    mouseEvent('mouseover', 329, 153);
 
-                window.setTimeout(function() {
+                    window.setTimeout(function() {
 
-                    expect(unhoverTester.get()).toBe(true);
-                    done();
-                }, 20);
+                        expect(unhoverTester.get()).toBe(true);
+                        resolve();
+                    }, 20);
 
-            }, 20);
+                }, 20);
+            })
+            .catch(fail)
+            .then(done);
 
         });
 
@@ -747,10 +758,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[0].dimensions[0].constraintrange).toBeDefined();
                 expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]);
                 expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined();
-
-                done();
-            });
-
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('Calling `Plotly.relayout`with object should amend the preexisting parcoords', function(done) {
@@ -768,10 +778,9 @@ describe('@gl parcoords', function() {
                 expect(gd.data[0].dimensions[0].constraintrange).toBeDefined();
                 expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]);
                 expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined();
-
-                done();
-            });
-
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('@flaky Calling `Plotly.animate` with patches targeting `dimensions` attributes should do the right thing', function(done) {
@@ -827,12 +836,13 @@ describe('@gl parcoords', function() {
 
                 expect(gd.data.length).toEqual(1);
 
-                Plotly.deleteTraces(gd, 0).then(function() {
+                return Plotly.deleteTraces(gd, 0).then(function() {
                     expect(d3.selectAll('.gl-canvas').node(0)).toEqual(null);
                     expect(gd.data.length).toEqual(0);
-                    done();
                 });
-            });
+            })
+            .catch(fail)
+            .then(done);
         });
 
         it('Plotly.deleteTraces with two traces removes the deleted plot', function(done) {
@@ -864,8 +874,9 @@ describe('@gl parcoords', function() {
                     expect(document.querySelectorAll('.gl-canvas').length).toEqual(0);
                     expect(document.querySelectorAll('.y-axis').length).toEqual(0);
                     expect(gd.data.length).toEqual(0);
-                    done();
-                });
+                })
+                .catch(fail)
+                .then(done);
         });
 
         it('Calling `Plotly.restyle` with zero panels left should erase lines', function(done) {
@@ -894,8 +905,9 @@ describe('@gl parcoords', function() {
                         } while(!foundPixel && i < imageArray.length);
                         expect(foundPixel).toEqual(false);
                     });
-                    done();
-                });
+                })
+                .catch(fail)
+                .then(done);
         });
 
         describe('Having two datasets', function() {
@@ -925,9 +937,9 @@ describe('@gl parcoords', function() {
                         expect(1).toEqual(1);
                         expect(document.querySelectorAll('.gl-container').length).toEqual(1);
                         expect(gd.data.length).toEqual(2);
-
-                        done();
-                    });
+                    })
+                    .catch(fail)
+                    .then(done);
             });
 
             it('Plotly.addTraces should add a new parcoords row', function(done) {
@@ -952,10 +964,9 @@ describe('@gl parcoords', function() {
                     .then(function() {
                         expect(document.querySelectorAll('.gl-container').length).toEqual(1);
                         expect(gd.data.length).toEqual(2);
-
-                        done();
-                    });
-
+                    })
+                    .catch(fail)
+                    .then(done);
             });
 
             it('Plotly.restyle should update the existing parcoords row', function(done) {
@@ -1001,10 +1012,9 @@ describe('@gl parcoords', function() {
 
                         expect(document.querySelectorAll('.gl-container').length).toEqual(1);
                         expect(gd.data.length).toEqual(1);
-
-                        done();
-                    });
-
+                    })
+                    .catch(fail)
+                    .then(done);
             });
         });
     });
diff --git a/test/jasmine/tests/plots_test.js b/test/jasmine/tests/plots_test.js
index af025d61ede..753a9b95523 100644
--- a/test/jasmine/tests/plots_test.js
+++ b/test/jasmine/tests/plots_test.js
@@ -852,3 +852,259 @@ describe('Test Plots', function() {
         });
     });
 });
+
+describe('grids', function() {
+    var gd;
+
+    beforeEach(function() {
+        gd = createGraphDiv();
+    });
+
+    afterEach(destroyGraphDiv);
+
+    function makeData(subplots) {
+        var data = [];
+        for(var i = 0; i < subplots.length; i++) {
+            var subplot = subplots[i];
+            var yPos = subplot.indexOf('y');
+            data.push({
+                y: [1, 2],
+                xaxis: subplot.slice(0, yPos),
+                yaxis: subplot.slice(yPos)
+            });
+        }
+        return data;
+    }
+
+    function _assertDomains(domains) {
+        for(var axName in domains) {
+            expect(gd._fullLayout[axName].domain)
+                .toBeCloseToArray(domains[axName], 3, axName);
+        }
+    }
+
+    function _assertMissing(axList) {
+        axList.forEach(function(axName) {
+            expect(gd._fullLayout[axName]).toBeUndefined(axName);
+        });
+    }
+
+    it('defaults to a coupled layout', function(done) {
+        Plotly.newPlot(gd,
+            // leave some empty rows/columns
+            makeData(['x2y2', 'x3y3']),
+            {grid: {rows: 4, columns: 4}}
+        )
+        .then(function() {
+            _assertDomains({
+                xaxis2: [1 / 3.9, 1.9 / 3.9],
+                yaxis2: [2 / 3.9, 2.9 / 3.9],
+                xaxis3: [2 / 3.9, 2.9 / 3.9],
+                yaxis3: [1 / 3.9, 1.9 / 3.9]
+            });
+            _assertMissing(['xaxis', 'yaxis', 'xaxis4', 'yaxis4']);
+
+            return Plotly.relayout(gd, {
+                'grid.xaxes': ['x2', 'x', '', 'x3'],
+                'grid.yaxes': ['y3', '', 'y', 'y2']
+            });
+        })
+        .then(function() {
+            _assertDomains({
+                xaxis2: [0, 0.9 / 3.9],
+                yaxis2: [0, 0.9 / 3.9],
+                xaxis3: [3 / 3.9, 1],
+                yaxis3: [3 / 3.9, 1]
+            });
+            _assertMissing(['xaxis', 'yaxis', 'xaxis4', 'yaxis4']);
+
+            return Plotly.relayout(gd, {'grid.roworder': 'bottom to top'});
+        })
+        .then(function() {
+            _assertDomains({
+                xaxis2: [0, 0.9 / 3.9],
+                yaxis2: [3 / 3.9, 1],
+                xaxis3: [3 / 3.9, 1],
+                yaxis3: [0, 0.9 / 3.9]
+            });
+            _assertMissing(['xaxis', 'yaxis', 'xaxis4', 'yaxis4']);
+        })
+        .catch(failTest)
+        .then(done);
+    });
+
+    it('has a bigger default gap with independent layout', function(done) {
+        Plotly.newPlot(gd,
+            makeData(['x2y2', 'x3y3', 'x4y4']),
+            {grid: {rows: 3, columns: 3, pattern: 'independent'}}
+        )
+        .then(function() {
+            _assertDomains({
+                xaxis2: [1 / 2.8, 1.8 / 2.8],
+                yaxis2: [2 / 2.7, 1],
+                xaxis3: [2 / 2.8, 1],
+                yaxis3: [2 / 2.7, 1],
+                xaxis4: [0, 0.8 / 2.8],
+                yaxis4: [1 / 2.7, 1.7 / 2.7]
+            });
+            _assertMissing(['xaxis', 'yaxis']);
+
+            return Plotly.relayout(gd, {
+                'grid.subplots': [['x4y4', '', 'x3y3'], [], ['', 'x2y2']]
+            });
+        })
+        .then(function() {
+            _assertDomains({
+                xaxis2: [1 / 2.8, 1.8 / 2.8],
+                yaxis2: [0, 0.7 / 2.7],
+                xaxis3: [2 / 2.8, 1],
+                yaxis3: [2 / 2.7, 1],
+                xaxis4: [0, 0.8 / 2.8],
+                yaxis4: [2 / 2.7, 1]
+            });
+            _assertMissing(['xaxis', 'yaxis']);
+
+            return Plotly.relayout(gd, {'grid.roworder': 'bottom to top'});
+        })
+        .then(function() {
+            _assertDomains({
+                xaxis2: [1 / 2.8, 1.8 / 2.8],
+                yaxis2: [2 / 2.7, 1],
+                xaxis3: [2 / 2.8, 1],
+                yaxis3: [0, 0.7 / 2.7],
+                xaxis4: [0, 0.8 / 2.8],
+                yaxis4: [0, 0.7 / 2.7]
+            });
+            _assertMissing(['xaxis', 'yaxis']);
+        })
+        .catch(failTest)
+        .then(done);
+    });
+
+    it('can set x and y gaps and change domain', function(done) {
+        Plotly.newPlot(gd,
+            // leave some empty rows/columns
+            makeData(['xy', 'x2y2']),
+            {grid: {rows: 2, columns: 2}}
+        )
+        .then(function() {
+            _assertDomains({
+                xaxis: [0, 0.9 / 1.9],
+                yaxis: [1 / 1.9, 1],
+                xaxis2: [1 / 1.9, 1],
+                yaxis2: [0, 0.9 / 1.9]
+            });
+
+            return Plotly.relayout(gd, {'grid.xgap': 0.2});
+        })
+        .then(function() {
+            _assertDomains({
+                xaxis: [0, 0.8 / 1.8],
+                yaxis: [1 / 1.9, 1],
+                xaxis2: [1 / 1.8, 1],
+                yaxis2: [0, 0.9 / 1.9]
+            });
+
+            return Plotly.relayout(gd, {'grid.ygap': 0.3});
+        })
+        .then(function() {
+            _assertDomains({
+                xaxis: [0, 0.8 / 1.8],
+                yaxis: [1 / 1.7, 1],
+                xaxis2: [1 / 1.8, 1],
+                yaxis2: [0, 0.7 / 1.7]
+            });
+
+            return Plotly.relayout(gd, {'grid.domain': {x: [0.2, 0.7], y: [0, 0.5]}});
+        })
+        .then(function() {
+            _assertDomains({
+                xaxis: [0.2, 0.2 + 0.4 / 1.8],
+                yaxis: [0.5 / 1.7, 0.5],
+                xaxis2: [0.2 + 0.5 / 1.8, 0.7],
+                yaxis2: [0, 0.35 / 1.7]
+            });
+        })
+        .catch(failTest)
+        .then(done);
+    });
+
+    it('responds to xside and yside', function(done) {
+        function checkAxis(axName, anchor, side, position) {
+            var ax = gd._fullLayout[axName];
+            expect(ax.anchor).toBe(anchor, axName);
+            expect(ax.side).toBe(side, axName);
+            expect(ax.position).toBe(position, axName);
+        }
+
+        Plotly.newPlot(gd,
+            // leave some empty rows/columns
+            makeData(['xy', 'x2y2']),
+            {grid: {rows: 2, columns: 2}}
+        )
+        .then(function() {
+            checkAxis('xaxis', 'y', 'bottom');
+            checkAxis('yaxis', 'x', 'left');
+            checkAxis('xaxis2', 'y2', 'bottom');
+            checkAxis('yaxis2', 'x2', 'left');
+
+            return Plotly.relayout(gd, {'grid.xside': 'top plot', 'grid.yside': 'right plot'});
+        })
+        .then(function() {
+            checkAxis('xaxis', 'y', 'top');
+            checkAxis('yaxis', 'x', 'right');
+            checkAxis('xaxis2', 'y2', 'top');
+            checkAxis('yaxis2', 'x2', 'right');
+
+            return Plotly.relayout(gd, {'grid.xside': 'top', 'grid.yside': 'right'});
+        })
+        .then(function() {
+            checkAxis('xaxis', 'free', 'top', 1);
+            checkAxis('yaxis', 'free', 'right', 1);
+            checkAxis('xaxis2', 'free', 'top', 1);
+            checkAxis('yaxis2', 'free', 'right', 1);
+
+            return Plotly.relayout(gd, {'grid.xside': 'bottom', 'grid.yside': 'left'});
+        })
+        .then(function() {
+            checkAxis('xaxis', 'free', 'bottom', 0);
+            checkAxis('yaxis', 'free', 'left', 0);
+            checkAxis('xaxis2', 'free', 'bottom', 0);
+            checkAxis('yaxis2', 'free', 'left', 0);
+        })
+        .catch(failTest)
+        .then(done);
+    });
+
+    it('places other subplots in the grid by default', function(done) {
+        function checkDomain(container, column, row, x, y) {
+            var domain = container.domain;
+            expect(domain.row).toBe(row);
+            expect(domain.column).toBe(column);
+            expect(domain.x).toBeCloseToArray(x, 3);
+            expect(domain.y).toBeCloseToArray(y, 3);
+        }
+        Plotly.newPlot(gd, [{
+            type: 'pie', labels: ['a', 'b'], values: [1, 2]
+        }, {
+            type: 'scattergeo', lon: [10, 20], lat: [20, 10]
+        }], {
+            grid: {rows: 2, columns: 2, xgap: 1 / 3, ygap: 1 / 3}
+        })
+        .then(function() {
+            // defaults to cell (0, 0)
+            // we're not smart enough to keep them from overlapping each other... should we try?
+            checkDomain(gd._fullData[0], 0, 0, [0, 0.4], [0.6, 1]);
+            checkDomain(gd._fullLayout.geo, 0, 0, [0, 0.4], [0.6, 1]);
+
+            return Plotly.update(gd, {'domain.column': 1}, {'geo.domain.row': 1}, [0]);
+        })
+        .then(function() {
+            // change row OR column, the other keeps its previous default
+            checkDomain(gd._fullData[0], 1, 0, [0.6, 1], [0.6, 1]);
+            checkDomain(gd._fullLayout.geo, 0, 1, [0, 0.4], [0, 0.4]);
+        })
+        .catch(failTest)
+        .then(done);
+    });
+});
diff --git a/test/jasmine/tests/validate_test.js b/test/jasmine/tests/validate_test.js
index 3014e3540a3..ad12aeefd50 100644
--- a/test/jasmine/tests/validate_test.js
+++ b/test/jasmine/tests/validate_test.js
@@ -440,4 +440,69 @@ describe('Plotly.validate', function() {
             'In layout, key yaxis2.overlaying (set to \'x\') got reset to \'false\' during defaults.'
         );
     });
+
+    it('catches bad axes in grid definitions', function() {
+        var out = Plotly.validate([
+            {y: [1, 2]},
+            {y: [1, 2], xaxis: 'x2', yaxis: 'y2'}
+        ], {
+            grid: {xaxes: ['x3', '', 'x2', 4], yaxes: ['y', 3, '', 'y4']},
+            // while we're at it check on another info_array
+            xaxis: {range: [5, 'lots']}
+        });
+
+        expect(out.length).toBe(5);
+        assertErrorContent(
+            out[0], 'dynamic', 'layout', null,
+            ['grid', 'xaxes', 0], 'grid.xaxes[0]',
+            'In layout, key grid.xaxes[0] (set to \'x3\') got reset to \'\' during defaults.'
+        );
+        assertErrorContent(
+            out[1], 'value', 'layout', null,
+            ['grid', 'xaxes', 3], 'grid.xaxes[3]',
+            'In layout, key grid.xaxes[3] is set to an invalid value (4)'
+        );
+        assertErrorContent(
+            out[2], 'value', 'layout', null,
+            ['grid', 'yaxes', 1], 'grid.yaxes[1]',
+            'In layout, key grid.yaxes[1] is set to an invalid value (3)'
+        );
+        assertErrorContent(
+            out[3], 'dynamic', 'layout', null,
+            ['grid', 'yaxes', 3], 'grid.yaxes[3]',
+            'In layout, key grid.yaxes[3] (set to \'y4\') got reset to \'\' during defaults.'
+        );
+        assertErrorContent(
+            out[4], 'dynamic', 'layout', null,
+            ['xaxis', 'range', 1], 'xaxis.range[1]',
+            'In layout, key xaxis.range[1] (set to \'lots\') got reset to \'50\' during defaults.'
+        );
+    });
+
+    it('catches bad subplots in grid definitions', function() {
+        var out = Plotly.validate([
+            {y: [1, 2]},
+            {y: [1, 2], xaxis: 'x2', yaxis: 'y2'},
+            {y: [1, 2], xaxis: 'x2'}
+        ], {
+            grid: {subplots: [['xy', 'x2y3'], ['x2y', 'x2y2'], [5, '']]},
+        });
+
+        expect(out.length).toBe(3);
+        assertErrorContent(
+            out[0], 'dynamic', 'layout', null,
+            ['grid', 'subplots', 0, 1], 'grid.subplots[0][1]',
+            'In layout, key grid.subplots[0][1] (set to \'x2y3\') got reset to \'\' during defaults.'
+        );
+        assertErrorContent(
+            out[1], 'dynamic', 'layout', null,
+            ['grid', 'subplots', 1, 0], 'grid.subplots[1][0]',
+            'In layout, key grid.subplots[1][0] (set to \'x2y\') got reset to \'\' during defaults.'
+        );
+        assertErrorContent(
+            out[2], 'value', 'layout', null,
+            ['grid', 'subplots', 2, 0], 'grid.subplots[2][0]',
+            'In layout, key grid.subplots[2][0] is set to an invalid value (5)'
+        );
+    });
 });