shared-coroutines

Shared Coroutines for KMP

Configure coroutines for cross-platform async operations with platform-appropriate dispatchers.

Dependencies

// build.gradle.kts
sourceSets {
    val commonMain by getting {
        dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.11.0")
        }
    }
    val commonTest by getting {
        dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.11.0")
        }
    }
    val androidMain by getting {
        dependencies {
            // Runtime artifact that provides the Android Dispatchers.Main implementation.
            // Without it, touching Dispatchers.Main throws IllegalStateException.
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.11.0")
        }
    }
}

Platform Dispatchers

Do NOT hand-roll GCD-backed dispatchers or expect/actual dispatcher objects — the built-ins cover Android and iOS:

• Dispatchers.Default and Dispatchers.Main are declared in the library's commonMain. On Darwin, Default is GCD's global concurrent queue and Main is dispatch_get_main_queue(); Main.immediate is supported there too. On Android, Main comes from the kotlinx-coroutines-android runtime artifact.
• Dispatchers.IO is declared in the library's concurrent source set (JVM + Native only) — there is no JS/Wasm implementation. It therefore resolves from your commonMain only while every target is JVM/Android/Native. Add a js/wasmJs target and commonMain stops seeing it; that is the one case where an expect/actual IO dispatcher is still required.
• On Native, Dispatchers.IO is a 2048-thread pool exposed at parallelism 64. As on JVM, Dispatchers.IO.limitedParallelism(n) views are elastic: they are not capped by IO's own 64, they just share its threads.

Keep a small abstraction anyway so tests can inject a TestDispatcher:

// commonMain/kotlin/coroutines/PlatformDispatcher.kt
interface PlatformDispatcher {
    val main: CoroutineDispatcher
    val io: CoroutineDispatcher
    val default: CoroutineDispatcher
}

object PlatformDispatchers : PlatformDispatcher {
    override val main: CoroutineDispatcher get() = Dispatchers.Main
    override val io: CoroutineDispatcher get() = Dispatchers.IO
    override val default: CoroutineDispatcher get() = Dispatchers.Default
}