Top Projects for Coroutines Mastery in 2025

Coroutines Mastery was full of lessons and practical exercises, so a final project was just the cherry on top. I haven't expected anything ambitious, I made it clear that projects can be simple, they only need to use coroutines and serve the community. Yet I was surprised with so many heroes, who decided to make ambitious, amazing project. To honor them, here is a small list of my favorite ones.

Comet

Comet (from Coroutine Telemetry) is a library for tracking coroutines made by Pandu Baraja. It provides a way to visually monitor coroutines execution, making it easier to debug and understand complex coroutine flows.

// 1. Create Comet instance (once, at app startup)
val comet = Comet.create {
    exporter(CallbackCoroutineTelemetryExporter(
        onEvent = { event -> println("[Comet] $event") },
    ))
} /
comet.start()

// 2. Add comet.traced("name") to ANY launch - that's it
scope.launch(comet.traced("my-operation")) {
    // This and all children coroutines are automatically traced
    launch(CoroutineName("child-task")) { /* auto traced with name */ }
    async(CoroutineName("async-task")) { /* auto traced with name */ }
}

Code 👉 https://github.com/pandubaraja/comet

kmp-resilient

I am especially proud of this project. I am sure it already offered a lot of value to the author, and it is likely it will offer great value to our community. kmp-resilient by Santiago Mattiauda is a complete solution for setting up resilience patterns in Kotlin Multiplatform (KMM), coroutines-native and with solid tests. It also offers a really nice DSL-based idiomatic API.

Code 👉 https://github.com/santimattius/kmp-resilient

Gemini client

Gemini client by Shamil Giylmetov was a very ambitious project, with many edge-cases to cover. Code is solid and well-structured, making it a great example for learning coroutines in Android development.

Code 👉 https://github.com/shamil-RS/Gemini

StrayCat

StrayCat is a beautiful Android application for location simulation and GPS tracking created by Marko Lainovic from TomTom. Perfect for testing location-based features and route simulations.

Code 👉 https://github.com/lainovic/StrayCat/

Where2fly

Time for an application for passionates of aviation. Where2fly (made by Krzysztof Cieślewicz) is an unofficial android version of https://airspace.pansa.pl web application. It allows downloading and viewing basic airspace and updated usage plans and related information for a Warsaw flight information region. It is well-written and looks good. It also presents how to deeply test view models and repositories using the power of kotlinx-coroutines-test.

Code 👉 https://gitlab.com/krzysztof.cieslewicz1/where-to-fly

Coroutines Visualizer

It isn't the hardest of all projects, but I was stunned by the simplicity and implementation of the idea. Krystian Mateja made an application that allows you to make any hierarchy of coroutines and observe how it will behave in response to cancellation, exceptions, and other events. The code is actually using coroutines and showing their state. Everything is simple and straightforward.

Code 👉 https://github.com/kmate-dev/CoroutinesVisualizer

VizCor

Talking about visualizing coroutines, I must mention VizCor, a great coroutines visualizer by Jiri Hermann. I believe it is the most ambitious project, showing how to implement backend services in Ktor, with Swagger, AsyncAPI, OpenAPI, Micrometer and much more.

Backend code 👉 https://github.com/hermanngeorge15/vizcor-be

Dropwizard Coroutines Demo

Dropwizard is a Java framework for developing ops-friendly, high-performance, RESTful web services. Apparently, there was no project showing how to use it together with Kotlin coroutines. This has changed thanks to Rui Pinto, who implemented a simple demo application that showcases how to use coroutines in Dropwizard.

Code 👉 https://github.com/rp199/dropwizard-coroutines-demo?tab=readme-ov-file

KoCache, KCache and suspending-cache

Cache is one of the greatest problems in programming. Of course, it is hard to make a cache that can compete with highly optimized solutions, but implementing a cache is a great exercise. A well-implemented cache needs to handle many edge cases, such as exception handling, cancellation, invalidation, capacity limits, etc. On this course I had three challengers, implementing their own cache.

KoCache by Anders Asplund (example use on the image above) 👉 https://codeberg.org/aasplund/KoCache

KCache by Matthias Reither 👉 https://github.com/reithma/kcache

suspending-cache by Mirko Ivanovic 👉 https://github.com/mirkoiv/kt-suspending-cache

Weather application

This one might not look that ambitious or big, but I like it as a nice showcase of how to correctly design an Android application. It implements search with multiple triggers, error handling, uiState pattern, simple yet correct architecture.

Code 👉 https://github.com/piotrkanarek-emr/CoroutinesMastery_final-project

Other projects...

KMP Dispatchers Test by Magnum Rocha is an application showing what happens when you use different dispatchers for different kinds of tasks in Android. An amazing project, I hoped it will be turned into a game. It could be really fun and useful for learning dispatchers.
ble-routines by Maksim Shchezhin is an amazing library for making BLE (Bluetooth Low Energy) usage quicker and simpler with Coroutines. The only reason it wasn't at the main list is that it is still WIP.
StockMarket Application by Steve Mason is an example application observing stock market data with Coroutines.

This list is far from being complete, there were many other great projects, but I couldn't present them all. Great kudos to all the heroes who decided to make ambitious projects for their own learning and for sharing them with the community.