Once again, the ultimate event for developers, tech leaders, and visionaries, Codemotion Madrid, is just around the corner. And with it come new opportunities to learn, connect, and explore the technological trends transforming the industry.
To whet your appetite, here’s a preview of one of the most exciting talks of this edition: Virtual Threads vs. Coroutines in 2026: Is Java Finally There? Led by Wout Werkman from JetBrains, this talk will explore how Java has evolved its concurrency model to compete with solutions that languages like Kotlin have offered for years.
Remember: if you don’t want to miss Codemotion Madrid 2026, happening on April 20–21 at La Nave (Madrid)
Talk Context
As any developer working in high-concurrency environments knows, efficiently managing threads and concurrent processes is key to modern application performance. And, as many are aware, Java has long been criticized for its challenges in this area.
Traditional Java threads, based on the operating system’s “one thread per request” model, have historically been heavy and resource-intensive. Each thread consumes significant memory, and creating them involves OS overhead, which limits scalability.
For years, this problem persisted. While asynchronous and reactive models (like RxJava or Project Reactor) offered partial solutions, they added complexity without addressing the root issue.
That’s when Kotlin stepped in with its coroutines.
Kotlin and Kotlin.coroutines
In 2011, JetBrains introduced Kotlin as an experimental project, and by 2014, its first stable version was officially released. Early adoption doubled year after year until 2017, when Google announced Kotlin would become an officially supported language—marking a turning point for widespread adoption.
It was in this context that JetBrains introduced coroutines in Kotlin 1.1’s standard library, providing a lightweight, efficient concurrency model that allowed developers to write asynchronous code sequentially and readably.
The ability to suspend and resume functions without blocking OS threads allowed developers to write code that looked synchronous but ran asynchronously.
Coroutines proved capable of handling millions of concurrent tasks with minimal resource consumption, surpassing the limitations of traditional Java threads. Since then, Kotlin has become an industry standard.
Java Responds: Virtual Threads (Project Loom)
Aware of this competitive disadvantage, Oracle began working on Project Loom, an initiative to modernize Java’s concurrency model. After years of development, Java 21 (released in September 2023) finally introduced Virtual Threads as an official language feature.
These threads allow concurrency to be managed by the JVM instead of the OS, drastically reducing overhead and enabling more efficient thread management. Unlike traditional platform threads, virtual threads are dynamically mapped onto a limited pool of carrier threads, optimizing resource use. This architecture allows writing blocking code naturally without sacrificing scalability or increasing complexity.
Additionally, the newly introduced Scoped Values complement this model by providing a way to propagate immutable data across threads without the overhead of ThreadLocal, further improving performance in high-concurrency scenarios.
In direct response to Kotlin’s Coroutine Scopes, Java also introduced Structured Concurrency APIs, which—though still in preview—allow multiple concurrent tasks running on different virtual threads to be treated as a single manageable unit of work.
The Talk: Virtual Threads vs. Coroutines in 2026: Is Java Finally There?
You may have heard the Kotlin community boast about coroutines compared to Java’s concurrency options.
However, as we’ve seen, Java has not stayed behind and has introduced many new features that bring it closer to the solutions Kotlin has offered for years. But the question remains: has Java finally closed the gap?
In the talk Virtual Threads vs. Coroutines in 2026: Is Java Finally There?, Wout Werkman will compare with attendees whether Java’s new concurrency capabilities truly measure up to Kotlin’s coroutines.
Speaker: Wout Werkman (Software Engineer & Developer Advocate at JetBrains)
Wout Werkman is a software developer with experience in industrial automation and backend development. He currently collaborates with the Kotlin Multiplatform team at JetBrains and is fully committed to sharing his knowledge. He has the privilege of giving talks on Kotlin and teaching the language to young developers.
