diff --git a/AppKit/CPScrollView.j b/AppKit/CPScrollView.j
index ac042e3a2..269b73880 100644
--- a/AppKit/CPScrollView.j
+++ b/AppKit/CPScrollView.j
@@ -31,6 +31,7 @@
 @import "CPView.j"
 
 @class CPTableView
+@class CPRulerView
 
 #define SHOULD_SHOW_CORNER_VIEW() (_scrollerStyle === CPScrollerStyleLegacy && _verticalScroller && ![_verticalScroller isHidden])
 
@@ -140,6 +141,14 @@ var CPScrollerStyleGlobal                       = CPScrollerStyleOverlay,
 
     int                         _scrollerStyle;
     int                         _scrollerKnobStyle;
+
+    // Ruler Support
+    BOOL                        _hasVerticalRuler;
+    BOOL                        _hasHorizontalRuler;
+    BOOL                        _rulersVisible;
+
+    CPRulerView                 _verticalRuler;
+    CPRulerView                 _horizontalRuler;
 }
 
 
@@ -306,6 +315,10 @@ var CPScrollerStyleGlobal                       = CPScrollerStyleOverlay,
         _scrollerKnobStyle = CPScrollerKnobStyleDefault;
         [self setScrollerStyle:CPScrollerStyleGlobal];
 
+        _hasVerticalRuler = NO;
+        _hasHorizontalRuler = NO;
+        _rulersVisible = NO;
+
         _delegate = nil;
         _scrollTimer = nil;
         _implementedDelegateMethods = 0;
@@ -794,6 +807,103 @@ Notifies the delegate when the scroll view has finished scrolling.
 }
 
 
+#pragma mark -
+#pragma mark Rulers
+
+- (BOOL)hasHorizontalRuler
+{
+    return _hasHorizontalRuler;
+}
+
+- (void)setHasHorizontalRuler:(BOOL)shouldHaveHorizontalRuler
+{
+    if (_hasHorizontalRuler === shouldHaveHorizontalRuler)
+        return;
+
+    _hasHorizontalRuler = shouldHaveHorizontalRuler;
+
+    if (_hasHorizontalRuler && !_horizontalRuler)
+    {
+        _horizontalRuler = [[CPRulerView alloc] initWithScrollView:self orientation:CPHorizontalRuler];
+    }
+
+    [self tile];
+}
+
+- (BOOL)hasVerticalRuler
+{
+    return _hasVerticalRuler;
+}
+
+- (void)setHasVerticalRuler:(BOOL)shouldHaveVerticalRuler
+{
+    if (_hasVerticalRuler === shouldHaveVerticalRuler)
+        return;
+
+    _hasVerticalRuler = shouldHaveVerticalRuler;
+
+    if (_hasVerticalRuler && !_verticalRuler)
+    {
+        _verticalRuler = [[CPRulerView alloc] initWithScrollView:self orientation:CPVerticalRuler];
+    }
+
+    [self tile];
+}
+
+- (BOOL)rulersVisible
+{
+    return _rulersVisible;
+}
+
+- (void)setRulersVisible:(BOOL)areRulersVisible
+{
+    if (_rulersVisible === areRulersVisible)
+        return;
+
+    _rulersVisible = areRulersVisible;
+
+    [self tile];
+}
+
+- (CPRulerView)horizontalRulerView
+{
+    return _horizontalRuler;
+}
+
+- (void)setHorizontalRulerView:(CPRulerView)aRulerView
+{
+    if (_horizontalRuler === aRulerView)
+        return;
+
+    [_horizontalRuler removeFromSuperview];
+    _horizontalRuler = aRulerView;
+
+    if (_horizontalRuler)
+        [self addSubview:_horizontalRuler];
+
+    [self tile];
+}
+
+- (CPRulerView)verticalRulerView
+{
+    return _verticalRuler;
+}
+
+- (void)setVerticalRulerView:(CPRulerView)aRulerView
+{
+    if (_verticalRuler === aRulerView)
+        return;
+
+    [_verticalRuler removeFromSuperview];
+    _verticalRuler = aRulerView;
+
+    if (_verticalRuler)
+        [self addSubview:_verticalRuler];
+
+    [self tile];
+}
+
+
 #pragma mark -
 #pragma mark Privates
 
@@ -1123,10 +1233,7 @@ Notifies the delegate when the scroll view has finished scrolling.
 */
 - (void)tile
 {
-    // yuck.
-    // RESIZE: tile->setHidden AND refl
-    // Outside Change: refl->tile->setHidden AND refl
-    // scroll: refl.
+    [self reflectScrolledClipView:_contentView];
 }
 
 /*!
@@ -1170,6 +1277,41 @@ Notifies the delegate when the scroll view has finished scrolling.
     contentFrame.origin.y += headerClipViewHeight;
     contentFrame.size.height -= headerClipViewHeight;
 
+    // Adjust content view based on horizontal / vertical ruler presence
+    var showHorizontalRuler = _rulersVisible && _hasHorizontalRuler && _horizontalRuler,
+        showVerticalRuler = _rulersVisible && _hasVerticalRuler && _verticalRuler;
+
+    var horizRulerThickness = showHorizontalRuler ? ([_horizontalRuler respondsToSelector:@selector(ruleThickness)] ? [_horizontalRuler ruleThickness] : 16.0) : 0.0,
+        vertRulerThickness = showVerticalRuler ? ([_verticalRuler respondsToSelector:@selector(ruleThickness)] ? [_verticalRuler ruleThickness] : 24.0) : 0.0;
+
+    if (showHorizontalRuler)
+    {
+        if ([_horizontalRuler superview] !== self)
+            [self addSubview:_horizontalRuler];
+        [_horizontalRuler setHidden:NO];
+    }
+    else if (_horizontalRuler)
+    {
+        [_horizontalRuler setHidden:YES];
+    }
+
+    if (showVerticalRuler)
+    {
+        if ([_verticalRuler superview] !== self)
+            [self addSubview:_verticalRuler];
+        [_verticalRuler setHidden:NO];
+    }
+    else if (_verticalRuler)
+    {
+        [_verticalRuler setHidden:YES];
+    }
+
+    contentFrame.origin.y += horizRulerThickness;
+    contentFrame.size.height -= horizRulerThickness;
+
+    contentFrame.origin.x += vertRulerThickness;
+    contentFrame.size.width -= vertRulerThickness;
+
     var difference = CGSizeMake(CGRectGetWidth(documentFrame) - CGRectGetWidth(contentFrame), CGRectGetHeight(documentFrame) - CGRectGetHeight(contentFrame)),
         verticalScrollerWidth = [_verticalScroller scrollerWidth],
         horizontalScrollerHeight = [_horizontalScroller scrollerWidth],
@@ -1262,6 +1404,7 @@ Notifies the delegate when the scroll view has finished scrolling.
     [_contentView setFrame:contentFrame];
     [_headerClipView setFrame:[self _headerClipViewFrame]];
     [[_headerClipView documentView] setNeedsDisplay:YES];
+    
     if (SHOULD_SHOW_CORNER_VIEW())
     {
         [_cornerView setFrame:[self _cornerViewFrame]];
@@ -1276,6 +1419,29 @@ Notifies the delegate when the scroll view has finished scrolling.
         [[self bottomCornerView] setBackgroundColor:[self currentValueForThemeAttribute:@"bottom-corner-color"]];
     }
 
+    // Position and redraw rulers to track viewport updates
+    if (showHorizontalRuler)
+    {
+        [_horizontalRuler setFrame:CGRectMake(
+            CGRectGetMinX(contentFrame), 
+            CGRectGetMinY(contentFrame) - horizRulerThickness, 
+            CGRectGetWidth(contentFrame), 
+            horizRulerThickness
+        )];
+        [_horizontalRuler setNeedsDisplay:YES];
+    }
+
+    if (showVerticalRuler)
+    {
+        [_verticalRuler setFrame:CGRectMake(
+            CGRectGetMinX(contentFrame) - vertRulerThickness, 
+            CGRectGetMinY(contentFrame), 
+            vertRulerThickness, 
+            CGRectGetHeight(contentFrame)
+        )];
+        [_verticalRuler setNeedsDisplay:YES];
+    }
+
     --_recursionCount;
 }
 
@@ -1438,8 +1604,8 @@ Notifies the delegate when the scroll view has finished scrolling.
 
     y = maxY - 1.5;
 
-    CGContextMoveToPoint(context, maxX - 1.0, y);
-    CGContextAddLineToPoint(context, minX + 2.0, y);
+    CGContextMoveToPoint(maxX - 1.0, y);
+    CGContextAddLineToPoint(minX + 2.0, y);
 
     x = minX + 0.5;
 
@@ -1618,7 +1784,14 @@ var CPScrollViewContentViewKey          = @"CPScrollViewContentView",
     CPScrollViewBottomCornerViewKey     = @"CPScrollViewBottomCornerViewKey",
     CPScrollViewBorderTypeKey           = @"CPScrollViewBorderTypeKey",
     CPScrollViewScrollerStyleKey        = @"CPScrollViewScrollerStyleKey",
-    CPScrollViewScrollerKnobStyleKey    = @"CPScrollViewScrollerKnobStyleKey";
+    CPScrollViewScrollerKnobStyleKey    = @"CPScrollViewScrollerKnobStyleKey",
+
+    // Ruler Coding Keys
+    CPScrollViewHasVRulerKey            = @"CPScrollViewHasVRuler",
+    CPScrollViewHasHRulerKey            = @"CPScrollViewHasHRuler",
+    CPScrollViewRulersVisibleKey        = @"CPScrollViewRulersVisible",
+    CPScrollViewVRulerKey               = @"CPScrollViewVRuler",
+    CPScrollViewHRulerKey               = @"CPScrollViewHRuler";
 
 @implementation CPScrollView (CPCoding)
 
@@ -1653,6 +1826,14 @@ var CPScrollViewContentViewKey          = @"CPScrollViewContentView",
         _cornerView             = [aCoder decodeObjectForKey:CPScrollViewCornerViewKey];
         _bottomCornerView       = [aCoder decodeObjectForKey:CPScrollViewBottomCornerViewKey];
 
+        // Ruler decoding
+        _hasVerticalRuler       = [aCoder decodeBoolForKey:CPScrollViewHasVRulerKey];
+        _hasHorizontalRuler     = [aCoder decodeBoolForKey:CPScrollViewHasHRulerKey];
+        _rulersVisible          = [aCoder decodeBoolForKey:CPScrollViewRulersVisibleKey];
+
+        _verticalRuler          = [aCoder decodeObjectForKey:CPScrollViewVRulerKey];
+        _horizontalRuler        = [aCoder decodeObjectForKey:CPScrollViewHRulerKey];
+
         _delegate = nil;
         _scrollTimer = nil;
         _implementedDelegateMethods = 0;
@@ -1706,6 +1887,14 @@ var CPScrollViewContentViewKey          = @"CPScrollViewContentView",
 
     [aCoder encodeInt:_scrollerStyle            forKey:CPScrollViewScrollerStyleKey];
     [aCoder encodeInt:_scrollerKnobStyle        forKey:CPScrollViewScrollerKnobStyleKey];
+
+    // Ruler encoding
+    [aCoder encodeBool:_hasVerticalRuler        forKey:CPScrollViewHasVRulerKey];
+    [aCoder encodeBool:_hasHorizontalRuler      forKey:CPScrollViewHasHRulerKey];
+    [aCoder encodeBool:_rulersVisible           forKey:CPScrollViewRulersVisibleKey];
+
+    [aCoder encodeObject:_verticalRuler         forKey:CPScrollViewVRulerKey];
+    [aCoder encodeObject:_horizontalRuler       forKey:CPScrollViewHRulerKey];
 }
 
 @end