Rust's eleventh year and the shape of a finished language
Six-week releases, no breakage, and a backlog that is finally shorter than it was. What's left is the hard part.
Another Rust release, another set of const stabilizations and library additions. The release notes have been pleasantly dull for a year, which is the best thing you can say about a language with load-bearing production deployments.
Rather than enumerate, it is worth asking what "finished" would look like and how close this is.
what got finished#
The list of "this obviously should work and does not" items has genuinely shrunk. Trait upcasting, let chains, RPIT capture, anonymous pipes, const in more places, SIMD intrinsics, async closures. Each of those was a multi-year open question and each is now just how the language works.
That is the signature of a language moving from the growth phase into the maintenance phase, and it is a good place to be. The compiler is faster than it was. The error messages remain the best in the industry. The tooling story — cargo, clippy, rustfmt, rust-analyzer — is coherent in a way that most languages never achieve.
what is left, honestly#
Async. Still the sharpest edge. Async traits work. Async closures work. What does not work smoothly: cancellation semantics that do not surprise you, async drop, Send bound propagation through generic async code, and the absence of a standard executor interface which fragments the ecosystem.
The Pin API remains the piece of Rust that experienced engineers most often describe as genuinely confusing, and the ergonomic improvements have been incremental.
This is the area where Rust is meaningfully harder than it needs to be, and where a new user is most likely to conclude the language is too complicated. It matters because async is how you write network services, and network services are most of software.
Const generic expressions. [T; N * 2] still needs nightly. The blocker is real — deciding when two type-level expressions are equal is undecidable in general and the team will not ship a rule they cannot explain.
GUI. Ten-plus years, several serious projects, no consensus. Partly a Rust problem: the borrow checker's relationship with the retained-mode widget tree that every traditional GUI framework uses is genuinely awkward. Partly not a Rust problem: cross-platform GUI is unsolved everywhere.
Compile times. Better every year. Still slower than Go. Structurally will remain so, because monomorphization and the optimization Rust performs are not free and are the reason the output is fast.
the adoption picture, unsentimentally#
Won decisively: systems programming, CLI tooling, JavaScript build tooling, cryptography implementations, embedded, WebAssembly targets, kernel drivers in both Linux and Windows.
Winning slowly: backend services, where Go's simplicity and compile speed are a real competitor and where the async ergonomics cost is felt daily.
Not winning and probably will not: application development, data science, scripting. Different constraints, different right answers.
That is a good outcome. A language does not need to win everything, and the places Rust won are the places where memory safety bugs were causing the most damage.
the thing to appreciate#
Eleven years of six-week releases and no broken stable program. Three editions with automated migration and no ecosystem split. A governance structure that has survived real disagreements in public.
For a language that has changed as much as Rust has, that stability record is the actual achievement, and it is the reason people are willing to put infrastructure on it. Features are cheap. Trust is not.
for someone deciding whether to learn it in 2026#
If you write systems software, networking infrastructure, embedded code, or anything where a memory safety bug is a security incident: yes, and you probably already know that.
If you write web applications: the async ergonomics are the thing you will fight, and Go or a good typed scripting language will make you more productive faster. Learn Rust anyway, eventually, because understanding ownership makes you better in every language.
If you tried it in 2021 and bounced off the compile times or the error messages: try again. Both are substantially different now.
— Dom, January 20, 2026