                     contentsLayer.contents = digitsImage.CGImage
                 #endif
             } else {
-                let contentsLayer = contentLayers[i]
+                let contentsLayer = contentLayers[contentLayersIndex]
+                
+                let needsVerticallyCenteredColon = needsVerticallyCenteredColonForCharacterAtIndex(charactersIndex, characters: text.characters)
+                let font = needsVerticallyCenteredColon ? self.font.verticallyCenteredColonFont : self.font
+                
+                let image = createImageForNonDigit(char, font: font)
+                
                 #if os(OSX)
-                    contentsLayer.contents = createImageForNonDigit(char)
+                    contentsLayer.contents = image
                 #elseif os(iOS) || os(tvOS)
-                    contentsLayer.contents = createImageForNonDigit(char).CGImage
+                    contentsLayer.contents = image.CGImage
                 #endif
             }
 
-            i++
-        }
-    }
-
+            contentLayersIndex++
+            charactersIndex++
+        }
+    }
+    
+    private func needsVerticallyCenteredColonForCharacterAtIndex(index:String.CharacterView.Index, characters:String.CharacterView) -> Bool {
+        guard characters[index] == ":" else { return false }
+        
+        if index != characters.startIndex {
+            let nextIndex = index.successor()
+            let prevIndex = index.predecessor()
+            if nextIndex != characters.endIndex {
+                let prevChar = String(characters[prevIndex])
+                let nextChar = String(characters[nextIndex])
+                
+                let prevCharIsDigit = Int(prevChar) != nil;
+                let nextCharIsDigit = Int(nextChar) != nil;
+
+                let isUpperCase = { (str:String) in str.uppercaseString == str && str.lowercaseString != str }
+                
+                if (prevCharIsDigit && nextCharIsDigit) ||
+                   (prevCharIsDigit && isUpperCase(nextChar)) ||
+                   (nextCharIsDigit && isUpperCase(prevChar)) {
+                    return true
+                }
+            }
+        }
+        
+        return false
+    }
+    
     private func relayoutScrollLayers() {
         let individualSize = digitsImageIndividualDigitSize
 
         var currentOrigin = CGPointZero
         var boundingSize = CGSizeZero
 
-        var i = 0
 
         let contentLayers = self.contentLayers
         var newLayers = [CALayer]()
 
-        for char in text.characters {
-            let currentLayer:CALayer? = (i < contentLayers.count) ? contentLayers[i] : nil
+        var contentLayersIndex = contentLayers.startIndex
+        var charactersIndex = text.characters.startIndex
+        
+        while charactersIndex < text.characters.endIndex {
+            let char = text.characters[charactersIndex]
+            let currentLayer:CALayer? = (contentLayersIndex < contentLayers.endIndex) ? contentLayers[contentLayersIndex] : nil
             if let _ = Int(String(char)) {
                 let scrollLayer:CALayer
                 if currentLayer?.valueForKey("myContents") as? String == "digits" {

    private var _digitsImage:TRZImage?
    public var digitsImage:TRZImage! {
        if (_digitsImage == nil) {
            _digitsImage = createDigitsImage()
        }
        return _digitsImage
    }

                    currentLayer?.removeFromSuperlayer()

                    charLayer = CALayer()
                    
                    let font = needsVerticallyCenteredColon ? self.font.verticallyCenteredColonFont : self.font
                    let image = createImageForNonDigit(char, font: font)
                    let imageSize = image.size
                    charLayer.setValue(String(char), forKey: "myContents")
                    charLayer.setValue(needsVerticallyCenteredColon, forKey: "verticallyCenteredColon")
                    
                    #if os(OSX)
                        charLayer.contents = image
                    #elseif os(iOS) || os(tvOS)
