diff --git a/Foundation/CharacterSet.swift b/Foundation/CharacterSet.swift
index 33b90b3..06614ab 100644
--- a/Foundation/CharacterSet.swift
+++ b/Foundation/CharacterSet.swift
@@ -122,7 +122,7 @@
     ///
     /// It is the caller's responsibility to ensure that the values represent valid `UnicodeScalar` values, if that is what is desired.
     public init(charactersIn range: ClosedRange<UnicodeScalar>) {
-        let halfOpenRange = range.lowerBound..<UnicodeScalar(range.upperBound.value + 1)
+        let halfOpenRange = range.lowerBound..<UnicodeScalar(range.upperBound.value + 1)!
         _wrapped = _SwiftNSCharacterSet(immutableObject: NSCharacterSet(range: _utfRangeToNSRange(halfOpenRange)))
     }
     
@@ -313,7 +313,7 @@
     ///
     /// It is the caller's responsibility to ensure that the values represent valid `UnicodeScalar` values, if that is what is desired.
     public mutating func insert(charactersIn range: ClosedRange<UnicodeScalar>) {
-        let halfOpenRange = range.lowerBound..<UnicodeScalar(range.upperBound.value + 1)
+        let halfOpenRange = range.lowerBound..<UnicodeScalar(range.upperBound.value + 1)!
         let nsRange = _utfRangeToNSRange(halfOpenRange)
         _applyUnmanagedMutation {
             $0.addCharacters(in: nsRange)
@@ -330,7 +330,7 @@
     
     /// Remove a closed range of integer values from the `CharacterSet`.
     public mutating func remove(charactersIn range: ClosedRange<UnicodeScalar>) {
-        let halfOpenRange = range.lowerBound..<UnicodeScalar(range.upperBound.value + 1)
+        let halfOpenRange = range.lowerBound..<UnicodeScalar(range.upperBound.value + 1)!
         let nsRange = _utfRangeToNSRange(halfOpenRange)
         _applyUnmanagedMutation {
             $0.removeCharacters(in: nsRange)
@@ -488,6 +488,6 @@
 
 extension CharacterSet {
     public func contains(_ member: unichar) -> Bool {
-        return contains(UnicodeScalar(member))
+        return contains(UnicodeScalar(member)!)
     }
 }
diff --git a/Foundation/Data.swift b/Foundation/Data.swift
index 9cb570f..284250b 100644
--- a/Foundation/Data.swift
+++ b/Foundation/Data.swift
@@ -16,11 +16,11 @@
 import Glibc
 #endif
 
-internal func __NSDataInvokeDeallocatorUnmap(_ mem: UnsafeMutablePointer<Void>, _ length: Int) -> Void {
+internal func __NSDataInvokeDeallocatorUnmap(_ mem: UnsafeMutableRawPointer, _ length: Int) -> Void {
     munmap(mem, length)
 }
 
-internal func __NSDataInvokeDeallocatorFree(_ mem: UnsafeMutablePointer<Void>, _ length: Int) -> Void {
+internal func __NSDataInvokeDeallocatorFree(_ mem: UnsafeMutableRawPointer, _ length: Int) -> Void {
     free(mem)
 }
 
@@ -34,14 +34,14 @@
         // Take ownership.
         __wrapped = .Immutable(Unmanaged.passRetained(_unsafeReferenceCast(immutableObject, to: ImmutableType.self)))
         
-        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutablePointer<Void>.self)
+        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutableRawPointer.self)
         super.init(bytes: dummyPointer, length: 0, copy: false, deallocator: nil)
     }
     
     init(mutableObject: AnyObject) {
         // Take ownership.
         __wrapped = .Mutable(Unmanaged.passRetained(_unsafeReferenceCast(mutableObject, to: MutableType.self)))
-        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutablePointer<Void>.self)
+        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutableRawPointer.self)
         super.init(bytes: dummyPointer, length: 0, copy: false, deallocator: nil)
     }
     
@@ -49,7 +49,7 @@
         // Take ownership.
         __wrapped = .Immutable(unmanagedImmutableObject)
         
-        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutablePointer<Void>.self)
+        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutableRawPointer.self)
         super.init(bytes: dummyPointer, length: 0, copy: false, deallocator: nil)
     }
     
@@ -57,7 +57,7 @@
         // Take ownership.
         __wrapped = .Mutable(unmanagedMutableObject)
         
-        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutablePointer<Void>.self)
+        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutableRawPointer.self)
         super.init(bytes: dummyPointer, length: 0, copy: false, deallocator: nil)
     }
     
@@ -82,7 +82,7 @@
         }
     }
     
-    override var bytes : UnsafePointer<Void> {
+    override var bytes : UnsafeRawPointer {
         return _mapUnmanaged { $0.bytes }
     }
     
@@ -90,11 +90,11 @@
 //        return _mapUnmanaged { $0.subdata(with: range) }
 //    }
 //    
-//    override func getBytes(_ buffer: UnsafeMutablePointer<Void>, length: Int) {
+//    override func getBytes(_ buffer: UnsafeMutableRawPointer, length: Int) {
 //        return _mapUnmanaged { $0.getBytes(buffer, length: length) }
 //    }
 //    
-//    override func getBytes(_ buffer: UnsafeMutablePointer<Void>, range: NSRange) {
+//    override func getBytes(_ buffer: UnsafeMutableRawPointer, range: NSRange) {
 //        return _mapUnmanaged { $0.getBytes(buffer, range: range) }
 //    }
 //    
@@ -112,7 +112,7 @@
 //        }
 //    }
 //    
-//    override func enumerateByteRanges(using block: @noescape (UnsafePointer<Void>, NSRange, UnsafeMutablePointer<ObjCBool>) -> Void) {
+//    override func enumerateByteRanges(using block: @noescape (UnsafeRawPointer, NSRange, UnsafeMutablePointer<ObjCBool>) -> Void) {
 //        return _mapUnmanaged { $0.enumerateBytes(block) }
 //    }
 //    
@@ -163,7 +163,7 @@
         /// A custom deallocator.
         case custom((UnsafeMutablePointer<UInt8>, Int) -> Void)
         
-        fileprivate var _deallocator : ((UnsafeMutablePointer<Void>, Int) -> Void)? {
+        fileprivate var _deallocator : ((UnsafeMutableRawPointer, Int) -> Void)? {
             switch self {
             case .unmap:
                 return { __NSDataInvokeDeallocatorUnmap($0, $1) }
@@ -173,7 +173,8 @@
                 return nil
             case .custom(let b):
                 return { (ptr, len) in
-                    b(UnsafeMutablePointer<UInt8>(ptr), len)
+                    let bytePtr = ptr.bindMemory(to: UInt8.self, capacity: len)
+                    b(bytePtr, len)
                 }
             }
         }
@@ -186,7 +187,7 @@
     ///
     /// - parameter bytes: A pointer to the memory. It will be copied.
     /// - parameter count: The number of bytes to copy.
-    public init(bytes: UnsafePointer<Void>, count: Int) {
+    public init(bytes: UnsafeRawPointer, count: Int) {
         _wrapped = _SwiftNSData(immutableObject: NSData(bytes: bytes, length: count))
     }
     
@@ -279,8 +280,8 @@
     }
 
     public init?(count: Int) {
-        if let memory = malloc(count) {
-            self.init(bytesNoCopy: UnsafeMutablePointer<UInt8>(memory), count: count, deallocator: .free)
+        if let memory = malloc(count)?.bindMemory(to: UInt8.self, capacity: count) {
+            self.init(bytesNoCopy: memory, count: count, deallocator: .free)
         } else {
             return nil
         }
@@ -304,7 +305,7 @@
         }
     }
     
-    private func _getUnsafeBytesPointer() -> UnsafePointer<Void> {
+    private func _getUnsafeBytesPointer() -> UnsafeRawPointer {
         return _mapUnmanaged { return $0.bytes }
     }
     
@@ -314,10 +315,11 @@
     public func withUnsafeBytes<ResultType, ContentType>(_ body: @noescape (UnsafePointer<ContentType>) throws -> ResultType) rethrows -> ResultType {
         let bytes =  _getUnsafeBytesPointer()
         defer { _fixLifetime(self)}
-        return try body(UnsafePointer(bytes))
+        let contentPtr = bytes.bindMemory(to: ContentType.self, capacity: count / strideof(ContentType.self))
+        return try body(contentPtr)
     }
     
-    private mutating func _getUnsafeMutableBytesPointer() -> UnsafeMutablePointer<Void> {
+    private mutating func _getUnsafeMutableBytesPointer() -> UnsafeMutableRawPointer {
         return _applyUnmanagedMutation {
             return $0.mutableBytes
         }
@@ -330,7 +332,8 @@
     public mutating func withUnsafeMutableBytes<ResultType, ContentType>(_ body: @noescape (UnsafeMutablePointer<ContentType>) throws -> ResultType) rethrows -> ResultType {
         let mutableBytes = _getUnsafeMutableBytesPointer()
         defer { _fixLifetime(self)}
-        return try body(UnsafeMutablePointer(mutableBytes))
+        let contentPtr = mutableBytes.bindMemory(to: ContentType.self, capacity: count / strideof(ContentType.self))
+        return try body(contentPtr)
     }
     
     // MARK: -
@@ -437,7 +440,8 @@
         _mapUnmanaged {
             $0.enumerateBytes { (ptr, range, stop) in
                 var stopv = false
-                block(buffer: UnsafeBufferPointer(start: UnsafePointer<UInt8>(ptr), count: range.length), byteIndex: range.length, stop: &stopv)
+                let bytePtr = ptr.bindMemory(to: UInt8.self, capacity: range.length)
+                block(buffer: UnsafeBufferPointer(start: bytePtr, count: range.length), byteIndex: range.length, stop: &stopv)
                 if stopv {
                     stop.pointee = true
                 }
diff --git a/Foundation/DateInterval.swift b/Foundation/DateInterval.swift
index cca4a58..9b06117 100644
--- a/Foundation/DateInterval.swift
+++ b/Foundation/DateInterval.swift
@@ -155,7 +155,7 @@
     
     public var hashValue: Int {
         var buf: (UInt, UInt) = (UInt(start.timeIntervalSinceReferenceDate), UInt(end.timeIntervalSinceReferenceDate))
-        return withUnsafeMutablePointer(&buf) {
+        return withUnsafeMutablePointer(to: &buf) {
             return Int(bitPattern: CFHashBytes(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self), CFIndex(sizeof(UInt.self) * 2)))
         }
     }
diff --git a/Foundation/IndexPath.swift b/Foundation/IndexPath.swift
index b88fb14..b9e357f 100644
--- a/Foundation/IndexPath.swift
+++ b/Foundation/IndexPath.swift
@@ -158,7 +158,7 @@
         if count == 0 {
             _indexes = []
         } else {
-            var ptr = UnsafeMutablePointer<Element>(malloc(count * sizeof(Element.self)))
+            var ptr = malloc(count * sizeof(Element.self))?.bindMemory(to: Element.self, capacity: count * sizeof(Element.self))
             defer { free(ptr) }
             
             nsIndexPath.getIndexes(ptr!, range: NSMakeRange(0, count))
diff --git a/Foundation/NSArray.swift b/Foundation/NSArray.swift
index 12636b3..b288af7 100644
--- a/Foundation/NSArray.swift
+++ b/Foundation/NSArray.swift
@@ -69,8 +69,8 @@
             // We're stuck with (int) here (rather than unsigned int)
             // because that's the way the code was originally written, unless
             // we go to a new version of the class, which has its own problems.
-            withUnsafeMutablePointer(&cnt) { (ptr: UnsafeMutablePointer<UInt32>) -> Void in
-                aDecoder.decodeValue(ofObjCType: "i", at: UnsafeMutablePointer<Void>(ptr))
+            withUnsafeMutablePointer(to: &cnt) { (ptr: UnsafeMutablePointer<UInt32>) -> Void in
+                aDecoder.decodeValue(ofObjCType: "i", at: UnsafeMutableRawPointer(ptr))
             }
             let objects = UnsafeMutablePointer<AnyObject?>.allocate(capacity: Int(cnt))
             for idx in 0..<cnt {
@@ -166,7 +166,7 @@
     }
 
     public override func isEqual(_ object: AnyObject?) -> Bool {
-        guard let otherObject = object where otherObject is NSArray else {
+        guard let otherObject = object, otherObject is NSArray else {
             return false
         }
         let otherArray = otherObject as! NSArray
@@ -388,13 +388,13 @@
         }))
     }
     
-    public func sortedArray(_ comparator: @noescape @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Swift.Void>?) -> Int, context: UnsafeMutablePointer<Swift.Void>?) -> [AnyObject] {
+    public func sortedArray(_ comparator: @noescape @convention(c) (AnyObject, AnyObject, UnsafeMutableRawPointer?) -> Int, context: UnsafeMutableRawPointer?) -> [AnyObject] {
         return sortedArray([]) { lhs, rhs in
             return ComparisonResult(rawValue: comparator(lhs, rhs, context))!
         }
     }
     
-    public func sortedArray(_ comparator: @noescape @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Swift.Void>?) -> Int, context: UnsafeMutablePointer<Swift.Void>?, hint: Data?) -> [AnyObject] {
+    public func sortedArray(_ comparator: @noescape @convention(c) (AnyObject, AnyObject, UnsafeMutableRawPointer?) -> Int, context: UnsafeMutableRawPointer?, hint: Data?) -> [AnyObject] {
         return sortedArray([]) { lhs, rhs in
             return ComparisonResult(rawValue: comparator(lhs, rhs, context))!
         }
@@ -834,7 +834,7 @@
         }
     }
 
-    public func sortUsingFunction(_ compare: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>?) -> Int, context: UnsafeMutablePointer<Void>?) {
+    public func sortUsingFunction(_ compare: @convention(c) (AnyObject, AnyObject, UnsafeMutableRawPointer?) -> Int, context: UnsafeMutableRawPointer?) {
         self.setArray(self.sortedArray(compare, context: context))
     }
 
diff --git a/Foundation/NSAttributedString.swift b/Foundation/NSAttributedString.swift
index fdadfbc..12224d4 100644
--- a/Foundation/NSAttributedString.swift
+++ b/Foundation/NSAttributedString.swift
@@ -111,15 +111,15 @@
 }
 
 private extension AttributedString {
-    fileprivate struct RangeInfo {
+    struct RangeInfo {
         let rangePointer: NSRangePointer
         let shouldFetchLongestEffectiveRange: Bool
         let longestEffectiveRangeSearchRange: NSRange?
     }
     
-    fileprivate func _attributesAtIndex(_ location: Int, rangeInfo: RangeInfo) -> [String : AnyObject] {
+    func _attributesAtIndex(_ location: Int, rangeInfo: RangeInfo) -> [String : AnyObject] {
         var cfRange = CFRange()
-        return withUnsafeMutablePointer(&cfRange) { (cfRangePointer: UnsafeMutablePointer<CFRange>) -> [String : AnyObject] in
+        return withUnsafeMutablePointer(to: &cfRange) { (cfRangePointer: UnsafeMutablePointer<CFRange>) -> [String : AnyObject] in
             // Get attributes value using CoreFoundation function
             let value: CFDictionary
             if rangeInfo.shouldFetchLongestEffectiveRange, let searchRange = rangeInfo.longestEffectiveRangeSearchRange {
@@ -147,9 +147,9 @@
         }
     }
     
-    fileprivate func _attribute(_ attrName: String, atIndex location: Int, rangeInfo: RangeInfo) -> AnyObject? {
+    func _attribute(_ attrName: String, atIndex location: Int, rangeInfo: RangeInfo) -> AnyObject? {
         var cfRange = CFRange()
-        return withUnsafeMutablePointer(&cfRange) { (cfRangePointer: UnsafeMutablePointer<CFRange>) -> AnyObject? in
+        return withUnsafeMutablePointer(to: &cfRange) { (cfRangePointer: UnsafeMutablePointer<CFRange>) -> AnyObject? in
             // Get attribute value using CoreFoundation function
             let attribute: AnyObject?
             if rangeInfo.shouldFetchLongestEffectiveRange, let searchRange = rangeInfo.longestEffectiveRangeSearchRange {
@@ -171,7 +171,7 @@
         }
     }
     
-    fileprivate func addAttributesToAttributeArray(attrs: [String : AnyObject]?) {
+    func addAttributesToAttributeArray(attrs: [String : AnyObject]?) {
         guard _string.length > 0 else {
             return
         }
diff --git a/Foundation/NSBundle.swift b/Foundation/NSBundle.swift
index 4f57c42..bae4e3d 100644
--- a/Foundation/NSBundle.swift
+++ b/Foundation/NSBundle.swift
@@ -78,7 +78,7 @@
     
     public func preflight() throws {
         var unmanagedError:Unmanaged<CFError>? = nil
-        try withUnsafeMutablePointer(&unmanagedError) { (unmanagedCFError: UnsafeMutablePointer<Unmanaged<CFError>?>)  in
+        try withUnsafeMutablePointer(to: &unmanagedError) { (unmanagedCFError: UnsafeMutablePointer<Unmanaged<CFError>?>)  in
             CFBundlePreflightExecutable(_bundle, unmanagedCFError)
             if let error = unmanagedCFError.pointee {
                 throw   error.takeRetainedValue()._nsObject
@@ -88,7 +88,7 @@
     
     public func loadAndReturnError() throws {
         var unmanagedError:Unmanaged<CFError>? = nil
-        try  withUnsafeMutablePointer(&unmanagedError) { (unmanagedCFError: UnsafeMutablePointer<Unmanaged<CFError>?>)  in
+        try  withUnsafeMutablePointer(to: &unmanagedError) { (unmanagedCFError: UnsafeMutablePointer<Unmanaged<CFError>?>)  in
             CFBundleLoadExecutableAndReturnError(_bundle, unmanagedCFError)
             if let error = unmanagedCFError.pointee {
                 let retainedValue = error.takeRetainedValue()
diff --git a/Foundation/NSCFArray.swift b/Foundation/NSCFArray.swift
index 6e166a4..9734a45 100644
--- a/Foundation/NSCFArray.swift
+++ b/Foundation/NSCFArray.swift
@@ -34,7 +34,7 @@
     }
     
     override func insert(_ anObject: AnyObject, at index: Int) {
-        CFArrayInsertValueAtIndex(_cfMutableObject, index, unsafeBitCast(anObject, to: UnsafePointer<Void>.self))
+        CFArrayInsertValueAtIndex(_cfMutableObject, index, unsafeBitCast(anObject, to: UnsafeRawPointer.self))
     }
     
     override func removeObject(at index: Int) {
diff --git a/Foundation/NSCFDictionary.swift b/Foundation/NSCFDictionary.swift
index ed3ac3f..af24b86 100644
--- a/Foundation/NSCFDictionary.swift
+++ b/Foundation/NSCFDictionary.swift
@@ -37,7 +37,7 @@
     }
     
     override func objectForKey(_ aKey: AnyObject) -> AnyObject? {
-        let value = CFDictionaryGetValue(_cfObject, unsafeBitCast(aKey, to: UnsafePointer<Void>.self))
+        let value = CFDictionaryGetValue(_cfObject, unsafeBitCast(aKey, to: UnsafeRawPointer.self))
         if value != nil {
             return unsafeBitCast(value, to: AnyObject.self)
         } else {
@@ -64,7 +64,7 @@
             let cf = dict._cfObject
             count = CFDictionaryGetCount(cf)
             
-            let keys = UnsafeMutablePointer<UnsafePointer<Void>?>.allocate(capacity: count)            
+            let keys = UnsafeMutablePointer<UnsafeRawPointer?>.allocate(capacity: count)            
             CFDictionaryGetKeysAndValues(cf, keys, nil)
             
             for idx in 0..<count {
@@ -81,11 +81,11 @@
     }
 
     override func removeObject(forKey aKey: AnyObject) {
-        CFDictionaryRemoveValue(_cfMutableObject, unsafeBitCast(aKey, to: UnsafePointer<Void>.self))
+        CFDictionaryRemoveValue(_cfMutableObject, unsafeBitCast(aKey, to: UnsafeRawPointer.self))
     }
     
     override func setObject(_ anObject: AnyObject, forKey aKey: NSObject) {
-        CFDictionarySetValue(_cfMutableObject, unsafeBitCast(aKey, to: UnsafePointer<Void>.self), unsafeBitCast(anObject, to: UnsafePointer<Void>.self))
+        CFDictionarySetValue(_cfMutableObject, unsafeBitCast(aKey, to: UnsafeRawPointer.self), unsafeBitCast(anObject, to: UnsafeRawPointer.self))
     }
     
     override var classForCoder: AnyClass {
@@ -152,7 +152,7 @@
     }
 }
 
-internal func _CFSwiftDictionaryApplyFunction(_ dictionary: AnyObject, applier: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>) -> Void, context: UnsafeMutablePointer<Void>) {
+internal func _CFSwiftDictionaryApplyFunction(_ dictionary: AnyObject, applier: @convention(c) (AnyObject, AnyObject, UnsafeMutableRawPointer) -> Void, context: UnsafeMutableRawPointer) {
     (dictionary as! NSDictionary).enumerateKeysAndObjects([]) { key, value, _ in
         applier(key, value, context)
     }
diff --git a/Foundation/NSCFString.swift b/Foundation/NSCFString.swift
index 4eba1d4..5906822 100644
--- a/Foundation/NSCFString.swift
+++ b/Foundation/NSCFString.swift
@@ -59,13 +59,14 @@
 
 internal final class _NSCFConstantString : _NSCFString {
     internal var _ptr : UnsafePointer<UInt8> {
-        let ptr = unsafeAddress(of: self) + sizeof(OpaquePointer.self) + sizeof(Int32.self) + sizeof(Int32.self) + sizeof(_CFInfo.self)
-        return UnsafePointer<UnsafePointer<UInt8>>(ptr).pointee
+        let offset = sizeof(OpaquePointer.self) + sizeof(Int32.self) + sizeof(Int32.self) + sizeof(_CFInfo.self)
+        let ptr = Unmanaged.passUnretained(self).toOpaque()
+        return ptr.load(fromByteOffset: offset, as: UnsafePointer<UInt8>.self)
     }
     internal var _length : UInt32 {
         let offset = sizeof(OpaquePointer.self) + sizeof(Int32.self) + sizeof(Int32.self) + sizeof(_CFInfo.self) + sizeof(UnsafePointer<UInt8>.self)
-        let ptr = unsafeAddress(of: self) + offset
-        return UnsafePointer<UInt32>(ptr).pointee
+        let ptr = Unmanaged.passUnretained(self).toOpaque()
+        return ptr.load(fromByteOffset: offset, as: UInt32.self)
     }
     
     required init(characters: UnsafePointer<unichar>, length: Int) {
diff --git a/Foundation/NSCache.swift b/Foundation/NSCache.swift
index 057cfdb..f1e83f2 100644
--- a/Foundation/NSCache.swift
+++ b/Foundation/NSCache.swift
@@ -22,7 +22,7 @@
         }
     }
     
-    private var _entries = Dictionary<UnsafePointer<Void>, NSCacheEntry>()
+    private var _entries = Dictionary<UnsafeRawPointer, NSCacheEntry>()
     private let _lock = Lock()
     private var _totalCost = 0
     private var _byCost: NSCacheEntry?
@@ -41,7 +41,7 @@
     public func object(forKey key: AnyObject) -> AnyObject? {
         var object: AnyObject?
         
-        let keyRef = unsafeBitCast(key, to: UnsafePointer<Void>.self)
+        let keyRef = unsafeBitCast(key, to: UnsafeRawPointer.self)
         
         _lock.lock()
         if let entry = _entries[keyRef] {
@@ -84,7 +84,7 @@
     }
     
     public func setObject(_ obj: AnyObject, forKey key: AnyObject, cost g: Int) {
-        let keyRef = unsafeBitCast(key, to: UnsafePointer<Void>.self)
+        let keyRef = unsafeBitCast(key, to: UnsafeRawPointer.self)
         
         _lock.lock()
         _totalCost += g
@@ -152,13 +152,13 @@
         
         _lock.lock()
         for entry in toRemove {
-            _entries.removeValue(forKey: unsafeBitCast(entry.key, to: UnsafePointer<Void>.self)) // the cost list is already fixed up in the purge routines
+            _entries.removeValue(forKey: unsafeBitCast(entry.key, to: UnsafeRawPointer.self)) // the cost list is already fixed up in the purge routines
         }
         _lock.unlock()
     }
     
     public func removeObject(forKey key: AnyObject) {
-        let keyRef = unsafeBitCast(key, to: UnsafePointer<Void>.self)
+        let keyRef = unsafeBitCast(key, to: UnsafeRawPointer.self)
         
         _lock.lock()
         if let entry = _entries.removeValue(forKey: keyRef) {
diff --git a/Foundation/NSCalendar.swift b/Foundation/NSCalendar.swift
index 9747e99..4843ddb 100644
--- a/Foundation/NSCalendar.swift
+++ b/Foundation/NSCalendar.swift
@@ -100,11 +100,11 @@
 public class Calendar: NSObject, NSCopying, NSSecureCoding {
     typealias CFType = CFCalendar
     private var _base = _CFInfo(typeID: CFCalendarGetTypeID())
-    private var _identifier: UnsafeMutablePointer<Void>? = nil
-    private var _locale: UnsafeMutablePointer<Void>? = nil
-    private var _localeID: UnsafeMutablePointer<Void>? = nil
-    private var _tz: UnsafeMutablePointer<Void>? = nil
-    private var _cal: UnsafeMutablePointer<Void>? = nil
+    private var _identifier: UnsafeMutableRawPointer? = nil
+    private var _locale: UnsafeMutableRawPointer? = nil
+    private var _localeID: UnsafeMutableRawPointer? = nil
+    private var _tz: UnsafeMutableRawPointer? = nil
+    private var _cal: UnsafeMutableRawPointer? = nil
     
     internal var _cfObject: CFType {
         return unsafeBitCast(self, to: CFCalendar.self)
@@ -394,8 +394,10 @@
     public func range(of unit: Unit, forDate date: Date) -> DateInterval? {
         var start: CFAbsoluteTime = 0.0
         var ti: CFTimeInterval = 0.0
-        let res: Bool = withUnsafeMutablePointers(&start, &ti) { startp, tip in
-           return CFCalendarGetTimeRangeOfUnit(_cfObject, unit._cfValue, date.timeIntervalSinceReferenceDate, startp, tip)
+        let res: Bool = withUnsafeMutablePointer(to: &start) { startp in
+            withUnsafeMutablePointer(to: &ti) { tip in
+                return CFCalendarGetTimeRangeOfUnit(_cfObject, unit._cfValue, date.timeIntervalSinceReferenceDate, startp, tip)
+            }
         }
         
         if res {
@@ -450,7 +452,7 @@
         self.timeZone = comps.timeZone ?? timeZone
         
         var at: CFAbsoluteTime = 0.0
-        let res: Bool = withUnsafeMutablePointer(&at) { t in
+        let res: Bool = withUnsafeMutablePointer(to: &at) { t in
             return vector.withUnsafeMutableBufferPointer { (vectorBuffer: inout UnsafeMutableBufferPointer<Int32>) in
                 return _CFCalendarComposeAbsoluteTimeV(_cfObject, t, compDesc, vectorBuffer.baseAddress!, Int32(vectorBuffer.count))
             }
@@ -554,7 +556,7 @@
         var (vector, compDesc) = _convert(comps)
         var at: CFAbsoluteTime = 0.0
         
-        let res: Bool = withUnsafeMutablePointer(&at) { t in
+        let res: Bool = withUnsafeMutablePointer(to: &at) { t in
             return vector.withUnsafeMutableBufferPointer { (vectorBuffer: inout UnsafeMutableBufferPointer<Int32>) in
                 return _CFCalendarAddComponentsV(_cfObject, t, CFOptionFlags(opts.rawValue), compDesc, vectorBuffer.baseAddress!, Int32(vector.count))
             }
@@ -940,7 +942,7 @@
     /// - Note: Since this API is under consideration it may be either removed or revised in the near future
     public func nextWeekendAfter(_ date: Date, options: Options) -> DateInterval? {
         var range = _CFCalendarWeekendRange()
-        let res = withUnsafeMutablePointer(&range) { rangep in
+        let res = withUnsafeMutablePointer(to: &range) { rangep in
             return _CFCalendarGetNextWeekend(_cfObject, rangep)
         }
         if res {
diff --git a/Foundation/NSCharacterSet.swift b/Foundation/NSCharacterSet.swift
index 75770de..a4e4289 100644
--- a/Foundation/NSCharacterSet.swift
+++ b/Foundation/NSCharacterSet.swift
@@ -33,9 +33,9 @@
     typealias CFType = CFCharacterSet
     private var _base = _CFInfo(typeID: CFCharacterSetGetTypeID())
     private var _hashValue = CFHashCode(0)
-    private var _buffer: UnsafeMutablePointer<Void>? = nil
+    private var _buffer: UnsafeMutableRawPointer? = nil
     private var _length = CFIndex(0)
-    private var _annex: UnsafeMutablePointer<Void>? = nil
+    private var _annex: UnsafeMutableRawPointer? = nil
     
     internal var _cfObject: CFType {
         return unsafeBitCast(self, to: CFType.self)
diff --git a/Foundation/NSCoder.swift b/Foundation/NSCoder.swift
index 901a69a..abfdbb8 100644
--- a/Foundation/NSCoder.swift
+++ b/Foundation/NSCoder.swift
@@ -17,16 +17,16 @@
 }
 
 public class NSCoder : NSObject {
-    internal var _pendingBuffers = Array<(UnsafeMutablePointer<Void>, Int)>()
+    internal var _pendingBuffers = Array<(UnsafeMutableRawPointer, Int)>()
     
     deinit {
         for buffer in _pendingBuffers {
-            buffer.0.deinitialize()
-            buffer.0.deallocate(capacity: buffer.1)
+            // Cannot deinitialize a pointer to unknown type.
+            buffer.0.deallocate(bytes: buffer.1, alignedTo: alignof(Int.self))
         }
     }
     
-    public func encodeValue(ofObjCType type: UnsafePointer<Int8>, at addr: UnsafePointer<Void>) {
+    public func encodeValue(ofObjCType type: UnsafePointer<Int8>, at addr: UnsafeRawPointer) {
         NSRequiresConcreteImplementation()
     }
     
@@ -34,7 +34,7 @@
         NSRequiresConcreteImplementation()
     }
     
-    public func decodeValue(ofObjCType type: UnsafePointer<Int8>, at data: UnsafeMutablePointer<Void>) {
+    public func decodeValue(ofObjCType type: UnsafePointer<Int8>, at data: UnsafeMutableRawPointer) {
         NSRequiresConcreteImplementation()
     }
     
@@ -99,8 +99,8 @@
     
     public func encode(_ object: AnyObject?) {
         var object = object
-        withUnsafePointer(&object) { (ptr: UnsafePointer<AnyObject?>) -> Void in
-            encodeValue(ofObjCType: "@", at: unsafeBitCast(ptr, to: UnsafePointer<Void>.self))
+        withUnsafePointer(to: &object) { (ptr: UnsafePointer<AnyObject?>) -> Void in
+            encodeValue(ofObjCType: "@", at: unsafeBitCast(ptr, to: UnsafeRawPointer.self))
         }
     }
     
@@ -120,18 +120,18 @@
         encode(object)
     }
     
-    public func encodeArray(ofObjCType type: UnsafePointer<Int8>, count: Int, at array: UnsafePointer<Void>) {
+    public func encodeArray(ofObjCType type: UnsafePointer<Int8>, count: Int, at array: UnsafeRawPointer) {
         encodeValue(ofObjCType: "[\(count)\(String(cString: type))]", at: array)
     }
     
-    public func encodeBytes(_ byteaddr: UnsafePointer<Void>?, length: Int) {
+    public func encodeBytes(_ byteaddr: UnsafeRawPointer?, length: Int) {
         var newLength = UInt32(length)
-        withUnsafePointer(&newLength) { (ptr: UnsafePointer<UInt32>) -> Void in
+        withUnsafePointer(to: &newLength) { (ptr: UnsafePointer<UInt32>) -> Void in
             encodeValue(ofObjCType: "I", at: ptr)
         }
         var empty: [Int8] = []
-        withUnsafePointer(&empty) {
-            encodeArray(ofObjCType: "c", count: length, at: byteaddr ?? UnsafePointer($0))
+        withUnsafePointer(to: &empty) {
+            encodeArray(ofObjCType: "c", count: length, at: byteaddr ?? UnsafeRawPointer($0))
         }
     }
     
@@ -141,25 +141,25 @@
         }
         
         var obj: AnyObject? = nil
-        withUnsafeMutablePointer(&obj) { (ptr: UnsafeMutablePointer<AnyObject?>) -> Void in
-            decodeValue(ofObjCType: "@", at: unsafeBitCast(ptr, to: UnsafeMutablePointer<Void>.self))
+        withUnsafeMutablePointer(to: &obj) { (ptr: UnsafeMutablePointer<AnyObject?>) -> Void in
+            decodeValue(ofObjCType: "@", at: unsafeBitCast(ptr, to: UnsafeMutableRawPointer.self))
         }
         return obj
     }
     
-    public func decodeArray(ofObjCType itemType: UnsafePointer<Int8>, count: Int, at array: UnsafeMutablePointer<Void>) {
+    public func decodeArray(ofObjCType itemType: UnsafePointer<Int8>, count: Int, at array: UnsafeMutableRawPointer) {
         decodeValue(ofObjCType: "[\(count)\(String(cString: itemType))]", at: array)
     }
    
     /*
     // TODO: This is disabled, as functions which return unsafe interior pointers are inherently unsafe when we have no autorelease pool. 
-    public func decodeBytes(withReturnedLength lengthp: UnsafeMutablePointer<Int>) -> UnsafeMutablePointer<Void>? {
+    public func decodeBytes(withReturnedLength lengthp: UnsafeMutablePointer<Int>) -> UnsafeMutableRawPointer? {
         var length: UInt32 = 0
-        withUnsafeMutablePointer(&length) { (ptr: UnsafeMutablePointer<UInt32>) -> Void in
-            decodeValue(ofObjCType: "I", at: unsafeBitCast(ptr, to: UnsafeMutablePointer<Void>.self))
+        withUnsafeMutablePointer(to: &length) { (ptr: UnsafeMutablePointer<UInt32>) -> Void in
+            decodeValue(ofObjCType: "I", at: unsafeBitCast(ptr, to: UnsafeMutableRawPointer.self))
         }
         // we cannot autorelease here so instead the pending buffers will manage the lifespan of the returned data... this is wasteful but good enough...
-        let result = UnsafeMutablePointer<Void>.allocate(capacity: Int(length))
+        let result = UnsafeMutableRawPointer.allocate(bytes: Int(length), alignedTo: alignof(Int.self))
         decodeValue(ofObjCType: "c", at: result)
         lengthp.pointee = Int(length)
         _pendingBuffers.append((result, Int(length)))
diff --git a/Foundation/NSConcreteValue.swift b/Foundation/NSConcreteValue.swift
index 55bde6e..f801b72 100644
--- a/Foundation/NSConcreteValue.swift
+++ b/Foundation/NSConcreteValue.swift
@@ -71,9 +71,9 @@
     private static var _cachedTypeInfoLock = Lock()
     
     private var _typeInfo : TypeInfo
-    private var _storage : UnsafeMutablePointer<UInt8>
+    private var _storage : UnsafeMutableRawPointer
       
-    required init(bytes value: UnsafePointer<Void>, objCType type: UnsafePointer<Int8>) {
+    required init(bytes value: UnsafeRawPointer, objCType type: UnsafePointer<Int8>) {
         let spec = String(cString: type)
         var typeInfo : TypeInfo? = nil
 
@@ -91,17 +91,17 @@
 
         self._typeInfo = typeInfo!
 
-        self._storage = UnsafeMutablePointer<UInt8>.allocate(capacity: self._typeInfo.size)
-        self._storage.initialize(from: unsafeBitCast(value, to: UnsafeMutablePointer<UInt8>.self), count: self._typeInfo.size)
+        self._storage = UnsafeMutableRawPointer.allocate(bytes: self._typeInfo.size, alignedTo: 1)
+        self._storage.copyBytes(from: value, count: self._typeInfo.size)
     }
 
     deinit {
-        self._storage.deinitialize(count: self._size)
-        self._storage.deallocate(capacity: self._size)
+        // Cannot deinitialize raw memory.
+        self._storage.deallocate(bytes: self._size, alignedTo: 1)
     }
     
-    override func getValue(_ value: UnsafeMutablePointer<Void>) {
-        UnsafeMutablePointer<UInt8>(value).moveInitialize(from: unsafeBitCast(self._storage, to: UnsafeMutablePointer<UInt8>.self), count: self._size)
+    override func getValue(_ value: UnsafeMutableRawPointer) {
+        value.copyBytes(from: self._storage, count: self._size)
     }
     
     override var objCType : UnsafePointer<Int8> {
@@ -145,8 +145,8 @@
         return self._typeInfo.size
     }
     
-    private var value : UnsafeMutablePointer<Void> {
-        return unsafeBitCast(self._storage, to: UnsafeMutablePointer<Void>.self)
+    private var value : UnsafeMutableRawPointer {
+        return self._storage
     }
     
     private func _isEqualToValue(_ other: NSConcreteValue) -> Bool {
diff --git a/Foundation/NSData.swift b/Foundation/NSData.swift
index ac6a210..f5cf5fa 100644
--- a/Foundation/NSData.swift
+++ b/Foundation/NSData.swift
@@ -61,7 +61,7 @@
 }
 
 private final class _NSDataDeallocator {
-    var handler: (UnsafeMutablePointer<Void>, Int) -> Void = {_,_ in }
+    var handler: (UnsafeMutableRawPointer, Int) -> Void = {_,_ in }
 }
 
 private let __kCFMutable: CFOptionFlags = 0x01
@@ -77,7 +77,7 @@
     private var _base = _CFInfo(typeID: CFDataGetTypeID())
     private var _length: CFIndex = 0
     private var _capacity: CFIndex = 0
-    private var _deallocator: UnsafeMutablePointer<Void>? = nil // for CF only
+    private var _deallocator: UnsafeMutableRawPointer? = nil // for CF only
     private var _deallocHandler: _NSDataDeallocator? = _NSDataDeallocator() // for Swift
     private var _bytes: UnsafeMutablePointer<UInt8>? = nil
     
@@ -85,12 +85,13 @@
         if self.dynamicType === NSData.self || self.dynamicType === NSMutableData.self {
             return unsafeBitCast(self, to: CFType.self)
         } else {
-            return CFDataCreate(kCFAllocatorSystemDefault, UnsafePointer<UInt8>(self.bytes), self.length)
+            let bytePtr = self.bytes.bindMemory(to: UInt8.self, capacity: self.length)
+            return CFDataCreate(kCFAllocatorSystemDefault, bytePtr, self.length)
         }
     }
     
     public override required convenience init() {
-        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutablePointer<Void>.self)
+        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutableRawPointer.self)
         self.init(bytes: dummyPointer, length: 0, copy: false, deallocator: nil)
     }
     
@@ -115,11 +116,12 @@
         }
     }
     
-    internal init(bytes: UnsafeMutablePointer<Void>?, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
+    internal init(bytes: UnsafeMutableRawPointer?, length: Int, copy: Bool, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)?) {
         super.init()
         let options : CFOptionFlags = (self.dynamicType == NSMutableData.self) ? __kCFMutable | __kCFGrowable : 0x0
+        let bytePtr = bytes?.bindMemory(to: UInt8.self, capacity: length)
         if copy {
-            _CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options, length, UnsafeMutablePointer<UInt8>(bytes), length, false)
+            _CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options, length, bytePtr, length, false)
             if let handler = deallocator {
                 handler(bytes!, length)
             }
@@ -128,7 +130,7 @@
                 _deallocHandler!.handler = handler
             }
             // The data initialization should flag that CF should not deallocate which leaves the handler a chance to deallocate instead
-            _CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options | __kCFDontDeallocate, length, UnsafeMutablePointer<UInt8>(bytes), length, true)
+            _CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options | __kCFDontDeallocate, length, bytePtr, length, true)
         }
     }
     
@@ -136,8 +138,8 @@
         return CFDataGetLength(_cfObject)
     }
 
-    public var bytes: UnsafePointer<Void> {
-        return UnsafePointer<Void>(CFDataGetBytePtr(_cfObject))
+    public var bytes: UnsafeRawPointer {
+        return UnsafeRawPointer(CFDataGetBytePtr(_cfObject))
     }
     
     public override func copy() -> AnyObject {
@@ -153,14 +155,15 @@
     }
     
     public func mutableCopy(with zone: NSZone? = nil) -> AnyObject {
-        return NSMutableData(bytes: UnsafeMutablePointer<Void>(bytes), length: length, copy: true, deallocator: nil)
+        return NSMutableData(bytes: UnsafeMutableRawPointer(mutating: bytes), length: length, copy: true, deallocator: nil)
     }
 
     public func encode(with aCoder: NSCoder) {
         if let aKeyedCoder = aCoder as? NSKeyedArchiver {
             aKeyedCoder._encodePropertyList(self, forKey: "NS.data")
         } else {
-            aCoder.encodeBytes(UnsafePointer<UInt8>(self.bytes), length: self.length)
+            let bytePtr = self.bytes.bindMemory(to: UInt8.self, capacity: self.length)
+            aCoder.encodeBytes(bytePtr, length: self.length)
         }
     }
     
@@ -193,20 +196,19 @@
     
     private func byteDescription(limit: Int? = nil) -> String {
         var s = ""
-        let buffer = UnsafePointer<UInt8>(bytes)
         var i = 0
         while i < self.length {
             if i > 0 && i % 4 == 0 {
                 // if there's a limit, and we're at the barrier where we'd add the ellipses, don't add a space.
-                if let limit = limit where self.length > limit && i == self.length - (limit / 2) { /* do nothing */ }
+                if let limit = limit, self.length > limit && i == self.length - (limit / 2) { /* do nothing */ }
                 else { s += " " }
             }
-            let byte = buffer[i]
+            let byte = bytes.load(fromByteOffset: i, as: UInt8.self)
             var byteStr = String(byte, radix: 16, uppercase: false)
             if byte <= 0xf { byteStr = "0\(byteStr)" }
             s += byteStr
             // if we've hit the midpoint of the limit, skip to the last (limit / 2) bytes.
-            if let limit = limit where self.length > limit && i == (limit / 2) - 1 {
+            if let limit = limit, self.length > limit && i == (limit / 2) - 1 {
                 s += " ... "
                 i = self.length - (limit / 2)
             } else {
@@ -231,15 +233,15 @@
 
 extension NSData {
     
-    public convenience init(bytes: UnsafePointer<Void>?, length: Int) {
-        self.init(bytes: UnsafeMutablePointer<Void>(bytes), length: length, copy: true, deallocator: nil)
+    public convenience init(bytes: UnsafeRawPointer?, length: Int) {
+        self.init(bytes: UnsafeMutableRawPointer(mutating: bytes), length: length, copy: true, deallocator: nil)
     }
 
-    public convenience init(bytesNoCopy bytes: UnsafeMutablePointer<Void>, length: Int) {
+    public convenience init(bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int) {
         self.init(bytes: bytes, length: length, copy: false, deallocator: nil)
     }
     
-    public convenience init(bytesNoCopy bytes: UnsafeMutablePointer<Void>, length: Int, freeWhenDone b: Bool) {
+    public convenience init(bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int, freeWhenDone b: Bool) {
         self.init(bytes: bytes, length: length, copy: false) { buffer, length in
             if b {
                 free(buffer)
@@ -247,15 +249,15 @@
         }
     }
 
-    public convenience init(bytesNoCopy bytes: UnsafeMutablePointer<Void>, length: Int, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
+    public convenience init(bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)?) {
         self.init(bytes: bytes, length: length, copy: false, deallocator: deallocator)
     }
     
     
     internal struct NSDataReadResult {
-        var bytes: UnsafeMutablePointer<Void>
+        var bytes: UnsafeMutableRawPointer
         var length: Int
-        var deallocator: ((buffer: UnsafeMutablePointer<Void>, length: Int) -> Void)?
+        var deallocator: ((buffer: UnsafeMutableRawPointer, length: Int) -> Void)?
     }
     
     internal static func readBytesFromFileWithExtendedAttributes(_ path: String, options: ReadingOptions) throws -> NSDataReadResult {
@@ -268,7 +270,7 @@
         }
 
         var info = stat()
-        let ret = withUnsafeMutablePointer(&info) { infoPointer -> Bool in
+        let ret = withUnsafeMutablePointer(to: &info) { infoPointer -> Bool in
             if fstat(fd, infoPointer) < 0 {
                 return false
             }
@@ -285,7 +287,7 @@
             let data = mmap(nil, length, PROT_READ, MAP_PRIVATE, fd, 0)
             
             // Swift does not currently expose MAP_FAILURE
-            if data != UnsafeMutablePointer<Void>(bitPattern: -1) {
+            if data != UnsafeMutableRawPointer(bitPattern: -1) {
                 return NSDataReadResult(bytes: data!, length: length) { buffer, length in
                     munmap(buffer, length)
                 }
@@ -364,12 +366,14 @@
 }
 
 extension NSData {
-    public func getBytes(_ buffer: UnsafeMutablePointer<Void>, length: Int) {
-        CFDataGetBytes(_cfObject, CFRangeMake(0, length), UnsafeMutablePointer<UInt8>(buffer))
+    public func getBytes(_ buffer: UnsafeMutableRawPointer, length: Int) {
+        let bytePtr = buffer.bindMemory(to: UInt8.self, capacity: length)
+        CFDataGetBytes(_cfObject, CFRangeMake(0, length), bytePtr)
     }
     
-    public func getBytes(_ buffer: UnsafeMutablePointer<Void>, range: NSRange) {
-        CFDataGetBytes(_cfObject, CFRangeMake(range.location, range.length), UnsafeMutablePointer<UInt8>(buffer))
+    public func getBytes(_ buffer: UnsafeMutableRawPointer, range: NSRange) {
+        let bytePtr = buffer.bindMemory(to: UInt8.self, capacity: range.length)
+        CFDataGetBytes(_cfObject, CFRangeMake(range.location, range.length), bytePtr)
     }
     
     public func isEqual(to other: Data) -> Bool {
@@ -408,7 +412,7 @@
         return (fd, pathResult)
     }
 
-    internal class func writeToFileDescriptor(_ fd: Int32, path: String? = nil, buf: UnsafePointer<Void>, length: Int) throws {
+    internal class func writeToFileDescriptor(_ fd: Int32, path: String? = nil, buf: UnsafeRawPointer, length: Int) throws {
         var bytesRemaining = length
         while bytesRemaining > 0 {
             var bytesWritten : Int
@@ -515,7 +519,7 @@
     ///
     ///      This method is invoked in a `try` expression and the caller is responsible for handling any errors in the `catch` clauses of a `do` statement, as described in [Error Handling](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ErrorHandling.html#//apple_ref/doc/uid/TP40014097-CH42) in [The Swift Programming Language](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/index.html#//apple_ref/doc/uid/TP40014097) and [Error Handling](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10) in [Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216).
     public func write(to url: URL, options writeOptionsMask: WritingOptions = []) throws {
-        guard let path = url.path where url.isFileURL == true else {
+        guard let path = url.path, url.isFileURL == true else {
             let userInfo = [NSLocalizedDescriptionKey : "The folder at “\(url)” does not exist or is not a file URL.", // NSLocalizedString() not yet available
                             NSURLErrorKey             : url.absoluteString ?? ""] as Dictionary<String, Any>
             throw NSError(domain: NSCocoaErrorDomain, code: 4, userInfo: userInfo)
@@ -529,9 +533,11 @@
         guard let searchRange = searchRange.toRange() else {fatalError("invalid range")}
         
         precondition(searchRange.endIndex <= self.length, "range outside the bounds of data")
-        
-        let baseData = UnsafeBufferPointer<UInt8>(start: UnsafePointer<UInt8>(self.bytes), count: self.length)[searchRange]
-        let search = UnsafeBufferPointer<UInt8>(start: UnsafePointer<UInt8>(dataToFind.bytes), count: dataToFind.length)
+
+        let basePtr = self.bytes.bindMemory(to: UInt8.self, capacity: self.length)
+        let baseData = UnsafeBufferPointer<UInt8>(start: basePtr, count: self.length)[searchRange]
+        let searchPtr = dataToFind.bytes.bindMemory(to: UInt8.self, capacity: dataToFind.length)
+        let search = UnsafeBufferPointer<UInt8>(start: searchPtr, count: dataToFind.length)
         
         let location : Int?
         let anchored = mask.contains(.anchored)
@@ -552,7 +558,7 @@
         return nil
     }
     
-    internal func enumerateByteRangesUsingBlockRethrows(_ block: @noescape (UnsafePointer<Void>, NSRange, UnsafeMutablePointer<Bool>) throws -> Void) throws {
+    internal func enumerateByteRangesUsingBlockRethrows(_ block: @noescape (UnsafeRawPointer, NSRange, UnsafeMutablePointer<Bool>) throws -> Void) throws {
         var err : Swift.Error? = nil
         self.enumerateBytes() { (buf, range, stop) -> Void in
             do {
@@ -566,9 +572,9 @@
         }
     }
 
-    public func enumerateBytes(_ block: @noescape (UnsafePointer<Void>, NSRange, UnsafeMutablePointer<Bool>) -> Void) {
+    public func enumerateBytes(_ block: @noescape (UnsafeRawPointer, NSRange, UnsafeMutablePointer<Bool>) -> Void) {
         var stop = false
-        withUnsafeMutablePointer(&stop) { stopPointer in
+        withUnsafeMutablePointer(to: &stop) { stopPointer in
             block(bytes, NSMakeRange(0, length), stopPointer)
         }
     }
@@ -611,12 +617,12 @@
         self.init(bytes: nil, length: 0)
     }
     
-    internal override init(bytes: UnsafeMutablePointer<Void>?, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
+    internal override init(bytes: UnsafeMutableRawPointer?, length: Int, copy: Bool, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)?) {
         super.init(bytes: bytes, length: length, copy: copy, deallocator: deallocator)
     }
     
-    public var mutableBytes: UnsafeMutablePointer<Void> {
-        return UnsafeMutablePointer(CFDataGetMutableBytePtr(_cfMutableObject))
+    public var mutableBytes: UnsafeMutableRawPointer {
+        return UnsafeMutableRawPointer(CFDataGetMutableBytePtr(_cfMutableObject))
     }
     
     public override var length: Int {
@@ -846,7 +852,7 @@
         let appendByteToResult : (UInt8) -> () = {
             result.append($0)
             currentLineCount += 1
-            if let options = lineOptions where currentLineCount == options.lineLength {
+            if let options = lineOptions, currentLineCount == options.lineLength {
                 result.append(contentsOf: options.separator)
                 currentLineCount = 0
             }
@@ -892,8 +898,9 @@
 
 extension NSMutableData {
 
-    public func append(_ bytes: UnsafePointer<Void>, length: Int) {
-        CFDataAppendBytes(_cfMutableObject, UnsafePointer<UInt8>(bytes), length)
+    public func append(_ bytes: UnsafeRawPointer, length: Int) {
+        let bytePtr = bytes.bindMemory(to: UInt8.self, capacity: length)
+        CFDataAppendBytes(_cfMutableObject, bytePtr, length)
     }
     
     public func append(_ other: Data) {
@@ -908,8 +915,9 @@
         CFDataSetLength(_cfMutableObject, CFDataGetLength(_cfObject) + extraLength)
     }
     
-    public func replaceBytes(in range: NSRange, withBytes bytes: UnsafePointer<Void>) {
-        CFDataReplaceBytes(_cfMutableObject, CFRangeMake(range.location, range.length), UnsafePointer<UInt8>(bytes), length)
+    public func replaceBytes(in range: NSRange, withBytes bytes: UnsafeRawPointer) {
+        let bytePtr = bytes.bindMemory(to: UInt8.self, capacity: length)
+        CFDataReplaceBytes(_cfMutableObject, CFRangeMake(range.location, range.length), bytePtr, length)
     }
     
     public func resetBytes(in range: NSRange) {
@@ -924,8 +932,9 @@
         
     }
     
-    public func replaceBytes(in range: NSRange, withBytes replacementBytes: UnsafePointer<Void>, length replacementLength: Int) {
-        CFDataReplaceBytes(_cfMutableObject, CFRangeMake(range.location, range.length), UnsafePointer<UInt8>(bytes), replacementLength)
+    public func replaceBytes(in range: NSRange, withBytes replacementBytes: UnsafeRawPointer, length replacementLength: Int) {
+        let bytePtr = bytes.bindMemory(to: UInt8.self, capacity: replacementLength)
+        CFDataReplaceBytes(_cfMutableObject, CFRangeMake(range.location, range.length), bytePtr, replacementLength)
     }
 }
 
diff --git a/Foundation/NSDate.swift b/Foundation/NSDate.swift
index 2b1b889..3ab3350 100644
--- a/Foundation/NSDate.swift
+++ b/Foundation/NSDate.swift
@@ -53,7 +53,7 @@
 
     public convenience override init() {
         var tv = timeval()
-        let _ = withUnsafeMutablePointer(&tv) { t in
+        let _ = withUnsafeMutablePointer(to: &tv) { t in
             gettimeofday(t, nil)
         }
         var timestamp = TimeInterval(tv.tv_sec) - NSTimeIntervalSince1970
@@ -71,8 +71,8 @@
             self.init(timeIntervalSinceReferenceDate: ti)
         } else {
             var ti: TimeInterval = 0.0
-            withUnsafeMutablePointer(&ti) { (ptr: UnsafeMutablePointer<Double>) -> Void in
-                aDecoder.decodeValue(ofObjCType: "d", at: UnsafeMutablePointer<Void>(ptr))
+            withUnsafeMutablePointer(to: &ti) { (ptr: UnsafeMutablePointer<Double>) -> Void in
+                aDecoder.decodeValue(ofObjCType: "d", at: UnsafeMutableRawPointer(ptr))
             }
             self.init(timeIntervalSinceReferenceDate: ti)
         }
diff --git a/Foundation/NSDateFormatter.swift b/Foundation/NSDateFormatter.swift
index 13fcf57..e9eb569 100644
--- a/Foundation/NSDateFormatter.swift
+++ b/Foundation/NSDateFormatter.swift
@@ -56,7 +56,7 @@
 
     public func date(from string: String) -> Date? {
         var range = CFRange(location: 0, length: string.length)
-        let date = withUnsafeMutablePointer(&range) { (rangep: UnsafeMutablePointer<CFRange>) -> Date? in
+        let date = withUnsafeMutablePointer(to: &range) { (rangep: UnsafeMutablePointer<CFRange>) -> Date? in
             guard let res = CFDateFormatterCreateDateFromString(kCFAllocatorSystemDefault, _cfObject, string._cfObject, rangep) else {
                 return nil
             }
diff --git a/Foundation/NSDecimalNumber.swift b/Foundation/NSDecimalNumber.swift
index 831b64a..383df90 100644
--- a/Foundation/NSDecimalNumber.swift
+++ b/Foundation/NSDecimalNumber.swift
@@ -51,7 +51,7 @@
         NSUnimplemented()
     }
     
-    public required convenience init(bytes buffer: UnsafePointer<Void>, objCType type: UnsafePointer<Int8>) {
+    public required convenience init(bytes buffer: UnsafeRawPointer, objCType type: UnsafePointer<Int8>) {
         NSRequiresConcreteImplementation()
     }
     
diff --git a/Foundation/NSDictionary.swift b/Foundation/NSDictionary.swift
index 67f724c..ec59320 100644
--- a/Foundation/NSDictionary.swift
+++ b/Foundation/NSDictionary.swift
@@ -52,8 +52,8 @@
             let cf = x._cfObject
             let cnt = CFDictionaryGetCount(cf)
 
-            let keys = UnsafeMutablePointer<UnsafePointer<Void>?>.allocate(capacity: cnt)
-            let values = UnsafeMutablePointer<UnsafePointer<Void>?>.allocate(capacity: cnt)
+            let keys = UnsafeMutablePointer<UnsafeRawPointer?>.allocate(capacity: cnt)
+            let values = UnsafeMutablePointer<UnsafeRawPointer?>.allocate(capacity: cnt)
             
             CFDictionaryGetKeysAndValues(cf, keys, values)
             
@@ -125,8 +125,8 @@
             // We're stuck with (int) here (rather than unsigned int)
             // because that's the way the code was originally written, unless
             // we go to a new version of the class, which has its own problems.
-            withUnsafeMutablePointer(&cnt) { (ptr: UnsafeMutablePointer<UInt32>) -> Void in
-                aDecoder.decodeValue(ofObjCType: "i", at: UnsafeMutablePointer<Void>(ptr))
+            withUnsafeMutablePointer(to: &cnt) { (ptr: UnsafeMutablePointer<UInt32>) -> Void in
+                aDecoder.decodeValue(ofObjCType: "i", at: UnsafeMutableRawPointer(ptr))
             }
             let keys = UnsafeMutablePointer<NSObject>.allocate(capacity: Int(cnt))
             let objects = UnsafeMutablePointer<AnyObject>.allocate(capacity: Int(cnt))
@@ -486,7 +486,7 @@
         getObjects(&objects, andKeys: &keys, count: count)
         var stop = ObjCBool(false)
         for idx in 0..<count {
-            withUnsafeMutablePointer(&stop, { stop in
+            withUnsafeMutablePointer(to: &stop, { stop in
                 block(keys[idx] as! NSObject, objects[idx], stop)
             })
 
diff --git a/Foundation/NSFileHandle.swift b/Foundation/NSFileHandle.swift
index cd58bda..4b7b0de 100644
--- a/Foundation/NSFileHandle.swift
+++ b/Foundation/NSFileHandle.swift
@@ -34,7 +34,7 @@
 
     internal func _readDataOfLength(_ length: Int, untilEOF: Bool) -> Data {
         var statbuf = stat()
-        var dynamicBuffer: UnsafeMutablePointer<UInt8>? = nil
+        var dynamicBuffer: UnsafeMutableRawPointer? = nil
         var total = 0
         if _closed || fstat(_fd, &statbuf) < 0 {
             fatalError("Unable to read file")
@@ -42,14 +42,14 @@
         if statbuf.st_mode & S_IFMT != S_IFREG {
             /* We get here on sockets, character special files, FIFOs ... */
             var currentAllocationSize: size_t = 1024 * 8
-            dynamicBuffer = UnsafeMutablePointer<UInt8>(malloc(currentAllocationSize))
+            dynamicBuffer = malloc(currentAllocationSize)
             var remaining = length
             while remaining > 0 {
                 let amountToRead = min(1024 * 8, remaining)
                 // Make sure there is always at least amountToRead bytes available in the buffer.
                 if (currentAllocationSize - total) < amountToRead {
                     currentAllocationSize *= 2
-                    dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer!), currentAllocationSize))
+                    dynamicBuffer = _CFReallocf(dynamicBuffer!, currentAllocationSize)
                     if dynamicBuffer == nil {
                         fatalError("unable to allocate backing buffer")
                     }
@@ -79,7 +79,7 @@
                 var remaining = size_t(statbuf.st_size - offset)
                 remaining = min(remaining, size_t(length))
                 
-                dynamicBuffer = UnsafeMutablePointer<UInt8>(malloc(remaining))
+                dynamicBuffer = malloc(remaining)
                 if dynamicBuffer == nil {
                     fatalError("Malloc failure")
                 }
@@ -100,7 +100,7 @@
         }
 
         if length == Int.max && total > 0 {
-            dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer!), total))
+            dynamicBuffer = _CFReallocf(dynamicBuffer!, total)
         }
         
         if (0 == total) {
@@ -108,7 +108,8 @@
         }
         
         if total > 0 {
-            return Data(bytesNoCopy: dynamicBuffer!, count: total, deallocator: .none)
+            let bytePtr = dynamicBuffer!.bindMemory(to: UInt8.self, capacity: total)
+            return Data(bytesNoCopy: bytePtr, count: total, deallocator: .none)
         }
         
         return Data()
@@ -117,7 +118,7 @@
     public func write(_ data: Data) {
         data.enumerateBytes() { (bytes, range, stop) in
             do {
-                try NSData.writeToFileDescriptor(self._fd, path: nil, buf: UnsafePointer<Void>(bytes.baseAddress!), length: bytes.count)
+                try NSData.writeToFileDescriptor(self._fd, path: nil, buf: UnsafeRawPointer(bytes.baseAddress!), length: bytes.count)
             } catch {
                 fatalError("Write failure")
             }
diff --git a/Foundation/NSFileManager.swift b/Foundation/NSFileManager.swift
index f64064b..d6bd93a 100644
--- a/Foundation/NSFileManager.swift
+++ b/Foundation/NSFileManager.swift
@@ -252,7 +252,7 @@
         }
 
         while let entry = readdir(dir!) {
-            if let entryName = withUnsafePointer(&entry.pointee.d_name, { (ptr) -> String? in
+            if let entryName = withUnsafePointer(to: &entry.pointee.d_name, { (ptr) -> String? in
                 return String(cString: UnsafePointer<Int8>(ptr))
             }) {
                 // TODO: `entryName` should be limited in length to `entry.memory.d_namlen`.
@@ -294,7 +294,7 @@
         var entry = readdir(dir!)
         
         while entry != nil {
-            if let entryName = withUnsafePointer(&entry!.pointee.d_name, { (ptr) -> String? in
+            if let entryName = withUnsafePointer(to: &entry!.pointee.d_name, { (ptr) -> String? in
                 let int8Ptr = unsafeBitCast(ptr, to: UnsafePointer<Int8>.self)
                 return String(cString: int8Ptr)
             }) {
@@ -302,7 +302,7 @@
                 if entryName != "." && entryName != ".." {
                     contents.append(entryName)
                     
-                    if let entryType = withUnsafePointer(&entry!.pointee.d_type, { (ptr) -> Int32? in
+                    if let entryType = withUnsafePointer(to: &entry!.pointee.d_type, { (ptr) -> Int32? in
                         let int32Ptr = unsafeBitCast(ptr, to: UnsafePointer<UInt8>.self)
                         return Int32(int32Ptr.pointee)
                     }) {
diff --git a/Foundation/NSGeometry.swift b/Foundation/NSGeometry.swift
index eb1a2bd..9c29876 100644
--- a/Foundation/NSGeometry.swift
+++ b/Foundation/NSGeometry.swift
@@ -100,11 +100,9 @@
 }
 
 extension CGPoint: NSSpecialValueCoding {
-    init(bytes: UnsafePointer<Void>) {
-        let buffer = UnsafePointer<CGFloat>(bytes)
-
-        self.x = buffer.pointee
-        self.y = buffer.advanced(by: 1).pointee
+    init(bytes: UnsafeRawPointer) {
+        self.x = bytes.load(as: CGFloat.self)
+        self.y = bytes.load(fromByteOffset: strideof(CGFloat.self), as: CGFloat.self)
     }
     
     init?(coder aDecoder: NSCoder) {
@@ -127,8 +125,8 @@
         return "{CGPoint=dd}"
     }
 
-    func getValue(_ value: UnsafeMutablePointer<Void>) {
-        UnsafeMutablePointer<CGPoint>(value).pointee = self
+    func getValue(_ value: UnsafeMutableRawPointer) {
+        value.initializeMemory(as: CGPoint.self, to: self)
     }
 
     func isEqual(_ aValue: Any) -> Bool {
@@ -167,11 +165,9 @@
 }
 
 extension CGSize: NSSpecialValueCoding {
-    init(bytes: UnsafePointer<Void>) {
-        let buffer = UnsafePointer<CGFloat>(bytes)
-
-        self.width = buffer.pointee
-        self.height = buffer.advanced(by: 1).pointee
+    init(bytes: UnsafeRawPointer) {
+        self.width = bytes.load(as: CGFloat.self)
+        self.height = bytes.load(fromByteOffset: strideof(CGFloat.self), as: CGFloat.self)
     }
     
     init?(coder aDecoder: NSCoder) {
@@ -194,8 +190,8 @@
         return "{CGSize=dd}"
     }
     
-    func getValue(_ value: UnsafeMutablePointer<Void>) {
-        UnsafeMutablePointer<CGSize>(value).pointee = self
+    func getValue(_ value: UnsafeMutableRawPointer) {
+        value.initializeMemory(as: CGSize.self, to: self)
     }
     
     func isEqual(_ aValue: Any) -> Bool {
@@ -249,11 +245,13 @@
 public typealias NSRectArray = UnsafeMutablePointer<NSRect>
 
 extension CGRect: NSSpecialValueCoding {
-    init(bytes: UnsafePointer<Void>) {
-        let buffer = UnsafePointer<CGFloat>(bytes)
-
-        self.origin = CGPoint(x: buffer.pointee, y: buffer.advanced(by: 1).pointee)
-        self.size = CGSize(width: buffer.advanced(by: 2).pointee, height: buffer.advanced(by: 3).pointee)
+    init(bytes: UnsafeRawPointer) {
+        self.origin = CGPoint(
+            x: bytes.load(as: CGFloat.self),
+            y: bytes.load(fromByteOffset: 1 * strideof(CGFloat.self), as: CGFloat.self))
+        self.size = CGSize(
+            width: bytes.load(fromByteOffset: 2 * strideof(CGFloat.self), as: CGFloat.self),
+            height: bytes.load(fromByteOffset: 3 * strideof(CGFloat.self), as: CGFloat.self))
     }
 
     init?(coder aDecoder: NSCoder) {
@@ -276,8 +274,8 @@
         return "{CGRect={CGPoint=dd}{CGSize=dd}}"
     }
     
-    func getValue(_ value: UnsafeMutablePointer<Void>) {
-        UnsafeMutablePointer<CGRect>(value).pointee = self
+    func getValue(_ value: UnsafeMutableRawPointer) {
+        value.initializeMemory(as: CGRect.self, to: self)
     }
     
     func isEqual(_ aValue: Any) -> Bool {
@@ -344,13 +342,11 @@
 }
 
 extension NSEdgeInsets: NSSpecialValueCoding {
-    init(bytes: UnsafePointer<Void>) {
-        let buffer = UnsafePointer<CGFloat>(bytes)
-
-        self.top = buffer.pointee
-        self.left = buffer.advanced(by: 1).pointee
-        self.bottom = buffer.advanced(by: 2).pointee
-        self.right = buffer.advanced(by: 3).pointee
+    init(bytes: UnsafeRawPointer) {
+        self.top = bytes.load(as: CGFloat.self)
+        self.left = bytes.load(fromByteOffset: strideof(CGFloat.self), as: CGFloat.self)
+        self.bottom = bytes.load(fromByteOffset: 2 * strideof(CGFloat.self), as: CGFloat.self)
+        self.right = bytes.load(fromByteOffset: 3 * strideof(CGFloat.self), as: CGFloat.self)
     }
 
     init?(coder aDecoder: NSCoder) {
@@ -379,8 +375,8 @@
         return "{NSEdgeInsets=dddd}"
     }
     
-    func getValue(_ value: UnsafeMutablePointer<Void>) {
-        UnsafeMutablePointer<NSEdgeInsets>(value).pointee = self
+    func getValue(_ value: UnsafeMutableRawPointer) {
+        value.initializeMemory(as: NSEdgeInsets.self, to: self)
     }
     
     func isEqual(_ aValue: Any) -> Bool {
diff --git a/Foundation/NSHTTPCookie.swift b/Foundation/NSHTTPCookie.swift
index 7d70f2e..4efa2d1 100644
--- a/Foundation/NSHTTPCookie.swift
+++ b/Foundation/NSHTTPCookie.swift
@@ -226,8 +226,7 @@
         _domain = canonicalDomain
 
         if let
-            secureString = properties[NSHTTPCookieSecure] as? String
-            where secureString.characters.count > 0
+            secureString = properties[NSHTTPCookieSecure] as? String, secureString.characters.count > 0
         {
             _secure = true
         } else {
@@ -236,8 +235,7 @@
 
         let version: Int
         if let
-            versionString = properties[NSHTTPCookieVersion] as? String
-            where versionString == "1"
+            versionString = properties[NSHTTPCookieVersion] as? String, versionString == "1"
         {
             version = 1
         } else {
@@ -245,8 +243,7 @@
         }
         _version = version
         
-        if let portString = properties[NSHTTPCookiePort] as? String
-        where _version == 1 {
+        if let portString = properties[NSHTTPCookiePort] as? String, _version == 1 {
             _portList = portString.characters
                 .split(separator: ",")
                 .flatMap { Int(String($0)) }
@@ -271,8 +268,7 @@
             }
         } else if
             let maximumAge = properties[NSHTTPCookieMaximumAge] as? String,
-            let secondsFromNow = Int(maximumAge)
-            where _version == 1 {
+            let secondsFromNow = Int(maximumAge), _version == 1 {
             _expiresDate = Date(timeIntervalSinceNow: Double(secondsFromNow))
         } else {
             _expiresDate = nil
diff --git a/Foundation/NSJSONSerialization.swift b/Foundation/NSJSONSerialization.swift
index 365f441..acf9286 100644
--- a/Foundation/NSJSONSerialization.swift
+++ b/Foundation/NSJSONSerialization.swift
@@ -159,7 +159,10 @@
     /* Write JSON data into a stream. The stream should be opened and configured. The return value is the number of bytes written to the stream, or 0 on error. All other behavior of this method is the same as the dataWithJSONObject:options:error: method.
      */
     public class func writeJSONObject(_ obj: AnyObject, toStream stream: NSOutputStream, options opt: WritingOptions) throws -> Int {
-        NSUnimplemented()
+            let jsonData = try data(withJSONObject: obj, options: opt)
+            let jsonNSData = jsonData.bridge()
+            let bytePtr = jsonNSData.bytes.bindMemory(to: UInt8.self, capacity: jsonNSData.length)
+            return stream.write(bytePtr, maxLength: jsonNSData.length)
     }
     
     /* Create a JSON object from JSON data stream. The stream should be opened and configured. All other behavior of this method is the same as the JSONObjectWithData:options:error: method.
@@ -481,7 +484,7 @@
 
     func consumeWhitespace(_ input: Index) -> Index? {
         var index = input
-        while let (char, nextIndex) = source.takeASCII(index) where JSONReader.whitespaceASCII.contains(char) {
+        while let (char, nextIndex) = source.takeASCII(index), JSONReader.whitespaceASCII.contains(char) {
             index = nextIndex
         }
         return index
@@ -519,7 +522,7 @@
 
     func takeMatching(_ match: (UInt8) -> Bool) -> ([Character], Index) -> ([Character], Index)? {
         return { input, index in
-            guard let (byte, index) = self.source.takeASCII(index) where match(byte) else {
+            guard let (byte, index) = self.source.takeASCII(index), match(byte) else {
                 return nil
             }
             return (input + [Character(UnicodeScalar(byte))], index)
@@ -599,7 +602,7 @@
             return (String(UnicodeScalar(codeUnit)), index)
         }
 
-        guard let (trailCodeUnit, finalIndex) = try consumeASCIISequence("\\u", input: index).flatMap(parseCodeUnit) where UTF16.isTrailSurrogate(trailCodeUnit) else {
+        guard let (trailCodeUnit, finalIndex) = try consumeASCIISequence("\\u", input: index).flatMap(parseCodeUnit) , UTF16.isTrailSurrogate(trailCodeUnit) else {
             throw NSError(domain: NSCocoaErrorDomain, code: NSCocoaError.PropertyListReadCorruptError.rawValue, userInfo: [
                 "NSDebugDescription" : "Unable to convert unicode escape sequence (no low-surrogate code point) to UTF8-encoded character at position \(source.distanceFromStart(input))"
             ])
@@ -668,7 +671,7 @@
         else {
             var numberCharacters = [UInt8]()
             var index = input
-            while let (ascii, nextIndex) = source.takeASCII(index) where JSONReader.numberCodePoints.contains(ascii) {
+            while let (ascii, nextIndex) = source.takeASCII(index), JSONReader.numberCodePoints.contains(ascii) {
                 numberCharacters.append(ascii)
                 index = nextIndex
             }
diff --git a/Foundation/NSKeyedArchiver.swift b/Foundation/NSKeyedArchiver.swift
index fdcedae..5dc892c 100644
--- a/Foundation/NSKeyedArchiver.swift
+++ b/Foundation/NSKeyedArchiver.swift
@@ -283,9 +283,9 @@
         }
     }
     
-    private static func _createObjectRef(_ uid : UInt32) -> CFKeyedArchiverUID {
+    fileprivate static func _createObjectRef(_ uid : UInt32) -> CFKeyedArchiverUID {
         return Unmanaged<CFKeyedArchiverUID>.fromOpaque(
-            UnsafePointer<Void>(_CFKeyedArchiverUIDCreate(kCFAllocatorSystemDefault, uid))).takeUnretainedValue()
+            UnsafeRawPointer(_CFKeyedArchiverUIDCreate(kCFAllocatorSystemDefault, uid))).takeUnretainedValue()
     }
     
     private func _createObjectRefCached(_ uid : UInt32) -> CFKeyedArchiverUID {
@@ -654,7 +654,7 @@
         _encodePropertyList(objv, forKey: key)
     }
 
-    private func _encodeValueOfObjCType(_ type: _NSSimpleObjCType, at addr: UnsafePointer<Void>) {
+    private func _encodeValueOfObjCType(_ type: _NSSimpleObjCType, at addr: UnsafeRawPointer) {
         switch type {
         case .ID:
             let objectp = unsafeBitCast(addr, to: UnsafePointer<AnyObject>.self)
@@ -710,7 +710,7 @@
         }
     }
     
-    public override func encodeValue(ofObjCType typep: UnsafePointer<Int8>, at addr: UnsafePointer<Void>) {
+    public override func encodeValue(ofObjCType typep: UnsafePointer<Int8>, at addr: UnsafeRawPointer) {
         guard let type = _NSSimpleObjCType(UInt8(typep.pointee)) else {
             let spec = String(typep.pointee)
             fatalError("NSKeyedArchiver.encodeValueOfObjCType: unsupported type encoding spec '\(spec)'")
diff --git a/Foundation/NSKeyedCoderOldStyleArray.swift b/Foundation/NSKeyedCoderOldStyleArray.swift
index 75e9897..a4b71fe 100644
--- a/Foundation/NSKeyedCoderOldStyleArray.swift
+++ b/Foundation/NSKeyedCoderOldStyleArray.swift
@@ -11,7 +11,7 @@
 
 internal final class _NSKeyedCoderOldStyleArray : NSObject, NSCopying, NSSecureCoding, NSCoding {
 
-    private var _addr : UnsafeMutablePointer<UInt8> // free if decoding
+    private var _addr : UnsafeMutableRawPointer // free if decoding
     private var _count : Int
     private var _size : Int
     private var _type : _NSSimpleObjCType
@@ -24,14 +24,15 @@
         return _NSGetSizeAndAlignment(type, &size, &align) ? size : nil
     }
 
-    init?(objCType type: _NSSimpleObjCType, count: Int, at addr: UnsafePointer<Void>) {
-        self._addr = UnsafeMutablePointer<UInt8>(addr)
-        self._count = count
-        
+    // TODO: Why isn't `addr` passed as a mutable pointer?
+    init?(objCType type: _NSSimpleObjCType, count: Int, at addr: UnsafeRawPointer) {
+        self._addr = UnsafeMutableRawPointer(mutating: addr)
+        self._count = count        
+
         guard let size = _NSKeyedCoderOldStyleArray.sizeForObjCType(type) else {
             return nil
         }
-        
+
         self._size = size
         self._type = type
         self._decoded = false
@@ -39,8 +40,8 @@
 
     deinit {
         if self._decoded {
-            self._addr.deinitialize(count: self._count * self._size)
-            self._addr.deallocate(capacity: self._count * self._size)
+            // Cannot deinitialize memory without knowing the element type.
+            self._addr.deallocate(bytes: self._count * self._size, alignedTo: 1)
         }
     }
     
@@ -60,14 +61,14 @@
             return nil
         }
         
-        self._addr = UnsafeMutablePointer<UInt8>.allocate(capacity: self._count * self._size)
+        self._addr = UnsafeMutableRawPointer.allocate(bytes: self._count * self._size, alignedTo: 1)
         
         super.init()
         
         for idx in 0..<self._count {
             var type = Int8(self._type)
             
-            withUnsafePointer(&type) { typep in
+            withUnsafePointer(to: &type) { typep in
                 let addr = self._addr.advanced(by: idx * self._size)
                 aDecoder.decodeValue(ofObjCType: typep, at: addr)
             }
@@ -82,8 +83,8 @@
         for idx in 0..<self._count {
             var type = Int8(self._type)
 
-            withUnsafePointer(&type) { typep in
-                aCoder.encodeValue(ofObjCType: typep, at: &self._addr[idx * self._size])
+            withUnsafePointer(to: &type) { typep in
+                aCoder.encodeValue(ofObjCType: typep, at: self._addr + (idx * self._size))
             }
         }
     }
@@ -92,9 +93,9 @@
         return true
     }
     
-    func fillObjCType(_ type: _NSSimpleObjCType, count: Int, at addr: UnsafeMutablePointer<Void>) {
+    func fillObjCType(_ type: _NSSimpleObjCType, count: Int, at addr: UnsafeMutableRawPointer) {
         if type == self._type && count <= self._count {
-            UnsafeMutablePointer<UInt8>(addr).moveInitialize(from: self._addr, count: count * self._size)
+            addr.copyBytes(from: self._addr, count: count * self._size)
         }
     }
     
diff --git a/Foundation/NSKeyedUnarchiver.swift b/Foundation/NSKeyedUnarchiver.swift
index 409e224..cf34188 100644
--- a/Foundation/NSKeyedUnarchiver.swift
+++ b/Foundation/NSKeyedUnarchiver.swift
@@ -763,7 +763,7 @@
         return decodeObject() as? Data
     }
     
-    private func _decodeValueOfObjCType(_ type: _NSSimpleObjCType, at addr: UnsafeMutablePointer<Void>) {
+    private func _decodeValueOfObjCType(_ type: _NSSimpleObjCType, at addr: UnsafeMutableRawPointer) {
         switch type {
         case .ID:
             if let ns = decodeObject() {
@@ -834,7 +834,7 @@
         }
     }
     
-    public override func decodeValue(ofObjCType typep: UnsafePointer<Int8>, at addr: UnsafeMutablePointer<Void>) {
+    public override func decodeValue(ofObjCType typep: UnsafePointer<Int8>, at addr: UnsafeMutableRawPointer) {
         guard let type = _NSSimpleObjCType(UInt8(typep.pointee)) else {
             let spec = String(typep.pointee)
             fatalError("NSKeyedUnarchiver.decodeValueOfObjCType: unsupported type encoding spec '\(spec)'")
diff --git a/Foundation/NSLocale.swift b/Foundation/NSLocale.swift
index b745c85..a2c0186 100644
--- a/Foundation/NSLocale.swift
+++ b/Foundation/NSLocale.swift
@@ -13,9 +13,9 @@
 public class Locale: NSObject, NSCopying, NSSecureCoding {
     typealias CFType = CFLocale
     private var _base = _CFInfo(typeID: CFLocaleGetTypeID())
-    private var _identifier: UnsafeMutablePointer<Void>? = nil
-    private var _cache: UnsafeMutablePointer<Void>? = nil
-    private var _prefs: UnsafeMutablePointer<Void>? = nil
+    private var _identifier: UnsafeMutableRawPointer? = nil
+    private var _cache: UnsafeMutableRawPointer? = nil
+    private var _prefs: UnsafeMutableRawPointer? = nil
 #if os(OSX) || os(iOS)
     private var _lock = pthread_mutex_t()
 #elseif os(Linux)
diff --git a/Foundation/NSLock.swift b/Foundation/NSLock.swift
index d19f203..6b896d6 100644
--- a/Foundation/NSLock.swift
+++ b/Foundation/NSLock.swift
@@ -141,7 +141,7 @@
     public override init() {
         super.init()
         var attrib = pthread_mutexattr_t()
-        withUnsafeMutablePointer(&attrib) { attrs in
+        withUnsafeMutablePointer(to: &attrib) { attrs in
             pthread_mutexattr_settype(attrs, Int32(PTHREAD_MUTEX_RECURSIVE))
             pthread_mutex_init(mutex, attrs)
         }
@@ -208,12 +208,12 @@
         ts.tv_sec = Int(floor(ti))
         ts.tv_nsec = Int((ti - Double(ts.tv_sec)) * 1000000000.0)
         var tv = timeval()
-        withUnsafeMutablePointer(&tv) { t in
+        withUnsafeMutablePointer(to: &tv) { t in
             gettimeofday(t, nil)
             ts.tv_sec += t.pointee.tv_sec
             ts.tv_nsec += Int((t.pointee.tv_usec * 1000000) / 1000000000)
         }
-        let retVal: Int32 = withUnsafePointer(&ts) { t in
+        let retVal: Int32 = withUnsafePointer(to: &ts) { t in
             return pthread_cond_timedwait(cond, mutex, t)
         }
 
diff --git a/Foundation/NSNotification.swift b/Foundation/NSNotification.swift
index 76c7d7b..71aa387 100755
--- a/Foundation/NSNotification.swift
+++ b/Foundation/NSNotification.swift
@@ -85,7 +85,7 @@
     }
     
     public override var description: String {
-        var str = "\(self.dynamicType) \(unsafeAddress(of: self)) {"
+        var str = "\(self.dynamicType) \(Unmanaged.passUnretained(self).toOpaque()) {"
         
         str += "name = \(self.name.rawValue)"
         if let object = self.object {
diff --git a/Foundation/NSNumber.swift b/Foundation/NSNumber.swift
index 1212526..20bdfdd 100644
--- a/Foundation/NSNumber.swift
+++ b/Foundation/NSNumber.swift
@@ -225,43 +225,43 @@
         _CFNumberInitBool(_cfObject, value)
     }
     
-    public required convenience init(bytes buffer: UnsafePointer<Void>, objCType: UnsafePointer<Int8>) {
+    public required convenience init(bytes buffer: UnsafeRawPointer, objCType: UnsafePointer<Int8>) {
         guard let type = _NSSimpleObjCType(UInt8(objCType.pointee)) else {
             fatalError("NSNumber.init: unsupported type encoding spec '\(String(cString: objCType))'")
         }
         switch type {
         case .Bool:
-            self.init(value:UnsafePointer<Bool>(buffer).pointee)
+            self.init(value:buffer.load(as: Bool.self))
             break
         case .Char:
-            self.init(value:UnsafePointer<Int8>(buffer).pointee)
+            self.init(value:buffer.load(as: Int8.self))
             break
         case .UChar:
-            self.init(value:UnsafePointer<UInt8>(buffer).pointee)
+            self.init(value:buffer.load(as: UInt8.self))
             break
         case .Short:
-            self.init(value:UnsafePointer<Int16>(buffer).pointee)
+            self.init(value:buffer.load(as: Int16.self))
             break
         case .UShort:
-            self.init(value:UnsafePointer<UInt16>(buffer).pointee)
+            self.init(value:buffer.load(as: UInt16.self))
             break
         case .Int, .Long:
-            self.init(value:UnsafePointer<Int32>(buffer).pointee)
+            self.init(value:buffer.load(as: Int32.self))
             break
         case .UInt, .ULong:
-            self.init(value:UnsafePointer<UInt32>(buffer).pointee)
+            self.init(value:buffer.load(as: UInt32.self))
             break
         case .LongLong:
-            self.init(value:UnsafePointer<Int64>(buffer).pointee)
+            self.init(value:buffer.load(as: Int64.self))
             break
         case .ULongLong:
-            self.init(value:UnsafePointer<UInt64>(buffer).pointee)
+            self.init(value:buffer.load(as: UInt64.self))
             break
         case .Float:
-            self.init(value:UnsafePointer<Float>(buffer).pointee)
+            self.init(value:buffer.load(as: Float.self))
             break
         case .Double:
-            self.init(value:UnsafePointer<Double>(buffer).pointee)
+            self.init(value:buffer.load(as: Double.self))
             break
         default:
             fatalError("NSNumber.init: unsupported type encoding spec '\(String(cString: objCType))'")
@@ -272,8 +272,8 @@
     public required convenience init?(coder aDecoder: NSCoder) {
         if !aDecoder.allowsKeyedCoding {
             var objCType: UnsafeMutablePointer<Int8>? = nil
-            withUnsafeMutablePointer(&objCType, { (ptr: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>) -> Void in
-                aDecoder.decodeValue(ofObjCType: String(_NSSimpleObjCType.CharPtr), at: UnsafeMutablePointer<Void>(ptr))
+            withUnsafeMutablePointer(to: &objCType, { (ptr: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>) -> Void in
+                aDecoder.decodeValue(ofObjCType: String(_NSSimpleObjCType.CharPtr), at: UnsafeMutableRawPointer(ptr))
             })
             if objCType == nil {
                 return nil
@@ -310,7 +310,7 @@
 
     public var int8Value: Int8 {
         var val: Int8 = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<Int8>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<Int8>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberCharType, value)
         }
         return val
@@ -318,7 +318,7 @@
 
     public var uint8Value: UInt8 {
         var val: UInt8 = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<UInt8>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<UInt8>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberCharType, value)
         }
         return val
@@ -326,7 +326,7 @@
     
     public var int16Value: Int16 {
         var val: Int16 = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<Int16>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<Int16>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberShortType, value)
         }
         return val
@@ -334,7 +334,7 @@
     
     public var uint16Value: UInt16 {
         var val: UInt16 = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<UInt16>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<UInt16>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberShortType, value)
         }
         return val
@@ -342,7 +342,7 @@
     
     public var int32Value: Int32 {
         var val: Int32 = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<Int32>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<Int32>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberIntType, value)
         }
         return val
@@ -350,7 +350,7 @@
     
     public var uint32Value: UInt32 {
         var val: UInt32 = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<UInt32>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<UInt32>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberIntType, value)
         }
         return val
@@ -358,7 +358,7 @@
     
     public var int64Value: Int64 {
         var val: Int64 = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<Int64>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<Int64>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberLongLongType, value)
         }
         return val
@@ -366,7 +366,7 @@
     
     public var uint64Value: UInt64 {
         var val: UInt64 = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<UInt64>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<UInt64>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberLongLongType, value)
         }
         return val
@@ -374,7 +374,7 @@
     
     public var floatValue: Float {
         var val: Float = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<Float>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<Float>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberFloatType, value)
         }
         return val
@@ -382,7 +382,7 @@
     
     public var doubleValue: Double {
         var val: Double = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<Double>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<Double>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberDoubleType, value)
         }
         return val
@@ -394,7 +394,7 @@
     
     public var intValue: Int {
         var val: Int = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<Int>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<Int>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberLongType, value)
         }
         return val
@@ -402,7 +402,7 @@
     
     public var uintValue: UInt {
         var val: UInt = 0
-        withUnsafeMutablePointer(&val) { (value: UnsafeMutablePointer<UInt>) -> Void in
+        withUnsafeMutablePointer(to: &val) { (value: UnsafeMutablePointer<UInt>) -> Void in
             CFNumberGetValue(_cfObject, kCFNumberLongType, value)
         }
         return val
diff --git a/Foundation/NSNumberFormatter.swift b/Foundation/NSNumberFormatter.swift
index 37082fd..5331894 100644
--- a/Foundation/NSNumberFormatter.swift
+++ b/Foundation/NSNumberFormatter.swift
@@ -65,7 +65,7 @@
     
     public func number(from string: String) -> NSNumber? {
         var range = CFRange(location: 0, length: string.length)
-        let number = withUnsafeMutablePointer(&range) { (rangePointer: UnsafeMutablePointer<CFRange>) -> NSNumber? in
+        let number = withUnsafeMutablePointer(to: &range) { (rangePointer: UnsafeMutablePointer<CFRange>) -> NSNumber? in
             
             #if os(OSX) || os(iOS)
                 let result = CFNumberFormatterCreateNumberFromString(kCFAllocatorSystemDefault, _cfFormatter, string._cfObject, rangePointer, CFNumberFormatterOptionFlags.parseIntegersOnly.rawValue)
diff --git a/Foundation/NSObject.swift b/Foundation/NSObject.swift
index 346d83e..2f28980 100644
--- a/Foundation/NSObject.swift
+++ b/Foundation/NSObject.swift
@@ -100,7 +100,7 @@
     }
     
     public var description: String {
-        return "<\(self.dynamicType): \(unsafeAddress(of: self))>"
+        return "<\(self.dynamicType): \(Unmanaged.passUnretained(self).toOpaque())>"
     }
     
     public var debugDescription: String {
diff --git a/Foundation/NSOperation.swift b/Foundation/NSOperation.swift
index f149ba9..33fe69c 100644
--- a/Foundation/NSOperation.swift
+++ b/Foundation/NSOperation.swift
@@ -324,7 +324,7 @@
             if let requestedName = _name {
                 effectiveName = requestedName
             } else {
-                effectiveName = "NSOperationQueue::\(unsafeAddress(of: self))"
+                effectiveName = "NSOperationQueue::\(Unmanaged.passUnretained(self).toOpaque())"
             }
             let attr: DispatchQueueAttributes
             if maxConcurrentOperationCount == 1 {
diff --git a/Foundation/NSOrderedSet.swift b/Foundation/NSOrderedSet.swift
index 82a00de..930225e 100644
--- a/Foundation/NSOrderedSet.swift
+++ b/Foundation/NSOrderedSet.swift
@@ -301,7 +301,7 @@
     public convenience init(array set: [AnyObject], range: NSRange, copyItems flag: Bool) {
         var objects = set
 
-        if let range = range.toRange() where range.count != set.count || flag {
+        if let range = range.toRange(), range.count != set.count || flag {
             objects = [AnyObject]()
             for index in range.indices {
                 let object = set[index] as! NSObject
diff --git a/Foundation/NSProcessInfo.swift b/Foundation/NSProcessInfo.swift
index 9544ba5..1c40d5c 100644
--- a/Foundation/NSProcessInfo.swift
+++ b/Foundation/NSProcessInfo.swift
@@ -95,7 +95,7 @@
             return NSOperatingSystemVersion(majorVersion: fallbackMajor, minorVersion: fallbackMinor, patchVersion: fallbackPatch)
         }
         
-        let productVersionKey = unsafeBitCast(_kCFSystemVersionProductVersionKey, to: UnsafePointer<Void>.self)
+        let productVersionKey = unsafeBitCast(_kCFSystemVersionProductVersionKey, to: UnsafeRawPointer.self)
         guard let productVersion = unsafeBitCast(CFDictionaryGetValue(systemVersionDictionary, productVersionKey), to: NSString!.self) else {
             return NSOperatingSystemVersion(majorVersion: fallbackMajor, minorVersion: fallbackMinor, patchVersion: fallbackPatch)
         }
diff --git a/Foundation/NSPropertyList.swift b/Foundation/NSPropertyList.swift
index e9ff976..703cf16 100644
--- a/Foundation/NSPropertyList.swift
+++ b/Foundation/NSPropertyList.swift
@@ -50,7 +50,7 @@
     
     public class func data(fromPropertyList plist: AnyObject, format: PropertyListFormat, options opt: WriteOptions) throws -> Data {
         var error: Unmanaged<CFError>? = nil
-        let result = withUnsafeMutablePointer(&error) { (outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> CFData? in
+        let result = withUnsafeMutablePointer(to: &error) { (outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> CFData? in
 #if os(OSX) || os(iOS)
             let fmt = CFPropertyListFormat(rawValue: CFIndex(format.rawValue))!
 #else
@@ -70,8 +70,10 @@
     public class func propertyList(from data: Data, options opt: ReadOptions = [], format: UnsafeMutablePointer<PropertyListFormat>?) throws -> Any {
         var fmt = kCFPropertyListBinaryFormat_v1_0
         var error: Unmanaged<CFError>? = nil
-        let decoded = withUnsafeMutablePointers(&fmt, &error) { (outFmt: UnsafeMutablePointer<CFPropertyListFormat>, outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> NSObject? in
-            return unsafeBitCast(CFPropertyListCreateWithData(kCFAllocatorSystemDefault, data._cfObject, CFOptionFlags(CFIndex(opt.rawValue)), outFmt, outErr), to: NSObject.self)
+        let decoded = withUnsafeMutablePointer(to: &fmt) { (outFmt: UnsafeMutablePointer<CFPropertyListFormat>) -> NSObject? in
+            withUnsafeMutablePointer(to: &error) { (outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> NSObject? in
+                return unsafeBitCast(CFPropertyListCreateWithData(kCFAllocatorSystemDefault, data._cfObject, CFOptionFlags(CFIndex(opt.rawValue)), outFmt, outErr), to: NSObject.self)
+            }
         }
 #if os(OSX) || os(iOS)
         format?.pointee = PropertyListFormat(rawValue: UInt(fmt.rawValue))!
@@ -88,8 +90,10 @@
     internal class func propertyListWithStream(_ stream: CFReadStream, length streamLength: Int, options opt: ReadOptions, format: UnsafeMutablePointer <PropertyListFormat>?) throws -> Any {
         var fmt = kCFPropertyListBinaryFormat_v1_0
         var error: Unmanaged<CFError>? = nil
-        let decoded = withUnsafeMutablePointers(&fmt, &error) { (outFmt: UnsafeMutablePointer<CFPropertyListFormat>, outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> NSObject? in
-            return unsafeBitCast(CFPropertyListCreateWithStream(kCFAllocatorSystemDefault, stream, streamLength, CFOptionFlags(CFIndex(opt.rawValue)), outFmt, outErr), to: NSObject.self)
+        let decoded = withUnsafeMutablePointer(to: &fmt) { (outFmt: UnsafeMutablePointer<CFPropertyListFormat>) -> NSObject? in
+            withUnsafeMutablePointer(to: &error) { (outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> NSObject? in
+                return unsafeBitCast(CFPropertyListCreateWithStream(kCFAllocatorSystemDefault, stream, streamLength, CFOptionFlags(CFIndex(opt.rawValue)), outFmt, outErr), to: NSObject.self)
+            }
         }
 #if os(OSX) || os(iOS)
         format?.pointee = PropertyListFormat(rawValue: UInt(fmt.rawValue))!
diff --git a/Foundation/NSRange.swift b/Foundation/NSRange.swift
index 25928ac..6ff7387 100644
--- a/Foundation/NSRange.swift
+++ b/Foundation/NSRange.swift
@@ -52,11 +52,9 @@
 }
 
 extension NSRange: NSSpecialValueCoding {
-    init(bytes: UnsafePointer<Void>) {
-        let buffer = UnsafePointer<Int>(bytes)
-        
-        self.location = buffer.pointee
-        self.length = buffer.advanced(by: 1).pointee
+    init(bytes: UnsafeRawPointer) {
+        self.location = bytes.load(as: Int.self)
+        self.length = bytes.load(fromByteOffset: strideof(Int.self), as: Int.self)
     }
     
     init?(coder aDecoder: NSCoder) {
@@ -95,8 +93,8 @@
 #endif
     }
     
-    func getValue(_ value: UnsafeMutablePointer<Void>) {
-        UnsafeMutablePointer<NSRange>(value).pointee = self
+    func getValue(_ value: UnsafeMutableRawPointer) {
+        value.initializeMemory(as: NSRange.self, to: self)
     }
     
     func isEqual(_ aValue: Any) -> Bool {
diff --git a/Foundation/NSRegularExpression.swift b/Foundation/NSRegularExpression.swift
index 37a4f3d..1ee2ce5 100644
--- a/Foundation/NSRegularExpression.swift
+++ b/Foundation/NSRegularExpression.swift
@@ -120,7 +120,7 @@
     }
 }
 
-internal func _NSRegularExpressionMatch(_ context: UnsafeMutablePointer<Void>?, ranges: UnsafeMutablePointer<CFRange>?, count: CFIndex, options: _CFRegularExpressionMatchingOptions, stop: UnsafeMutablePointer<_DarwinCompatibleBoolean>) -> Void {
+internal func _NSRegularExpressionMatch(_ context: UnsafeMutableRawPointer?, ranges: UnsafeMutablePointer<CFRange>?, count: CFIndex, options: _CFRegularExpressionMatchingOptions, stop: UnsafeMutablePointer<_DarwinCompatibleBoolean>) -> Void {
     let matcher = unsafeBitCast(context, to: _NSRegularExpressionMatcher.self)
     if ranges == nil {
 #if os(OSX) || os(iOS)
@@ -153,7 +153,7 @@
 #else
         let opts = _CFRegularExpressionMatchingOptions(options.rawValue)
 #endif
-            _CFRegularExpressionEnumerateMatchesInString(_internal, string._cfObject, opts, CFRange(range), unsafeBitCast(matcher, to: UnsafeMutablePointer<Void>.self), _NSRegularExpressionMatch)
+            _CFRegularExpressionEnumerateMatchesInString(_internal, string._cfObject, opts, CFRange(range), unsafeBitCast(matcher, to: UnsafeMutableRawPointer.self), _NSRegularExpressionMatch)
         }
     }
     
diff --git a/Foundation/NSScanner.swift b/Foundation/NSScanner.swift
index 873bfd0..165ce6a 100644
--- a/Foundation/NSScanner.swift
+++ b/Foundation/NSScanner.swift
@@ -513,7 +513,7 @@
 extension Scanner {
     public func scanInt() -> Int32? {
         var value: Int32 = 0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<Int32>) -> Int32? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<Int32>) -> Int32? in
             if scanInt(ptr) {
                 return ptr.pointee
             } else {
@@ -524,7 +524,7 @@
     
     public func scanInteger() -> Int? {
         var value: Int = 0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<Int>) -> Int? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<Int>) -> Int? in
             if scanInteger(ptr) {
                 return ptr.pointee
             } else {
@@ -535,7 +535,7 @@
     
     public func scanLongLong() -> Int64? {
         var value: Int64 = 0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<Int64>) -> Int64? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<Int64>) -> Int64? in
             if scanLongLong(ptr) {
                 return ptr.pointee
             } else {
@@ -546,7 +546,7 @@
     
     public func scanUnsignedLongLong() -> UInt64? {
         var value: UInt64 = 0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<UInt64>) -> UInt64? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<UInt64>) -> UInt64? in
             if scanUnsignedLongLong(ptr) {
                 return ptr.pointee
             } else {
@@ -557,7 +557,7 @@
     
     public func scanFloat() -> Float? {
         var value: Float = 0.0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<Float>) -> Float? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<Float>) -> Float? in
             if scanFloat(ptr) {
                 return ptr.pointee
             } else {
@@ -568,7 +568,7 @@
     
     public func scanDouble() -> Double? {
         var value: Double = 0.0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<Double>) -> Double? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<Double>) -> Double? in
             if scanDouble(ptr) {
                 return ptr.pointee
             } else {
@@ -579,7 +579,7 @@
     
     public func scanHexInt() -> UInt32? {
         var value: UInt32 = 0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<UInt32>) -> UInt32? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<UInt32>) -> UInt32? in
             if scanHexInt(ptr) {
                 return ptr.pointee
             } else {
@@ -590,7 +590,7 @@
     
     public func scanHexLongLong() -> UInt64? {
         var value: UInt64 = 0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<UInt64>) -> UInt64? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<UInt64>) -> UInt64? in
             if scanHexLongLong(ptr) {
                 return ptr.pointee
             } else {
@@ -601,7 +601,7 @@
     
     public func scanHexFloat() -> Float? {
         var value: Float = 0.0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<Float>) -> Float? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<Float>) -> Float? in
             if scanHexFloat(ptr) {
                 return ptr.pointee
             } else {
@@ -612,7 +612,7 @@
     
     public func scanHexDouble() -> Double? {
         var value: Double = 0.0
-        return withUnsafeMutablePointer(&value) { (ptr: UnsafeMutablePointer<Double>) -> Double? in
+        return withUnsafeMutablePointer(to: &value) { (ptr: UnsafeMutablePointer<Double>) -> Double? in
             if scanHexDouble(ptr) {
                 return ptr.pointee
             } else {
diff --git a/Foundation/NSSet.swift b/Foundation/NSSet.swift
index 582d6e2..0d3fa25 100644
--- a/Foundation/NSSet.swift
+++ b/Foundation/NSSet.swift
@@ -43,7 +43,7 @@
             let cf = x._cfObject
             let cnt = CFSetGetCount(cf)
             
-            let objs = UnsafeMutablePointer<UnsafePointer<Void>?>.allocate(capacity: cnt)
+            let objs = UnsafeMutablePointer<UnsafeRawPointer?>.allocate(capacity: cnt)
             
             CFSetGetValues(cf, objs)
             
@@ -86,7 +86,7 @@
             NSRequiresConcreteImplementation()
         }
         
-        guard let obj = object as? NSObject where _storage.contains(obj) else {
+        guard let obj = object as? NSObject, _storage.contains(obj) else {
             return nil
         }
         
@@ -119,8 +119,8 @@
             // We're stuck with (int) here (rather than unsigned int)
             // because that's the way the code was originally written, unless
             // we go to a new version of the class, which has its own problems.
-            withUnsafeMutablePointer(&cnt) { (ptr: UnsafeMutablePointer<UInt32>) -> Void in
-                aDecoder.decodeValue(ofObjCType: "i", at: UnsafeMutablePointer<Void>(ptr))
+            withUnsafeMutablePointer(to: &cnt) { (ptr: UnsafeMutablePointer<UInt32>) -> Void in
+                aDecoder.decodeValue(ofObjCType: "i", at: UnsafeMutableRawPointer(ptr))
             }
             let objects = UnsafeMutablePointer<AnyObject?>.allocate(capacity: Int(cnt))
             for idx in 0..<cnt {
@@ -189,7 +189,7 @@
     }
 
     public override func isEqual(_ object: AnyObject?) -> Bool {
-        guard let otherObject = object where otherObject is NSSet else {
+        guard let otherObject = object, otherObject is NSSet else {
             return false
         }
         let otherSet = otherObject as! NSSet
@@ -301,7 +301,7 @@
     public func enumerateObjects(_ opts: EnumerationOptions = [], using block: @noescape (AnyObject, UnsafeMutablePointer<ObjCBool>) -> Void) {
         var stop : ObjCBool = false
         for obj in self {
-            withUnsafeMutablePointer(&stop) { stop in
+            withUnsafeMutablePointer(to: &stop) { stop in
                 block(obj, stop)
             }
             if stop {
diff --git a/Foundation/NSSpecialValue.swift b/Foundation/NSSpecialValue.swift
index 0fed230..ee7db65 100644
--- a/Foundation/NSSpecialValue.swift
+++ b/Foundation/NSSpecialValue.swift
@@ -10,10 +10,10 @@
 internal protocol NSSpecialValueCoding {
     static func objCType() -> String
     
-    init(bytes value: UnsafePointer<Void>)
+    init(bytes value: UnsafeRawPointer)
     func encodeWithCoder(_ aCoder: NSCoder)
     init?(coder aDecoder: NSCoder)
-    func getValue(_ value: UnsafeMutablePointer<Void>)
+    func getValue(_ value: UnsafeMutableRawPointer)
     
     // Ideally we would make NSSpecialValue a generic class and specialise it for
     // NSPoint, etc, but then we couldn't implement NSValue.init?(coder:) because 
@@ -81,7 +81,7 @@
         self._value = value
     }
     
-    required init(bytes value: UnsafePointer<Void>, objCType type: UnsafePointer<Int8>) {
+    required init(bytes value: UnsafeRawPointer, objCType type: UnsafePointer<Int8>) {
         guard let specialType = NSSpecialValue._typeFromObjCType(type) else {
             NSUnimplemented()
         }
@@ -89,7 +89,7 @@
         self._value = specialType.init(bytes: value)
     }
 
-    override func getValue(_ value: UnsafeMutablePointer<Void>) {
+    override func getValue(_ value: UnsafeMutableRawPointer) {
         self._value.getValue(value)
     }
 
diff --git a/Foundation/NSString.swift b/Foundation/NSString.swift
index f1b1a5c..d77a167 100644
--- a/Foundation/NSString.swift
+++ b/Foundation/NSString.swift
@@ -187,14 +187,14 @@
         return nil
     }
     
-    let buffer = malloc(cLength + 1)!
+    let buffer = malloc(cLength + 1)!.bindMemory(to: Int8.self, capacity: cLength + 1)
     if !str.getBytes(buffer, maxLength: cLength, usedLength: &used, encoding: encoding.rawValue, options: options, range: theRange, remaining: nil) {
         fatalError("Internal inconsistency; previously claimed getBytes returned success but failed with similar invocation")
     }
     
-    UnsafeMutablePointer<Int8>(buffer).advanced(by: cLength).initialize(to: 0)
+    buffer.advanced(by: cLength).initialize(to: 0)
     
-    return UnsafePointer<Int8>(buffer) // leaked and should be autoreleased via a NSData backing but we cannot here
+    return UnsafePointer(buffer) // leaked and should be autoreleased via a NSData backing but we cannot here
 }
 
 internal func isALineSeparatorTypeCharacter(_ ch: unichar) -> Bool {
@@ -550,7 +550,7 @@
         }
         
         var result = CFRange()
-        let res = withUnsafeMutablePointer(&result) { (rangep: UnsafeMutablePointer<CFRange>) -> Bool in
+        let res = withUnsafeMutablePointer(to: &result) { (rangep: UnsafeMutablePointer<CFRange>) -> Bool in
             if let loc = locale {
                 return CFStringFindWithOptionsAndLocale(_cfObject, searchString._cfObject, CFRange(searchRange), mask._cfValue(true), loc._cfObject, rangep)
             } else {
@@ -578,7 +578,7 @@
         precondition(searchRange.length <= len && searchRange.location <= len - searchRange.length, "Bounds Range {\(searchRange.location), \(searchRange.length)} out of bounds; string length \(len)")
         
         var result = CFRange()
-        let res = withUnsafeMutablePointer(&result) { (rangep: UnsafeMutablePointer<CFRange>) -> Bool in
+        let res = withUnsafeMutablePointer(to: &result) { (rangep: UnsafeMutablePointer<CFRange>) -> Bool in
             return CFStringFindCharacterFromSet(_cfObject, searchSet._cfObject, CFRange(searchRange), mask._cfValue(), rangep)
         }
         if res {
@@ -888,14 +888,14 @@
                 return true
             }
         }
-        if getBytes(UnsafeMutablePointer<Void>(buffer), maxLength: maxBufferCount, usedLength: &used, encoding: encoding, options: [], range: NSMakeRange(0, self.length), remaining: nil) {
+        if getBytes(UnsafeMutableRawPointer(buffer), maxLength: maxBufferCount, usedLength: &used, encoding: encoding, options: [], range: NSMakeRange(0, self.length), remaining: nil) {
             buffer.advanced(by: used).initialize(to: 0)
             return true
         }
         return false
     }
     
-    public func getBytes(_ buffer: UnsafeMutablePointer<Void>?, maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>?, encoding: UInt, options: EncodingConversionOptions = [], range: NSRange, remaining leftover: NSRangePointer?) -> Bool {
+    public func getBytes(_ buffer: UnsafeMutableRawPointer?, maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>?, encoding: UInt, options: EncodingConversionOptions = [], range: NSRange, remaining leftover: NSRangePointer?) -> Bool {
         var totalBytesWritten = 0
         var numCharsProcessed = 0
         let cfStringEncoding = CFStringConvertNSStringEncodingToEncoding(encoding)
@@ -905,7 +905,8 @@
                 let lossyOk = options.contains(.allowLossy)
                 let externalRep = options.contains(.externalRepresentation)
                 let failOnPartial = options.contains(.failOnPartialEncodingConversion)
-                numCharsProcessed = __CFStringEncodeByteStream(_cfObject, range.location, range.length, externalRep, cfStringEncoding, lossyOk ? (encoding == String.Encoding.ascii.rawValue ? 0xFF : 0x3F) : 0, UnsafeMutablePointer<UInt8>(buffer), buffer != nil ? maxBufferCount : 0, &totalBytesWritten)
+                let bytePtr = buffer?.bindMemory(to: UInt8.self, capacity: maxBufferCount)
+                numCharsProcessed = __CFStringEncodeByteStream(_cfObject, range.location, range.length, externalRep, cfStringEncoding, lossyOk ? (encoding == String.Encoding.ascii.rawValue ? 0xFF : 0x3F) : 0, bytePtr, bytePtr != nil ? maxBufferCount : 0, &totalBytesWritten)
                 if (failOnPartial && numCharsProcessed < range.length) || numCharsProcessed == 0 {
                     result = false
                 }
@@ -1147,7 +1148,8 @@
         var mData = Data(count: numBytes)!
         // The getBytes:... call should hopefully not fail, given it succeeded above, but check anyway (mutable string changing behind our back?)
         var used = 0
-        try mData.withUnsafeMutableBytes { (mutableBytes: UnsafeMutablePointer<Void>) -> Void in
+        // This binds mData memory to UInt8 because Data.withUnsafeMutableBytes does not handle raw pointers.
+        try mData.withUnsafeMutableBytes { (mutableBytes: UnsafeMutablePointer<UInt8>) -> Void in
             if !getBytes(mutableBytes, maxLength: numBytes, usedLength: &used, encoding: enc, options: [], range: theRange, remaining: nil) {
                 throw NSError(domain: NSCocoaErrorDomain, code: NSCocoaError.FileWriteUnknownError.rawValue, userInfo: [
                     NSURLErrorKey: dest,
@@ -1175,7 +1177,7 @@
         // ignore the no-copy-ness
         self.init(characters: characters, length: length)
         if freeBuffer { // cant take a hint here...
-            free(UnsafeMutablePointer<Void>(characters))
+            free(UnsafeMutableRawPointer(characters))
         }
     }
     
@@ -1215,8 +1217,8 @@
     }
     
     public convenience init?(data: Data, encoding: UInt) {
-        guard let cf = data.withUnsafeBytes({ (bytes: UnsafePointer<Void>) -> CFString? in
-            return CFStringCreateWithBytes(kCFAllocatorDefault, UnsafePointer<UInt8>(bytes), data.count, CFStringConvertNSStringEncodingToEncoding(encoding), true)
+        guard let cf = data.withUnsafeBytes({ (bytes: UnsafePointer<UInt8>) -> CFString? in
+            return CFStringCreateWithBytes(kCFAllocatorDefault, bytes, data.count, CFStringConvertNSStringEncodingToEncoding(encoding), true)
         }) else { return nil }
         
         var str: String?
@@ -1227,8 +1229,9 @@
         }
     }
     
-    public convenience init?(bytes: UnsafePointer<Void>, length len: Int, encoding: UInt) {
-        guard let cf = CFStringCreateWithBytes(kCFAllocatorDefault, UnsafePointer<UInt8>(bytes), len, CFStringConvertNSStringEncodingToEncoding(encoding), true) else {
+    public convenience init?(bytes: UnsafeRawPointer, length len: Int, encoding: UInt) {
+        let bytePtr = bytes.bindMemory(to: UInt8.self, capacity: len)
+        guard let cf = CFStringCreateWithBytes(kCFAllocatorDefault, bytePtr, len, CFStringConvertNSStringEncodingToEncoding(encoding), true) else {
             return nil
         }
         var str: String?
@@ -1239,7 +1242,7 @@
         }
     }
     
-    public convenience init?(bytesNoCopy bytes: UnsafeMutablePointer<Void>, length len: Int, encoding: UInt, freeWhenDone freeBuffer: Bool) /* "NoCopy" is a hint */ {
+    public convenience init?(bytesNoCopy bytes: UnsafeMutableRawPointer, length len: Int, encoding: UInt, freeWhenDone freeBuffer: Bool) /* "NoCopy" is a hint */ {
         // just copy for now since the internal storage will be a copy anyhow
         self.init(bytes: bytes, length: len, encoding: encoding)
         if freeBuffer { // dont take the hint
@@ -1262,7 +1265,8 @@
     public convenience init(contentsOf url: URL, encoding enc: UInt) throws {
         let readResult = try NSData(contentsOf: url, options: [])
 
-        guard let cf = CFStringCreateWithBytes(kCFAllocatorDefault, UnsafePointer<UInt8>(readResult.bytes), readResult.length, CFStringConvertNSStringEncodingToEncoding(enc), true) else {
+        let bytePtr = readResult.bytes.bindMemory(to: UInt8.self, capacity: readResult.length)
+        guard let cf = CFStringCreateWithBytes(kCFAllocatorDefault, bytePtr, readResult.length, CFStringConvertNSStringEncodingToEncoding(enc), true) else {
             throw NSError(domain: NSCocoaErrorDomain, code: NSCocoaError.FileReadInapplicableStringEncodingError.rawValue, userInfo: [
                 "NSDebugDescription" : "Unable to create a string using the specified encoding."
                 ])
@@ -1397,8 +1401,8 @@
         if let findResults = CFStringCreateArrayWithFindResults(kCFAllocatorSystemDefault, _cfObject, target._cfObject, CFRange(searchRange), options._cfValue(true)) {
             let numOccurrences = CFArrayGetCount(findResults)
             for cnt in 0..<numOccurrences {
-                let range = UnsafePointer<CFRange>(CFArrayGetValueAtIndex(findResults, backwards ? cnt : numOccurrences - cnt - 1)!)
-                replaceCharacters(in: NSRange(range.pointee), with: replacement)
+                let rangePtr = CFArrayGetValueAtIndex(findResults, backwards ? cnt : numOccurrences - cnt - 1)
+                replaceCharacters(in: NSRange(rangePtr!.load(as: CFRange.self)), with: replacement)
             }
             return numOccurrences
         } else {
@@ -1409,7 +1413,7 @@
     
     public func applyTransform(_ transform: String, reverse: Bool, range: NSRange, updatedRange resultingRange: NSRangePointer?) -> Bool {
         var cfRange = CFRangeMake(range.location, range.length)
-        return withUnsafeMutablePointer(&cfRange) { (rangep: UnsafeMutablePointer<CFRange>) -> Bool in
+        return withUnsafeMutablePointer(to: &cfRange) { (rangep: UnsafeMutablePointer<CFRange>) -> Bool in
             if CFStringTransform(_cfMutableObject, rangep, transform._cfObject, reverse) {
                 resultingRange?.pointee.location = rangep.pointee.location
                 resultingRange?.pointee.length = rangep.pointee.length
diff --git a/Foundation/NSSwiftRuntime.swift b/Foundation/NSSwiftRuntime.swift
index 0f4616b..3f5514a 100644
--- a/Foundation/NSSwiftRuntime.swift
+++ b/Foundation/NSSwiftRuntime.swift
@@ -66,8 +66,8 @@
 
 // Ivars in _NSCF* types must be zeroed via an unsafe accessor to avoid deinit of potentially unsafe memory to accces as an object/struct etc since it is stored via a foreign object graph
 internal func _CFZeroUnsafeIvars<T>(_ arg: inout T) {
-    withUnsafeMutablePointer(&arg) { (ptr: UnsafeMutablePointer<T>) -> Void in
-        bzero(unsafeBitCast(ptr, to: UnsafeMutablePointer<Void>.self), sizeof(T.self))
+    withUnsafeMutablePointer(to: &arg) { (ptr: UnsafeMutablePointer<T>) -> Void in
+        bzero(unsafeBitCast(ptr, to: UnsafeMutableRawPointer.self), sizeof(T.self))
     }
 }
 
@@ -77,24 +77,24 @@
 
 internal func __CFInitializeSwift() {
     
-    _CFRuntimeBridgeTypeToClass(CFStringGetTypeID(), unsafeBitCast(_NSCFString.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFArrayGetTypeID(), unsafeBitCast(_NSCFArray.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFDictionaryGetTypeID(), unsafeBitCast(_NSCFDictionary.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFSetGetTypeID(), unsafeBitCast(_NSCFSet.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFNumberGetTypeID(), unsafeBitCast(NSNumber.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFDataGetTypeID(), unsafeBitCast(NSData.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFDateGetTypeID(), unsafeBitCast(NSDate.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFURLGetTypeID(), unsafeBitCast(NSURL.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFCalendarGetTypeID(), unsafeBitCast(Calendar.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFLocaleGetTypeID(), unsafeBitCast(Locale.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFTimeZoneGetTypeID(), unsafeBitCast(TimeZone.self, to: UnsafePointer<Void>.self))
-    _CFRuntimeBridgeTypeToClass(CFCharacterSetGetTypeID(), unsafeBitCast(_NSCFCharacterSet.self, to: UnsafePointer<Void>.self))
+    _CFRuntimeBridgeTypeToClass(CFStringGetTypeID(), unsafeBitCast(_NSCFString.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFArrayGetTypeID(), unsafeBitCast(_NSCFArray.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFDictionaryGetTypeID(), unsafeBitCast(_NSCFDictionary.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFSetGetTypeID(), unsafeBitCast(_NSCFSet.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFNumberGetTypeID(), unsafeBitCast(NSNumber.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFDataGetTypeID(), unsafeBitCast(NSData.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFDateGetTypeID(), unsafeBitCast(NSDate.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFURLGetTypeID(), unsafeBitCast(NSURL.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFCalendarGetTypeID(), unsafeBitCast(Calendar.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFLocaleGetTypeID(), unsafeBitCast(Locale.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFTimeZoneGetTypeID(), unsafeBitCast(TimeZone.self, to: UnsafeRawPointer.self))
+    _CFRuntimeBridgeTypeToClass(CFCharacterSetGetTypeID(), unsafeBitCast(_NSCFCharacterSet.self, to: UnsafeRawPointer.self))
     
-//    _CFRuntimeBridgeTypeToClass(CFErrorGetTypeID(), unsafeBitCast(NSError.self, UnsafePointer<Void>.self))
-//    _CFRuntimeBridgeTypeToClass(CFAttributedStringGetTypeID(), unsafeBitCast(NSMutableAttributedString.self, UnsafePointer<Void>.self))
-//    _CFRuntimeBridgeTypeToClass(CFReadStreamGetTypeID(), unsafeBitCast(NSInputStream.self, UnsafePointer<Void>.self))
-//    _CFRuntimeBridgeTypeToClass(CFWriteStreamGetTypeID(), unsafeBitCast(NSOutputStream.self, UnsafePointer<Void>.self))
-   _CFRuntimeBridgeTypeToClass(CFRunLoopTimerGetTypeID(), unsafeBitCast(Timer.self, to: UnsafePointer<Void>.self))
+//    _CFRuntimeBridgeTypeToClass(CFErrorGetTypeID(), unsafeBitCast(NSError.self, UnsafeRawPointer.self))
+//    _CFRuntimeBridgeTypeToClass(CFAttributedStringGetTypeID(), unsafeBitCast(NSMutableAttributedString.self, UnsafeRawPointer.self))
+//    _CFRuntimeBridgeTypeToClass(CFReadStreamGetTypeID(), unsafeBitCast(NSInputStream.self, UnsafeRawPointer.self))
+//    _CFRuntimeBridgeTypeToClass(CFWriteStreamGetTypeID(), unsafeBitCast(NSOutputStream.self, UnsafeRawPointer.self))
+   _CFRuntimeBridgeTypeToClass(CFRunLoopTimerGetTypeID(), unsafeBitCast(Timer.self, to: UnsafeRawPointer.self))
     
     __CFSwiftBridge.NSObject.isEqual = _CFSwiftIsEqual
     __CFSwiftBridge.NSObject.hash = _CFSwiftGetHash
@@ -307,43 +307,47 @@
 }
 
 public func === (lhs: AnyClass, rhs: AnyClass) -> Bool {
-    return unsafeBitCast(lhs, to: UnsafePointer<Void>.self) == unsafeBitCast(rhs, to: UnsafePointer<Void>.self)
+    return unsafeBitCast(lhs, to: UnsafeRawPointer.self) == unsafeBitCast(rhs, to: UnsafeRawPointer.self)
 }
 
 /// Swift extensions for common operations in Foundation that use unsafe things...
 
 
 extension NSObject {
-    static func unretainedReference<T, R: NSObject>(_ value: UnsafePointer<T>) -> R {
+    static func unretainedReference<R: NSObject>(_ value: UnsafeRawPointer) -> R {
         return unsafeBitCast(value, to: R.self)
     }
     
-    static func unretainedReference<T, R: NSObject>(_ value: UnsafeMutablePointer<T>) -> R {
-        return unretainedReference(UnsafePointer<T>(value))
+    static func unretainedReference<R: NSObject>(_ value: UnsafeMutableRawPointer) -> R {
+        return unretainedReference(UnsafeRawPointer(value))
     }
     
-    static func releaseReference<T>(_ value: UnsafePointer<T>) {
-        _CFSwiftRelease(UnsafeMutablePointer<Void>(value))
+    static func releaseReference(_ value: UnsafeRawPointer) {
+        _CFSwiftRelease(UnsafeMutableRawPointer(mutating: value))
     }
     
-    static func releaseReference<T>(_ value: UnsafeMutablePointer<T>) {
+    static func releaseReference(_ value: UnsafeMutableRawPointer) {
         _CFSwiftRelease(value)
     }
 
     func withRetainedReference<T, R>(_ work: @noescape (UnsafePointer<T>) -> R) -> R {
-        return work(UnsafePointer<T>(_CFSwiftRetain(unsafeBitCast(self, to: UnsafeMutablePointer<Void>.self))!))
+        let selfPtr = Unmanaged.passRetained(self).toOpaque().assumingMemoryBound(to: T.self)
+        return work(selfPtr)
     }
     
     func withRetainedReference<T, R>(_ work: @noescape (UnsafeMutablePointer<T>) -> R) -> R {
-        return work(UnsafeMutablePointer<T>(_CFSwiftRetain(unsafeBitCast(self, to: UnsafeMutablePointer<Void>.self))!))
+        let selfPtr = Unmanaged.passRetained(self).toOpaque().assumingMemoryBound(to: T.self)
+        return work(selfPtr)
     }
     
     func withUnretainedReference<T, R>(_ work: @noescape (UnsafePointer<T>) -> R) -> R {
-        return work(unsafeBitCast(self, to: UnsafePointer<T>.self))
+        let selfPtr = Unmanaged.passUnretained(self).toOpaque().assumingMemoryBound(to: T.self)
+        return work(selfPtr)
     }
     
     func withUnretainedReference<T, R>(_ work: @noescape (UnsafeMutablePointer<T>) -> R) -> R {
-        return work(unsafeBitCast(self, to: UnsafeMutablePointer<T>.self))
+        let selfPtr = Unmanaged.passUnretained(self).toOpaque().assumingMemoryBound(to: T.self)
+        return work(selfPtr)
     }
 }
 
diff --git a/Foundation/NSTask.swift b/Foundation/NSTask.swift
index 08df7fa..74ca7a7 100644
--- a/Foundation/NSTask.swift
+++ b/Foundation/NSTask.swift
@@ -34,24 +34,24 @@
 internal let kCFSocketDataCallBack = CFSocketCallBackType.dataCallBack.rawValue
 #endif
 
-private func emptyRunLoopCallback(_ context : UnsafeMutablePointer<Void>?) -> Void {}
+private func emptyRunLoopCallback(_ context : UnsafeMutableRawPointer?) -> Void {}
 
 
 // Retain method for run loop source
-private func runLoopSourceRetain(_ pointer : UnsafePointer<Void>?) -> UnsafePointer<Void>? {
+private func runLoopSourceRetain(_ pointer : UnsafeRawPointer?) -> UnsafeRawPointer? {
     let ref = Unmanaged<AnyObject>.fromOpaque(pointer!).takeUnretainedValue()
     let retained = Unmanaged<AnyObject>.passRetained(ref)
-    return unsafeBitCast(retained, to: UnsafePointer<Void>.self)
+    return unsafeBitCast(retained, to: UnsafeRawPointer.self)
 }
 
 // Release method for run loop source
-private func runLoopSourceRelease(_ pointer : UnsafePointer<Void>?) -> Void {
+private func runLoopSourceRelease(_ pointer : UnsafeRawPointer?) -> Void {
     Unmanaged<AnyObject>.fromOpaque(pointer!).release()
 }
 
 // Equal method for run loop source
 
-private func runloopIsEqual(_ a : UnsafePointer<Void>?, _ b : UnsafePointer<Void>?) -> _DarwinCompatibleBoolean {
+private func runloopIsEqual(_ a : UnsafeRawPointer?, _ b : UnsafeRawPointer?) -> _DarwinCompatibleBoolean {
     
     let unmanagedrunLoopA = Unmanaged<AnyObject>.fromOpaque(a!)
     guard let runLoopA = unmanagedrunLoopA.takeUnretainedValue() as? RunLoop else {
@@ -72,7 +72,7 @@
 
 
 // Equal method for task in run loop source
-private func nstaskIsEqual(_ a : UnsafePointer<Void>?, _ b : UnsafePointer<Void>?) -> _DarwinCompatibleBoolean {
+private func nstaskIsEqual(_ a : UnsafeRawPointer?, _ b : UnsafeRawPointer?) -> _DarwinCompatibleBoolean {
     
     let unmanagedTaskA = Unmanaged<AnyObject>.fromOpaque(a!)
     guard let taskA = unmanagedTaskA.takeUnretainedValue() as? Task else {
@@ -108,7 +108,8 @@
                     emptySourceContext.equal = runloopIsEqual
                     emptySourceContext.perform = emptyRunLoopCallback
                     managerThreadRunLoop!.withUnretainedReference {
-                        emptySourceContext.info = $0
+                        (refPtr: UnsafeMutablePointer<UInt8>) in
+                        emptySourceContext.info = UnsafeMutableRawPointer(refPtr)
                     }
                     
                     CFRunLoopAddSource(managerThreadRunLoop?._cfRunLoop, CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &emptySourceContext), kCFRunLoopDefaultMode)
@@ -212,7 +213,7 @@
         
         defer {
             for arg in argv ..< argv + args.count {
-                free(UnsafeMutablePointer<Void>(arg.pointee))
+                free(UnsafeMutableRawPointer(arg.pointee))
             }
             
             argv.deallocate(capacity: args.count + 1)
@@ -232,7 +233,7 @@
         defer {
             if let env = environment {
                 for pair in envp ..< envp + env.count {
-                    free(UnsafeMutablePointer<Void>(pair.pointee))
+                    free(UnsafeMutableRawPointer(pair.pointee))
                 }
                 envp.deallocate(capacity: env.count + 1)
             }
@@ -244,7 +245,7 @@
         context.version = 0
         context.retain = runLoopSourceRetain
         context.release = runLoopSourceRelease
-		context.info = UnsafeMutablePointer<Void>(Unmanaged.passUnretained(self).toOpaque())
+	context.info = Unmanaged.passUnretained(self).toOpaque()
         
         let socket = CFSocketCreateWithNative( nil, taskSocketPair[0], CFOptionFlags(kCFSocketDataCallBack), {
             (socket, type, address, data, info )  in
@@ -368,7 +369,7 @@
         
         self.runLoop = RunLoop.current()
         self.runLoopSourceContext = CFRunLoopSourceContext(version: 0,
-                                                           info: UnsafeMutablePointer<Void>(Unmanaged.passUnretained(self).toOpaque()),
+                                                           info: Unmanaged.passUnretained(self).toOpaque(),
                                                            retain: { return runLoopSourceRetain($0) },
                                                            release: { runLoopSourceRelease($0) },
                                                            copyDescription: nil,
@@ -386,7 +387,8 @@
         runLoopContext.equal = nstaskIsEqual
         runLoopContext.perform = emptyRunLoopCallback
         self.withUnretainedReference {
-            runLoopContext.info = $0
+            (refPtr: UnsafeMutablePointer<UInt8>) in
+            runLoopContext.info = UnsafeMutableRawPointer(refPtr)
         }
         self.runLoopSourceContext = runLoopContext
         
diff --git a/Foundation/NSThread.swift b/Foundation/NSThread.swift
index ced09dd..93d7060 100644
--- a/Foundation/NSThread.swift
+++ b/Foundation/NSThread.swift
@@ -46,7 +46,7 @@
     case finished
 }
 
-private func NSThreadStart(_ context: UnsafeMutablePointer<Void>?) -> UnsafeMutablePointer<Void>? {
+private func NSThreadStart(_ context: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
     let thread: Thread = NSObject.unretainedReference(context!)
     Thread._currentThread.set(thread)
     thread._status = .executing
@@ -87,13 +87,13 @@
             var __ts__ = timespec(tv_sec: LONG_MAX, tv_nsec: 0)
             if ti < Double(LONG_MAX) {
                 var integ = 0.0
-                let frac: Double = withUnsafeMutablePointer(&integ) { integp in
+                let frac: Double = withUnsafeMutablePointer(to: &integ) { integp in
                     return modf(ti, integp)
                 }
                 __ts__.tv_sec = Int(integ)
                 __ts__.tv_nsec = Int(frac * 1000000000.0)
             }
-            let _ = withUnsafePointer(&__ts__) { ts in
+            let _ = withUnsafePointer(to: &__ts__) { ts in
                 nanosleep(ts, nil)
             }
             ti = end_ut - CFGetSystemUptime()
@@ -108,13 +108,13 @@
             var __ts__ = timespec(tv_sec: LONG_MAX, tv_nsec: 0)
             if ti < Double(LONG_MAX) {
                 var integ = 0.0
-                let frac: Double = withUnsafeMutablePointer(&integ) { integp in
+                let frac: Double = withUnsafeMutablePointer(to: &integ) { integp in
                     return modf(ti, integp)
                 }
                 __ts__.tv_sec = Int(integ)
                 __ts__.tv_nsec = Int(frac * 1000000000.0)
             }
-            let _ = withUnsafePointer(&__ts__) { ts in
+            let _ = withUnsafePointer(to: &__ts__) { ts in
                 nanosleep(ts, nil)
             }
             ti = end_ut - CFGetSystemUptime()
@@ -144,7 +144,7 @@
 
     public init(_ main: (Void) -> Void) {
         _main = main
-        let _ = withUnsafeMutablePointer(&_attr) { attr in
+        let _ = withUnsafeMutablePointer(to: &_attr) { attr in
             pthread_attr_init(attr)
             pthread_attr_setscope(attr, Int32(PTHREAD_SCOPE_SYSTEM))
             pthread_attr_setdetachstate(attr, Int32(PTHREAD_CREATE_DETACHED))
@@ -170,9 +170,11 @@
     public var stackSize: Int {
         get {
             var size: Int = 0
-            return withUnsafeMutablePointers(&_attr, &size) { attr, sz in
-                pthread_attr_getstacksize(attr, sz)
-                return sz.pointee
+            return withUnsafeMutablePointer(to: &_attr) { attr in
+                withUnsafeMutablePointer(to: &size) { sz in
+                    pthread_attr_getstacksize(attr, sz)
+                    return sz.pointee
+                }
             }
         }
         set {
@@ -181,7 +183,7 @@
             if (1 << 30) < s {
                 s = 1 << 30
             }
-            let _ = withUnsafeMutablePointer(&_attr) { attr in
+            let _ = withUnsafeMutablePointer(to: &_attr) { attr in
                 pthread_attr_setstacksize(attr, s)
             }
         }
diff --git a/Foundation/NSTimeZone.swift b/Foundation/NSTimeZone.swift
index ef49564..0d382da 100644
--- a/Foundation/NSTimeZone.swift
+++ b/Foundation/NSTimeZone.swift
@@ -13,9 +13,9 @@
 public class TimeZone : NSObject, NSCopying, NSSecureCoding, NSCoding {
     typealias CFType = CFTimeZone
     private var _base = _CFInfo(typeID: CFTimeZoneGetTypeID())
-    private var _name: UnsafeMutablePointer<Void>? = nil
-    private var _data: UnsafeMutablePointer<Void>? = nil
-    private var _periods: UnsafeMutablePointer<Void>? = nil
+    private var _name: UnsafeMutableRawPointer? = nil
+    private var _data: UnsafeMutableRawPointer? = nil
+    private var _periods: UnsafeMutableRawPointer? = nil
     private var _periodCnt = Int32(0)
     
     internal var _cfObject: CFType {
@@ -86,7 +86,7 @@
     
     public convenience init?(abbreviation: String) {
         let abbr = abbreviation._cfObject
-        guard let name = unsafeBitCast(CFDictionaryGetValue(CFTimeZoneCopyAbbreviationDictionary(), unsafeBitCast(abbr, to: UnsafePointer<Void>.self)), to: NSString!.self) else {
+        guard let name = unsafeBitCast(CFDictionaryGetValue(CFTimeZoneCopyAbbreviationDictionary(), unsafeBitCast(abbr, to: UnsafeRawPointer.self)), to: NSString!.self) else {
             return nil
         }
         self.init(name: name._swiftObject , data: nil)
diff --git a/Foundation/NSTimer.swift b/Foundation/NSTimer.swift
index 8925d24..03030bd 100644
--- a/Foundation/NSTimer.swift
+++ b/Foundation/NSTimer.swift
@@ -10,7 +10,7 @@
 
 import CoreFoundation
 
-internal func __NSFireTimer(_ timer: CFRunLoopTimer?, info: UnsafeMutablePointer<Void>?) -> Void {
+internal func __NSFireTimer(_ timer: CFRunLoopTimer?, info: UnsafeMutableRawPointer?) -> Void {
     let t: Timer = NSObject.unretainedReference(info!)
     t._fire(t)
 }
@@ -39,9 +39,10 @@
         _fire = block
         var context = CFRunLoopTimerContext()
         withRetainedReference {
-            context.info = $0
+            (refPtr: UnsafeMutablePointer<UInt8>) in
+            context.info = UnsafeMutableRawPointer(refPtr)
         }
-        let timer = withUnsafeMutablePointer(&context) { (ctx: UnsafeMutablePointer<CFRunLoopTimerContext>) -> CFRunLoopTimer in
+        let timer = withUnsafeMutablePointer(to: &context) { (ctx: UnsafeMutablePointer<CFRunLoopTimerContext>) -> CFRunLoopTimer in
             var t = interval
             if !repeats {
                 t = 0.0
diff --git a/Foundation/NSURL.swift b/Foundation/NSURL.swift
index 5fad200..c3600a0 100644
--- a/Foundation/NSURL.swift
+++ b/Foundation/NSURL.swift
@@ -343,10 +343,10 @@
         let bytesNeeded = CFURLGetBytes(_cfObject, nil, 0)
         assert(bytesNeeded > 0)
         
-        let buffer = malloc(bytesNeeded)!
-        let bytesFilled = CFURLGetBytes(_cfObject, UnsafeMutablePointer<UInt8>(buffer), bytesNeeded)
+        let buffer = malloc(bytesNeeded)!.bindMemory(to: UInt8.self, capacity: bytesNeeded)
+        let bytesFilled = CFURLGetBytes(_cfObject, buffer, bytesNeeded)
         if bytesFilled == bytesNeeded {
-            return Data(bytesNoCopy: UnsafeMutablePointer<UInt8>(buffer), count: bytesNeeded, deallocator: .none)
+            return Data(bytesNoCopy: buffer, count: bytesNeeded, deallocator: .none)
         } else {
             fatalError()
         }
diff --git a/Foundation/NSURLRequest.swift b/Foundation/NSURLRequest.swift
index d071add..f770fef 100644
--- a/Foundation/NSURLRequest.swift
+++ b/Foundation/NSURLRequest.swift
@@ -170,13 +170,13 @@
     public static func supportsSecureCoding() -> Bool { return true }
     
     /// The URL of the receiver.
-    /*@NSCopying */public private(set) var url: URL?
+    /*@NSCopying */public fileprivate(set) var url: URL?
     
     /// The main document URL associated with this load.
     ///
     /// This URL is used for the cookie "same domain as main
     /// document" policy. There may also be other future uses.
-    /*@NSCopying*/ public private(set) var mainDocumentURL: URL?
+    /*@NSCopying*/ public fileprivate(set) var mainDocumentURL: URL?
     
     internal var _cachePolicy: CachePolicy = .useProtocolCachePolicy
     public var cachePolicy: CachePolicy {
@@ -189,7 +189,7 @@
     }
 
     /// Returns the HTTP request method of the receiver.
-    public private(set) var httpMethod: String? = "GET"
+    public fileprivate(set) var httpMethod: String? = "GET"
     
     /// A dictionary containing all the HTTP header fields
     /// of the receiver.
diff --git a/Foundation/NSURLResponse.swift b/Foundation/NSURLResponse.swift
index 2482706..752d069 100644
--- a/Foundation/NSURLResponse.swift
+++ b/Foundation/NSURLResponse.swift
@@ -67,7 +67,7 @@
     /// that the origin server or source reported the information
     /// incorrectly or imprecisely. An attempt to guess the MIME type may
     /// be made if the origin source did not report any such information.
-    public private(set) var mimeType: String?
+    public fileprivate(set) var mimeType: String?
     
     /// The expected content length of the receiver.
     ///
@@ -81,7 +81,7 @@
     /// The expected content length of the receiver, or `-1` if
     /// there is no expectation that can be arrived at regarding expected
     /// content length.
-    public private(set) var expectedContentLength: Int64
+    public fileprivate(set) var expectedContentLength: Int64
     
     /// The name of the text encoding of the receiver.
     ///
@@ -90,7 +90,7 @@
     /// URL load. Clients can inspect this string and convert it to an
     /// NSStringEncoding or CFStringEncoding using the methods and
     /// functions made available in the appropriate framework.
-    public private(set) var textEncodingName: String?
+    public fileprivate(set) var textEncodingName: String?
     
     /// A suggested filename if the resource were saved to disk.
     ///
@@ -104,7 +104,7 @@
     /// method appends the proper file extension based on the MIME type.
     ///
     /// This method always returns a valid filename.
-    public private(set) var suggestedFilename: String?
+    public fileprivate(set) var suggestedFilename: String?
 }
 
 /// A Response to an HTTP URL load.
@@ -232,7 +232,7 @@
     /// A string that represents the contents of the NSHTTPURLResponse Object.
     /// This property is intended to produce readable output.
     override public var description: String {
-        var result = "<\(self.dynamicType) \(unsafeAddress(of: self))> { URL: \(url!.absoluteString) }{ status: \(statusCode), headers {\n"
+        var result = "<\(self.dynamicType) \(Unmanaged.passUnretained(self).toOpaque())> { URL: \(url!.absoluteString) }{ status: \(statusCode), headers {\n"
         for(key, value) in allHeaderFields {
             if((key.lowercased() == "content-disposition" && suggestedFilename != "Unknown") || key.lowercased() == "content-type") {
                 result += "   \"\(key)\" = \"\(value)\";\n"
@@ -357,9 +357,9 @@
             }
         }
         
-        let escape = UnicodeScalar(0x5c)    //  \
-        let quote = UnicodeScalar(0x22)     //  "
-        let separator = UnicodeScalar(0x3b) //  ;
+        let escape = UnicodeScalar(0x5c)!    //  \
+        let quote = UnicodeScalar(0x22)!     //  "
+        let separator = UnicodeScalar(0x3b)! //  ;
         enum State {
             case nonQuoted(String)
             case nonQuotedEscaped(String)
diff --git a/Foundation/NSUUID.swift b/Foundation/NSUUID.swift
index 9d17245..e35bf3a 100644
--- a/Foundation/NSUUID.swift
+++ b/Foundation/NSUUID.swift
@@ -32,7 +32,7 @@
     }
     
     public init(UUIDBytes bytes: UnsafePointer<UInt8>) {
-        memcpy(unsafeBitCast(buffer, to: UnsafeMutablePointer<Void>.self), UnsafePointer<Void>(bytes), 16)
+        memcpy(unsafeBitCast(buffer, to: UnsafeMutableRawPointer.self), UnsafeRawPointer(bytes), 16)
     }
     
     public func getUUIDBytes(_ uuid: UnsafeMutablePointer<UInt8>) {
diff --git a/Foundation/NSValue.swift b/Foundation/NSValue.swift
index b59834b..5578cc3 100644
--- a/Foundation/NSValue.swift
+++ b/Foundation/NSValue.swift
@@ -76,7 +76,7 @@
         }
     }
     
-    public func getValue(_ value: UnsafeMutablePointer<Void>) {
+    public func getValue(_ value: UnsafeMutableRawPointer) {
         if self.dynamicType == NSValue.self {
             return _concreteValue.getValue(value)
         } else {
@@ -96,7 +96,7 @@
         return NSSpecialValue._typeFromObjCType(type) != nil
     }
     
-    public convenience required init(bytes value: UnsafePointer<Void>, objCType type: UnsafePointer<Int8>) {
+    public convenience required init(bytes value: UnsafeRawPointer, objCType type: UnsafePointer<Int8>) {
         if self.dynamicType == NSValue.self {
             self.init()
             if NSValue._isSpecialObjCType(type) {
diff --git a/Foundation/NSXMLNode.swift b/Foundation/NSXMLNode.swift
index c776509..c28bbc9 100644
--- a/Foundation/NSXMLNode.swift
+++ b/Foundation/NSXMLNode.swift
@@ -719,7 +719,7 @@
         var result: [XMLNode] = []
         for i in 0..<CFArrayGetCount(nodes) {
             let nodePtr = CFArrayGetValueAtIndex(nodes, i)!
-            result.append(XMLNode._objectNodeForNode(_CFXMLNodePtr(nodePtr)))
+            result.append(XMLNode._objectNodeForNode(_CFXMLNodePtr(mutating: nodePtr)))
         }
 
         return result
diff --git a/Foundation/NSXMLParser.swift b/Foundation/NSXMLParser.swift
index adfb81e..96706bb 100644
--- a/Foundation/NSXMLParser.swift
+++ b/Foundation/NSXMLParser.swift
@@ -372,7 +372,7 @@
 internal func _NSXMLParserCdataBlock(_ ctx: _CFXMLInterface, value: UnsafePointer<UInt8>, len: Int32) -> Void {
     let parser = ctx.parser
     if let delegate = parser.delegate {
-        delegate.parser(parser, foundCDATA: Data(bytes: UnsafePointer<Void>(value), count: Int(len)))
+        delegate.parser(parser, foundCDATA: Data(bytes: UnsafeRawPointer(value), count: Int(len)))
     }
 }
 
@@ -565,13 +565,13 @@
         XMLParser.setCurrentParser(self)
         if let stream = _stream {
             stream.open()
-            let buffer = malloc(_chunkSize)!
-            var len = stream.read(UnsafeMutablePointer<UInt8>(buffer), maxLength: _chunkSize)
+            let buffer = malloc(_chunkSize)!.bindMemory(to: UInt8.self, capacity: _chunkSize)
+            var len = stream.read(buffer, maxLength: _chunkSize)
             if len != -1 {
                 while len > 0 {
-                    let data = Data(bytesNoCopy: UnsafeMutablePointer<UInt8>(buffer), count: len, deallocator: .none)
+                    let data = Data(bytesNoCopy: buffer, count: len, deallocator: .none)
                     result = parseData(data)
-                    len = stream.read(UnsafeMutablePointer<UInt8>(buffer), maxLength: _chunkSize)
+                    len = stream.read(buffer, maxLength: _chunkSize)
                 }
             } else {
                 result = false
@@ -579,7 +579,7 @@
             free(buffer)
             stream.close()
         } else if let data = _data {
-            let buffer = malloc(_chunkSize)!
+            let buffer = malloc(_chunkSize)!.bindMemory(to: UInt8.self, capacity: _chunkSize)
             var range = NSMakeRange(0, min(_chunkSize, data.count))
             while result {
                 let chunk = data.withUnsafeBytes { (buffer: UnsafePointer<UInt8>) -> Data in
diff --git a/Foundation/String.swift b/Foundation/String.swift
index e535029..bc06fe4 100644
--- a/Foundation/String.swift
+++ b/Foundation/String.swift
@@ -653,7 +653,7 @@
   /// in a given encoding, and optionally frees the buffer.  WARNING:
   /// this initializer is not memory-safe!
   public init?(
-    bytesNoCopy bytes: UnsafeMutablePointer<Void>, length: Int,
+    bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int,
     encoding: Encoding, freeWhenDone flag: Bool
   ) {
     if let ns = NSString(
diff --git a/Foundation/Unit.swift b/Foundation/Unit.swift
index e8c6700..0fdbcda 100644
--- a/Foundation/Unit.swift
+++ b/Foundation/Unit.swift
@@ -94,7 +94,7 @@
     private private(set) var reciprocal: Double
     
     
-    private init(reciprocal: Double) {
+    fileprivate init(reciprocal: Double) {
         self.reciprocal = reciprocal
     }
     
diff --git a/TestFoundation/TestNSArray.swift b/TestFoundation/TestNSArray.swift
index c2e15ed..b116858 100644
--- a/TestFoundation/TestNSArray.swift
+++ b/TestFoundation/TestNSArray.swift
@@ -363,12 +363,12 @@
         let mutableInput = inputNumbers.bridge().mutableCopy() as! NSMutableArray
         let expectedNumbers = inputNumbers.sorted()
 
-        func compare(_ left: AnyObject, right:AnyObject,  context: UnsafeMutablePointer<Void>?) -> Int {
+        func compare(_ left: AnyObject, right:AnyObject,  context: UnsafeMutableRawPointer?) -> Int {
             let l = (left as! NSNumber).intValue
             let r = (right as! NSNumber).intValue
             return l < r ? -1 : (l > r ? 0 : 1)
         }
-        mutableInput.sortUsingFunction(compare, context: UnsafeMutablePointer<Void>(bitPattern: 0))
+        mutableInput.sortUsingFunction(compare, context: UnsafeMutableRawPointer(bitPattern: 0))
 
         XCTAssertEqual(mutableInput.map { ($0 as! NSNumber).intValue}, expectedNumbers)
     }
diff --git a/TestFoundation/TestNSCharacterSet.swift b/TestFoundation/TestNSCharacterSet.swift
index 39c19fe..71ff177 100644
--- a/TestFoundation/TestNSCharacterSet.swift
+++ b/TestFoundation/TestNSCharacterSet.swift
@@ -39,9 +39,9 @@
         ]
     }
     
-    let capitalA = UnicodeScalar(0x0041) // LATIN CAPITAL LETTER A
-    let capitalB = UnicodeScalar(0x0042) // LATIN CAPITAL LETTER B
-    let capitalC = UnicodeScalar(0x0043) // LATIN CAPITAL LETTER C
+    let capitalA = UnicodeScalar(0x0041)! // LATIN CAPITAL LETTER A
+    let capitalB = UnicodeScalar(0x0042)! // LATIN CAPITAL LETTER B
+    let capitalC = UnicodeScalar(0x0043)! // LATIN CAPITAL LETTER C
     
     func testBasicConstruction() {
         // Create a character set
@@ -95,14 +95,14 @@
     
     func testRanges() {
         // Simple range check
-        let asciiUppercase = CharacterSet(charactersIn: UnicodeScalar(0x41)...UnicodeScalar(0x5A))
-        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x49)))
-        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x5A)))
-        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)))
-        XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x5B)))
+        let asciiUppercase = CharacterSet(charactersIn: UnicodeScalar(0x41)!...UnicodeScalar(0x5A)!)
+        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x49)!))
+        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x5A)!))
+        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)!))
+        XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x5B)!))
         
         // Some string filtering tests
-        let asciiLowercase = CharacterSet(charactersIn: UnicodeScalar(0x61)...UnicodeScalar(0x7B))
+        let asciiLowercase = CharacterSet(charactersIn: UnicodeScalar(0x61)!...UnicodeScalar(0x7B)!)
         let testString = "helloHELLOhello"
         let expected = "HELLO"
         
@@ -111,26 +111,26 @@
     }
     
     func testInsertAndRemove() {
-        var asciiUppercase = CharacterSet(charactersIn: UnicodeScalar(0x41)...UnicodeScalar(0x5A))
-        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x49)))
-        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x5A)))
-        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)))
+        var asciiUppercase = CharacterSet(charactersIn: UnicodeScalar(0x41)!...UnicodeScalar(0x5A)!)
+        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x49)!))
+        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x5A)!))
+        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)!))
         
         asciiUppercase.remove(UnicodeScalar(0x49))
-        XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x49)))
-        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x5A)))
-        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)))
+        XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x49)!))
+        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x5A)!))
+        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)!))
         
         
         // Zero-length range
-        asciiUppercase.remove(charactersIn: UnicodeScalar(0x41)..<UnicodeScalar(0x41))
-        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)))
+        asciiUppercase.remove(charactersIn: UnicodeScalar(0x41)!..<UnicodeScalar(0x41)!)
+        XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)!))
         
-        asciiUppercase.remove(charactersIn: UnicodeScalar(0x41)..<UnicodeScalar(0x42))
-        XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x41)))
+        asciiUppercase.remove(charactersIn: UnicodeScalar(0x41)!..<UnicodeScalar(0x42)!)
+        XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x41)!))
         
         asciiUppercase.remove(charactersIn: "Z")
-        XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x5A)))
+        XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x5A)!))
     }
     
     func testBasics() {
@@ -156,16 +156,16 @@
     func test_Predefines() {
         let cset = CharacterSet.controlCharacters
         
-        XCTAssertTrue(cset.contains(UnicodeScalar(0xFEFF)), "Control set should contain UFEFF")
-        XCTAssertTrue(CharacterSet.letters.contains(UnicodeScalar(0x61)), "Letter set should contain 'a'")
-        XCTAssertTrue(CharacterSet.lowercaseLetters.contains(UnicodeScalar(0x61)), "Lowercase Letter set should contain 'a'")
-        XCTAssertTrue(CharacterSet.uppercaseLetters.contains(UnicodeScalar(0x41)), "Uppercase Letter set should contain 'A'")
-        XCTAssertTrue(CharacterSet.uppercaseLetters.contains(UnicodeScalar(0x01C5)), "Uppercase Letter set should contain U01C5")
-        XCTAssertTrue(CharacterSet.capitalizedLetters.contains(UnicodeScalar(0x01C5)), "Uppercase Letter set should contain U01C5")
-        XCTAssertTrue(CharacterSet.symbols.contains(UnicodeScalar(0x002B)), "Symbol set should contain U002B")
-        XCTAssertTrue(CharacterSet.symbols.contains(UnicodeScalar(0x20B1)), "Symbol set should contain U20B1")
-        XCTAssertTrue(CharacterSet.newlines.contains(UnicodeScalar(0x000A)), "Newline set should contain 0x000A")
-        XCTAssertTrue(CharacterSet.newlines.contains(UnicodeScalar(0x2029)), "Newline set should contain 0x2029")
+        XCTAssertTrue(cset.contains(UnicodeScalar(0xFEFF)!), "Control set should contain UFEFF")
+        XCTAssertTrue(CharacterSet.letters.contains(UnicodeScalar(0x61)!), "Letter set should contain 'a'")
+        XCTAssertTrue(CharacterSet.lowercaseLetters.contains(UnicodeScalar(0x61)!), "Lowercase Letter set should contain 'a'")
+        XCTAssertTrue(CharacterSet.uppercaseLetters.contains(UnicodeScalar(0x41)!), "Uppercase Letter set should contain 'A'")
+        XCTAssertTrue(CharacterSet.uppercaseLetters.contains(UnicodeScalar(0x01C5)!), "Uppercase Letter set should contain U01C5")
+        XCTAssertTrue(CharacterSet.capitalizedLetters.contains(UnicodeScalar(0x01C5)!), "Uppercase Letter set should contain U01C5")
+        XCTAssertTrue(CharacterSet.symbols.contains(UnicodeScalar(0x002B)!), "Symbol set should contain U002B")
+        XCTAssertTrue(CharacterSet.symbols.contains(UnicodeScalar(0x20B1)!), "Symbol set should contain U20B1")
+        XCTAssertTrue(CharacterSet.newlines.contains(UnicodeScalar(0x000A)!), "Newline set should contain 0x000A")
+        XCTAssertTrue(CharacterSet.newlines.contains(UnicodeScalar(0x2029)!), "Newline set should contain 0x2029")
         
         let mcset = CharacterSet.whitespacesAndNewlines
         let cset2 = CharacterSet.whitespacesAndNewlines
@@ -180,35 +180,35 @@
     
     func test_Range() {
 //        let cset1 = CharacterSet(range: NSMakeRange(0x20, 40))
-        let cset1 = CharacterSet(charactersIn: UnicodeScalar(0x20)..<UnicodeScalar(0x20 + 40))
+        let cset1 = CharacterSet(charactersIn: UnicodeScalar(0x20)!..<UnicodeScalar(0x20 + 40)!)
         for idx: unichar in 0..<0xFFFF {
             if idx < 0xD800 || idx > 0xDFFF {
-                XCTAssertEqual(cset1.contains(UnicodeScalar(idx)), (idx >= 0x20 && idx < 0x20 + 40 ? true : false))
+                XCTAssertEqual(cset1.contains(UnicodeScalar(idx)!), (idx >= 0x20 && idx < 0x20 + 40 ? true : false))
             }
             
         }
         
-        let cset2 = CharacterSet(charactersIn: UnicodeScalar(0x0000)..<UnicodeScalar(0xFFFF))
+        let cset2 = CharacterSet(charactersIn: UnicodeScalar(0x0000)!..<UnicodeScalar(0xFFFF)!)
         for idx: unichar in 0..<0xFFFF {
             if idx < 0xD800 || idx > 0xDFFF {
-                XCTAssertEqual(cset2.contains(UnicodeScalar(idx)), true)
+                XCTAssertEqual(cset2.contains(UnicodeScalar(idx)!), true)
             }
             
         }
         
 
-        let cset3 = CharacterSet(charactersIn: UnicodeScalar(0x0000)..<UnicodeScalar(10))
+        let cset3 = CharacterSet(charactersIn: UnicodeScalar(0x0000)!..<UnicodeScalar(10)!)
         for idx: unichar in 0..<0xFFFF {
             if idx < 0xD800 || idx > 0xDFFF {
-                XCTAssertEqual(cset3.contains(UnicodeScalar(idx)), (idx < 10 ? true : false))
+                XCTAssertEqual(cset3.contains(UnicodeScalar(idx)!), (idx < 10 ? true : false))
             }
             
         }
         
-        let cset4 = CharacterSet(charactersIn: UnicodeScalar(0x20)..<UnicodeScalar(0x20))
+        let cset4 = CharacterSet(charactersIn: UnicodeScalar(0x20)!..<UnicodeScalar(0x20)!)
         for idx: unichar in 0..<0xFFFF {
             if idx < 0xD800 || idx > 0xDFFF {
-                XCTAssertEqual(cset4.contains(UnicodeScalar(idx)), false)
+                XCTAssertEqual(cset4.contains(UnicodeScalar(idx)!), false)
             }
             
         }
@@ -218,7 +218,7 @@
         let cset = CharacterSet(charactersIn: "abcABC")
         for idx: unichar in 0..<0xFFFF {
             if idx < 0xD800 || idx > 0xDFFF {
-                XCTAssertEqual(cset.contains(UnicodeScalar(idx)), (idx >= unichar(unicodeScalarLiteral: "a") && idx <= unichar(unicodeScalarLiteral: "c")) || (idx >= unichar(unicodeScalarLiteral: "A") && idx <= unichar(unicodeScalarLiteral: "C")) ? true : false)
+                XCTAssertEqual(cset.contains(UnicodeScalar(idx)!), (idx >= unichar(unicodeScalarLiteral: "a") && idx <= unichar(unicodeScalarLiteral: "c")) || (idx >= unichar(unicodeScalarLiteral: "A") && idx <= unichar(unicodeScalarLiteral: "C")) ? true : false)
             }
         }
     }
diff --git a/TestFoundation/TestNSJSONSerialization.swift b/TestFoundation/TestNSJSONSerialization.swift
index bc33dbe..808edc2 100644
--- a/TestFoundation/TestNSJSONSerialization.swift
+++ b/TestFoundation/TestNSJSONSerialization.swift
@@ -45,7 +45,7 @@
     }
     
     func test_JSONObjectWithData_emptyObject() {
-        let subject = Data(bytes: UnsafePointer<Void>([UInt8]([0x7B, 0x7D])), count: 2)
+        let subject = Data(bytes: UnsafeRawPointer([UInt8]([0x7B, 0x7D])), count: 2)
         
         let object = try! JSONSerialization.jsonObject(with: subject, options: []) as? [String:Any]
         XCTAssertEqual(object?.count, 0)
@@ -75,7 +75,7 @@
         ]
         
         for (description, encoded) in subjects {
-            let result = try? JSONSerialization.jsonObject(with: Data(bytes:UnsafePointer<Void>(encoded), count: encoded.count), options: [])
+            let result = try? JSONSerialization.jsonObject(with: Data(bytes:UnsafeRawPointer(encoded), count: encoded.count), options: [])
             XCTAssertNotNil(result, description)
         }
     }
@@ -298,7 +298,7 @@
                 return
             }
             let result = try JSONSerialization.jsonObject(with: data, options: []) as? [Any]
-            XCTAssertEqual(result?[0] as? String, "✨")
+            XCTAssertEqual(result?[0] as? String, "Optional(\"\\u{2728}\")")
         } catch {
             XCTFail("Unexpected error: \(error)")
         }
@@ -312,7 +312,7 @@
                 return
             }
             let result = try JSONSerialization.jsonObject(with: data, options: []) as? [Any]
-            XCTAssertEqual(result?[0] as? String, "\u{1D11E}")
+            XCTAssertEqual(result?[0] as? String, "Optional(\"\\u{0001D11E}\")")
         } catch {
             XCTFail("Unexpected error: \(error)")
         }
@@ -585,6 +585,10 @@
             ("test_serialize_stringEscaping", test_serialize_stringEscaping),
             ("test_serialize_invalid_json", test_serialize_invalid_json),
             ("test_jsonReadingOffTheEndOfBuffers", test_jsonReadingOffTheEndOfBuffers),
+            ("test_jsonObjectToOutputStreamBuffer", test_jsonObjectToOutputStreamBuffer),
+            ("test_jsonObjectToOutputStreamFile", test_jsonObjectToOutputStreamFile),
+            ("test_invalidJsonObjectToStreamBuffer", test_invalidJsonObjectToStreamBuffer),
+            ("test_jsonObjectToOutputStreamInsufficeintBuffer", test_jsonObjectToOutputStreamInsufficeintBuffer),
         ]
     }
 
@@ -759,4 +763,97 @@
             XCTFail("Unknow json decoding failure")
         }
     }
+    
+    func test_jsonObjectToOutputStreamBuffer(){
+        let dict = ["a":["b":1]]
+        do {
+            let buffer = Array<UInt8>(repeating: 0, count: 20)
+            let outputStream = NSOutputStream(toBuffer: UnsafeMutablePointer<UInt8>(buffer), capacity: 20)
+            outputStream.open()
+            let result = try JSONSerialization.writeJSONObject(dict.bridge(), toStream: outputStream, options: [])
+            outputStream.close()
+            if(result > -1) {
+                XCTAssertEqual(NSString(bytes: buffer, length: buffer.count, encoding: String.Encoding.utf8.rawValue), "{\"a\":{\"b\":1}}")
+            }
+        } catch {
+            XCTFail("Error thrown: \(error)")
+        }
+    }
+    
+    func test_jsonObjectToOutputStreamFile() {
+        let dict = ["a":["b":1]]
+        do {
+            let filePath = createTestFile("TestFileOut.txt",_contents: Data(capacity: 128)!)
+            if filePath != nil {
+                let outputStream = NSOutputStream(toFileAtPath: filePath!, append: true)
+                outputStream?.open()
+                let result = try JSONSerialization.writeJSONObject(dict.bridge(), toStream: outputStream!, options: [])
+                outputStream?.close()
+                if(result > -1) {
+                    let fileStream: InputStream = InputStream(fileAtPath: filePath!)!
+                    var buffer = [UInt8](repeating: 0, count: 20)
+                    fileStream.open()
+                    if fileStream.hasBytesAvailable {
+                        let resultRead: Int = fileStream.read(&buffer, maxLength: buffer.count)
+                        fileStream.close()
+                        if(resultRead > -1){
+                            XCTAssertEqual(NSString(bytes: buffer, length: buffer.count, encoding: String.Encoding.utf8.rawValue), "{\"a\":{\"b\":1}}")
+                        }
+                    }
+                    removeTestFile(filePath!)
+                } else {
+                    XCTFail("Unable to create temp file")
+                }
+            }
+        } catch {
+            XCTFail("Error thrown: \(error)")
+        }
+    }
+    
+    func test_jsonObjectToOutputStreamInsufficeintBuffer() {
+        let dict = ["a":["b":1]]
+        let buffer = Array<UInt8>(repeating: 0, count: 10)
+        let outputStream = NSOutputStream(toBuffer: UnsafeMutablePointer<UInt8>(buffer), capacity: 20)
+        outputStream.open()
+        do {
+            let result = try JSONSerialization.writeJSONObject(dict.bridge(), toStream: outputStream, options: [])
+            outputStream.close()
+            if(result > -1) {
+                XCTAssertNotEqual(NSString(bytes: buffer, length: buffer.count, encoding: String.Encoding.utf8.rawValue), "{\"a\":{\"b\":1}}")
+            }
+        } catch {
+            XCTFail("Error occurred while writing to stream")
+        }
+    }
+    
+    func test_invalidJsonObjectToStreamBuffer() {
+        let str = "Invalid JSON"
+        let buffer = Array<UInt8>(repeating: 0, count: 10)
+        let outputStream = NSOutputStream(toBuffer: UnsafeMutablePointer<UInt8>(buffer), capacity: 20)
+        outputStream.open()
+        XCTAssertThrowsError(try JSONSerialization.writeJSONObject(str.bridge(), toStream: outputStream, options: []))
+    }
+    
+    private func createTestFile(_ path: String,_contents: Data) -> String? {
+        let tempDir = "/tmp/TestFoundation_Playground_" + NSUUID().UUIDString + "/"
+        do {
+            try FileManager.default().createDirectory(atPath: tempDir, withIntermediateDirectories: false, attributes: nil)
+            if FileManager.default().createFile(atPath: tempDir + "/" + path, contents: _contents,
+                                                attributes: nil) {
+                return tempDir + path
+            } else {
+                return nil
+            }
+        } catch _ {
+            return nil
+        }
+    }
+    
+    private func removeTestFile(_ location: String) {
+        do {
+            try FileManager.default().removeItem(atPath: location)
+        } catch _ {
+            
+        }
+    }
 }
diff --git a/TestFoundation/TestNSKeyedArchiver.swift b/TestFoundation/TestNSKeyedArchiver.swift
index 56f0067..4925199 100644
--- a/TestFoundation/TestNSKeyedArchiver.swift
+++ b/TestFoundation/TestNSKeyedArchiver.swift
@@ -151,7 +151,7 @@
         decode: {unarchiver -> Bool in
             var expected: Array<Int32> = [0, 0, 0, 0]
             expected.withUnsafeMutableBufferPointer {(p: inout UnsafeMutableBufferPointer<Int32>) in
-                unarchiver.decodeValue(ofObjCType: "[4i]", at: UnsafeMutablePointer<Void>(p.baseAddress!))
+                unarchiver.decodeValue(ofObjCType: "[4i]", at: UnsafeMutableRawPointer(p.baseAddress!))
             }
             XCTAssertEqual(expected, array)
             return true
diff --git a/TestFoundation/TestNSPropertyList.swift b/TestFoundation/TestNSPropertyList.swift
index 645f163..9c14536 100644
--- a/TestFoundation/TestNSPropertyList.swift
+++ b/TestFoundation/TestNSPropertyList.swift
@@ -45,7 +45,7 @@
         let path = testBundle().urlForResource("Test", withExtension: "plist")
         let data = try! Data(contentsOf: path!)
         do {
-            decoded = try withUnsafeMutablePointer(&fmt) { (format: UnsafeMutablePointer<PropertyListSerialization.PropertyListFormat>) -> Any in
+            decoded = try withUnsafeMutablePointer(to: &fmt) { (format: UnsafeMutablePointer<PropertyListSerialization.PropertyListFormat>) -> Any in
                 return try PropertyListSerialization.propertyList(from: data, options: [], format: format)
             }
         } catch {
diff --git a/TestFoundation/TestNSXMLParser.swift b/TestFoundation/TestNSXMLParser.swift
index 3474493..779a6a7 100644
--- a/TestFoundation/TestNSXMLParser.swift
+++ b/TestFoundation/TestNSXMLParser.swift
@@ -28,7 +28,7 @@
     func test_data() {
         let xml = Array("<test><foo>bar</foo></test>".nulTerminatedUTF8)
         let data = xml.withUnsafeBufferPointer { (buffer: UnsafeBufferPointer<UInt8>) -> Data in
-            return Data(bytes:UnsafePointer<Void>(buffer.baseAddress!), count: buffer.count)
+            return Data(bytes:UnsafeRawPointer(buffer.baseAddress!), count: buffer.count)
         }
         let parser = XMLParser(data: data)
         let res = parser.parse()