Welcome to the end-of-year update for the Rust language. 2030 has been a huge year for us, with some huge wins but also a couple setbacks. We’d like to highlight some of these moments and look back on the past year of work on Rust.

Async woes

Despite our best efforts, there are still some large issues with async rust. Async traits come with significant limitations, async closures aren’t supported, error messages can be cryptic, it’s easy to accidentally block the executor, and many crates only work with specific runtimes.

To tackle this, we have decided to split the Async Working Group into 10 smaller teams, Async Working Groups 0-9, and have them tackle these problems in parallel.

You may remember we tried this same approach back in 2026, only to find out at the end of the year that nothing had been done for 8 months. Our post-mortem revealed that Async Working Group 0 had been blocked on Async Working Group 1, which had been blocked on Async Working Group 2, which had been blocked on Async Working Group 0.

We have ironed out the kinks in team communication, and expect better results this year from the async Async Working Groups.

An update on higher-kinded types

The original proposal to bring HKTs to Rust was opened in 2016 by Withoutboats. A couple years ago, this issue was revived by his son, Withoutboats Junior. Realizing that a whole new generation of programmers has been raised in the time we let this issue languish, we resolved to devote significant effort here.

As you may know, in 2028 we put a crack team of type system experts onto this problem. After countless nights of research, they managed to publish an elegant proof, that showed definitively that higher-kinded types are theoretically impossible. We closed out the RFC, and moved on.

Shortly after, some rustaceans pointed out the existence of Haskell. The team had to retract its research, and the RFC was re-opened.

Two members of the team, Alice and Bob, after a late-night revelation where they achieved simultaneous enlightenment on what a Monad is, abandoned their research and joined the Cult of Pointfree. Communication has been sparse, but we have received some short missives from them, such as:

It’s so simple $ We can see it all now $ Monads are just monoids in the category of endofunctors $ You’ll see too $ We’re working on a tutorial

As is typical of the acolytes of the Cult of Pointfree, these communications have been written without periods. If you know Alice and Bob personally, we urge you to reach out and try to pull them away from this dangerous organization. We think they may hold the key to finally figuring out higher-kinded types in Rust.

Compile times

As ever, compile times continue to be a focus for the team.

Early this year, we tried to re-imagine what a compiler could look like. Using state-of-the-art LLMs, we implemented a system where code didn’t need to be compiled at all. GPT-6 could simply take in your code, and the input to your program, and generate the output it expected your code to generate. This was a massive win for compile times, but after a couple minor plane crashes, the “Crypto Implosion”, and the “Total Breakdown of the Web”, we were forced to roll back these changes. Let it be known this is not a legally binding admission of guilt or wrongdoing, and that The Rust Foundation™ was never officially found to be culpable for these events.

We went back to the drawing board, and The Rust Foundation™’s lawyers pulled through for us. They discovered that rui348, the creator of Mold, had a sticker of Ferris on his laptop. Of course, this meant that all work done on that laptop was now the sole property of The Rust Foundation™. Using this newly acquired IP, we were able to couple the linker more tightly with the Rust compiler, achieving 0.13% faster compile times.

Our lawyers weren’t done yet though. It turns out there are hundreds of programmers that actually have a tattoo of Ferris on their body. Legally, of course, these programmers are property of The Rust Foundation™. We’ve put this free labor force to work on the compiler, and this added manpower has improved compile times by about 1.2%.

We’re also putting great effort into quantum computing, in partnership with Alphabet and ClosedAI. Our quantum computer can now crack 256-bit elliptic curve cryptography in 17 milliseconds, and solve the traveling salesman problem in linear time. We expect massive compile time improvements from such a leap forward in computing, of up to 3%.

Looking forward

As always, there’s a lot more to be done. Our survey back in 2028 of our users revealed many potential areas of focus. We’re very grateful for all your responses, such as:

“Seriously, no REPL yet?”

“I was stuck on the international space station for 18 months, and all I wanted to see on my return was async traits with Send support”

“Why does async-stripe still take 30 minutes to compile on my M6 chip?”

We have more work to do, clearly, but we’re happy with our recent progress, and excited for the milestones to come.