Awesome Open Source
Awesome Open Source


Gradle Plugin Portal Maven Central Kotlin License

Realm is a mobile database that runs directly inside phones, tablets or wearables. It allows synchronization of data between devices using Atlas App Services and Device Sync.

This repository holds the source code for the Kotlin SDK for Realm, which runs on Kotlin Multiplatform and Android.

General Availability

The Realm Kotlin SDK is GA.

Documentation can be found here.

Sample projects can be found here.

If you are upgrading from a previous beta release of Realm Kotlin, please see the CHANGELOG for the full list of changes.

If you are migrating from Realm Java, please see the Migration Guide.



Installation differs slightly depending on the type of project and whether or not you are using Device Sync. See the details in the documentation:

Define model

Start writing your database logic by first defining your model.

class Person : RealmObject {
    var name: String = "Foo"
    var dog: Dog? = null

class Dog : RealmObject {
    var name: String = ""
    var age: Int = 0

Open Database

Define a RealmConfiguration with the database schema, then open the Realm using it.

// use the RealmConfiguration.Builder() for more options
val configuration = RealmConfiguration.create(schema = setOf(Person::class, Dog::class)) 
val realm =


Persist some data by instantiating the model object and copying it into the open Realm instance.

// plain old kotlin object
val person = Person().apply {
    name = "Carlo"
    dog = Dog().apply { name = "Fido"; age = 16 }

// Persist it in a transaction
realm.writeBlocking { // this : MutableRealm
    val managedPerson = copyToRealm(person)

// Asynchronous updates with Kotlin coroutines
CoroutineScope(context).async {
    realm.write { // this : MutableRealm
        val managedPerson = copyToRealm(person)


The query language supported by Realm is inspired by Apple’s NSPredicate, see more examples here

// All persons
import io.realm.kotlin.ext.query

val all = realm.query<Person>().find()

// Persons named 'Carlo'
val personsByNameQuery: RealmQuery<Person> = realm.query<Person>("name = $0", "Carlo")
val filteredByName: RealmResults<Person> = personsByNameQuery.find()

// Person having a dog aged more than 7 with a name starting with 'Fi'
val filteredByDog = realm.query<Person>("dog.age > $0 AND BEGINSWITH $1", 7, "Fi").find()

// Observing changes with Coroutine Flows
CoroutineScope(context).async {
    personsByNameQuery.asFlow().collect { result: ResultsChange<Person> ->
        println("Realm updated: Number of persons is ${result.list.size}")


// Find the first Person without a dog
realm.query<Person>("dog == NULL LIMIT(1)")
    ?.also { personWithoutDog ->
        // Add a dog in a transaction
        realm.writeBlocking {
            findLatest(personWithoutDog)?.dog = Dog().apply { name = "Laika"; age = 3 }


Use the result of a query to delete from the database.

// delete all Dogs
realm.writeBlocking {
    // Selected by a query
    val query = this.query<Dog>()

    // From a query result
    val results = query.find()

    // From individual objects
    results.forEach { delete(it) }

Observing data changes

Realm support asynchronous observers on all its data structures.


A Realm can be observed globally for changes on its data.

    .collect { realmChange: RealmChange<Realm> ->
        when (realmChange) {
            is InitialRealm<*> -> println("Initial Realm")
            is UpdatedRealm<*> -> println("Realm updated")


Realm objects can be observed individually. A list of the changed field names is provided on each update.

person.asFlow().collect { objectChange: ObjectChange<Person> ->
        when (objectChange) {
            is InitialObject -> println("Initial object: ${}")
            is UpdatedObject -> 
                println("Updated object: ${}, changed fields: ${objectChange.changedFields.size}")
            is DeletedObject -> println("Deleted object")


Realm data structures can be observed too. On RealmList on each update you receive what positions were inserted, changed or deleted.

        .collect { listChange: ListChange<String> ->
            when (listChange) {
                is InitialList -> println("Initial list size: ${listChange.list.size}")
                is UpdatedList -> 
                    println("Updated list size: ${listChange.list.size} insertions ${listChange.insertions.size}")
                is DeletedList -> println("Deleted list")


Query results are also observable, and like RealmList on each update, the inserted, changed and deleted indices are also provided.

    .collect { resultsChange: ResultsChange<Person> ->
        when (resultsChange) {
            is InitialResults -> println("Initial results size: ${resultsChange.list.size}")
            is UpdatedResults -> 
                println("Updated results size: ${resultsChange.list.size} insertions ${resultsChange.insertions.size}")


Single element queries allow observing a RealmObject that might not be in the realm.

realm.query<Person>("name = $0", "Carlo").first().asFlow()
    .collect { objectChange: SingleQueryChange<Person> ->
        when (objectChange) {
            is PendingObject -> println("Pending object")
            is InitialObject -> println("Initial object: ${}")
            is UpdatedObject -> 
                println("Updated object: ${}, changed fields: ${objectChange.changedFields.size}")
            is DeletedObject -> println("Deleted object")

Next: head to the full KMM example.

Using Snapshots

If you want to test recent bugfixes or features that have not been packaged in an official release yet, you can use a -SNAPSHOT release of the current development version of Realm via Gradle, available on Maven Central

// Global build.gradle
buildscript {
    repositories {
        maven {
            url ''
    dependencies {
        classpath 'io.realm.kotlin:gradle-plugin:<VERSION>'

allprojects {
    repositories {
        maven {
            url ''

// Module build.gradle

// Don't cache SNAPSHOT (changing) dependencies.
configurations.all {
    resolutionStrategy.cacheChangingModulesFor 0, 'seconds'

apply plugin: "io.realm.kotlin"

See Config.kt for the latest version number.

Kotlin Memory Model and Coroutine compatibility

Realm Kotlin is implemented against Kotlin's default memory model (the old one), but still supports running with the new memory model if enabled in the consuming project. See for details on enabled the new memory model.

By default Realm Kotlin depends and requires you to run with Kotlin Coroutines version 1.6.0-native-mt. To use Realm Kotlin with the non-native-mt version of Coroutines you will have to enable the new memory model and also disables our internal freezing to accomodate the new freeze transparency for Coroutine 1.6.0.


See for more details.


See for more details!

Code of Conduct

This project adheres to the MongoDB Code of Conduct. By participating, you are expected to uphold this code. Please report unacceptable behavior to [email protected].


Realm Kotlin is published under the Apache 2.0 license.

This product is not being made available to any person located in Cuba, Iran, North Korea, Sudan, Syria or the Crimea region, or to any other person that is not eligible to receive the product under U.S. law.

Related Awesome Lists
Top Programming Languages
Top Projects

Get A Weekly Email With Trending Projects For These Topics
No Spam. Unsubscribe easily at any time.
Database (92,938
Kotlin (46,375
Sdk (32,780
Realm (2,418
Multi Platform (1,644
Nosql Database (569
Kotlin Multiplatform (477
Realtime Database (344
Kotlin Native (209
Ktlint (208
Kotlin Multiplatform Library (38
Kotlin Multiplatform Mobile (33