Type-safe ORM and SQL DSL for Kotlin Multiplatform.

Korm gives you an Exposed-like Kotlin API for tables, entities, typed predicates, transactions, migrations, joins and aggregations, while keeping the core portable across JVM and Kotlin/Native. It ships PostgreSQL, SQLite, async r2dbc PostgreSQL and Ktor integration modules.

object App : Catalog

object Users : Table<App, User>("users", ::User) {
    val id by Column.UUID().primaryKey()
    val name by Column.Text()
    val age by Column.Int()
}

class User : Entity() {
    var id by Users.id
    var name by Users.name
    var age by Users.age
}

val db: Database<App> = createDatabase(
    host = "localhost",
    database = "postgres",
    user = "postgres",
    password = "password",
)

val adults = db.autocommit {
    Users.find {
        where { Users.age gtEq 18 }
        orderBy DESC Users.age
        limit = 50
    }
}

• Multiplatform core. Write tables, entities, queries and migrations once; run them on JVM and Kotlin/Native backends.
• Typed SQL DSL. Predicates are built from columns and Kotlin values (Users.age gtEq 18), and values are always bound as parameters.
• Catalog safety. A Table<App, User> cannot be used inside a Database<Cache> scope, and the compiler catches that before runtime.
• Blocking and suspend APIs. Blocking backends expose transaction { } and autocommit { }; suspend code uses suspendTransaction { } and suspendAutocommit { }.
• PostgreSQL without JDBC on Native. JVM uses JDBC/HikariCP, Native uses libpq, and r2dbc gives a true async PostgreSQL option on JVM.
• SQLite for apps, tests and caches. JVM uses sqlite-jdbc, Native uses sqlite3 cinterop, Android uses AndroidX SQLite.
• Reactive queries. korm-observe turns a query into a Flow that re-emits when the tables it reads change — for Compose Multiplatform and Android UIs.
• Server integration. Ktor helpers are split into DI-agnostic, Ktor DI and Koin artifacts.

Korm is pre-1.0. The public API is usable and tested, but still allowed to change. It is a good fit for experiments, internal tools, prototypes, benchmarks and feedback. Do not make it the only persistence layer for critical production systems yet.

Requires JDK 21+ for JVM builds. The JVM suspend offload path uses virtual threads.

Korm is published to Maven Central under io.github.kormium.

dependencies {
    implementation(platform("io.github.kormium:korm-bom:<version>"))

    implementation("io.github.kormium:korm-postgres") // PostgreSQL, JVM + Native
    // implementation("io.github.kormium:korm-sqlite")   // SQLite, JVM + Native + Android
    // implementation("io.github.kormium:korm-r2dbc")    // async PostgreSQL, JVM only

    // implementation("io.github.kormium:korm-observe")  // reactive Flow queries
    // implementation("io.github.kormium:korm-migrate")  // SQL migration runner

    // optional Ktor integration
    // implementation("io.github.kormium:korm-ktor")
    // implementation("io.github.kormium:korm-ktor-di")
    // implementation("io.github.kormium:korm-ktor-koin")
}

See Installation for Gradle variants, native system libraries and module details.

• Documentation index
• Installation
• Quick start
• Tables and entities
• Queries, joins and aggregations
• Transactions, suspend API and migrations
• Backends and platform support
• Ktor integration
• API cookbook
• API ergonomics
• Observability
• Production guide
• Compatibility policy
• Design notes
• Roadmap
• Samples, benchmarks and contributing

Korm does not own schema management — create tables with raw SQL or a migration tool.

db.transaction {
    executeUpdate(
        """CREATE TABLE IF NOT EXISTS "users" ("id" uuid NOT NULL, "name" text NOT NULL, "age" integer NOT NULL, PRIMARY KEY ("id"))""",
    )
    Users.insert(User().apply {
        id = Uuid.random()
        name = "Ada"
        age = 36
    })
}

val ada = db.autocommit {
    Users.find {
        where { Users.name like "A%" }
        where { Users.age gtEq 18 }
    }
}

For deeper examples, start with Quick start and then read Queries.

Runnable samples live under samples/:

See Samples and benchmarks.

MIT. See LICENSE.