This Week in Rust

Hey Rustaceans! 👋 Welcome back to another week of Rust community updates. If you thought last week was exciting with the LLD linker performance boost, this week brings even more powerful tools to the ecosystem. From SeaORM 2.0’s complete overhaul to a React framework that’s outperforming Next.js, the Rust community continues to push boundaries. Let’s explore what made waves this week. 🎯 The Big Stories SeaORM 2.0: A Complete Entity Overhaul The team behind SeaORM just dropped version 2.0, featuring a completely reimagined “Entity First Workflow.” This isn’t just an incremental update — it’s a fundamental rethinking of how developers interact with databases in Rust. For those building database-backed applications, this represents a major leap forward in ergonomics while maintaining the performance guarantees that make Rust special. The new entity format promises more intuitive relational capabilities without sacrificing any of the type safety we’ve come to expect. Rari v0.3.0: The React Framework That’s Rewriting the Rules Here’s a stat that’ll make web developers do a double-take: Rari is 12x faster with 10x higher throughput than Next.js. This Rust-based React framework with server-side rendering is proving that Rust’s performance advantages aren’t just for systems programming — they’re transforming the web development landscape. The framework demonstrates what’s possible when you combine React’s developer experience with Rust’s raw speed. For teams considering their next web framework, these numbers are hard to ignore. Burn 0.19.0: ML Gets More Powerful The Burn deep learning framework released version 0.19.0 with some seriously impressive features:

• Quantization support
• Distributed training capabilities
• LLVM backend integration

If you’re working in machine learning with Rust, Burn continues to mature into a production-ready option that rivals established frameworks in other languages. 🛠️ Tooling Evolution Fyrox 1.0.0-rc.1: Game Engine Milestone The Fyrox game engine hit release candidate status this week, marking a significant milestone in Rust gamedev. After years of development, the team is approaching a stable 1.0 release — a big win for developers building games in Rust. Typst 0.14: Accessibility First The Typst typesetting system released version 0.14 with a focus on accessibility. As Rust tools mature, we’re seeing this pattern more often: performance and accessibility aren’t trade-offs, they’re requirements. Apache Fory™: New Serialization Framework A new player entered the serialization arena with Apache Fory™, positioning itself as a “versatile serialization framework.” In a space dominated by serde, competition drives innovation, and it’ll be interesting to see how Fory differentiates itself. Deep Technical Reads This week brought some thought-provoking technical writing: “Explicit Capture Clauses” by Niko Matsakis explores improvements to closure capture semantics. If you’ve ever been confused by what a closure captures (and who hasn’t?), this deep dive clarifies the ongoing evolution of Rust’s capture mechanisms. “How Signal Uses Rust to Secure Communications” reveals how one of the world’s most trusted messaging apps leverages Rust’s safety guarantees to protect millions of users. It’s a compelling case study for organizations considering Rust for security-critical applications. “When O3 is 2x Slower Than O2” investigates counter-intuitive optimization behavior. This kind of deep performance analysis showcases the Rust community’s commitment to understanding not just what works, but why it works. 🔧 Compiler & Language Updates The compiler team merged 463 pull requests this week (slightly down from last week’s 369, but still impressive). Some highlights: Compiler Improvements

• The -Znext-solver continues to evolve with better predicate instantiation
• Added NonNull pattern types for safer pointer handling
• New fast path for lowering trivial constants (with great speedup!)
• Array/slice indices no longer get lifetime-extended — a subtle but important safety improvement

Standard Library Additions

• String::replace_first and String::replace_last methods
• UTF-8 versions of OsStr/OsString
• Cell methods are now const
• FromIterator implementations for ASCII characters to strings

Rust-Analyzer Gets Smarter The IDE experience keeps improving:

• New “Flip range expression” assist
• “Remove else branches" assist for cleaner code
• Improved field completion parentheses heuristic
• Better handling of incomplete statements
• Support for let-chains in various assists

Performance Triage This week brought mostly negative performance results, primarily from adding sizedness bounds in one PR. However, we got nice wins:

• Async code optimization through state transform improvements
• Multiple smaller codegen optimizations

The transparency around performance regressions shows the team’s commitment to keeping Rust fast while adding features. Crate of the Week: tower-resilience This week’s featured crate is tower-resilience, offering resilience features for the Tower service framework. If you're building microservices or distributed systems, this library provides circuit breakers, retries, and other fault-tolerance patterns that are crucial for production systems. Community Highlights Quote That Captures the Spirit A community member jokingly suggested: “Petition to add an unwise keyword in Rust" This perfectly captures Rust’s philosophy — safety by default, but with escape hatches for when you know what you’re doing. Sometimes you just need to acknowledge that what you’re about to do is… unwise. Research & Learning Several excellent tutorials and walkthroughs dropped this week:

• “How to Avoid Fighting the Rust Borrow Checker” (the eternal struggle)
• “Data Analysis in Rust” (complete practical guide)
• “Building a Coding Agent in Rust: Introduction” (AI meets systems programming)
• “Rust for JavaScript Engineers — Connect-4 Interactivity” (bridging communities)

Upcoming Events The global Rust community continues to gather: Major Conferences:

• RustLab 2025 (November 2–4 in Florence, Italy) — happening this weekend!
• Dozens of meetups from New York to Stockholm to Bangalore

Virtual Events: Nearly daily virtual meetups continue, making Rust education accessible worldwide. The Bigger Picture This week exemplifies Rust’s maturation across multiple domains:

• Web Development: Rari shows Rust can outperform established JavaScript frameworks
• Databases: SeaORM 2.0 proves Rust ORMs can match ergonomics of any language
• Machine Learning: Burn adds enterprise features like distributed training
• Security: Signal’s adoption validates Rust for critical infrastructure
• Developer Experience: Rust-analyzer improvements make daily coding smoother

The ecosystem isn’t just growing — it’s maturing. Tools are hitting 1.0 and 2.0 milestones. Performance optimizations continue. Documentation improves. The feedback loop between users and maintainers remains strong. What’s Next? As we move into November, keep an eye on:

• RustLab 2025 presentations and announcements
• TokioConf 2026 CFP (closing December 8)
• Continued evolution of the -Znext-solver
• More language features entering final comment period

The momentum behind Rust shows no signs of slowing. Whether you’re building web services, system utilities, games, or ML pipelines, the Rust ecosystem has mature tools ready for production use.