Two signals converging this week: Rust's most significant production adoption in months just merged into a major JavaScript runtime, and the Rust community is literally converging on Utrecht for RustWeek 2026. Bun's Rust migration landed, image-rs just got substantially faster, and hundreds of contributors are one day away from a week in the same room. The ecosystem has momentum in every direction.

RustWeek 2026: Utrecht Hosts the Rust Community's Annual Convergence

The week of May 18th, Utrecht will host what the Rust project's program managers describe as "the highest per-capita Rustacean concentration" on Earth. RustWeek 2026 and the Rust All Hands run back to back, giving contributors five consecutive days to align on language direction, meet maintainers face to face, and ship decisions that have been circling in RFC threads for months.

The format mirrors last year: workshops on Monday, the RustWeek conference Tuesday and Wednesday, a hackathon on Thursday, and the All Hands Friday and Saturday. The speaker list covers embedded, async, tooling, and compiler internals. Rust for Linux kernel developers received a direct invitation from the Project and will attend, making cross-project coordination in person possible for the first time this cycle.

Several workstreams at the All Hands have direct production implications: sessions on in-place initialization and field projections (both critical to Rust for Linux), CoccinelleForRust, BPF compilation, and C++ interop. The 2026 Project goals RFC is under active review, and with most team leads in the same building, the All Hands is where open decisions tend to land.

The speaker list and schedule are live. Tickets remain available via the event page. Recordings will follow for those who cannot make it to the Netherlands.

Takeaways:

• RustWeek 2026 runs May 19-20 in Utrecht, followed by the Rust All Hands May 21-23; the combined week is the main venue for cross-team decisions
• Rust for Linux kernel developers are attending, enabling direct collaboration on in-place initialization, field projections, and BPF compilation
• The 2026 Project goals RFC is under active review, and the All Hands is where open decisions across teams historically get resolved
• C++ interop sessions are on the All Hands agenda; the Foundation's initiative has published 8 formal problem statements covering allocators, strings, type layout, and cross-language linking, and is moving into implementation
• If you cannot attend, watch the RustWeek website for recordings; historically this week produces a burst of stabilization announcements

Bun's Rust Migration Merges: Memory Safety Comes to a JavaScript Runtime

The PR migrating Bun's memory-unsafe subsystems to Rust has been merged. Bun, the fast JavaScript and TypeScript runtime competing with Node and Deno, spent months moving key internals from Zig to Rust. The architecture and data structures are otherwise largely unchanged, this is a targeted memory-safety migration, not a ground-up rewrite.

Bun is used in production by teams that chose it specifically for performance, and the team's decision to bring Rust in reflects a pattern that is now well-established: when you are already operating at the performance limit and reliability starts to matter at scale, Rust becomes the practical choice rather than the ideological one.

The migration came from Zig, not from C or C++, which makes it unusual. Rust won a comparison against another systems language that also prioritizes performance and memory control. The tradeoffs involved, interop with existing Zig code, FFI boundaries, and build system complexity, are documented in the PR discussion and worth reading for anyone managing a mixed-language codebase.

Takeaways:

• Bun is a production JavaScript runtime with real users; this migration carries production weight, not just benchmark credibility
• The architecture and data structures stay the same; Rust replaces the memory-unsafe subsystems, not the whole codebase
• The migration came from Zig, making this a Rust-versus-another-performance-language comparison, not a Rust-versus-C++ story
• Safety and performance are no longer in tension; performance-first projects are choosing Rust because it delivers both

Nearly 6× Faster Blur in image-rs: What Methodical Optimization Looks Like

Atharva Patel's writeup on speeding up fast_blur in the image-rs crate is the kind of deep-dive the Rust community produces well. Starting from a correct but naive implementation, the post walks through two changes that produced a 5.9× speedup: replacing float arithmetic with integer accumulators, and replacing integer division with reciprocal multiplication using the Granlund-Montgomery algorithm.

What makes this worth reading is the methodology. Each optimization is motivated, measured in isolation, and explained in terms of what the hardware is doing. The techniques generalize to any algorithm with repeated division or floating-point accumulation over large data.

The improvement ships downstream without any code changes from library consumers. image-rs is a dependency in a large portion of the Rust image-processing ecosystem.

Takeaways:

• A 5.9× improvement in a mature crate from two arithmetic changes, not a rewrite
• The post is a template for performance work: profile first, measure each change in isolation, explain the hardware reason
• Reciprocal multiplication to replace division is a classical trick; the post shows how to apply it in Rust without unsafe
• image-rs is a transitive dependency in many projects; this improvement reaches downstream users without any action on their part

Snippets

• Toasty v0.6 Released The Tokio team's async ORM reaches 0.6 with expanded database support and a refined API. If you have been evaluating Rust ORM options, this release is worth a fresh look.

• Burn ONNX 0.21.0: Build-Time ONNX Import burn-onnx now imports ONNX models at build time and generates plain Rust code, eliminating the graph runtime and protobuf dependency at runtime. The result is a standard Rust forward pass with no overhead from the model format.

• Build Game Boy Advance ROMs with Rust A practical tutorial series starting with setup and pixel rendering on real GBA hardware. Embedded Rust now covers everything from Linux kernel drivers to 1989 handheld consoles.

• Arc vs Rc vs Borrow: How Senior Rust Devs Decide A thread where experienced engineers explain the actual decision process behind shared ownership. Useful reading for anyone still reaching for Arc<Mutex<T>> by reflex.

• What Finally Convinced You to Learn Rust? The r/rust thread collecting first-contact stories. Performance and safety are the expected answers; the more interesting ones are from engineers who came for the tooling and stayed for the type system.

• Self-Referencing Structs Without Modifying the Struct A sharp-edged thread on MaybeUninit and what Miri has to say about it. The unsafe corner cases here are exactly what the Rust community documents better than anyone else.

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!