diff --git a/src/lib/template/dom-repeat.html b/src/lib/template/dom-repeat.html
index b75f8ed496..f39144cee4 100644
--- a/src/lib/template/dom-repeat.html
+++ b/src/lib/template/dom-repeat.html
@@ -241,18 +241,6 @@
         value: 20
       },
 
-      /**
-       * Maximum number of removed instances to pool for reuse when rows are
-       * added in a future turn.  By default, pooling is enabled.
-       *
-       * Set to 0 to disable pooling, which will allow all removed instances to
-       * be garbage collected.
-       */
-      poolSize: {
-        type: Number,
-        value: 1000
-      },
-
       _targetFrameTime: {
         computed: '_computeFrameTime(targetFramerate)'
       }
@@ -338,10 +326,10 @@
       return Math.ceil(1000/rate);
     },
 
-    _initializeChunkCount: function(initialCount, chunkCount) {
-      if (initialCount) {
-        this.limit = initialCount;
-        this._chunkCount = parseInt(chunkCount, 10) || initialCount;
+    _initializeChunkCount: function() {
+      if (this.initialCount) {
+        this.limit = this.initialCount;
+        this._chunkCount = parseInt(this.chunkCount, 10) || this.initialCount;
       }
     },
 
@@ -387,6 +375,9 @@
           this._error(this._logf('dom-repeat', 'expected array for `items`,' +
             ' found', this.items));
         }
+        if (this._instances.length && this.initialCount) {
+          this._initializeChunkCount();
+        }
         this._keySplices = [];
         this._indexSplices = [];
         this._needFullRefresh = true;
@@ -472,8 +463,12 @@
         }
       }
       // Reset the pool
-      // TODO(kschaaf): Allow pool to be reused across turns & between nested
-      // peer repeats (requires updating parentProps when reusing from pool)
+      // TODO(kschaaf): Reuse pool across turns and nested templates
+      // Requires updating parentProps and dealing with the fact that path
+      // notifications won't reach instances sitting in the pool, which
+      // could result in out-of-sync instances since simply re-setting
+      // `item` may not be sufficient if the pooled instance happens to be
+      // the same item.
       this._pool.length = 0;
       // Notify users
       this.fire('dom-change');
@@ -518,10 +513,8 @@
         var key = keys[i];
         var inst = this._instances[i];
         if (inst) {
-          if (inst.isPlaceholder) {
-            inst.__key__ = key;
-          } else {
-            inst.__setProperty('__key__', key, true);
+          inst.__key__ = key;
+          if (!inst.isPlaceholder && i < this.limit) {
             inst.__setProperty(this.as, c.getItem(key), true);
           }
         } else {
@@ -661,7 +654,9 @@
           var el = inst._children[i];
           Polymer.dom(inst.root).appendChild(el);
         }
-        this._pool.push(inst);
+        if (!keepInstance) {
+          this._pool.push(inst);
+        }
       }
       if (!keepInstance) {
         this._instances.splice(idx, 1);
@@ -669,6 +664,13 @@
       return inst;
     },
 
+    _detachAllRows: function() {
+      for (var i=0; i<this._instances.length; i++) {
+        this._detachRow(i, true);
+      }
+      this._instances.length = 0;
+    },
+
     _insertRow: function(idx, key, replace, makePlaceholder) {
       var inst;
       if (makePlaceholder || idx >= this.limit) {
@@ -678,6 +680,8 @@
         };
       } else {
         if (inst = this._pool.pop()) {
+          // TODO(kschaaf): If the pool is shared across turns, parentProps
+          // need to be re-set to reused instances in addition to item/key
           inst.__setProperty(this.as, this.collection.getItem(key), true);
           inst.__setProperty('__key__', key, true);
         } else {
@@ -749,18 +753,24 @@
     // Called as side-effect of a host property change, responsible for
     // notifying parent path change on each inst
     _forwardParentProp: function(prop, value) {
-      this._instances.forEach(function(inst) {
-        inst.__setProperty(prop, value, true);
-      }, this);
+      for (var i=0, i$=this._instances, il=i$.length; i<il; i++) {
+        var inst = i$[i];
+        if (!inst.isPlaceholder) {
+          inst.__setProperty(prop, value, true);
+        }
+      }
     },
 
     // Implements extension point from Templatizer
     // Called as side-effect of a host path change, responsible for
     // notifying parent path change on each inst
     _forwardParentPath: function(path, value) {
-      this._instances.forEach(function(inst) {
-        inst._notifyPath(path, value, true);
-      }, this);
+      for (var i=0, i$=this._instances, il=i$.length; i<il; i++) {
+        var inst = i$[i];
+        if (!inst.isPlaceholder) {
+          inst._notifyPath(path, value, true);
+        }
+      }
     },
 
     // Called as a side effect of a host items.<key>.<path> path change,
@@ -771,7 +781,7 @@
         var key = path.substring(0, dot < 0 ? path.length : dot);
         var idx = this._keyToInstIdx[key];
         var inst = this._instances[idx];
-        if (inst) {
+        if (inst && !inst.isPlaceholder) {
           if (dot >= 0) {
             path = this.as + '.' + path.substring(dot+1);
             inst._notifyPath(path, value, true);
diff --git a/test/unit/dom-repeat-elements.html b/test/unit/dom-repeat-elements.html
index 274294dae0..0ef268b41e 100644
--- a/test/unit/dom-repeat-elements.html
+++ b/test/unit/dom-repeat-elements.html
@@ -411,3 +411,64 @@
     });
   </script>
 </dom-module>
+
+<dom-module id="x-repeat-limit">
+  <template>
+    <template id="repeater" is="dom-repeat" items="{{items}}" limit="2">
+      <div prop="{{outerProp.prop}}">{{item.prop}}</div>
+    </template>
+  </template>
+  <script>
+    Polymer({
+      is: 'x-repeat-limit',
+      properties: {
+        items: {
+          value: function() {
+            var ar = [];
+            for (var i = 0; i < 20; i++) {
+              ar.push({prop: i});
+            }
+            return ar;
+          }
+        },
+        outerProp: {
+          value: function() {
+            return {prop: 'outer'};
+          }
+        }
+      }
+    });
+  </script>
+</dom-module>
+
+<dom-module id="x-repeat-chunked">
+  <template>
+    <template id="repeater" is="dom-repeat" items="{{items}}" initial-count="10">
+      <x-wait>{{item.prop}}</x-wait>
+    </template>
+  </template>
+  <script>
+    Polymer({
+      is: 'x-repeat-chunked',
+      properties: {
+        preppedItems: {
+          value: function() {
+            var ar = [];
+            for (var i = 0; i < 100; i++) {
+              ar.push({prop: i});
+            }
+            return ar;
+          }
+        }
+      }
+    });
+    Polymer({
+      is: 'x-wait',
+      created: function() {
+        var time = performance.now();
+        time += 4;
+        while (performance.now() < time) {}
+      }
+    });
+  </script>
+</dom-module>
diff --git a/test/unit/dom-repeat.html b/test/unit/dom-repeat.html
index 65de283c22..45eff0fe18 100644
--- a/test/unit/dom-repeat.html
+++ b/test/unit/dom-repeat.html
@@ -71,6 +71,12 @@ <h4>inDocumentRepeater</h4>
   <h4>x-primitive-large</h4>
   <x-primitive-large id="primitiveLarge"></x-primitive-large>
 
+  <h4>x-repeat-limit</h4>
+  <x-repeat-limit id="limited"></x-repeat-limit>
+
+  <h4>x-repeat-chunked</h4>
+  <x-repeat-chunked id="chunked"></x-repeat-chunked>
+
   <div id="inDocumentContainer">
   </div>
 
@@ -93,6 +99,7 @@ <h4>x-primitive-large</h4>
       stamped[38] .. 3-3-3
     */
 
+
     suite('errors', function() {
 
       test('items must be array', function() {
@@ -3348,6 +3355,501 @@ <h4>x-primitive-large</h4>
 
     });
 
+
+    suite('limit', function() {
+
+      var checkItemOrder = function(stamped) {
+        for (var i=0; i<stamped.length; i++) {
+          assert.equal(parseInt(stamped[i].textContent), i);
+        }
+      };
+
+      test('initial limit', function() {
+        var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 2);
+        checkItemOrder(stamped);
+      });
+
+      test('change item paths in & out of limit', function() {
+        var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        limited.outerProp = {prop: 'changed'};
+        assert.equal(stamped[0].prop, 'changed');
+        limited.set('items.0.prop', '0-changed');
+        limited.set('items.3.prop', '3-changed');
+        assert.equal(stamped[0].textContent, '0-changed');
+        limited.set('outerProp.prop', 'changed again');
+        assert.equal(stamped[0].prop, 'changed again');
+      });
+
+      test('increase limit', function(done) {
+        // Increase limit and test async rendering
+        limited.$.repeater.limit = 10;
+        setTimeout(function() {
+          var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 10);
+          checkItemOrder(stamped);
+          assert.equal(stamped[3].prop, 'changed again');
+          assert.equal(stamped[3].textContent, '3-changed');
+          limited.set('items.0.prop', 0);
+          limited.set('items.3.prop', 3);
+          // Increase limit and test sync rendering
+          limited.$.repeater.limit = 20;
+          Polymer.dom.flush();
+          stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 20);
+          checkItemOrder(stamped);
+          done();
+        });
+      });
+
+      test('increase limit above items.length', function() {
+        limited.$.repeater.limit = 30;
+        Polymer.dom.flush();
+        stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 20);
+          checkItemOrder(stamped);
+      });
+
+      test('decrease limit', function(done) {
+        // Decrease limit and test async rendering
+        limited.$.repeater.limit = 15;
+        setTimeout(function() {
+          var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 15);
+          checkItemOrder(stamped);
+          // Decrease limit and test sync rendering
+          limited.$.repeater.limit = 0;
+          Polymer.dom.flush();
+          stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 0);
+          done();
+        });
+      });
+
+      test('negative limit', function() {
+        limited.$.repeater.limit = -10;
+        Polymer.dom.flush();
+        stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 0);
+      });
+
+    });
+
+    suite('limit with sort', function() {
+
+      var checkItemOrder = function(stamped) {
+        for (var i=0; i<stamped.length; i++) {
+          assert.equal(stamped[i].textContent, 19 - i);
+        }
+      };
+
+      test('initial limit', function() {
+        var items = limited.items;
+        limited.$.repeater.limit = 2;
+        limited.$.repeater.sort = function(a, b) {
+          return b.prop - a.prop;
+        };
+        limited.items = null;
+        Polymer.dom.flush();
+        limited.items = items;
+        Polymer.dom.flush();
+        var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 2);
+        checkItemOrder(stamped);
+      });
+
+      test('increase limit', function(done) {
+        // Increase limit and test async rendering
+        limited.$.repeater.limit = 10;
+        setTimeout(function() {
+          var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 10);
+          checkItemOrder(stamped);
+          // Increase limit and test sync rendering
+          limited.$.repeater.limit = 20;
+          Polymer.dom.flush();
+          stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 20);
+          checkItemOrder(stamped);
+          done();
+        });
+      });
+
+      test('increase limit above items.length', function() {
+        limited.$.repeater.limit = 30;
+        Polymer.dom.flush();
+        stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 20);
+          checkItemOrder(stamped);
+      });
+
+      test('decrease limit', function(done) {
+        // Decrease limit and test async rendering
+        limited.$.repeater.limit = 15;
+        setTimeout(function() {
+          var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 15);
+          checkItemOrder(stamped);
+          // Decrease limit and test sync rendering
+          limited.$.repeater.limit = 0;
+          Polymer.dom.flush();
+          stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 0);
+          done();
+        });
+      });
+
+      test('negative limit', function() {
+        limited.$.repeater.limit = -10;
+        Polymer.dom.flush();
+        stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 0);
+      });
+
+    });
+
+    suite('limit with filter', function() {
+
+      var checkItemOrder = function(stamped) {
+        for (var i=0; i<stamped.length; i++) {
+          assert.equal(stamped[i].textContent, i * 2);
+        }
+      };
+
+      test('initial limit', function() {
+        var items = limited.items;
+        limited.$.repeater.limit = 2;
+        limited.$.repeater.sort = null;
+        limited.$.repeater.filter = function(a) {
+          return (a.prop % 2) === 0;
+        };
+        limited.items = null;
+        Polymer.dom.flush();
+        limited.items = items;
+        Polymer.dom.flush();
+        var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 2);
+        checkItemOrder(stamped);
+      });
+
+      test('increase limit', function(done) {
+        // Increase limit and test async rendering
+        limited.$.repeater.limit = 5;
+        setTimeout(function() {
+          var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 5);
+          checkItemOrder(stamped);
+          // Increase limit and test sync rendering
+          limited.$.repeater.limit = 10;
+          Polymer.dom.flush();
+          stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 10);
+          checkItemOrder(stamped);
+          done();
+        });
+      });
+
+      test('increase limit above items.length', function() {
+        limited.$.repeater.limit = 30;
+        Polymer.dom.flush();
+        stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 10);
+          checkItemOrder(stamped);
+      });
+
+      test('decrease limit', function(done) {
+        // Decrease limit and test async rendering
+        limited.$.repeater.limit = 5;
+        setTimeout(function() {
+          var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 5);
+          checkItemOrder(stamped);
+          // Decrease limit and test sync rendering
+          limited.$.repeater.limit = 0;
+          Polymer.dom.flush();
+          stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 0);
+          done();
+        });
+      });
+
+      test('negative limit', function() {
+        limited.$.repeater.limit = -10;
+        Polymer.dom.flush();
+        stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 0);
+      });
+
+    });
+
+    suite('limit with sort & filter', function() {
+
+      var checkItemOrder = function(stamped) {
+        for (var i=0; i<stamped.length; i++) {
+          assert.equal(stamped[i].textContent, (9 - i) * 2);
+        }
+      };
+
+      test('initial limit', function() {
+        var items = limited.items;
+        limited.$.repeater.limit = 2;
+        limited.$.repeater.sort = function(a, b) {
+          return b.prop - a.prop;
+        };
+        limited.$.repeater.filter = function(a) {
+          return (a.prop % 2) === 0;
+        };
+        limited.items = null;
+        Polymer.dom.flush();
+        limited.items = items;
+        Polymer.dom.flush();
+        var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 2);
+        checkItemOrder(stamped);
+      });
+
+      test('increase limit', function(done) {
+        // Increase limit and test async rendering
+        limited.$.repeater.limit = 5;
+        setTimeout(function() {
+          var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 5);
+          checkItemOrder(stamped);
+          // Increase limit and test sync rendering
+          limited.$.repeater.limit = 10;
+          Polymer.dom.flush();
+          stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 10);
+          checkItemOrder(stamped);
+          done();
+        });
+      });
+
+      test('increase limit above items.length', function() {
+        limited.$.repeater.limit = 30;
+        Polymer.dom.flush();
+        stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 10);
+        checkItemOrder(stamped);
+      });
+
+      test('decrease limit', function(done) {
+        // Decrease limit and test async rendering
+        limited.$.repeater.limit = 5;
+        setTimeout(function() {
+          var stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 5);
+          checkItemOrder(stamped);
+          // Decrease limit and test sync rendering
+          limited.$.repeater.limit = 0;
+          Polymer.dom.flush();
+          stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+          assert.equal(stamped.length, 0);
+          done();
+        });
+      });
+
+      test('negative limit', function() {
+        limited.$.repeater.limit = -10;
+        Polymer.dom.flush();
+        stamped = Polymer.dom(limited.root).querySelectorAll('*:not(template)');
+        assert.equal(stamped.length, 0);
+      });
+
+    });
+
+    suite('chunked rendering', function() {
+
+      test('basic chunked rendering', function(done) {
+
+        var checkItemOrder = function(stamped) {
+          for (var i=0; i<stamped.length; i++) {
+            assert.equal(stamped[i].textContent, i);
+          }
+        };
+
+        var lastLength = 0;
+        var checkCount = function() {
+          var stamped = Polymer.dom(chunked.root).querySelectorAll('*:not(template)');
+          checkItemOrder(stamped);
+          if (stamped.length && lastLength === 0) {
+            // Initial rendering of initial count
+            assert.equal(stamped.length, 10);
+          } else {
+            // Remaining rendering incremenets
+            assert.isTrue(stamped.length > lastLength);
+          }
+          if (stamped.length < 100) {
+            lastLength = stamped.length;
+            checkUntilComplete();
+          } else {
+            // Final rendering at exact item count
+            assert.equal(stamped.length, 100);
+            done();
+          }
+        };
+        var checkUntilComplete = function() {
+          // On polyfilled MO, need to wait one setTimeout before rAF
+          if (MutationObserver._isPolyfilled) {
+            setTimeout(function() {
+              requestAnimationFrame(checkCount);
+            });
+          } else {
+            requestAnimationFrame(checkCount);
+          }
+        };
+
+        chunked.items = chunked.preppedItems.slice();
+        checkUntilComplete();
+
+      });
+
+      test('mutations during chunked rendering', function(done) {
+
+        var checkItemOrder = function(stamped) {
+          var last = -1;
+          for (var i=0; i<stamped.length; i++) {
+            var curr = parseFloat(stamped[i].textContent);
+            assert.isTrue(curr > last);
+            last = curr;
+          }
+        };
+
+        var mutateArray = function(repeater, renderedCount) {
+          // The goal here is to remove & add some, and do it over
+          // the threshold of where we have currently rendered items, and
+          // ensure that the prop values of the newly inserted items are in
+          // ascending order so we can do a simple check in checkItemOrder
+          var overlap = 2;
+          var remove = 4;
+          var add = 6;
+          var start = renderedCount.length - overlap;
+          if (start + add < repeater.items.length) {
+            var end = start + remove;
+            var args = ['items', start, remove];
+            var startVal = repeater.items[start].prop;
+            var endVal = repeater.items[end].prop;
+            var delta = (endVal - startVal) / add;
+            for (var i=0; i<add; i++) {
+              args.push({prop: startVal + i*delta});
+            }
+            repeater.splice.apply(repeater, args);
+          }
+        };
+
+        var lastLength = 0;
+        var mutateCount = 5;
+        var checkCount = function() {
+          var stamped = Polymer.dom(chunked.root).querySelectorAll('*:not(template)');
+          checkItemOrder(stamped);
+          if (stamped.length && lastLength === 0) {
+            // Initial rendering of initial count
+            assert.equal(stamped.length, 10);
+          } else {
+            // Remaining rendering incremenets
+            assert.isTrue(stamped.length > lastLength);
+          }
+          if (stamped.length < chunked.items.length) {
+            if (mutateCount-- > 0) {
+              mutateArray(chunked, stamped);
+            }
+            lastLength = stamped.length;
+            checkUntilComplete();
+          } else {
+            // Final rendering at exact item count
+            assert.equal(stamped.length, chunked.items.length);
+            done();
+          }
+        };
+        var checkUntilComplete = function() {
+          // On polyfilled MO, need to wait one setTimeout before rAF
+          if (MutationObserver._isPolyfilled) {
+            setTimeout(function() {
+              requestAnimationFrame(checkCount);
+            });
+          } else {
+            requestAnimationFrame(checkCount);
+          }
+        };
+
+        chunked.items = chunked.preppedItems.slice();
+        checkUntilComplete();
+
+      });
+
+
+      test('mutations during chunked rendering, sort & filtered', function(done) {
+
+        var checkItemOrder = function(stamped) {
+          var last = Infinity;
+          for (var i=0; i<stamped.length; i++) {
+            var curr = parseFloat(stamped[i].textContent);
+            assert.isTrue(curr <= last);
+            assert.strictEqual(curr % 2, 0);
+            last = curr;
+          }
+        };
+
+        var mutateArray = function(repeater, stamped) {
+          var start = parseInt(stamped[0].textContent);
+          var end = parseInt(stamped[stamped.length-1].textContent);
+          var mid = (end-start)/2;
+          for (var i=0; i<5; i++) {
+            chunked.push('items', {prop: mid + 1});
+          }
+          chunked.splice('items', Math.round(stamped.length/2), 3);
+        };
+
+        var lastLength = 0;
+        var mutateCount = 5;
+        var checkCount = function() {
+          var stamped = Polymer.dom(chunked.root).querySelectorAll('*:not(template)');
+          checkItemOrder(stamped);
+          var filteredLength = chunked.items.filter(chunked.$.repeater.filter).length;
+          if (stamped.length && lastLength === 0) {
+            // Initial rendering of initial count
+            assert.equal(stamped.length, 10);
+          } else {
+            // Remaining rendering incremenets
+            if (stamped.length < filteredLength) {
+              assert.isTrue(stamped.length > lastLength);
+            }
+          }
+          if (stamped.length < filteredLength) {
+            if (mutateCount-- > 0) {
+              mutateArray(chunked, stamped);
+            }
+            lastLength = stamped.length;
+            checkUntilComplete();
+          } else {
+            assert.equal(stamped.length, filteredLength);
+            done();
+          }
+        };
+        var checkUntilComplete = function() {
+          // On polyfilled MO, need to wait one setTimeout before rAF
+          if (MutationObserver._isPolyfilled) {
+            setTimeout(function() {
+              requestAnimationFrame(checkCount);
+            });
+          } else {
+            requestAnimationFrame(checkCount);
+          }
+        };
+
+        chunked.$.repeater.sort = function(a, b) {
+          return b.prop - a.prop;
+        };
+        chunked.$.repeater.filter = function(a) {
+          return (a.prop % 2) === 0;
+        };
+        chunked.items = chunked.preppedItems.slice();
+        checkUntilComplete();
+
+      });
+
+    });
+
   </script>
 
 </body>