Need help with coroutineworker?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

294 Stars 19 Forks Apache License 2.0 65 Commits 1 Opened issues


Kotlin Coroutine-based workers for native

Services available


Need anything else?

Contributors list


Build Status

Maven Central


  • Supported on Native, JVM, and JS (legacy and IR) (feel free to contribute adding more targets)
  • Kotlin 1.5.0


To use in your multiplatform project, update your common dependencies in your gradle configuration:

kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation "com.autodesk:coroutineworker:0.7.0"

CoroutineWorker uses gradle module metadata. We recommend adding the following to your settings.gradle to take advantage of that (not necessary for Gradle 6+):



CoroutineWorker helps support multi-threaded coroutine usage in common code that works in Kotlin/Native and on JVM until kotlinx.coroutines has full support for native, multi-threaded coroutines.

Projects Using this on your Devices

Sample Usage

Spawning Asynchronous Work


to start background work from common code:
val worker = CoroutineWorker.execute {
  // - In here, `this` is a `CoroutineScope`
  // - Run suspend functions, call launch, etc.
  // - This code runs in a thread pool

// Tells the worker to cancel (uses standard coroutine cancellation) worker.cancel()

// Tells the worker to cancel; it suspends until cancellation is finished worker.cancelAndJoin()

Waiting on Asynchronous Work to Complete

From a coroutine context (i.e. somewhere you can call a

suspend fun
), use
to kick off work to another thread. It will non-blocking/suspend wait for the cross-thread work to complete:
suspend fun doWork() {
  val result = CoroutineWorker.withContext {
    // This is similar to execute, but it returns
    // the result of the work at the end of this lambda
  print(result) // prints 1

This is like using

on JVM to switch coroutine contexts. You can also properly pass a dispatcher, which will be used on JVM:
withContext(Dispatchers.IO) { … }
. The idea here is that this will be easy to migrate when we do get multi-threaded coroutine support in Kotlin/Native.

Waiting on Asynchronous Callback-based Work


to bridge callback-style async work into your code as a
suspend fun
suspend fun performNetworkFetch() {
  val result = threadSafeSuspendCallback { completion ->
    // example: fetch network data that isn't coroutine-compatible
    fetchNetworkData { networkResult ->
      // notify that async work is complete

// result is now available here }

Sample Project

In the sample directory, there is a sample project that demonstrates adding CoroutineWorker to an iOS + JVM library. We just used the sample library from IntelliJ's template for a "Mobile Shared Library." In the sample is a function called

(common code) that takes a completion lambda and demonstrates
. In tests, we use K/N concurrency helpers from
to demonstrate capturing a result across threads in K/N and executing this function.

CoroutineWorker Prefers Frozen State

Object detachment (i.e. transferring object ownership from one thread to another) is relatively difficult to achieve (outside of simple scenarios) compared to working with objects that are frozen and immutable. Because of this, CoroutineWorker prefers taking the frozen, immutable route:

  • Lambdas passed to CoroutineWorker are automatically frozen when they are going to be passed across threads.
  • The result value from
    is also frozen.

Tips for Working with Frozen State

  • Be careful about what your frozen lambdas capture; those objects will be frozen too. Especially, watch for implicit references to
  • Call
    on objects that you don't expect to ever be frozen.

IO-Bound Work

In the JVM world, you typically write code like this for managing IO-bound work with coroutines:

withContext(Dispatchers.IO) {
    // IO writes

Similar behavior is supported in CoroutineWorker for Kotlin/Native via the

. To use it in common code, make an
expect val Dispatchers.IO: CoroutineDispatcher
that returns
for Kotlin/Native and
for JVM, and pass that to
when performing IO-bound worker.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.