Swift 6 · iOS · macOS

The local-first database built for Swift apps.

BoutiqueDB combines SQLite-compatible local persistence, CDC-backed LiveQuery, CloudKit synchronization, and Turso engine capabilities in one native Swift package.

Get started Explore architecture

Local-firstSQLite-compatibleReactive SwiftUIOptional CloudKit

Turso engineSQLite · FTS · vectors · encryption

BoutiqueDB actorQueries · migrations · transactions

BoutiqueDBNative persistence for Apple platforms

LiveQuery

CloudKit

Swift

One native data layer

Start simple. Keep the ceiling high.

BoutiqueDB handles the local database path first, then lets the app adopt reactive observation, private synchronization, search, vectors, and encryption only when they are useful.

Core engine

Local-first by construction

Durable storage lives inside the app sandbox, with actor-isolated access and type-safe Structured Queries.

Explore the engine

Reactive UI

CDC-backed live queries

@LiveQuery and @LiveQueryOne update SwiftUI from database changes without a manual refresh pipeline.

Build reactive views

Apple sync

CloudKit without a backend

Keep the local database authoritative while optionally synchronizing private user data through CKSyncEngine.

Configure synchronization

Engine extensions

Search, vectors, views, encryption

Opt into Tantivy FTS, dense and sparse vectors, incremental materialized views, and AEGIS encryption.

See Turso capabilities

Designed as a system

A predictable path from SwiftUI to durable data.

The public API stays Swift-native. BoutiqueDB owns isolation and observation, the Turso engine owns storage, and CloudKit remains an optional synchronization layer.

Read the architecture guide

SwiftUIViews and app state

→

LiveQueryCDC observation

BoutiqueDB actorQueries · migrations · transactions · isolation

Turso engineLocal durable storage

CloudKitOptional private sync

Swift-native API

Define the model. Query it reactively.

Schema macros, structured queries, and property wrappers keep database code legible without hiding the underlying persistence model.

Type-safe query construction Local operation without a service Reactive SwiftUI observation

NotesView.swiftSwift

@Table
struct Note {
    @Column(primaryKey: true) let id: UUID
    var title: String
}

struct NotesView: View {
    @LiveQuery var notes: [Note]

    init(db: BoutiqueDB) {
        _notes = LiveQuery(db) {
            Note.order { $0.title }.asSelect()
        }
    }
}

Why BoutiqueDB

Native ergonomics without a low ceiling.

Apple-platform shaped

Swift concurrency, SwiftUI observation, CloudKit, and app-sandbox storage are first-class constraints.

SQLite-compatible foundation

Begin with familiar local persistence and selectively adopt advanced engine features as the product grows.

No backend requirement

The application remains useful offline before synchronization or remote infrastructure is introduced.

Compare persistence options

Start with the local database

Build the first reactive model in minutes.

Add the package, define a table, open the database, and connect the result to SwiftUI.

Open Quick Start GitHub

Getting Started

Fundamentals

Swift & SwiftUI

Turso & CloudKit Engine