SwiftyTeeth for iOS Early Access!


First Blueteeth, now SwiftyTeeth! No, I don’t have a dental fetish.

SwiftyTeeth is an iOS BLE library created by myself and Basem (I’d highly recommend checking out his blog!).

What is SwiftyTeeth?

SwiftyTeeth is a simple, lightweight library intended to take away some of the cruft and tediousness of using iOS BLE. It replaces CoreBluetooth’s protocols and delegates with a callback-based pattern, and handles much of the code overhead associated with handling connections, discovery, reads/writes, and notifications. It is a spiritually similar library to Android’s Blueteeth.

Both libraries were originally inspired by the simplicity and ease-of-use of LGBluetooth.


The motivation for this library was to provide an alternate (ideally - simpler) API than what iOS offers in CoreBluetooth to reduce complexity and code overhead. Another motivator was to provide an API that might make more sense ‘practically’ than CoreBluetooth’s API, which exposes underlying implementation-specifics rather than abstracting them away.

For instance, with BLE devices, you connect to a peripheral, but in CoreBluetooth - you call connect on a manager singleton to connect to a peripheral, which makes sense for implementation-specifics (as there is only 1 Bluetooth radio which needs to manage all connections), but not semantically. In SwiftyTeeth, the ‘Device’ object has the connect method, the caller ‘connects to a device’, rather than the caller ‘asks a singleton to connect to a device on it’s behalf’.


Scan for BLE devices using SwiftyTeeth with a 1 second timeout:

SwiftyTeeth.shared.scan(for: 1) { devices in
        self.devices = devices

Alternatively, you could use the SwiftyTeethable protocol in an extension:

extension DeviceListViewController: SwiftyTeethable {
    func scanTapped() {
        swiftyTeeth.scan(for: 1) { devices in
            self.devices = devices

Initiate a connection using a SwiftyTeeth.Device:

device?.connect(complete: { isConnected in
    print("Is device connected? \(isConnected == true)")

Discover Bluetooth services and characteristics:

self.device?.discoverServices(complete: { services, error in
        print("Discovering characteristics for service: \($0.uuid.uuidString)")
        self.device?.discoverCharacteristics(for: $0, complete: { service, characteristics, error in
                print("App: Discovered characteristic: \($0.uuid.uuidString) in \(service.uuid.uuidString)")

            if service == services.last {
                print("App: All services/characteristics discovered")

Write to a connected SwiftyTeeth.Device:

let command = Data(bytes: [0x01])
device?.write(data: command, to: characteristic, in: service, complete: { error in
    print("Write with response successful? \(error == nil)")

Read from a connected SwiftyTeeth.Device:

device?.read(from: characteristic, in: service, complete: { data, error in
    print("Read value: \(data?.base64EncodedString())")

Subscribe to notifications from a connected SwiftyTeeth.Device:

device?.subscribe(to: characteristic, in: service, complete: { data, error in
    print("Subscribed value: \(data?.base64EncodedString())")

Check out the sample app in SwiftyTeeth Sample/ to see the API in action.

Future Directions

Better Error handling

Error handling in a BLE library is always tricky - but generally they should be fully asynchronous. In addition, having clear and concise error conditions, alongside seamless retries is crucial.


As mentioned in the Blueteeth post, Callback Hell (or rightward drift) sucks, but that hasn’t yet been solved in this library. The current usage for chaining calls is still, unfortunately, callbacks in callbacks.


CoreBluetooth is also available on MacOS, so once completed and compiled correctly - there is no reason that it couldn’t be used directly on a Mac, rather than only from iOS devices.

SwiftyTeeth as a Peripheral

For the purposes of testing and debugging, being able to use a Mac as a demo-peripheral has immense value. CoreBluetooth supports central and peripheral modes of operation, so this would be a great (and useful) extension.

Reactive Everything!

Now that this library is released and progressively becoming more stable, the next step in the process is to create Reactive bindings (RxSwift bindings specifically). They will be created in a separate repo, so that there isn’t a forced, heavy dependency on the Rx framework in any app that just wants to use SwiftyTeeth.


  • iOS 9+
  • Swift 3+
  • XCode 8+



Currently, you can use the master or develop branches and git directly until the API has stabilized.

platform :ios, '9.0'

pod 'SwiftyTeeth', :git => '', :branch => 'master'


Instructions coming soon.


Please report all bugs or feature requests to:

Swifty Community

Other iOS-centric Bluetooth libraries.