{"id":681725,"date":"2026-02-17T14:06:27","date_gmt":"2026-02-17T13:06:27","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=rust&#038;p=681725"},"modified":"2026-02-27T14:41:02","modified_gmt":"2026-02-27T13:41:02","slug":"the-evolution-of-async-rust-from-tokio-to-high-level-applications","status":"publish","type":"rust","link":"https:\/\/blog.jetbrains.com\/fr\/rust\/2026\/02\/17\/the-evolution-of-async-rust-from-tokio-to-high-level-applications","title":{"rendered":"The Evolution of Async Rust: From Tokio to High-Level Applications"},"content":{"rendered":"\n<p><em>Disclaimer: This article was created using AI-based writing and communication companions. With its help, the core topics of this rich and nuanced livestream were conveniently distilled into a compact blog post format.<\/em><\/p>\n\n\n\n<p>In our yet another JetBrains livestream, <a href=\"https:\/\/x.com\/VBragilevsky\" data-type=\"link\" data-id=\"https:\/\/x.com\/VBragilevsky\" target=\"_blank\">Vitaly Bragilevsky<\/a> was joined by <a href=\"https:\/\/x.com\/carllerche\" data-type=\"link\" data-id=\"https:\/\/x.com\/carllerche\" target=\"_blank\">Carl Lerche<\/a>, the creator of <a href=\"https:\/\/tokio.rs\/\" data-type=\"link\" data-id=\"https:\/\/tokio.rs\/\" target=\"_blank\" rel=\"noopener\">Tokio<\/a>, for an in-depth conversation about the evolution of async Rust. Tokio has become the de facto asynchronous runtime for high-performance networking in Rust, powering everything from backend services to databases. During the discussion, they explored how async Rust matured over the years, the architectural decisions behind Tokio, common challenges developers face today, and where the ecosystem is heading next. If you missed the live session, you can watch the full recording on JetBrains TV. Below, you\u2019ll find a structured recap of the key questions and insights from the conversation.<\/p>\n\n\n\n<figure class=\"wp-block-embed is-type-video is-provider-youtube wp-block-embed-youtube wp-embed-aspect-16-9 wp-has-aspect-ratio\"><div class=\"wp-block-embed__wrapper\">\n<iframe loading=\"lazy\" title=\"The Evolution of Async Rust: From Tokio to High-Level Applications\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/2aZaBZVJWm0?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>\n<\/div><\/figure>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q1. What is TokioConf and why did you decide to organize it?<\/strong><\/h2>\n\n\n\n<p><a href=\"https:\/\/www.tokioconf.com\/\" target=\"_blank\" rel=\"noopener\">TokioConf<\/a> is the first conference dedicated to the Tokio ecosystem, taking place in Portland, Oregon. This year marks ten years since Tokio was first announced, making it a natural moment to bring the community together. Use the <strong>code jetbrains10 for 10% off<\/strong> the <a href=\"https:\/\/tokioconf.com\/?utm_source=jetbrains&amp;utm_medium=podcast&amp;utm_campaign=promo\" data-type=\"link\" data-id=\"https:\/\/tokioconf.com\/?utm_source=jetbrains&amp;utm_medium=podcast&amp;utm_campaign=promo\" target=\"_blank\" rel=\"noopener\">general admission ticket <\/a>(excluding any add-ons).<\/p>\n\n\n    <div class=\"buttons\">\n        <div class=\"buttons__row\">\n                                                <a href=\"https:\/\/tokioconf.com\/?utm_source=jetbrains&#038;utm_medium=podcast&#038;utm_campaign=promo\" class=\"btn\" target=\"\" rel=\"noopener\">Buy TokioConf ticket<\/a>\n                                                    <\/div>\n    <\/div>\n\n\n\n\n\n\n\n<p>Tokio and Rust have become foundational technologies for infrastructure-level networking software, including databases and proxies. The conference is meant to reflect that maturity and growth. While the name highlights Tokio, the scope includes broader async and networking topics in Rust.<\/p>\n\n\n\n<p><\/p>\n\n\n    <div class=\"blockquote\">\n                    <blockquote><p>\u201cTokio and Rust have become one of the default ways companies build infrastructure-level networking software these days.\u201d<\/p><\/blockquote>\n            <div class=\"blockquote__author\">\n                                    <img decoding=\"async\" class=\"blockquote__author-img\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2026\/02\/portrait_2.png\" alt=\"\">\n                                <div class=\"blockquote__author-info\">\n                                                        <\/div>\n            <\/div>\n            <\/div>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q2. When people hear \u201cAsync Rust,\u201d what should they picture?<\/strong><\/h2>\n\n\n\n<p>Async Rust is about more than performance. While handling high concurrency is a key advantage, async programming also improves how developers structure event-driven systems.<\/p>\n\n\n\n<p>Timeouts, cancellation, and managing multiple in-flight tasks become significantly easier in async Rust compared to traditional threaded approaches. Async in Rust leverages the ownership model and Drop, enabling safe and clean cancellation patterns.<\/p>\n\n\n    <div class=\"blockquote\">\n                    <blockquote><p>\u201cAsync is both performance, but also a way of managing lots of in-flight threads of logic well.\u201d<\/p><\/blockquote>\n            <div class=\"blockquote__author\">\n                                    <img decoding=\"async\" class=\"blockquote__author-img\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2026\/02\/portrait_2.png\" alt=\"\">\n                                <div class=\"blockquote__author-info\">\n                                                        <\/div>\n            <\/div>\n            <\/div>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q3. How did Tokio begin? Why did Rust need it?<\/strong><\/h2>\n\n\n\n<p>Tokio evolved from earlier experimentation with non-blocking I\/O in Rust. Initially, Rust only had blocking socket APIs, and building efficient network systems required low-level abstractions. The journey went from Mio (epoll bindings), to the <code>Future<\/code> trait, and to async\/await. Async\/await was a major milestone in making async programming ergonomic in Rust.<\/p>\n\n\n    <div class=\"blockquote\">\n                    <blockquote><p>\u201cThe way async\/await ended up being designed is actually quite impressive.\u201d<\/p><\/blockquote>\n            <div class=\"blockquote__author\">\n                                    <img decoding=\"async\" class=\"blockquote__author-img\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2026\/02\/portrait_2.png\" alt=\"\">\n                                <div class=\"blockquote__author-info\">\n                                                        <\/div>\n            <\/div>\n            <\/div>\n\n\n\n<p>The language team managed to deliver memory safety and zero-cost abstractions in a way that wasn\u2019t obvious at the time.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q4. Could Rust have something like Java\u2019s virtual threads?<\/strong><\/h2>\n\n\n\n<p>Rust originally had green threads and coroutines before version 1.0, but they were removed to preserve zero-cost abstractions and C-level performance characteristics. The overhead and complexity of stack management for green threads conflicted with Rust\u2019s design goals at the time.<\/p>\n\n\n    <div class=\"blockquote\">\n                    <blockquote><p>\u201cRust actually started with lightweight virtual threads and coroutines.\u201d<\/p><\/blockquote>\n            <div class=\"blockquote__author\">\n                                    <img decoding=\"async\" class=\"blockquote__author-img\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2026\/02\/portrait_2.png\" alt=\"\">\n                                <div class=\"blockquote__author-info\">\n                                                        <\/div>\n            <\/div>\n            <\/div>\n\n\n\n<p>Whether such a feature could return is an open question, but today\u2019s Rust async model is fundamentally different.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q5. How does cancellation work in Async Rust?<\/strong><\/h2>\n\n\n\n<p>Cancellation in Rust is implemented through <code>Drop<\/code>. When you drop a future, its cleanup logic runs automatically.<\/p>\n\n\n\n<p>If the future directly owns a socket, it closes immediately. If the socket is owned by another task (for example in Hyper), cancellation signals cascade through channels and trigger cleanup.<\/p>\n\n\n\n<p>However, async functions can be dropped at any point, and developers must write defensively to handle that reality correctly.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q6. Why did Tokio become the dominant async runtime?<\/strong><\/h2>\n\n\n\n<p>Tokio became the de facto standard largely due to ecosystem momentum. Early crates like Hyper built on Tokio, and once that foundation solidified, switching runtimes required compelling reasons.<\/p>\n\n\n\n<p>Other runtimes exist (especially for embedded or specialized contexts) but for general server-side development, Tokio\u2019s ecosystem depth made it the default.<\/p>\n\n\n    <div class=\"blockquote\">\n                    <blockquote><p>\u201cThere just wasn\u2019t a good reason to not use Tokio.\u201d<\/p><\/blockquote>\n            <div class=\"blockquote__author\">\n                                    <img decoding=\"async\" class=\"blockquote__author-img\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2026\/02\/portrait_2.png\" alt=\"\">\n                                <div class=\"blockquote__author-info\">\n                                                        <\/div>\n            <\/div>\n            <\/div>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q7. What about io_uring? Is it the future?<\/strong><\/h2>\n\n\n\n<p>io_uring can provide benefits, especially for batching filesystem operations. However, for networking workloads, real-world gains are often limited. It is more complex than epoll and has historically had more security issues. That said, Tokio allows mixing in io_uring-specific crates when you have a clear use case.<\/p>\n\n\n    <div class=\"blockquote\">\n                    <blockquote><p>\u201cI\u2019ve not seen real performance benefits with swapping out io_uring for sockets under the hood in Tokio.\u201d<\/p><\/blockquote>\n            <div class=\"blockquote__author\">\n                                    <img decoding=\"async\" class=\"blockquote__author-img\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2026\/02\/portrait_2.png\" alt=\"\">\n                                <div class=\"blockquote__author-info\">\n                                                        <\/div>\n            <\/div>\n            <\/div>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q8. What were the most important design decisions in Tokio?<\/strong><\/h2>\n\n\n\n<p>Tokio intentionally avoided reinventing scheduling patterns. Instead, it adopted proven strategies from Go and Erlang, including work-stealing schedulers.<\/p>\n\n\n\n<p>The philosophy was to provide:<\/p>\n\n\n\n<ul>\n<li>Good defaults,<\/li>\n\n\n\n<li>Strong performance,<\/li>\n\n\n\n<li>Escape hatches for advanced tuning.<br><\/li>\n<\/ul>\n\n\n\n<p>The goal was to make Tokio easy enough for most developers while still enabling performance optimization when needed.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q9. What are common mistakes in Async Rust?<\/strong><\/h2>\n\n\n\n<p>The biggest issue comes from cooperative scheduling. Tasks only yield at .await, so long CPU-heavy work without awaiting can stall the runtime. Tokio provides runtime metrics to help detect such problems. Understanding how the scheduler works is crucial to avoiding tail-latency problems.<\/p>\n\n\n    <div class=\"blockquote\">\n                    <blockquote><p>\u201cBecause async is cooperative scheduling, you have to make sure you\u2019re yielding back to the runtime regularly enough.\u201d<\/p><\/blockquote>\n            <div class=\"blockquote__author\">\n                                    <img decoding=\"async\" class=\"blockquote__author-img\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2026\/02\/portrait_2.png\" alt=\"\">\n                                <div class=\"blockquote__author-info\">\n                                                        <\/div>\n            <\/div>\n            <\/div>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q10. What\u2019s the best way to debug Async Rust?<\/strong><\/h2>\n\n\n\n<p>Debugging async systems often involves:<\/p>\n\n\n\n<ul>\n<li>Tracing,<\/li>\n\n\n\n<li>Runtime metrics,<\/li>\n\n\n\n<li>Async backtraces,<\/li>\n\n\n\n<li>Traditional debuggers.<br><\/li>\n<\/ul>\n\n\n\n<p>Stuck tasks and high tail latency remain the hardest issues to diagnose. Better static analysis and linting tools could significantly improve this area in the future.<\/p>\n\n\n    <div class=\"blockquote\">\n                    <blockquote><p>\u201cThe biggest pitfall stems down to developers accidentally canceling something and not handling the cancellation appropriately.\u201d<\/p><\/blockquote>\n            <div class=\"blockquote__author\">\n                                    <img decoding=\"async\" class=\"blockquote__author-img\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2026\/02\/portrait_2.png\" alt=\"\">\n                                <div class=\"blockquote__author-info\">\n                                                        <\/div>\n            <\/div>\n            <\/div>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q11. What is Toasty, and why are you building it?<\/strong><\/h2>\n\n\n\n<p>Rust has matured as a systems and infrastructure language, but higher-level web application tooling remains underdeveloped. Toasty aims to explore that space by building a productive, ergonomic data modeling and query layer. The goal is not just performance, but developer ergonomics \u2013 while still preserving escape hatches for advanced use cases.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Q12. Can Rust move into high-level web frameworks?<\/strong><\/h2>\n\n\n\n<p>Rust already has a foothold in many organizations thanks to its infrastructure strengths. As internal <a href=\"https:\/\/blog.jetbrains.com\/rust\/2026\/02\/11\/state-of-rust-2025\/#is-rust-still-popular-in-2025\" data-type=\"link\" data-id=\"https:\/\/blog.jetbrains.com\/rust\/2026\/02\/11\/state-of-rust-2025\/#is-rust-still-popular-in-2025\">Rust ecosystems grow<\/a>, the demand for higher-level tooling increases. The missing piece is ergonomic, opinionated frameworks that prioritize productivity. The long-term vision is not to replace existing ecosystems, but to expand Rust\u2019s reach upward into full-stack development.<\/p>\n\n\n    <div class=\"blockquote\">\n                    <blockquote><p>\u201cI do think there\u2019s a way to build productive and ergonomic libraries with Rust that focus on ease of use.\u201d<\/p><\/blockquote>\n            <div class=\"blockquote__author\">\n                                    <img decoding=\"async\" class=\"blockquote__author-img\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2026\/02\/portrait_2.png\" alt=\"\">\n                                <div class=\"blockquote__author-info\">\n                                                        <\/div>\n            <\/div>\n            <\/div>\n\n\n\n<p><\/p>\n\n\n\n<h2 class=\"wp-block-heading\"><strong>Closing Thoughts<\/strong><\/h2>\n\n\n\n<p>Rust has firmly established itself as the best choice for many infrastructure-level systems. The next frontier is higher-level application development. Tokio solved async infrastructure and now the ecosystem is evolving toward productivity and full-stack capability.<\/p>\n\n\n\n<p>If you\u2019re interested:<\/p>\n\n\n\n<ul>\n<li>Explore <a href=\"https:\/\/github.com\/tokio-rs\/toasty\" target=\"_blank\" rel=\"noopener\">Toasty on the Tokio GitHub<\/a><\/li>\n\n\n\n<li>Join the <a href=\"https:\/\/discord.com\/invite\/tokio\" data-type=\"link\" data-id=\"https:\/\/discord.com\/invite\/tokio\" target=\"_blank\" rel=\"noopener\">Tokio Discord<\/a><\/li>\n\n\n\n<li>Attend <a href=\"https:\/\/tokioconf.com\/?utm_source=jetbrains&amp;utm_medium=podcast&amp;utm_campaign=promo\" data-type=\"link\" data-id=\"https:\/\/www.tokioconf.com\/\" target=\"_blank\" rel=\"noopener\">TokioConf in Portland, Oregon<\/a><\/li>\n<\/ul>\n\n\n\n<p>Watch our previous lifestream with Herbert Wolverson and explore everything you wanted to ask about Rust<\/p>\n","protected":false},"author":1454,"featured_media":681871,"comment_status":"closed","ping_status":"closed","template":"","categories":[8643],"tags":[9036,530,9035],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/rust\/681725"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/rust"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/types\/rust"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/users\/1454"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/comments?post=681725"}],"version-history":[{"count":7,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/rust\/681725\/revisions"}],"predecessor-version":[{"id":681894,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/rust\/681725\/revisions\/681894"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media\/681871"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media?parent=681725"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/categories?post=681725"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/tags?post=681725"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/cross-post-tag?post=681725"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}