Rust keeps rebuilding its own tools in Rust. This fortnight the author of the mold linker said he is porting it from C++ to Rust, the GCC backend hits a milestone, and the Wasmi interpreter got about 2x as fast. The flip side is the learning curve. Async Rust is still where newcomers get stuck, and this edition has an honest thread about that, alongside early signs the rough edges are being smoothed. Let's dig in.

Featured sponsor Send webhooks without building the infrastructure. Svix is the enterprise-ready webhooks service, and its core is built in Rust. Retries, signature verification, fan-out, rate limiting, and observability arrive as an API you can drop in within minutes, so your team ships product instead of maintaining webhook plumbing. Start sending at svix.com →

Even the Linker Is Getting Rewritten in Rust

Rui Ueyama, the author of the mold linker and before it the LLVM linker lld, says he is rewriting mold in Rust. mold is one of the fastest linkers, currently written in C++, and Ueyama understands linker internals as well as anyone working today.

This is not a newcomer reaching for Rust. It is the domain expert choosing it for a from-scratch rewrite of exactly the kind of pointer-dense, performance-critical systems code Rust was built for. The reasons that come up in the discussion are the familiar ones: memory safety and long-term maintainability, plus the pragmatic hope that Rust's tooling lowers the barrier for new contributors to a project that has largely been one person's work.

A linker is also a demanding test case. Its whole job is raw throughput, so the rewrite will be watched closely for whether Rust can match the C++ speed rather than trade performance for safety. If it can, that is a strong data point for Rust in the last redoubt of hand-tuned C++.

Takeaways:

• The author of one of the fastest linkers is porting it from C++ to Rust, a domain-expert endorsement rather than a hype cycle
• Memory safety and maintainability are the stated motives, with easier contributor onboarding as a bonus
• Watch whether Rust matches C++ on a purely throughput-bound workload; that is the real question a linker rewrite answers

AsyncIterator Inches Forward

Jack O'Connor, best known for BLAKE3, posted a progress update on AsyncIterator, the trait that would give Rust a standard, ergonomic way to iterate over asynchronous streams of values. Think of it as the async analogue of Iterator, and one of async Rust's longest-running gaps.

Today you reach for the Stream trait from the futures crate. It works, but the absence of a standard-library-blessed equivalent, and eventually an async for loop to go with it, is a real paper cut that shows up the moment you move past request-response code into anything streaming. The update walks through where the design stands and what still needs to land before stabilization.

Progress here is slow by design: this is the kind of foundational trait that the whole ecosystem builds on, so getting the shape right matters more than shipping fast. It is worth tracking precisely because so much downstream ergonomics depends on it.

Takeaways:

• AsyncIterator is the async counterpart to Iterator, and its absence from std is a long-standing async paper cut
• The near-term stand-in is Stream from the futures crate; the end goal includes ergonomic async for iteration
• Foundational and deliberately slow, but one of the higher-leverage pieces of async Rust still in flight

Learning Async Rust Feels Like Playing Dark Souls

The most relatable thread of the fortnight comes from a twelve-year C programmer, a year into Rust, who says almost every feature is genuinely amazing, except async, which feels like playing Dark Souls: punishing, opaque, and full of moments where you die without quite understanding why.

It resonated with me because it names a real gap. Sync Rust rewards you quickly, but async Rust throws Pin, lifetimes across await points, Send bounds, and executor choice at you all at once, and the error messages rarely point at the actual mental model you are missing. The comments are the best part: seasoned async developers largely agreeing, then offering the models the docs still do not gather in one place, the state-machine desugaring, why Pin exists, and when you genuinely need to care about it.

Read it as a newcomer to feel less alone, and as a library author to see exactly where the cliff is. The ergonomics are improving, slowly, but the thread is an honest map of today's terrain.

A personal note: I am currently reviewing a new edition of a Packt book on async Rust, still to be published, and its whole aim is to make exactly this material more approachable. From what I have seen so far, the cliff this thread describes is real but very much climbable. Async Rust does not need to be this hard to learn, it mostly needs teaching that meets people where they are, and I am glad to see work heading in that direction.

Takeaways:

• Async is still where Rust's learning curve spikes hardest: Pin, await-point lifetimes, Send, and executor choice arrive together
• The thread's comments double as informal async mentorship, better than the scattered official docs on these points
• It pairs naturally with the AsyncIterator work: the pain is real, and the ergonomics are being chipped away at

A Relational Database, Built From Scratch in Rust

A developer shared that they finally finished building a relational database from scratch in Rust, and the r/rust thread lit up with more than five hundred upvotes.

Writing your own database is one of those projects that teaches more than any tutorial. You end up implementing a storage engine, a page cache, a query parser and planner, an index structure, and transaction handling, and Rust's ownership model turns out to be a surprisingly good fit for reasoning about who owns a page and when it is safe to evict one. The borrow checker that annoys you in a web handler becomes an ally when the invariant you are protecting is "no two parts of the engine mutate this buffer at once."

Projects like this are worth more than their production readiness suggests. They are how people build the intuition that makes them genuinely dangerous, in the best way, on real systems code, and they read as some of the best learning material out there for everyone following along.

Takeaways:

• Building a database from scratch is a deep, high-leverage learning project, and Rust is a strong language to do it in
• Ownership maps cleanly onto storage-engine concerns like page ownership and safe eviction
• Worth a read even if you never ship your own DB; this is how systems intuition gets built

Snippets

• Wasmi 2.0 The Rust WebAssembly interpreter shipped 2.0, roughly 2.2x faster than 1.0, thanks to a new dispatch engine with direct-threaded code, accumulator registers, and a lock-free code map.

• Rust Glancer 0.2 The memory-frugal language server featured last edition shipped 0.2 with Windows and Zed support and better Bevy indexing. Moving fast.

• The world's first Game Boy ROM written in pure Rust After two years, the Rust-GB project compiles Rust down to a real Game Boy ROM, with a working demo to show for it.

• The first safety-certified product built in Rust ADAR One, a 3D ultrasonic sensor that keeps robots safe around people, is described as the world's first safety-certified embedded system built in Rust. Concrete proof Rust is clearing certification bars in safety-critical hardware.

• Tried Rust. I'm a believer now. A PHP, TypeScript, and Python developer writes up why Rust finally clicked. A grounded, non-evangelical conversion story for anyone still on the fence.

We are thrilled to have you as part of our growing community of Rust enthusiasts! If you found value in this newsletter, don't keep it to yourself — share it with your network and let's grow the Rust community together.

👉 Take Action Now:

• Share: Forward this email to share this newsletter with your colleagues and friends.

• Engage: Have thoughts or questions? Reply to this email.

• Subscribe: Not a subscriber yet? Click here to never miss an update from Rust Trends.
  
  

Cheers,
Bob Peters

Want to sponsor Rust Trends? We reach thousands of Rust developers biweekly. Get in touch!