 
 public extension CGPoint {
     /// Creates a point with coordinates specified as integer values.
-    @inlinable
-    init<T: BinaryInteger>(_ x: T, _ y: T) {
-        self.init(x: CGFloat(x), y: CGFloat(y))
+    @inlinable init<T: BinaryInteger>(_ x: T, _ y: T) {
+        self.init(x: x.cgFloat, y: y.cgFloat)
     }
     
     /// Creates a point with coordinates specified as floating-point values.
-    @inlinable
-    init<T: BinaryFloatingPoint>(_ x: T, _ y: T) {
-        self.init(x: CGFloat(x), y: CGFloat(y))
+    @inlinable init<T: BinaryFloatingPoint>(_ x: T, _ y: T) {
+        self.init(x: x.cgFloat, y: y.cgFloat)
+    }
+    
+    /// Creates a point with coordinates specified as floating-point values.
+    @inlinable init(_ x: CGFloat, _ y: CGFloat) {
+        self.init(x: x, y: y)
+    }
+}
+
+public extension CGPoint {
+    
+    /// The receiver's SIMD representation.
+    @inlinable var simd2: SIMD2<CGFloat.NativeType> {
+        get { .init(x.native, y.native) }
+        set { (x, y) = (newValue.x.cgFloat, newValue.y.cgFloat) }
+    }
+    
+    @inlinable init(simd2: SIMD2<CGFloat.NativeType>) {
+        self.init()
+        
+        self.x.native = simd2.x
+        self.y.native = simd2.y
     }
 }
 
 public extension CGPoint {
     /// Returns the vector that exists between `self` and `p2`.
-    @inlinable
-    func formVector(with p2: CGPoint) -> CGVector {
-        CGVector(dx: p2.x - self.x, dy: p2.y - self.y)
+    @inlinable func formVector(with p2: CGPoint) -> CGVector {
+        .init(simd2: p2.simd2 - simd2)
     }
     
     /// Returns a copy of `self` translated along the given vector.
-    @inlinable
-    func translated(along vector: CGVector) -> CGPoint {
-        CGPoint(x: self.x + vector.dx, y: self.y + vector.dy)
+    @inlinable func translated(along vector: CGVector) -> CGPoint {
+        .init(simd2: simd2 + vector.simd2)
     }
     
     /// Returns a copy of `self` translated by `tx` on the X-axis and by `ty` on the Y-axis.
-    @inlinable
-    func translated<I: BinaryInteger>(tx: I, ty: I) -> CGPoint {
-        CGPoint(x: self.x + CGFloat(tx), y: self.y + CGFloat(ty))
+    @inlinable func translated<I: BinaryInteger>(tx: I, ty: I) -> CGPoint {
+        .init(simd2: simd2 + .init(tx.native, ty.native))
     }
     
     /// Returns a copy of `self` translated by `tx` on the X-axis and by `ty` on the Y-axis.
-    @inlinable
-    func translated<F: BinaryFloatingPoint>(tx: F, ty: F) -> CGPoint {
-        CGPoint(x: self.x + CGFloat(tx), y: self.y + CGFloat(ty))
+    @inlinable func translated<F: BinaryFloatingPoint>(tx: F, ty: F) -> CGPoint {
+        .init(simd2: simd2 + .init(tx.native, ty.native))
     }
     
     /// Returns a copy of `self` translated by `tx` on the X-axis and by `ty` on the Y-axis.
-    @inlinable
-    func translated(tx: CGFloat, ty: CGFloat) -> CGPoint {
-        CGPoint(x: self.x + tx, y: self.y + ty)
-    }
-    
+    @inlinable func translated(tx: CGFloat.NativeType, ty: CGFloat.NativeType) -> CGPoint {
+        .init(simd2: simd2 + .init(tx, ty))
+    }
+    
+    /// FIXME: deprecated.
     /// Translates `self` along the given vector.
-    @inlinable
-    mutating func translate(by vector: CGVector) {
-        self = self.translated(along: vector)
+    @inlinable mutating func translate(by vector: CGVector) {
+        simd2 += vector.simd2
+    }
+    
+    /// Translates `self` along the given vector.
+    @inlinable mutating func translate(along vector: CGVector) {
+        simd2 += vector.simd2
     }
     
     /// Translates `self` by `tx` on the X-axis and by `ty` on the Y-axis.
-    @inlinable
-    mutating func translate<I: BinaryInteger>(tx: I, ty: I) {
-        self = self.translated(tx: tx, ty: ty)
+    @inlinable mutating func translate<I: BinaryInteger>(tx: I, ty: I) {
+        simd2 += .init(tx.native, ty.native)
     }
     
     /// Translates `self` by `tx` on the X-axis and by `ty` on the Y-axis.
-    @inlinable
-    mutating func translate<F: BinaryFloatingPoint>(tx: F, ty: F) {
-        self = self.translated(tx: tx, ty: ty)
+    @inlinable mutating func translate<F: BinaryFloatingPoint>(tx: F, ty: F) {
+        simd2 += .init(tx.native, ty.native)
     }
     
     /// Translates `self` by `tx` on the X-axis and by `ty` on the Y-axis.
-    @inlinable
-    mutating func translate(tx: CGFloat, ty: CGFloat) {
-        self = self.translated(tx: tx, ty: ty)
+    @inlinable mutating func translate(tx: CGFloat.NativeType, ty: CGFloat.NativeType) {
+        simd2 += .init(tx, ty)
     }
     
     /// Returns a copy of `self` rotated around the given center by the given angle.
     ///
     /// - note: Rotates clockwise on iOS and counter-clockwise on OS X.
-    @inlinable
-    func rotated(relativeTo center: CGPoint, by angle: CGFloat) -> CGPoint {
+    @inlinable func rotated(relativeTo center: CGPoint, by angle: CGFloat) -> CGPoint {
         var transform = CGAffineTransform(translationX: center.x, y: center.y)
         transform = transform.rotated(by: angle)
         transform = transform.translatedBy(x: -center.x, y: -center.y)
-        return self.applying(transform)
+        return applying(transform)
     }
     
     /// Rotates `self` around the givent center by the given angle.
     ///
     /// - note: Rotates clockwise on iOS and counter-clockwise on OS X.
-    @inlinable
-    mutating func rotate(relativeTo center: CGPoint, by angle: CGFloat) {
+    @inlinable mutating func rotate(relativeTo center: CGPoint, by angle: CGFloat) {
         self = self.rotated(relativeTo: center, by: angle)
     }
 }

    ///   - lhs: A point to devide.
    ///   - rhs: Another point the devide.
    @inlinable
    static func /(lhs: CGPoint, rhs: CGPoint) -> CGPoint {
        CGPoint(x: lhs.x / rhs.x, y: lhs.y / rhs.y)
    }
}

extension CGPoint: AdditiveArithmetic {
    @inlinable
    public static func +(lhs: CGPoint, rhs: CGPoint) -> CGPoint {
        return CGPoint(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
    }
    
    @inlinable
    public static func -(lhs: CGPoint, rhs: CGPoint) -> CGPoint {
        return CGPoint(x: lhs.x - rhs.x, y: lhs.y - rhs.y)
    }
}

    ///   - lhs: The point to divide components.
    ///   - rhs: The value to devide by.
    @inlinable
    static func / <I: BinaryInteger>(lhs: CGPoint, rhs: I) -> CGPoint {
        .init(simd2: lhs.simd2 / rhs.native)
    }
    
    /// Divides `x` and `y` by the given value and returns the resulting `CGPoint`.
