Kotlin Multiplatform

expect declares an API in commonMain with no body, and each platform source set supplies a matching actual. A target whose actual is missing fails to compile, so the seam is checked by the compiler, not at runtime.

commonMain compiles for every target, so it sees only the common standard library, not any platform SDK. androidMain and iosMain each compile for one target and may use its full API. Common code reaches them through expect/actual.

Ktor publishes a common API plus a per-target engine — OkHttp on Android, Darwin on iOS — declared by its platform source set. The API is a multiplatform library, so commonMain compiles against it and each target links its engine.

KMP shares Kotlin logic — networking, persistence, validation — compiling it to a JVM library for Android and to a native framework for iOS. UI stays platform-native by default; sharing it is a separate opt-in through Compose Multiplatform.

It is a compiler plugin, not a reflection library. At compile time it generates a KSerializer for each @Serializable class from its structure, so the serializer is ordinary code in each target's output — no JVM reflection needed.

Share the logic, keep the UI native. Networking, caching and pricing are plain Kotlin in commonMain with almost no platform seam: low risk, and it kills the drift you paid for twice. Shared UI buys less and costs more.

Put the client, DTOs, retry and cache policy and business rules in commonMain on Ktor, kotlinx.serialization and SQLDelight. Seam only the Ktor engine and the database driver. The rest stays common, tested once in commonTest.

freeze() is still declared but deprecated at error level, so the call will not compile. It belonged to the retired legacy memory manager: modern Kotlin/Native uses a tracing garbage collector and shares objects across threads unfrozen.

A klib holds serialized Kotlin declarations plus an intermediate representation, not JVM bytecode. A jar carries bytecode alone, which Kotlin/Native and Kotlin/JS cannot use, so a common dependency ships as a klib lowered per target.

Kotlin/Native exports via an Objective-C header, which has no default arguments and no exhaustive sums — so Swift demands every parameter and still wants a default. Add explicit overloads and expose a discriminator Swift can switch over.

No freeze: the shared module is just another dependency, so both apps keep shipping. Move one platform-free leaf slice first — domain models plus a pure algorithm like pricing. Expand while it deletes duplicates; stop when seams cost more.

The modern memory manager lets Kotlin/Native threads share mutable objects, so nothing complains: this is an ordinary data race, just as on the JVM. Freezing is gone and is not the fix — guard the state from common code with a Mutex.

Model the policy in commonMain — keys, time-to-live, eviction, read-through — over a multiplatform store, free of platform types. Seam only the driver, the file path and the clock. Test it once in commonTest with a fake clock.

Kotlin/Native ships iOS through an Objective-C framework Swift consumes, losing default arguments, exhaustive sums and generic precision. Swift export emits Swift bindings directly and keeps far more, but it is Alpha, not shippable.

KMP shares logic and compiles to a native binary per target — no added runtime, VM or bridge — so each platform keeps its own UI and full API access. Flutter ships its own engine and widgets; React Native drives native views from JS.

Kotlin/Wasm compiles to WebAssembly and is Beta, not Stable: usable, but its surface can shift between releases, so budget for re-verifying upgrades. It targets browsers, where Compose Multiplatform renders a shared UI, and WASI runtimes.

commonMain takes what is platform-independent: models, validation, business rules, networking and persistence via KMP libraries. Permissions, background work and UI stay native, behind expect/actual only if common code needs them.

Do not put an Alpha feature on a release branch carrying payments. Prototype Swift export on a branch, but ship this train on the Objective-C header and fix the ergonomics where it is cheapest: a Swift-facing facade in the shared module.