Enables type-safe SQLite database access with auto-generated code from SQL files, comment-based annotations for code control, and no need for IDE plugins, focusing on SQLite-specific optimizations.
Surfaced from shared tags and platforms — no rankings paid for.
If SQLiteNow saves you time, please consider starring ⭐ the repository - it helps more KMP and Flutter/Dart developers find it.
SQLiteNow is SQL-first tooling for type-safe SQLite access in Kotlin Multiplatform and Flutter/Dart apps. Write schema, migration, and query files in SQL, then generate platform-native code with typed parameters, typed results, migrations, transactions, and reactive invalidation.
Kotlin Multiplatform apps use the dev.goquick.sqlitenow Gradle plugin and KMP
runtime libraries.
Flutter and Dart apps use sqlitenow_runtime plus sqlitenow_cli. You might see a
little documentation bias toward KMP at first, because originally project was started
as KMP-only, but eventually it will have a full docs parity.
Sync-Ready: SQLiteNow includes Oversqlite, a synchronization system for multi-device applications with conflict resolution and offline-first behavior.
SQLiteNow generates code from your SQL files, giving you full control over your queries while maintaining type safety. Unlike SQLDelight (for KMP), which supports multiple database engines, SQLiteNow is focused exclusively on SQLite, allowing for deeper integration and SQLite-specific optimizations.
Full documentation is available at https://mobiletoly.github.io/sqlitenow-kmp/.
[plugins]
sqlitenow = { id = "dev.goquick.sqlitenow", version = "0.10.0" }
[libraries]
sqlitenow-core = { module = "dev.goquick.sqlitenow:core", version = "0.10.0" }
sqliteNow {
databases {
create("SampleDatabase") {
packageName.set("com.example.app.db")
}
}
}
Start here: https://mobiletoly.github.io/sqlitenow-kmp/kmp/
While we have added includes few sample projects to this repository, but for a very simple end-to-end walkthrough, follow the Mood Tracker tutorial series and browse the accompanying sample project.
dependencies:
sqlitenow_runtime: ^0.10.0
dev_dependencies:
sqlitenow_cli: ^0.10.0
flutter pub run sqlitenow_cli generate
For pure Dart packages, use:
dart run sqlitenow_cli generate
The released Dart CLI package embeds the SQLiteNow compiler jar. Flutter and
Dart users do not pass --compiler-jar for normal consumption.
Start here: https://mobiletoly.github.io/sqlitenow-kmp/flutter/
-- @@{ annotations }
comments in your SQL.Client-side framework components:
Server-side components:
It is important to mention that you can use SQLiteNow Generator and SQLiteNow Library without using OverSqlite for synchronization. And vice versa - you can use OverSqlite for synchronization of SQLite database with PostgreSQL without using SQLiteNow Generator and SQLiteNow Library.
Even if you don't care about multi-device synchronization, SQLiteNow has few key differences from SQLDelight:
First of all, I wanted to target specifically SQLite in Kotlin Multiplatform and Dart environments, these are my platform of choice as of now for mobile development.
Second, since we use comment-based annotations, no plugin is required (like in case of SQLDelight), so you can easily use just a regular SQL files that will be validated by your IDE or other external tools for correctness.
Third, I wanted to have a more flexible and extensible code generation system that can be easily extended and customized. I use hexagonal architecture in my code, but sometimes converting between multiple layers is tiresome, so I wanted to have a way to generate code that will be very close to my domain layer, without sacrificing the ability to write pure SQL queries.
Here is the brief example:
-- @@{ queryResult=PersonWithAddresses }
SELECT p.id,
p.first_name,
p.last_name,
p.email,
p.created_at,
a.address_type,
a.postal_code,
a.country,
a.street,
a.city,
a.state
/* @@{ dynamicField=addresses,
mappingType=collection,
propertyType=List<Address>,
sourceTable=a,
collectionKey=address_id } */
FROM Person p
LEFT JOIN PersonAddress a ON p.id = a.person_id
ORDER BY p.id, a.address_type
LIMIT :limit OFFSET :offset
This will generate PersonWithAddresses data class. This class has addresses: List<Address>
property that contains all home addresses for the person. Another class
PersonQuery.SelectAllWithAddresses.Params will be generated as well with limit and offset
parameters to pass parameters to the query.
And you can define your own adapters to convert between SQLite and your domain types and register them for seamless integration. We provide few built-in adapters as well, such as converting from TEXT to Kotlin's date/time etc.
You can always shape your data even more with mapTo annotation.
Full example is available in the /sample-kmp directory (for KMP) and
in [/dart/examples] for Dart/Flutter.
SQLiteNow includes a complete synchronization system for building multi-device applications. Sync setup requires three explicit pieces on each client:
The sync system automatically handles:
If you have a table to sync, annotate it with enableSync=true:
-- Enable sync for this table
-- @@{ enableSync=true }
CREATE TABLE person (
id TEXT PRIMARY KEY NOT NULL,
first_name TEXT NOT NULL,
last_name TEXT NOT NULL,
email TEXT UNIQUE,
created_at INTEGER NOT NULL DEFAULT (unixepoch())
);
Sync-enabled tables must use exactly one local PRIMARY KEY column of type TEXT or BLOB.
INTEGER/BIGINT sync keys are rejected, and local sync-enabled tables must not model the
reserved server scope column _sync_scope_id.
Add the KMP runtime artifacts and enable Oversqlite in the Gradle DSL:
commonMain.dependencies {
implementation("dev.goquick.sqlitenow:core:<version>")
implementation("dev.goquick.sqlitenow:oversqlite:<version>")
}
sqliteNow {
databases {
create("AppDatabase") {
packageName = "com.example.app.db"
oversqlite = true
}
}
}
Then use the generated sync client in your application:
// Create authenticated HTTP client with JWT token refresh and base URL
val httpClient = HttpClient {
install(Auth) {
bearer {
loadTokens { /* load saved token */ }
refreshTokens { }
}
}
defaultRequest {
url()
}
}
syncClient = db.newOversqliteClient(
schema = ,
httpClient = httpClient,
resolver = ServerWinsResolver
)
syncClient.().getOrThrow()
syncClient.attach(userId = ).getOrThrow()
syncClient.sync().getOrThrow()
automaticDownloads = coroutineScope.launch {
syncClient.runAutomaticDownloads(
db.buildOversqliteAutomaticDownloadConfig(
bundleChangeWatchMode = BundleChangeWatchMode.AUTO,
),
)
}
automaticDownloads.cancelAndJoin()
KMP sync example: /samplesync-kmp.
Add the Dart runtime packages and enable Oversqlite in sqlitenow.yaml:
dependencies:
sqlitenow_runtime: ^0.10.0
sqlitenow_oversqlite: ^0.10.0
dev_dependencies:
sqlitenow_cli: ^0.10.0
databases:
AppDatabase:
input: lib/db/sql/AppDatabase
output: lib/db/generated
package: app.db
runtime: dart
oversqlite: true
Then use the generated sync client in your application:
final httpClient = IoOversqliteHttpClient(
baseUri: Uri.parse('https://api.myapp.com'),
defaultHeaders: {
HttpHeaders.authorizationHeader: 'Bearer $token',
},
);
final syncClient = db.newOversqliteClient(
schema: 'myapp',
httpClient: httpClient,
);
await syncClient.open();
await syncClient.attach('user123');
await syncClient.sync();
// Optional: start default-off automatic downloads.
// Bundle-change watch is only a wake-up hint; pullToStable() remains authoritative.
final automaticDownloads = syncClient.startAutomaticDownloads();
await automaticDownloads.stop();
Dart sync package and realserver coverage: /dart/packages/sqlitenow_oversqlite.
Full documentation is available in the https://mobiletoly.github.io/sqlitenow-kmp/
macosArm64macosX64linuxX64, linuxArm64) with bundled SQLitepackage:sqlite3