Kotlin Multiplatform: wat is het, shared module en expect/actual

Wat is Kotlin Multiplatform?

Kotlin Multiplatform — cross-compilatietechnologie waarmee gemeenschappelijke code in Kotlin kan worden geschreven en gecompileerd voor verschillende platforms: JVM (Android), LLVM (iOS, macOS, watchOS), JavaScript (Web) en native binaire bestanden (Linux, Windows). KMP is geen UI-framework — het lost het probleem van herbruikbaarheid van bedrijfslogica op, niet van interfaces.

De architectuur van KMP is gebouwd rond shared module — een Gradle-module met commonMain met platformonafhankelijke code en source sets voor elk doel (androidMain, iosMain, desktopMain). Volgens gegevens van JetBrains uit 2025 gebruikt meer dan 40% van de nieuwe Kotlin-projecten KMP voor het delen van code tussen platforms.

Kotlin Multiplatform Mobile (KMM) — de vorige naam voor het mobiele scenario iOS+Android. Sinds Kotlin 2.1+ is de term KMM vervangen door de algemene Kotlin Multiplatform, omdat de technologie de grenzen van mobiele ontwikkeling heeft overschreden. Netflix, McDonald's en VMware gebruiken KMP in productie voor het delen van code tussen mobiele applicaties.

Expect/actual-mechanisme: architectuur

Expect/actual — het belangrijkste KMP-mechanisme voor het werken met platformcode. In commonMain wordt een expect-declaratie (functie, klasse, property) gedeclareerd, en in elke platform-specifieke source set (androidMain, iosMain) — de actual-implementatie. De compiler controleert of er voor elke expect een actual bestaat op elk doelplatform.

// commonMain — declaratie van platform-API
expect fun getPlatformName(): String

expect class PlatformContext(val appVersion: String)

// androidMain — actual voor Android
actual fun getPlatformName(): String = "Android \${Build.VERSION.SDK_INT}"

// iosMain — actual voor iOS
actual fun getPlatformName(): String =
    UIDevice.currentDevice.systemName

Hiërarchie van source sets in KMP maakt het mogelijk om tussenniveaus te creëren: bijvoorbeeld iosArm64Main (fysieke iOS-apparaten) en iosSimulatorArm64Main (simulator) met gemeenschappelijke iosMain. Code uit commonMain is toegankelijk voor alle platforms, en code uit iosMain alleen voor iOS-doelen. Dit vermindert duplicatie wanneer de implementatie niet voor elk platform verschilt, maar voor een groep platforms.

In de praktijk wordt expect/actual gebruikt voor: het verkrijgen van lokale opslag (SharedPreferences vs NSUserDefaults), werken met netwerk (HttpEngine voor elk platform), toegang tot bestandssysteem, cryptografie en analytics. JetBrains raadt aan om het aantal expect/actual te minimaliseren en zoveel mogelijk code naar commonMain te verplaatsen.

Shared module: structuur en Gradle

Shared module — een standaard Gradle-module met de plugin `org.jetbrains.kotlin.multiplatform`. Het bevat gemeenschappelijke code in `src/commonMain/kotlin/` en platformimplementaties in `src/androidMain/kotlin/` en `src/iosMain/kotlin/`. Een KMP-project verbindt ook `androidApp` en `iosApp`, die afhankelijk zijn van de shared module.

// build.gradle.kts — shared module
plugins {
    kotlin("multiplatform")
    id("com.android.library")
}

kotlin {
    androidTarget()
    
    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach {
        it.binaries.framework {
            baseName = "shared"
            isStatic = true
        }
    }

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("io.ktor:ktor-client-core:3.1.0")
                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
            }
        }
        val androidMain by getting {
            dependencies {
                implementation("io.ktor:ktor-client-okhttp:3.1.0")
            }
        }
        val iosMain by creating {
            dependencies {
                implementation("io.ktor:ktor-client-darwin:3.1.0")
            }
        }
    }
}

Configuratie van Gradle voor KMP vereist expliciete vermelding van iOS-doelen — x64 (Intel-simulator), arm64 (fysieke apparaten) en simulatorArm64 (Apple Silicon-simulator). Voor elk doel wordt een afzonderlijk Apple framework gegenereerd. De plugin `kotlin("multiplatform")` configureert automatisch compilatie voor JVM en LLVM op basis van de gedeclareerde doelen.

Ktor en kotlinx.serialization — de standaard KMP-bibliotheken die gemeenschappelijke code ondersteunen. Ktor biedt een HTTP-client met engines voor elk platform (OkHttp voor Android, Darwin voor iOS). kotlinx.serialization werkt op elk platform zonder expect/actual dankzij de multiplatform-implementatie in commonMain.

Integratie met iOS via Kotlin/Native

Kotlin/Native — de compiler van Kotlin naar native code via LLVM. Voor iOS wordt shared module gecompileerd naar een Apple framework (.framework) dat via Xcode wordt verbonden. Het aanroepen van gemeenschappelijke code vanuit Swift/Objective-C gebeurt via gegenereerde Objective-C-headers, daarom moet de shared module API compatibel zijn met Objective-C.

Beperkingen van iOS-integratie: Kotlin-collecties (List, Map) worden geconverteerd naar NSArray/NSDictionary. Functies met standaardparameters worden niet geëxporteerd — overloads zijn nodig. Voor suspend-functies worden callback-gebaseerde methoden gegenereerd met `@ObjCName` en async/await-ondersteuning vanaf Kotlin 2.0+.

// iOS-app: shared module aanroepen vanuit Swift
import shared

class ViewModel: ObservableObject {
    let repository = UserRepository()
    
    func loadUsers() {
        repository.fetchUsers(completionHandler: { result, error in
            if let users = result as? [User] {
                print("Users: \(users.count)")
            }
        })
    }
}

Integratie van shared module in Xcode gebeurt via embed-and-framework — het gegenereerde `.xcframework` wordt toegevoegd aan het Xcode-project. De Gradle-plugin kan het framework automatisch updaten tijdens het bouwen via embedAndSignAppleFrameworkForXcode. Voor testen op de simulator is iosSimulatorArm64 of iosX64 binary voldoende.

KMP vs Flutter vs React Native

De keuze tussen KMP, Flutter en React Native hangt af van de prioriteit: herbruikbaarheid van logica of volledige multiplatform. KMP biedt native UI op elk platform, maar vereist twee codebases voor de interface. Flutter en React Native gebruiken een uniforme UI, maar offeren nativeiteit op.

Wanneer KMP kiezen: het project vereist high-performance UI (games, kaarten, animaties), bestaande native code moet worden hergebruikt, het team kent Kotlin en native platforms al. Wanneer Flutter/RN kiezen: MVP of startup met beperkt budget, team met één profiel, UI vereist geen diepe native aanpassing.

KMP-tools en bibliotheken

Het ecosysteem van KMP-tools omvat bibliotheken voor alle lagen van de applicatie: netwerk (Ktor), serialisatie (kotlinx.serialization), database (SQLDelight), navigatie (Decompose), DI (Koin) en gegevensopslag (multiplatform-settings). JetBrains ondersteunt Compose Multiplatform — een UI-framework in Kotlin dat op alle platforms werkt.

// Repository in KMP met SQLDelight + Ktor
class UserRepository(
    private val httpClient: HttpClient,
    private val db: AppDatabase
) {
    suspend fun syncUsers(): List<User> {
        val remote = httpClient.get("https://api.example.com/users")
            .body<List<UserDto>>()
        
        db.userQueries.replaceAll(remote.map { it.toDomain() })
        
        return db.userQueries.selectAll().executeAsList()
    }
}

Compose Multiplatform — UI-framework voor KMP gebaseerd op Jetpack Compose. Maakt het mogelijk om interfaces in Kotlin te schrijven voor Android, iOS, Desktop en Web. In 2025 bereikte Compose Multiplatform een stabiele status voor Android en Desktop; het iOS-doel is in bèta. Voor productieprojecten met native UI blijft het voordeel van KMP het belangrijkste verschil met Flutter.