{
  "id": 12220160,
  "title": "Async Rust: Where does the scheduler live?",
  "url": "https://urgent.news/2026/10/05/async-rust-where-does-the-scheduler-live",
  "topic": "tech",
  "section": "Tech",
  "published": "2026-10-05T18:31:29.000Z",
  "source": {
    "name": "Lobsters",
    "slug": "lobsters",
    "url": "https://herecomesthemoon.net/2026/10/async-rust-where-does-the-scheduler-live/"
  },
  "original_language": "en",
  "account": "The core issue surrounding async Rust revolves around the necessity of a runtime for concurrency. Unlike other parts of Rust that operate without a runtime requirement (like memory safety), async programming demands a runtime to manage scheduling and execution. This requirement stems from the fundamental nature of concurrent code, where some form of runtime is indispensable. The runtime essentially handles the scheduling of tasks, an essential aspect of any concurrent system.\n\nHowever, the implementation of a runtime introduces several challenges and trade-offs. One major concern is the optimization of scheduling algorithms, which is inherently complex and trade-off-heavy. No single scheduling algorithm fits all scenarios, leading to a situation where developers often find themselves tweaking runtime configurations—like the Tokio runtime—just to achieve marginal performance improvements. This mirrors the experience with Java garbage collectors, where performance tuning becomes a significant part of the development process.\n\nAn interesting comparison can be drawn with languages like Go, which employ a different approach (green threads) and accept a performance trade-off for ease of use. This highlights that there's no one-size-fits-all solution in concurrency, and each language or runtime has its own set of compromises. For Rust, the need for a runtime is unavoidable, and the most pragmatic approach is to package this runtime into a crate. Developers then initialize the runtime, manage the stack, and use it to schedule their asynchronous tasks.\n\nInterestingly, this setup isn't fundamentally different from using threads: the kernel takes over the role of the runtime scheduler. While this shifts the scheduler responsibility to the kernel, the underlying problems of concurrency and runtime management persist. The discussion emphasizes that Rust, with its low-level nature and performance focus, cannot abstract away these complexities. Thus, the runtime remains an integral part of async Rust, despite the various frustrations and optimization hurdles that developers encounter.",
  "summary": null,
  "key_points": [],
  "editors_take": null,
  "illustration": null,
  "coverage": {
    "outlets": 1,
    "also_reported_by": []
  },
  "ai_generated": true,
  "disclaimer": "Summaries, key points and the editor’s take are written by software from other outlets’ reporting and may contain errors — always check the linked original."
}