diff --git a/src/lib/template/dom-repeat.html b/src/lib/template/dom-repeat.html
index 86d8bd4b96..37c2cede7c 100644
--- a/src/lib/template/dom-repeat.html
+++ b/src/lib/template/dom-repeat.html
@@ -137,7 +137,7 @@
 
       /**
        * The name of the variable to add to the binding scope with the index
-       * for the row.  If `sort` is provided, the index will reflect the
+       * for the inst.  If `sort` is provided, the index will reflect the
        * sorted order (rather than the original array order).
        */
       indexAs: {
@@ -200,22 +200,22 @@
     ],
 
     created: function() {
-      this.rows = [];
+      this._instances = [];
     },
 
     detached: function() {
-      if (this.rows) {
-        for (var i=0; i<this.rows.length; i++) {
+      if (this._instances) {
+        for (var i=0; i<this._instances.length; i++) {
           this._detachRow(i);
         }
       }
     },
 
     attached: function() {
-      if (this.rows) {
+      if (this._instances) {
         var parentNode = Polymer.dom(this).parentNode;
-        for (var i=0; i<this.rows.length; i++) {
-          Polymer.dom(parentNode).insertBefore(this.rows[i].root, this);
+        for (var i=0; i<this._instances.length; i++) {
+          Polymer.dom(parentNode).insertBefore(this._instances[i].root, this);
         }
       }
     },
@@ -321,25 +321,25 @@
         this._needFullRefresh = false;
       } else {
         if (this._sortFn) {
-          this._applySplicesViewSort(this._splices);
+          this._applySplicesUserSort(this._splices);
         } else {
           if (this._filterFn) {
             // TODK(kschaaf): Filtering using array sort takes slow path
             this._applyFullRefresh();
           } else {
-            this._applySplicesArraySort(this._splices);
+            this._applySplicesArrayOrder(this._splices);
           }
         }
       }
       this._splices = [];
-      // Update final rowForKey and row indices
-      var rowForKey = this._rowForKey = {};
-      var keys = this._orderedKeys;
+      // Update final _keyToInstIdx and inst indices
+      var keyToIdx = this._keyToInstIdx = {};
+      var keys = this._keys;
       for (var i=0; i<keys.length; i++) {
         var key = keys[i];
-        var row = this.rows[i];
-        rowForKey[key] = i;
-        row.__setProperty(this.indexAs, i, true);
+        var inst = this._instances[i];
+        keyToIdx[key] = i;
+        inst.__setProperty(this.indexAs, i, true);
       }
       this.fire('dom-change');
     },
@@ -350,55 +350,55 @@
       // Start with unordered keys for view sort,
       // or get them in array order for array sort
       if (this._sortFn) {
-        this._orderedKeys = c ? c.getKeys() : [];
+        this._keys = c ? c.getKeys() : [];
       } else {
-        this._orderedKeys = [];
+        this._keys = [];
         var items = this.items;
         if (items) {
           for (var i=0; i<items.length; i++) {
-            this._orderedKeys.push(c.getKey(items[i]));
+            this._keys.push(c.getKey(items[i]));
           }
         }
       }
       // Apply user filter to keys
       if (this._filterFn) {
-        this._orderedKeys = this._orderedKeys.filter(function(a) {
+        this._keys = this._keys.filter(function(a) {
           return this._filterFn(c.getItem(a));
         }, this);
       }
       // Apply user sort to keys
       if (this._sortFn) {
-        this._orderedKeys.sort(function(a, b) {
+        this._keys.sort(function(a, b) {
           return this._sortFn(c.getItem(a), c.getItem(b));
         }.bind(this));
       }
-      // Generate rows and assign items and keys
-      var keys = this._orderedKeys;
+      // Generate instances and assign items and keys
+      var keys = this._keys;
       for (var i=0; i<keys.length; i++) {
         var key = keys[i];
-        var row = this.rows[i];
-        if (!row) {
-          this.rows.push(this._insertRow(i, null, key));
+        var inst = this._instances[i];
+        if (!inst) {
+          this._instances.push(this._insertRow(i, null, key));
         } else {
-          row.__setProperty('__key__', key, true);
-          row.__setProperty(this.as, c.getItem(key), true);
+          inst.__setProperty('__key__', key, true);
+          inst.__setProperty(this.as, c.getItem(key), true);
         }
       }
-      // Remove any extra rows from previous state
-      for (; i<this.rows.length; i++) {
+      // Remove any extra instances from previous state
+      for (; i<this._instances.length; i++) {
         this._detachRow(i);
       }
-      this.rows.splice(keys.length, this.rows.length-keys.length);
+      this._instances.splice(keys.length, this._instances.length-keys.length);
     },
 
     _keySort: function(a, b) {
       return this.collection.getKey(a) - this.collection.getKey(b);
     },
 
-    _applySplicesViewSort: function(splices) {
+    _applySplicesUserSort: function(splices) {
       var c = this.collection;
-      var keys = this._orderedKeys;
-      var rows = this.rows;
+      var keys = this._keys;
+      var instances = this._instances;
       var keyMap = {};
       var pool = [];
       var sortFn = this._sortFn || this._keySort.bind(this);
@@ -414,32 +414,32 @@
         }
       }, this);
       // Convert added/removed key map to added/removed arrays
-      var removedRows = [];
+      var removedIdxs = [];
       var addedKeys = [];
       for (var key in keyMap) {
         if (keyMap[key] === -1) {
-          removedRows.push(this._rowForKey[key]);
+          removedIdxs.push(this._keyToInstIdx[key]);
         }
         if (keyMap[key] === 1) {
           addedKeys.push(key);
         }
       }
-      // Remove & pool removed rows
-      if (removedRows.length) {
-        // Sort removed rows idx's then remove backwards,
-        // so we don't invalidate row index
-        removedRows.sort();
-        for (var i=removedRows.length-1; i>=0 ; i--) {
-          var idx = removedRows[i];
+      // Remove & pool removed instances
+      if (removedIdxs.length) {
+        // Sort removed instances idx's then remove backwards,
+        // so we don't invalidate inst index
+        removedIdxs.sort();
+        for (var i=removedIdxs.length-1; i>=0 ; i--) {
+          var idx = removedIdxs[i];
           // Removed idx may be undefined if item was previously filtered out
           if (idx !== undefined) {
             pool.push(this._detachRow(idx));
-            rows.splice(idx, 1);
+            instances.splice(idx, 1);
             keys.splice(idx, 1);
           }
         }
       }
-      // Add rows for added keys
+      // Add instances for added keys
       if (addedKeys.length) {
         // Filter added keys
         if (this._filterFn) {
@@ -451,24 +451,24 @@
         addedKeys.sort(function(a, b) {
           return this._sortFn(c.getItem(a), c.getItem(b));
         }.bind(this));
-        // Insertion-sort new rows into place (from pool or newly created)
+        // Insertion-sort new instances into place (from pool or newly created)
         var start = 0;
         for (var i=0; i<addedKeys.length; i++) {
-          start = this._insertRowIntoViewSort(start, addedKeys[i], pool);
+          start = this._insertRowUserSort(start, addedKeys[i], pool);
         }
       }
     },
 
-    _insertRowIntoViewSort: function(start, key, pool) {
+    _insertRowUserSort: function(start, key, pool) {
       var c = this.collection;
       var item = c.getItem(key);
-      var end = this.rows.length - 1;
+      var end = this._instances.length - 1;
       var idx = -1;
       var sortFn = this._sortFn || this._keySort.bind(this);
       // Binary search for insertion point
       while (start <= end) {
         var mid = (start + end) >> 1;
-        var midKey = this._orderedKeys[mid];
+        var midKey = this._keys[mid];
         var cmp = sortFn(c.getItem(midKey), item);
         if (cmp < 0) {
           start = mid + 1;
@@ -482,77 +482,77 @@
       if (idx < 0) {
         idx = end + 1;
       }
-      // Insert key & row at insertion point
-      this._orderedKeys.splice(idx, 0, key);
-      this.rows.splice(idx, 0, this._insertRow(idx, pool, key));
+      // Insert key & inst at insertion point
+      this._keys.splice(idx, 0, key);
+      this._instances.splice(idx, 0, this._insertRow(idx, pool, key));
       return idx;
     },
 
-    _applySplicesArraySort: function(splices) {
-      var keys = this._orderedKeys;
+    _applySplicesArrayOrder: function(splices) {
+      var keys = this._keys;
       var pool = [];
       var c = this.collection;
       splices.forEach(function(s) {
         // Apply splices to keys
         var args = [s.index, s.removed.length].concat(s.added);
         keys.splice.apply(keys, args);
-        // Detach & pool removed rows
+        // Detach & pool removed instances
         for (var i=0; i<s.removed.length; i++) {
-          var row = this._detachRow(s.index + i);
-          if (!row.isPlaceholder) {
-            pool.push(row);
+          var inst = this._detachRow(s.index + i);
+          if (!inst.isPlaceholder) {
+            pool.push(inst);
           }
         }
-        this.rows.splice(s.index, s.removed.length);
-        // Insert new rows (from pool or placeholder)
+        this._instances.splice(s.index, s.removed.length);
+        // Insert new instances (from pool or placeholder)
         for (var i=0; i<s.added.length; i++) {
-          var row;
+          var inst;
           if (pool.length) {
-            row = this._insertRow(s.index + i, pool, s.added[i]);
+            inst = this._insertRow(s.index + i, pool, s.added[i]);
           } else {
-            var beforeRow = this.rows[s.index + i];
-            row = {
+            var beforeRow = this._instances[s.index + i];
+            inst = {
               isPlaceholder: true,
               key: s.added[i],
               _children: [beforeRow ? beforeRow._children[0] : null]
             };
           }
-          this.rows.splice(s.index + i, 0, row);
+          this._instances.splice(s.index + i, 0, inst);
         }
       }, this);
-      // Replace placeholders with actual rows (from pool or newly created)
-      this.rows.forEach(function(row, idx) {
-        if (row.isPlaceholder) {
-          this.rows[idx] = this._insertRow(idx, pool, row.key);
+      // Replace placeholders with actual instances (from pool or newly created)
+      this._instances.forEach(function(inst, idx) {
+        if (inst.isPlaceholder) {
+          this._instances[idx] = this._insertRow(idx, pool, inst.key);
         }
       }, this);
     },
 
     _detachRow: function(idx) {
-      var row = this.rows[idx];
-      if (!row.isPlaceholder) {
+      var inst = this._instances[idx];
+      if (!inst.isPlaceholder) {
         var parentNode = Polymer.dom(this).parentNode;
-        for (var i=0; i<row._children.length; i++) {
-          var el = row._children[i];
-          Polymer.dom(row.root).appendChild(el);
+        for (var i=0; i<inst._children.length; i++) {
+          var el = inst._children[i];
+          Polymer.dom(inst.root).appendChild(el);
         }
       }
-      return row;
+      return inst;
     },
 
     _insertRow: function(idx, pool, key) {
-      var row;
-      if (row = pool && pool.pop()) {
-        row.__setProperty(this.as, this.collection.getItem(key), true);
-        row.__setProperty('__key__', key, true);
+      var inst;
+      if (inst = pool && pool.pop()) {
+        inst.__setProperty(this.as, this.collection.getItem(key), true);
+        inst.__setProperty('__key__', key, true);
       } else {
-        row = this._generateRow(idx, key);
+        inst = this._generateRow(idx, key);
       }
-      var beforeRow = this.rows[idx];
+      var beforeRow = this._instances[idx];
       var beforeNode = beforeRow ? beforeRow._children[0] : this;
       var parentNode = Polymer.dom(this).parentNode;
-      Polymer.dom(parentNode).insertBefore(row.root, beforeNode);
-      return row;
+      Polymer.dom(parentNode).insertBefore(inst.root, beforeNode);
+      return inst;
     },
 
     _generateRow: function(idx, key) {
@@ -561,22 +561,22 @@
       };
       model[this.as] = this.collection.getItem(key);
       model[this.indexAs] = idx;
-      var row = this.stamp(model);
-      return row;
+      var inst = this.stamp(model);
+      return inst;
     },
 
     // Implements extension point from Templatizer mixin
     _showHideChildren: function(hidden) {
-      if (this.rows) {
-        for (var i=0; i<this.rows.length; i++) {
-          this.rows[i]._showHideChildren(hidden);
+      if (this._instances) {
+        for (var i=0; i<this._instances.length; i++) {
+          this._instances[i]._showHideChildren(hidden);
         }
       }
     },
 
     // Called as a side effect of a template item change, responsible
-    // for notifying items.<key-for-row> change up to host
-    _forwardInstanceProp: function(row, prop, value) {
+    // for notifying items.<key-for-inst> change up to host
+    _forwardInstanceProp: function(inst, prop, value) {
       if (prop == this.as) {
         var idx;
         if (this._sortFn || this._filterFn) {
@@ -584,10 +584,10 @@
           // efficiently memoize the array index and keep it in sync with array
           // mutations, so we need to look the item up in the array
           // This can happen e.g. when array of strings is repeated into inputs
-          idx = this.items.indexOf(this.collection.getItem(row.__key__));
+          idx = this.items.indexOf(this.collection.getItem(inst.__key__));
         } else {
           // When there is no sort/filter, the view index is the array index
-          idx = row[this.indexAs];
+          idx = inst[this.indexAs];
         }
         this.set('items.' + idx, value);
       }
@@ -595,50 +595,50 @@
 
     // Implements extension point from Templatizer
     // Called as a side effect of a template instance path change, responsible
-    // for notifying items.<key-for-row>.<path> change up to host
-    _forwardInstancePath: function(row, path, value) {
+    // for notifying items.<key-for-inst>.<path> change up to host
+    _forwardInstancePath: function(inst, path, value) {
       if (path.indexOf(this.as + '.') === 0) {
-        this.notifyPath('items.' + row.__key__ + '.' +
+        this.notifyPath('items.' + inst.__key__ + '.' +
           path.slice(this.as.length + 1), value);
       }
     },
 
     // Implements extension point from Templatizer mixin
     // Called as side-effect of a host property change, responsible for
-    // notifying parent path change on each row
+    // notifying parent path change on each inst
     _forwardParentProp: function(prop, value) {
-      if (this.rows) {
-        this.rows.forEach(function(row) {
-          row.__setProperty(prop, value, true);
+      if (this._instances) {
+        this._instances.forEach(function(inst) {
+          inst.__setProperty(prop, value, true);
         }, this);
       }
     },
 
     // Implements extension point from Templatizer
     // Called as side-effect of a host path change, responsible for
-    // notifying parent path change on each row
+    // notifying parent path change on each inst
     _forwardParentPath: function(path, value) {
-      if (this.rows) {
-        this.rows.forEach(function(row) {
-          row.notifyPath(path, value, true);
+      if (this._instances) {
+        this._instances.forEach(function(inst) {
+          inst.notifyPath(path, value, true);
         }, this);
       }
     },
 
     // Called as a side effect of a host items.<key>.<path> path change,
-    // responsible for notifying item.<path> changes to row for key
+    // responsible for notifying item.<path> changes to inst for key
     _forwardItemPath: function(path, value) {
-      if (this._rowForKey) {
+      if (this._keyToInstIdx) {
         var dot = path.indexOf('.');
         var key = path.substring(0, dot < 0 ? path.length : dot);
-        var idx = this._rowForKey[key];
-        var row = this.rows[idx];
-        if (row) {
+        var idx = this._keyToInstIdx[key];
+        var inst = this._instances[idx];
+        if (inst) {
           if (dot >= 0) {
             path = this.as + '.' + path.substring(dot+1);
-            row.notifyPath(path, value, true);
+            inst.notifyPath(path, value, true);
           } else {
-            row.__setProperty(this.as, value, true);
+            inst.__setProperty(this.as, value, true);
           }
         }
       }
@@ -675,7 +675,7 @@
     },
 
     /**
-     * Returns the row index for a given element stamped by this `dom-repeat`.
+     * Returns the inst index for a given element stamped by this `dom-repeat`.
      * If `sort` is provided, the index will reflect the sorted order (rather
      * than the original array order).
      *
diff --git a/test/unit/dom-repeat.html b/test/unit/dom-repeat.html
index 37f1a4ed9c..3739ff1a2c 100644
--- a/test/unit/dom-repeat.html
+++ b/test/unit/dom-repeat.html
@@ -3160,11 +3160,11 @@ <h4>inDocumentRepeater</h4>
         var stamped2 = Polymer.dom(unconfigured2.root).querySelectorAll('*:not(template)');
         var old = unconfigured.items[0];
         // Change first item
-        unconfigured1.$.repeater.rows[0].itema = {prop: 'change!'};
+        unconfigured1.$.repeater._instances[0].itema = {prop: 'change!'};
         assert.equal(stamped1[0].itemaProp, 'change!');
         assert.equal(stamped2[0].itemaProp, 'change!');
         // Revert
-        unconfigured2.$.repeater.rows[0].itema = old;
+        unconfigured2.$.repeater._instances[0].itema = old;
         assert.equal(stamped1[0].itemaProp, 'prop-1');
         assert.equal(stamped2[0].itemaProp, 'prop-1');
       });
@@ -3178,11 +3178,11 @@ <h4>inDocumentRepeater</h4>
         var stamped2 = Polymer.dom(unconfigured2.root).querySelectorAll('*:not(template)');
         var old = unconfigured.items[2];
         // Change last item (first rendered in #1, last rendered in #2)
-        unconfigured1.$.repeater.rows[0].itema = {prop: 'change!'};
+        unconfigured1.$.repeater._instances[0].itema = {prop: 'change!'};
         assert.equal(stamped1[0].itemaProp, 'change!');
         assert.equal(stamped2[26].itemaProp, 'change!');
         // Revert
-        unconfigured2.$.repeater.rows[2].itema = old;
+        unconfigured2.$.repeater._instances[2].itema = old;
         assert.equal(stamped1[0].itemaProp, 'prop-3');
         assert.equal(stamped2[26].itemaProp, 'prop-3');
         unconfigured1.$.repeater.sort = null;