diff --git a/config/build.config.js b/config/build.config.js
index ee9580e2898..6d0cb27eee3 100644
--- a/config/build.config.js
+++ b/config/build.config.js
@@ -55,6 +55,7 @@ module.exports = {
     // Views
     'js/views/view.js',
     'js/views/scrollView.js',
+    'js/views/scrollViewNative.js',
     'js/views/listView.js',
     'js/views/modalView.js',
     'js/views/sideMenuView.js',
diff --git a/js/angular/controller/refresherController.js b/js/angular/controller/refresherController.js
index 2d3ade2685b..5c5892531b8 100644
--- a/js/angular/controller/refresherController.js
+++ b/js/angular/controller/refresherController.js
@@ -238,8 +238,8 @@ IonicModule
       scrollParent = $element.parent().parent()[0];
       scrollChild = $element.parent()[0];
 
-      if (!scrollParent.classList.contains('ionic-scroll') ||
-          !scrollChild.classList.contains('scroll')) {
+      if (!scrollParent || !scrollParent.classList.contains('ionic-scroll') ||
+        !scrollChild || !scrollChild.classList.contains('scroll')) {
         throw new Error('Refresher must be immediate child of ion-content or ion-scroll');
       }
 
diff --git a/js/angular/controller/scrollController.js b/js/angular/controller/scrollController.js
index 1f86c06680e..7ee055b0784 100644
--- a/js/angular/controller/scrollController.js
+++ b/js/angular/controller/scrollController.js
@@ -26,10 +26,19 @@ function($scope,
   self.__timeout = $timeout;
 
   self._scrollViewOptions = scrollViewOptions; //for testing
+  self.isNative = function() {
+    return !!scrollViewOptions.nativeScrolling;
+  };
 
   var element = self.element = scrollViewOptions.el;
   var $element = self.$element = jqLite(element);
-  var scrollView = self.scrollView = new ionic.views.Scroll(scrollViewOptions);
+  var scrollView;
+  if (self.isNative()) {
+    scrollView = self.scrollView = new ionic.views.ScrollNative(scrollViewOptions);
+  } else {
+    scrollView = self.scrollView = new ionic.views.Scroll(scrollViewOptions);
+  }
+
 
   //Attach self to element as a controller so other directives can require this controller
   //through `require: '$ionicScroll'
diff --git a/js/angular/directive/content.js b/js/angular/directive/content.js
index adfe2c404ff..b5260db175c 100644
--- a/js/angular/directive/content.js
+++ b/js/angular/directive/content.js
@@ -109,37 +109,55 @@ function($timeout, $controller, $ionicBind, $ionicConfig) {
 
         if ($attr.scroll === "false") {
           //do nothing
-        } else if (attr.overflowScroll === "true" || !$ionicConfig.scrolling.jsScrolling()) {
-          // use native scrolling
-          $element.addClass('overflow-scroll');
         } else {
-          var scrollViewOptions = {
-            el: $element[0],
-            delegateHandle: attr.delegateHandle,
-            locking: (attr.locking || 'true') === 'true',
-            bouncing: $scope.$eval($scope.hasBouncing),
-            startX: $scope.$eval($scope.startX) || 0,
-            startY: $scope.$eval($scope.startY) || 0,
-            scrollbarX: $scope.$eval($scope.scrollbarX) !== false,
-            scrollbarY: $scope.$eval($scope.scrollbarY) !== false,
-            scrollingX: $scope.direction.indexOf('x') >= 0,
-            scrollingY: $scope.direction.indexOf('y') >= 0,
-            scrollEventInterval: parseInt($scope.scrollEventInterval, 10) || 10,
-            scrollingComplete: function() {
-              $scope.$onScrollComplete({
-                scrollTop: this.__scrollTop,
-                scrollLeft: this.__scrollLeft
-              });
-            }
-          };
+          var scrollViewOptions = {};
+
+          if (attr.overflowScroll === "true" || !$ionicConfig.scrolling.jsScrolling()) {
+            // use native scrolling
+            $element.addClass('overflow-scroll');
+
+            scrollViewOptions = {
+              el: $element[0],
+              delegateHandle: attr.delegateHandle,
+              startX: $scope.$eval($scope.startX) || 0,
+              startY: $scope.$eval($scope.startY) || 0,
+              nativeScrolling:true
+            };
+
+          } else {
+            // Use JS scrolling
+            scrollViewOptions = {
+              el: $element[0],
+              delegateHandle: attr.delegateHandle,
+              locking: (attr.locking || 'true') === 'true',
+              bouncing: $scope.$eval($scope.hasBouncing),
+              startX: $scope.$eval($scope.startX) || 0,
+              startY: $scope.$eval($scope.startY) || 0,
+              scrollbarX: $scope.$eval($scope.scrollbarX) !== false,
+              scrollbarY: $scope.$eval($scope.scrollbarY) !== false,
+              scrollingX: $scope.direction.indexOf('x') >= 0,
+              scrollingY: $scope.direction.indexOf('y') >= 0,
+              scrollEventInterval: parseInt($scope.scrollEventInterval, 10) || 10,
+              scrollingComplete: function() {
+                $scope.$onScrollComplete({
+                  scrollTop: this.__scrollTop,
+                  scrollLeft: this.__scrollLeft
+                });
+              }
+            };
+          }
+
+          // init scroll controller with appropriate options
           $controller('$ionicScroll', {
             $scope: $scope,
             scrollViewOptions: scrollViewOptions
           });
 
           $scope.$on('$destroy', function() {
-            scrollViewOptions.scrollingComplete = noop;
-            delete scrollViewOptions.el;
+            if (scrollViewOptions) {
+              scrollViewOptions.scrollingComplete = noop;
+              delete scrollViewOptions.el;
+            }
             innerElement = null;
             $element = null;
             attr.$$element = null;
diff --git a/js/angular/directive/infiniteScroll.js b/js/angular/directive/infiniteScroll.js
index b76f5780ff0..b23933f0d1b 100644
--- a/js/angular/directive/infiniteScroll.js
+++ b/js/angular/directive/infiniteScroll.js
@@ -79,10 +79,14 @@ IonicModule
     link: function($scope, $element, $attrs, ctrls) {
       var infiniteScrollCtrl = ctrls[1];
       var scrollCtrl = infiniteScrollCtrl.scrollCtrl = ctrls[0];
-      var jsScrolling = infiniteScrollCtrl.jsScrolling = !!scrollCtrl;
+      var jsScrolling = infiniteScrollCtrl.jsScrolling = !scrollCtrl.isNative();
+
       // if this view is not beneath a scrollCtrl, it can't be injected, proceed w/ native scrolling
       if (jsScrolling) {
         infiniteScrollCtrl.scrollView = scrollCtrl.scrollView;
+        $scope.scrollingType = 'js-scrolling';
+        //bind to JS scroll events
+        scrollCtrl.$element.on('scroll', infiniteScrollCtrl.checkBounds);
       } else {
         // grabbing the scrollable element, to determine dimensions, and current scroll pos
         var scrollEl = ionic.DomUtil.getParentOrSelfWithClass($element[0].parentNode,'overflow-scroll');
@@ -91,14 +95,10 @@ IonicModule
         if (!scrollEl) {
           throw 'Infinite scroll must be used inside a scrollable div';
         }
-      }
-      //bind to appropriate scroll event
-      if (jsScrolling) {
-        $scope.scrollingType = 'js-scrolling';
-        scrollCtrl.$element.on('scroll', infiniteScrollCtrl.checkBounds);
-      } else {
+        //bind to native scroll events
         infiniteScrollCtrl.scrollEl.addEventListener('scroll', infiniteScrollCtrl.checkBounds);
       }
+
       // Optionally check bounds on start after scrollView is fully rendered
       var doImmediateCheck = isDefined($attrs.immediateCheck) ? $scope.$eval($attrs.immediateCheck) : true;
       if (doImmediateCheck) {
diff --git a/js/angular/directive/refresher.js b/js/angular/directive/refresher.js
index 06328e1bc8b..b564ddaa1ac 100644
--- a/js/angular/directive/refresher.js
+++ b/js/angular/directive/refresher.js
@@ -87,10 +87,11 @@ IonicModule
       // JS Scrolling uses the scroll controller
       var scrollCtrl = ctrls[0],
           refresherCtrl = ctrls[1];
-
-      if (!!scrollCtrl) {
+      if (!scrollCtrl || scrollCtrl.isNative()) {
+        // Kick off native scrolling
+        refresherCtrl.init();
+      } else {
         $element[0].classList.add('js-scrolling');
-
         scrollCtrl._setRefresher(
           $scope,
           $element[0],
@@ -102,10 +103,6 @@ IonicModule
             scrollCtrl.scrollView.finishPullToRefresh();
           });
         });
-
-      } else {
-        // Kick off native scrolling
-        refresherCtrl.init();
       }
 
     }
diff --git a/js/views/scrollViewNative.js b/js/views/scrollViewNative.js
new file mode 100644
index 00000000000..3503d4d4bd5
--- /dev/null
+++ b/js/views/scrollViewNative.js
@@ -0,0 +1,344 @@
+(function(ionic) {
+  var NOOP = function() {};
+  var depreciated = function(name) {
+    console.error('Method not available in native scrolling: ' + name);
+  };
+  ionic.views.ScrollNative = ionic.views.View.inherit({
+
+    initialize: function(options) {
+      var self = this;
+      self.__container = self.el = options.el;
+      self.__content = options.el.firstElementChild;
+      self.isNative = true;
+
+      self.__scrollTop = self.el.scrollTop;
+      self.__scrollLeft = self.el.scrollLeft;
+      self.__clientHeight = self.__content.clientHeight,
+      self.__clientWidth = self.__content.clientWidth,
+      self.__maxScrollTop = Math.max((self.__contentHeight) - self.__clientHeight, 0),
+      self.__maxScrollLeft = Math.max((self.__contentWidth) - self.__clientWidth, 0),
+
+      self.options = {
+
+        freeze: false,
+
+        getContentWidth: function() {
+          return Math.max(self.__content.scrollWidth, self.__content.offsetWidth);
+        },
+
+        getContentHeight: function() {
+          return Math.max(self.__content.scrollHeight, self.__content.offsetHeight + (self.__content.offsetTop * 2));
+        }
+
+      };
+
+      for (var key in options) {
+        self.options[key] = options[key];
+      }
+
+      /**
+       * Sets isScrolling to true, and automatically deactivates if not called again in 80ms.
+       */
+      self.onScroll = function(event) {
+        if (!ionic.scroll.isScrolling) {
+          ionic.scroll.isScrolling = true;
+        }
+
+        clearTimeout(self.scrollTimer);
+        self.scrollTimer = setTimeout(function() {
+          ionic.scroll.isScrolling = false;
+        }, 80);
+      };
+
+      self.freeze = NOOP;
+
+      self.__initEventHandlers();
+    },
+
+    /**  Methods not used in native scrolling */
+    __callback: function() {depreciated('__callback');},
+    zoomTo: function() {depreciated('zoomTo');},
+    zoomBy: function() {depreciated('zoomBy');},
+    activatePullToRefresh: function() {depreciated('activatePullToRefresh');},
+
+    /**
+     * Returns the scroll position and zooming values
+     *
+     * @return {Map} `left` and `top` scroll position and `zoom` level
+     */
+    resize: function(continueScrolling) {
+      var self = this;
+      if (!self.__container || !self.options) return;
+
+      // Update Scroller dimensions for changed content
+      // Add padding to bottom of content
+      self.setDimensions(
+        self.__container.clientWidth,
+        self.__container.clientHeight,
+        self.options.getContentWidth(),
+        self.options.getContentHeight(),
+        continueScrolling
+      );
+    },
+
+    /**
+     * Initialize the scrollview
+     * In native scrolling, this only means we need to gather size information
+     */
+    run: function() {
+      this.resize();
+    },
+
+    /**
+     * Returns the scroll position and zooming values
+     *
+     * @return {Map} `left` and `top` scroll position and `zoom` level
+     */
+    getValues: function() {
+      var self = this;
+      self.update();
+      return {
+        left: self.__scrollLeft,
+        top: self.__scrollTop,
+        zoom: 1
+      };
+    },
+
+    /**
+     * Updates the __scrollLeft and __scrollTop values to el's current value
+     */
+    update: function() {
+      var self = this;
+      self.__scrollLeft = self.el.scrollLeft;
+      self.__scrollTop = self.el.scrollTop;
+    },
+
+    /**
+     * Configures the dimensions of the client (outer) and content (inner) elements.
+     * Requires the available space for the outer element and the outer size of the inner element.
+     * All values which are falsy (null or zero etc.) are ignored and the old value is kept.
+     *
+     * @param clientWidth {Integer} Inner width of outer element
+     * @param clientHeight {Integer} Inner height of outer element
+     * @param contentWidth {Integer} Outer width of inner element
+     * @param contentHeight {Integer} Outer height of inner element
+     */
+    setDimensions: function(clientWidth, clientHeight, contentWidth, contentHeight) {
+      var self = this;
+
+      if (!clientWidth && !clientHeight && !contentWidth && !contentHeight) {
+        // this scrollview isn't rendered, don't bother
+        return;
+      }
+
+      // Only update values which are defined
+      if (clientWidth === +clientWidth) {
+        self.__clientWidth = clientWidth;
+      }
+
+      if (clientHeight === +clientHeight) {
+        self.__clientHeight = clientHeight;
+      }
+
+      if (contentWidth === +contentWidth) {
+        self.__contentWidth = contentWidth;
+      }
+
+      if (contentHeight === +contentHeight) {
+        self.__contentHeight = contentHeight;
+      }
+
+      // Refresh maximums
+      self.__computeScrollMax();
+    },
+
+    /**
+     * Returns the maximum scroll values
+     *
+     * @return {Map} `left` and `top` maximum scroll values
+     */
+    getScrollMax: function() {
+      return {
+        left: this.__maxScrollLeft,
+        top: this.__maxScrollTop
+      };
+    },
+
+    /**
+     * Scrolls by the given amount in px.
+     *
+     * @param left {Number} Horizontal scroll position, keeps current if value is <code>null</code>
+     * @param top {Number} Vertical scroll position, keeps current if value is <code>null</code>
+     * @param animate {Boolean} Whether the scrolling should happen using an animation
+     */
+
+    scrollBy: function(left, top, animate) {
+      var self = this;
+
+      // update scroll vars before refferencing them
+      self.update();
+
+      var startLeft = self.__isAnimating ? self.__scheduledLeft : self.__scrollLeft;
+      var startTop = self.__isAnimating ? self.__scheduledTop : self.__scrollTop;
+
+      self.scrollTo(startLeft + (left || 0), startTop + (top || 0), animate);
+    },
+
+    /**
+     * Scrolls to the given position in px.
+     *
+     * @param left {Number} Horizontal scroll position, keeps current if value is <code>null</code>
+     * @param top {Number} Vertical scroll position, keeps current if value is <code>null</code>
+     * @param animate {Boolean} Whether the scrolling should happen using an animation
+     */
+    scrollTo: function(left, top, animate) {
+      var self = this;
+      if (!animate) {
+        self.el.scrollTop = top;
+        self.el.scrollLeft = left;
+        self.resize();
+        return;
+      }
+      animateScroll(top, left);
+
+      function animateScroll(Y, X) {
+        // scroll animation loop w/ easing
+        // credit https://gist.github.com/dezinezync/5487119
+        var start = Date.now(),
+          duration = 1000, //milliseconds
+          fromY = self.el.scrollTop,
+          fromX = self.el.scrollLeft;
+
+        if (fromY === Y && fromX === X) {
+          self.resize();
+          return; /* Prevent scrolling to the Y point if already there */
+        }
+
+        // decelerating to zero velocity
+        function easeOutCubic(t) {
+          return (--t) * t * t + 1;
+        }
+
+        // scroll loop
+        function animateScrollStep() {
+          var currentTime = Date.now(),
+            time = Math.min(1, ((currentTime - start) / duration)),
+          // where .5 would be 50% of time on a linear scale easedT gives a
+          // fraction based on the easing method
+            easedT = easeOutCubic(time);
+
+          if (fromY != Y) {
+            self.el.scrollTop = parseInt((easedT * (Y - fromY)) + fromY, 10);
+          }
+          if (fromX != X) {
+            self.el.scrollLeft = parseInt((easedT * (X - fromX)) + fromX, 10);
+          }
+
+          if (time < 1) {
+            ionic.requestAnimationFrame(animateScrollStep);
+
+          } else {
+            // done
+            self.resize();
+          }
+        }
+
+        // start scroll loop
+        ionic.requestAnimationFrame(animateScrollStep);
+      }
+    },
+
+
+
+    /*
+     ---------------------------------------------------------------------------
+     PRIVATE API
+     ---------------------------------------------------------------------------
+     */
+
+    /**
+     * If the scroll view isn't sized correctly on start, wait until we have at least some size
+     */
+    __waitForSize: function() {
+      var self = this;
+
+      clearTimeout(self.__sizerTimeout);
+
+      var sizer = function() {
+        self.resize(true);
+      };
+
+      sizer();
+      self.__sizerTimeout = setTimeout(sizer, 500);
+    },
+
+
+    /**
+     * Recomputes scroll minimum values based on client dimensions and content dimensions.
+     */
+    __computeScrollMax: function() {
+      var self = this;
+
+      self.__maxScrollLeft = Math.max((self.__contentWidth) - self.__clientWidth, 0);
+      self.__maxScrollTop = Math.max((self.__contentHeight) - self.__clientHeight, 0);
+
+      if (!self.__didWaitForSize && !self.__maxScrollLeft && !self.__maxScrollTop) {
+        self.__didWaitForSize = true;
+        self.__waitForSize();
+      }
+    },
+
+    __initEventHandlers: function() {
+      var self = this;
+
+      // Event Handler
+      var container = self.__container;
+
+      // should be unnecessary in native scrolling, but keep in case bugs show up
+      self.scrollChildIntoView = NOOP;
+
+      self.resetScrollView = function(e) {
+        //return scrollview to original height once keyboard has hidden
+        if (self.isScrolledIntoView) {
+          self.isScrolledIntoView = false;
+          container.style.height = "";
+          container.style.overflow = "";
+          self.resize();
+          ionic.scroll.isScrolling = false;
+        }
+      };
+
+      container.addEventListener('resetScrollView', self.resetScrollView);
+      container.addEventListener('scroll', self.onScroll);
+
+      //Broadcasted when keyboard is shown on some platforms.
+      //See js/utils/keyboard.js
+      container.addEventListener('scrollChildIntoView', self.scrollChildIntoView);
+      container.addEventListener('resetScrollView', self.resetScrollView);
+    },
+
+    __cleanup: function() {
+      var self = this;
+      var container = self.__container;
+
+      container.removeEventListener('resetScrollView', self.resetScrollView);
+      container.removeEventListener('scroll', self.onScroll);
+
+      container.removeEventListener('scrollChildIntoView', self.scrollChildIntoView);
+      container.removeEventListener('resetScrollView', self.resetScrollView);
+
+      ionic.tap.removeClonedInputs(container, self);
+
+      delete self.__container;
+      delete self.__content;
+      delete self.__indicatorX;
+      delete self.__indicatorY;
+      delete self.options.el;
+
+      self.resize = self.scrollTo = self.onScroll = self.resetScrollView = NOOP;
+      container = null;
+    }
+  });
+
+})(ionic);
+
diff --git a/test/html/infinite-scroll.html b/test/html/infinite-scroll.html
index c060c122415..0527ba616b6 100644
--- a/test/html/infinite-scroll.html
+++ b/test/html/infinite-scroll.html
@@ -25,7 +25,9 @@
 
   <script>
   angular.module('ionicApp', ['ionic'])
-
+      .config(function($ionicConfigProvider) {
+        if(!ionic.Platform.isIOS())$ionicConfigProvider.scrolling.jsScrolling(false);
+      })
   .controller('MyCtrl', ['$scope', '$timeout', function($scope, $timeout) {
 
     $scope.data = { items: [] };
diff --git a/test/unit/angular/controller/refreshController.unit.js b/test/unit/angular/controller/refreshController.unit.js
index beca46ee92c..e8639bd1e32 100644
--- a/test/unit/angular/controller/refreshController.unit.js
+++ b/test/unit/angular/controller/refreshController.unit.js
@@ -12,17 +12,18 @@ describe('$ionicRefresh Controller', function() {
     options.el = options.el ||
       angular.element('<ion-refresher></ion-refresher><div class="list"></div>')[0];
     scrollEl = options.parent ||
-      angular.element('<div class="ionic-scroll"><div class="scroll"></div></div>');
-    scrollEl.find('.scroll').append(options.el);
+      angular.element('<ion-content overflow-scroll="true">');
+    scrollEl.append(options.el);
 
-    inject(function($controller, $rootScope, $timeout, $compile) {
+    inject(function($rootScope, $timeout, $compile) {
       scope = $rootScope.$new();
 
       $compile(scrollEl)(scope);
       scope.$apply();
-      scope.$onRefresh = jasmine.createSpy('onRefresh');
-      scope.$onPulling = jasmine.createSpy('onPulling');
+
       refresher = scrollEl.find('.scroll-refresher')[0];
+      angular.element(refresher).scope().$onRefresh = jasmine.createSpy('onRefresh');
+      angular.element(refresher).scope().$onPulling = jasmine.createSpy('onPulling');
       ctrl = angular.element(refresher).controller('ionRefresher');
       timeout = $timeout;
     });
@@ -37,8 +38,9 @@ describe('$ionicRefresh Controller', function() {
   }
 
   it('should error if not child of scroll view', function() {
-    setup({parent: angular.element('<div></div>')});
-    expect(ctrl).toBe(undefined);
+    expect(function() {
+      setup({parent: angular.element('<div></div>')});
+    }).toThrow();
   });
 
   it('should oversroll using CSS transforms', function() {
@@ -92,15 +94,17 @@ describe('$ionicRefresh Controller', function() {
   it('should update refresher class when shared methods fire', function() {
     setup();
 
-    scope.$onRefresh = jasmine.createSpy('onRefresh');
-    scope.$onPulling = jasmine.createSpy('onPulling');
+    var refresherScope = angular.element(refresher).scope();
+
+    refresherScope.$onRefresh = jasmine.createSpy('onRefresh');
+    refresherScope.$onPulling = jasmine.createSpy('onPulling');
 
 
     expect(refresher.classList.contains('active')).toBe(false);
     expect(refresher.classList.contains('refreshing')).toBe(false);
     expect(refresher.classList.contains('invisible')).toBe(true);
-    expect(scope.$onRefresh).not.toHaveBeenCalled();
-    expect(scope.$onPulling).not.toHaveBeenCalled();
+    expect(refresherScope.$onRefresh).not.toHaveBeenCalled();
+    expect(refresherScope.$onPulling).not.toHaveBeenCalled();
 
     ctrl.getRefresherDomMethods().show();
     expect(refresher.classList.contains('invisible')).toBe(false);
@@ -108,11 +112,11 @@ describe('$ionicRefresh Controller', function() {
     ctrl.getRefresherDomMethods().activate();
     expect(refresher.classList.contains('active')).toBe(true);
     expect(refresher.classList.contains('refreshing')).toBe(false);
-    expect(scope.$onPulling).toHaveBeenCalled();
+    expect(refresherScope.$onPulling).toHaveBeenCalled();
 
     ctrl.getRefresherDomMethods().start();
     expect(refresher.classList.contains('refreshing')).toBe(true);
-    expect(scope.$onRefresh).toHaveBeenCalled();
+    expect(refresherScope.$onRefresh).toHaveBeenCalled();
 
     ctrl.getRefresherDomMethods().tail();
     expect(refresher.classList.contains('refreshing-tail')).toBe(true);
diff --git a/test/unit/angular/controller/scrollController.unit.js b/test/unit/angular/controller/scrollController.unit.js
index 84962fbd24b..60185273da6 100644
--- a/test/unit/angular/controller/scrollController.unit.js
+++ b/test/unit/angular/controller/scrollController.unit.js
@@ -7,9 +7,10 @@ describe('$ionicScroll Controller', function() {
     ionic.requestAnimationFrame = function(cb) { cb(); };
   });
 
-  var scope, ctrl, timeout;
+  var scope, ctrl, timeout, nativeScrolling;
   function setup(options) {
     options = options || {};
+    options.nativeScrolling = nativeScrolling || false;
 
     options.el = options.el ||
       //scrollView requires an outer container element and a child
@@ -27,209 +28,243 @@ describe('$ionicScroll Controller', function() {
       timeout = $timeout;
     });
   }
-
-  it('should register with no handle', inject(function($ionicScrollDelegate) {
-    spyOn($ionicScrollDelegate, '_registerInstance');
-    var el = setup();
-    expect($ionicScrollDelegate._registerInstance)
-      .toHaveBeenCalledWith(ctrl, undefined, jasmine.any(Function));
-  }));
-
-  it('should register with given handle and deregister on destroy', inject(function($ionicScrollDelegate) {
-    var deregisterSpy = jasmine.createSpy('deregister');
-    spyOn($ionicScrollDelegate, '_registerInstance').andCallFake(function() {
-      return deregisterSpy;
-    });
-    setup({
-      delegateHandle: 'something'
-    });
-    expect($ionicScrollDelegate._registerInstance)
-      .toHaveBeenCalledWith(ctrl, 'something', jasmine.any(Function));
-
-    expect(deregisterSpy).not.toHaveBeenCalled();
-    scope.$destroy();
-    expect(deregisterSpy).toHaveBeenCalled();
-  }));
-
-  it('should set bouncing to option if given', function() {
-    spyOn(ionic.Platform, 'isAndroid');
-    setup({
-      bouncing: true
+  [false, true].forEach(function(nativeScrollingSetting) {
+
+    it('should register with no handle', inject(function ($ionicScrollDelegate) {
+      nativeScrolling = nativeScrollingSetting;
+      spyOn($ionicScrollDelegate, '_registerInstance');
+      var el = setup();
+      expect($ionicScrollDelegate._registerInstance)
+        .toHaveBeenCalledWith(ctrl, undefined, jasmine.any(Function));
+    }));
+
+    it('should register with given handle and deregister on destroy', inject(function ($ionicScrollDelegate) {
+      nativeScrolling = nativeScrollingSetting;
+      var deregisterSpy = jasmine.createSpy('deregister');
+      spyOn($ionicScrollDelegate, '_registerInstance').andCallFake(function () {
+        return deregisterSpy;
+      });
+      setup({
+        delegateHandle: 'something'
+      });
+      expect($ionicScrollDelegate._registerInstance)
+        .toHaveBeenCalledWith(ctrl, 'something', jasmine.any(Function));
+
+      expect(deregisterSpy).not.toHaveBeenCalled();
+      scope.$destroy();
+      expect(deregisterSpy).toHaveBeenCalled();
+    }));
+
+    it('should set bouncing to option if given', function () {
+      nativeScrolling = nativeScrollingSetting;
+      spyOn(ionic.Platform, 'isAndroid');
+      setup({
+        bouncing: true
+      });
+      expect(ionic.Platform.isAndroid).not.toHaveBeenCalled();
     });
-    expect(ionic.Platform.isAndroid).not.toHaveBeenCalled();
-  });
-  it('should set bouncing false if isAndroid true', function() {
-    spyOn(ionic.Platform, 'isAndroid').andCallFake(function() {
-      return true;
+    it('should set bouncing false if isAndroid true', function () {
+      nativeScrolling = nativeScrollingSetting;
+      spyOn(ionic.Platform, 'isAndroid').andCallFake(function () {
+        return true;
+      });
+      setup();
+      expect(ctrl.scrollView.options.bouncing).toBe(false);
     });
-    setup();
-    expect(ctrl.scrollView.options.bouncing).toBe(false);
-  });
-  it('should set bouncing true if android false', function() {
-    spyOn(ionic.Platform, 'isAndroid').andCallFake(function() {
-      return false;
+    it('should set bouncing true if android false', function () {
+      nativeScrolling = nativeScrollingSetting;
+      spyOn(ionic.Platform, 'isAndroid').andCallFake(function () {
+        return false;
+      });
+      setup();
+      expect(ctrl.scrollView.options.bouncing).toBe(true);
     });
-    setup();
-    expect(ctrl.scrollView.options.bouncing).toBe(true);
-  });
 
-  it('should set this.element and this.$element', function() {
-    setup();
-    expect(ctrl.element.tagName).toMatch(/div/i);
-    expect(ctrl.$element[0]).toBe(ctrl.element);
-  });
-
-  it('should register scrollView as this.scrollView', function() {
-    setup();
-    expect(ctrl.scrollView instanceof ionic.views.Scroll).toBe(true);
-  });
+    it('should set this.element and this.$element', function () {
+      nativeScrolling = nativeScrollingSetting;
+      setup();
+      expect(ctrl.element.tagName).toMatch(/div/i);
+      expect(ctrl.$element[0]).toBe(ctrl.element);
+    });
 
-  it('should register controller on element.data', function() {
-    setup();
-    expect(ctrl.$element.parent().data('$$ionicScrollController')).toBe(ctrl);
-  });
+    it('should register scrollView as this.scrollView', function () {
+      nativeScrolling = nativeScrollingSetting;
+      setup();
+      if (nativeScrolling) {
+        expect(ctrl.scrollView instanceof ionic.views.ScrollNative).toBe(true);
+      }else {
+        expect(ctrl.scrollView instanceof ionic.views.Scroll).toBe(true);
+      }
+    });
 
-  it('should run after a timeout', function() {
-    setup();
-    timeout.flush();
-    expect(ctrl.scrollView.run).toHaveBeenCalled();
-  });
+    it('should register controller on element.data', function () {
+      nativeScrolling = nativeScrollingSetting;
+      setup();
+      expect(ctrl.$element.parent().data('$$ionicScrollController')).toBe(ctrl);
+    });
 
-  it('should listen to scroll event and call $onScroll', function() {
-    setup();
-    scope.$onScroll = jasmine.createSpy();
+    it('should run after a timeout', function () {
+      nativeScrolling = nativeScrollingSetting;
+      setup();
+      timeout.flush();
+      expect(ctrl.scrollView.run).toHaveBeenCalled();
+    });
 
-    expect(scope.$onScroll).not.toHaveBeenCalled();
+    it('should listen to scroll event and call $onScroll', function () {
+      nativeScrolling = nativeScrollingSetting;
+      setup();
+      scope.$onScroll = jasmine.createSpy();
 
-    ionic.trigger('scroll', {target: ctrl.element});
-    expect(scope.$onScroll).toHaveBeenCalled();
-    expect(scope.$onScroll.mostRecentCall.args[0].scrollLeft).toBe(0);
-    expect(scope.$onScroll.mostRecentCall.args[0].scrollTop).toBe(0);
+      expect(scope.$onScroll).not.toHaveBeenCalled();
 
-    scope.$onScroll.reset();
-    ionic.trigger('scroll', {target: ctrl.element, scrollTop: 3, scrollLeft: 4});
-    expect(scope.$onScroll.mostRecentCall.args[0].scrollLeft).toBe(4);
-    expect(scope.$onScroll.mostRecentCall.args[0].scrollTop).toBe(3);
-  });
+      ionic.trigger('scroll', {target: ctrl.element});
+      expect(scope.$onScroll).toHaveBeenCalled();
+      expect(scope.$onScroll.mostRecentCall.args[0].scrollLeft).toBe(0);
+      expect(scope.$onScroll.mostRecentCall.args[0].scrollTop).toBe(0);
 
-  it('.getScrollView', function() {
-    setup();
-    expect(ctrl.getScrollView()).toBe(ctrl.scrollView);
-  });
-  it('.getScrollPosition', function() {
-    setup();
-    var values = {};
-    spyOn(ctrl.scrollView, 'getValues').andReturn(values);
-    expect(ctrl.getScrollPosition()).toBe(values);
-  });
+      scope.$onScroll.reset();
+      ionic.trigger('scroll', {target: ctrl.element, scrollTop: 3, scrollLeft: 4});
+      expect(scope.$onScroll.mostRecentCall.args[0].scrollLeft).toBe(4);
+      expect(scope.$onScroll.mostRecentCall.args[0].scrollTop).toBe(3);
+    });
 
-  [false, true].forEach(function(shouldAnimate) {
-    describe('with animate='+shouldAnimate, function() {
+    it('.getScrollView', function () {
+      nativeScrolling = nativeScrollingSetting;
+      setup();
+      expect(ctrl.getScrollView()).toBe(ctrl.scrollView);
+    });
+    it('.getScrollPosition', function () {
+      nativeScrolling = nativeScrollingSetting;
+      setup();
+      var values = {};
+      spyOn(ctrl.scrollView, 'getValues').andReturn(values);
+      expect(ctrl.getScrollPosition()).toBe(values);
+    });
 
-      describe('scroll action', function() {
-        beforeEach(function() {
-          setup();
-          //Mock resize to insta-call through for easier tests
-          ctrl.resize = function() {
-            return { then: function(cb) { cb(); } };
-          };
-        });
-        it('.scrollTop', function() {
-          spyOn(ctrl.scrollView, 'scrollTo');
-          ctrl.scrollTop(shouldAnimate);
-          expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(0, 0, shouldAnimate);
-        });
-        it('.scrollBottom', function() {
-          spyOn(ctrl.scrollView, 'scrollTo');
-          spyOn(ctrl.scrollView, 'getScrollMax').andCallFake(function() {
-            return { left: 33, top: 44 };
-          });
-          ctrl.scrollBottom(shouldAnimate);
-          expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(33, 44, shouldAnimate);
-        });
-        it('.scrollTo', function() {
-          spyOn(ctrl.scrollView, 'scrollTo');
-          ctrl.scrollTo(1, 2, shouldAnimate);
-          expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(1, 2, shouldAnimate);
-        });
-        it('.scrollBy', function() {
-          spyOn(ctrl.scrollView, 'scrollBy');
-          ctrl.scrollBy(1, 2, shouldAnimate);
-          expect(ctrl.scrollView.scrollBy).toHaveBeenCalledWith(1, 2, shouldAnimate);
-        });
-        it('.anchorScroll without hash should scrollTop', inject(function($location, $document) {
-          $document[0].getElementById = jasmine.createSpy();
-          $location.hash = function() { return null; };
-          spyOn(ctrl.scrollView, 'scrollTo');
-          ctrl.anchorScroll(shouldAnimate);
-          expect($document[0].getElementById).not.toHaveBeenCalled();
-          expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(0, 0, shouldAnimate);
-        }));
-        it('.anchorScroll with hash but no element should scrollTop', inject(function($location, $document) {
-          $document[0].getElementById = jasmine.createSpy();
-          $location.hash = function() { return 'foo'; };
-          spyOn(ctrl.scrollView, 'scrollTo');
-          ctrl.anchorScroll(shouldAnimate);
-          expect($document[0].getElementById).toHaveBeenCalledWith('foo');
-          expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(0, 0, shouldAnimate);
-        }));
-        it('.anchorScroll with el matching hash should scroll to it', inject(function($location, $document) {
-          $document[0].getElementById = jasmine.createSpy('byId').andCallFake(function() {
-            return {
-              offsetLeft: 8,
-              offsetTop: 9,
-              attributes:[],
-              offsetParent:{}
+    [false, true].forEach(function (shouldAnimate) {
+      describe('with animate=' + shouldAnimate, function () {
+
+        describe('scroll action', function () {
+          beforeEach(function () {
+            nativeScrolling = nativeScrollingSetting;
+            setup();
+            //Mock resize to insta-call through for easier tests
+            ctrl.resize = function () {
+              return {
+                then: function (cb) {
+                  cb();
+                }
+              };
             };
           });
-          spyOn($location, 'hash').andCallFake(function() {
-            return 'foo';
+          it('.scrollTop', function () {
+            spyOn(ctrl.scrollView, 'scrollTo');
+            ctrl.scrollTop(shouldAnimate);
+            expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(0, 0, shouldAnimate);
+          });
+          it('.scrollBottom', function () {
+            spyOn(ctrl.scrollView, 'scrollTo');
+            spyOn(ctrl.scrollView, 'getScrollMax').andCallFake(function () {
+              return {left: 33, top: 44};
+            });
+            ctrl.scrollBottom(shouldAnimate);
+            expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(33, 44, shouldAnimate);
           });
-          spyOn(ctrl.scrollView, 'scrollTo');
-          ctrl.anchorScroll(shouldAnimate);
-          expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(8, 9, shouldAnimate);
-        }));
+          it('.scrollTo', function () {
+            spyOn(ctrl.scrollView, 'scrollTo');
+            ctrl.scrollTo(1, 2, shouldAnimate);
+            expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(1, 2, shouldAnimate);
+          });
+          it('.scrollBy', function () {
+            spyOn(ctrl.scrollView, 'scrollBy');
+            ctrl.scrollBy(1, 2, shouldAnimate);
+            expect(ctrl.scrollView.scrollBy).toHaveBeenCalledWith(1, 2, shouldAnimate);
+          });
+          it('.anchorScroll without hash should scrollTop', inject(function ($location, $document) {
+            $document[0].getElementById = jasmine.createSpy();
+            $location.hash = function () {
+              return null;
+            };
+            spyOn(ctrl.scrollView, 'scrollTo');
+            ctrl.anchorScroll(shouldAnimate);
+            expect($document[0].getElementById).not.toHaveBeenCalled();
+            expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(0, 0, shouldAnimate);
+          }));
+          it('.anchorScroll with hash but no element should scrollTop', inject(function ($location, $document) {
+            $document[0].getElementById = jasmine.createSpy();
+            $location.hash = function () {
+              return 'foo';
+            };
+            spyOn(ctrl.scrollView, 'scrollTo');
+            ctrl.anchorScroll(shouldAnimate);
+            expect($document[0].getElementById).toHaveBeenCalledWith('foo');
+            expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(0, 0, shouldAnimate);
+          }));
+          it('.anchorScroll with el matching hash should scroll to it', inject(function ($location, $document) {
+            $document[0].getElementById = jasmine.createSpy('byId').andCallFake(function () {
+              return {
+                offsetLeft: 8,
+                offsetTop: 9,
+                attributes: [],
+                offsetParent: {}
+              };
+            });
+            spyOn($location, 'hash').andCallFake(function () {
+              return 'foo';
+            });
+            spyOn(ctrl.scrollView, 'scrollTo');
+            ctrl.anchorScroll(shouldAnimate);
+            expect(ctrl.scrollView.scrollTo).toHaveBeenCalledWith(8, 9, shouldAnimate);
+          }));
+        });
       });
     });
-  });
 
-  it('.anchorScroll with el matching hash should scroll to it, even if the el is not directly below the list', function() {
-    var ele = {
-      offsetLeft: 8,
-      offsetTop: 9,
-      attributes:[],
-      offsetParent:{
-        offsetLeft: 10,
-        offsetTop: 11,
-        attributes:[],
-        offsetParent:{}
-      }
-    };
-    module('ionic', function($provide) {
-      $provide.value('$document', [ { getElementById: function(){ return ele; }, createElement: function(tagName){ return document.createElement(tagName); } } ]);
-    });
-    inject(function($controller, $rootScope, $location, $timeout) {
-      var scrollCtrl = $controller('$ionicScroll', {
-        $scope: $rootScope.$new(),
-        $element: jqLite('<div><div></div></div>'),
-        scrollViewOptions: { el: jqLite('<div><div></div></div>')[0] }
+    it('.anchorScroll with el matching hash should scroll to it, even if the el is not directly below the list', function () {
+      nativeScrolling = nativeScrollingSetting;
+      var ele = {
+        offsetLeft: 8,
+        offsetTop: 9,
+        attributes: [],
+        offsetParent: {
+          offsetLeft: 10,
+          offsetTop: 11,
+          attributes: [],
+          offsetParent: {}
+        }
+      };
+      module('ionic', function ($provide) {
+        $provide.value('$document', [{
+          getElementById: function () {
+            return ele;
+          }, createElement: function (tagName) {
+            return document.createElement(tagName);
+          }
+        }]);
       });
-      spyOn($location, 'hash').andCallFake(function() {
-           return 'bar';
+      inject(function ($controller, $rootScope, $location, $timeout) {
+        var scrollCtrl = $controller('$ionicScroll', {
+          $scope: $rootScope.$new(),
+          $element: jqLite('<div><div></div></div>'),
+          scrollViewOptions: {el: jqLite('<div><div></div></div>')[0]}
+        });
+        spyOn($location, 'hash').andCallFake(function () {
+          return 'bar';
+        });
+        spyOn(scrollCtrl.scrollView, 'scrollTo');
+        scrollCtrl.anchorScroll()
+        $timeout.flush();
+        expect(scrollCtrl.scrollView.scrollTo.mostRecentCall.args).toEqual([18, 20, false]);
       });
-      spyOn(scrollCtrl.scrollView, 'scrollTo')
-      scrollCtrl.anchorScroll()
-      $timeout.flush();
-      expect(scrollCtrl.scrollView.scrollTo.mostRecentCall.args).toEqual([18, 20, false]);
     });
-  });
 
-  it('should not activatePullToRefresh if setRefresher is not called', function() {
-    setup();
-    timeout.flush();
-    expect(ctrl.refresher).toBeFalsy();
-    spyOn(ctrl.scrollView, 'activatePullToRefresh');
-    expect(ctrl.scrollView.activatePullToRefresh).not.toHaveBeenCalled();
+    it('should not activatePullToRefresh if setRefresher is not called', function () {
+      setup();
+      timeout.flush();
+      expect(ctrl.refresher).toBeFalsy();
+      spyOn(ctrl.scrollView, 'activatePullToRefresh');
+      expect(ctrl.scrollView.activatePullToRefresh).not.toHaveBeenCalled();
+    });
   });
 
   it('should activatePullToRefresh and work when setRefresher', inject(function($compile) {
@@ -241,6 +276,7 @@ describe('$ionicScroll Controller', function() {
         hideCB,
         tailCB,
         onPullProgressCB;
+    nativeScrolling = false;
     setup({
       el: angular.element('<div><ion-refresher class="refresher"></ion-refresher></div>')[0]
     });
diff --git a/test/unit/angular/directive/infiniteScroll.unit.js b/test/unit/angular/directive/infiniteScroll.unit.js
index 6f8ac175b43..f9e9d95a444 100644
--- a/test/unit/angular/directive/infiniteScroll.unit.js
+++ b/test/unit/angular/directive/infiniteScroll.unit.js
@@ -33,7 +33,8 @@ describe('ionicInfiniteScroll directive', function() {
           resize: jasmine.createSpy('resize')
         },
         resize: jasmine.createSpy('resize'),
-        $element: angular.element('<div>')
+        $element: angular.element('<div>'),
+        isNative: function() {return false;}
       });
       $compile(element)(scope);
       ionic.requestAnimationFrame = function() {};
@@ -48,15 +49,18 @@ describe('ionicInfiniteScroll directive', function() {
     inject(function($rootScope, $compile, $document) {
       var scope = $rootScope.$new();
       angular.extend(scope, scopeProps || {});
-      parent = angular.element('<ion-content class="overflow-scroll"><ion-infinite-scroll ' + (attrs || '') +
-                               '></ion-infinite-scroll></ion-content></ion-content>');
+      parent = angular.element('<ion-content class="overflow-scroll" overflow-scroll="true">' +
+                               '<ion-infinite-scroll ' + (attrs || '') +
+                               '></ion-infinite-scroll></ion-content>');
       if (options && !!options.scrollingX) parent[0].style['overflow-x'] ='scroll';
       if (options && !!options.scrollingY) parent[0].style['overflow-y'] ='scroll';
-      element = parent.find('ion-infinite-scroll');
+
       ionic.animationFrameThrottle = function(cb) { return function() { cb(); }; };
-      $compile(element)(scope);
+      $compile(parent)(scope);
+      element = parent.find('ion-infinite-scroll');
       ionic.requestAnimationFrame = function() {};
       ctrl = element.controller('ionInfiniteScroll');
+
       // create a fake scrollEl since they can't be faked if we're passing in scroll data
       if (options) {
         ctrl.scrollEl = {style:{
diff --git a/test/unit/angular/directive/refresher.unit.js b/test/unit/angular/directive/refresher.unit.js
index 3ac5d3b9813..5ce266ae6f8 100644
--- a/test/unit/angular/directive/refresher.unit.js
+++ b/test/unit/angular/directive/refresher.unit.js
@@ -8,21 +8,19 @@ describe('ionRefresher directive', function() {
     var el;
     inject(function($compile, $rootScope) {
       var scope = $rootScope.$new();
-      var ionicScrollCtrl = {
-        _setRefresher: jasmine.createSpy('setRefresher'),
-        scrollView: {
-          finishPullToRefresh: jasmine.createSpy('finishPullToRefresh')
-        }
-      };
 
       angular.extend(scope, scopeProps || {});
 
-      el = angular.element('<ion-refresher '+(attrs||'')+'></ion-refresher>');
-      el.data('$$ionicScrollController', ionicScrollCtrl);
+      parent = angular.element('<ion-content><ion-refresher '+(attrs||'')+'>');
 
-      $compile(el)(scope);
+      //el.data('$$ionicScrollController', ionicScrollCtrl);
+
+      $compile(parent)(scope);
+      el = parent.find('.scroll-refresher');
       ionic.requestAnimationFrame = function() {};
       el.refresherCtrl = el.data('$ionRefresherController');
+      spyOn(el.controller('$ionicScroll'),'_setRefresher');
+
       $rootScope.$apply();
     });
     return el;
@@ -54,18 +52,15 @@ describe('ionRefresher directive', function() {
     expect(spyMe).toHaveBeenCalled();
   });
 
-  it('should setRefresher on scrollCtrl', function() {
-    var el = setup();
-    expect(el.controller('$ionicScroll')._setRefresher.callCount).toBe(1);
-    expect(el.controller('$ionicScroll')._setRefresher).toHaveBeenCalledWith(
-      el.scope(), el[0], el.refresherCtrl.getRefresherDomMethods()
-    );
-  });
-
   it('should listen for scroll.refreshComplete', function() {
+    // this is only for js scrolling
+    if (!jsScrollingEnabled) return;
+
     var el = setup();
     el.addClass('active');
     var ctrl = el.controller('$ionicScroll');
+    spyOn(ctrl.scrollView, 'finishPullToRefresh');
+
     expect(ctrl.scrollView.finishPullToRefresh).not.toHaveBeenCalled();
     el.scope().$broadcast('scroll.refreshComplete');
     expect(el.hasClass('active')).toBe(true);
diff --git a/test/unit/views/scrollViewNative.unit.js b/test/unit/views/scrollViewNative.unit.js
new file mode 100644
index 00000000000..1e1a3a7d296
--- /dev/null
+++ b/test/unit/views/scrollViewNative.unit.js
@@ -0,0 +1,38 @@
+describe('Scroll View', function() {
+  var sc;
+  beforeEach(function() {
+    sc = document.createElement('scroll-content');
+    s = document.createElement('scroll');
+    sc.appendChild(s);
+  });
+
+  it('Should init', function() {
+    var sv = new ionic.views.ScrollNative({
+      el: sc
+    });
+  });
+
+  it('Should bind to event listeners', function() {
+    spyOn(sc,'addEventListener');
+    var sv = new ionic.views.ScrollNative({
+      el: sc
+    });
+
+    expect(sc.addEventListener).toHaveBeenCalled();
+    expect(sc.addEventListener.callCount).toBe(4);
+    expect(sc.addEventListener.mostRecentCall.args[0]).toBe('resetScrollView');
+  });
+
+  it('Should remove event listeners on cleanup', function() {
+    spyOn(sc,'removeEventListener');
+    var sv = new ionic.views.ScrollNative({
+      el: sc
+    });
+    sv.__cleanup();
+
+    expect(sc.removeEventListener).toHaveBeenCalled();
+    expect(sc.removeEventListener.callCount).toBe(4);
+    expect(sc.removeEventListener.mostRecentCall.args[0]).toBe('resetScrollView');
+  });
+
+});