The 2025H2 Project Goal period wrapped up with an impressive push: 41 distinct goals, 13 of them designated as Flagship Goals. While many projects continue into 2026, this cycle produced tangible progress across the language, compiler, tooling, and ecosystem. Below are the top 10 updates—spanning ergonomics, performance, and language evolution—that define the Rust Project's recent strides. Each item links to its tracking issue for deeper dives.
1. Pin Ergonomics Experimentation Gains Momentum
The Pin type has long been a pain point for safe self-referential structs. During 2025H2, Frank King drove forward the &pin borrow-checking algorithms, designed to make pinned data more ergonomic without sacrificing safety. Key milestones include merging coercions between &pin (mut|const) T and &(mut) T when T: Unpin, and opening a draft PR for actual borrow-checking of &pin mut|const $place. This work lays the groundwork for a future language feature that could eliminate many unsafe blocks today. The community can now experiment with these changes on nightly. Back to top
2. Designing Field Projections for Controlled Access
Field projections allow safe, partial access to data behind references like Pin<Box<T>>. The goal here is to solve the long-standing challenge of enabling safe field-level operations on pinned or borrowed data without violating aliasing rules. Progress in 2025H2 focused on prototype designs and gathering feedback from the lang team. The aim is to eventually stabilize a feature that lets developers write pin.field instead of resorting to unsafe pointer arithmetic. This is a stepping stone toward a more expressive ownership system. Back to top
3. Reborrow Traits: Simplifying Borrow Patterns
Reborrow traits aim to make borrowing more flexible by allowing the compiler to automatically reborrow values in more contexts. This reduces the need for explicit reborrowing syntax like &*x. The 2025H2 cycle saw continued design discussions and early implementation sketches. By enabling more implicit reborrows, the feature could streamline common patterns in iterator chains, method calls, and closures. The lang team is evaluating trade-offs, especially around inference complexity. Back to top
4. Build-Std: Standard Library Customization for Embedded
The build-std feature lets you compile the standard library from source, tailoring it to your target (e.g., no std for embedded). In 2025H2, the focus was on stabilization and polishing: fixing bugs, improving performance, and ensuring compatibility with the Cranelift backend. This is critical for projects like embedded systems and WASM, where fine-grained control over std features reduces binary size. Almost ready for a stabilization announcement, it will soon be a first-class cargo feature. Back to top
5. Production-Ready Cranelift Backend
Rust's alternative code generation backend, Cranelift, has been incubating for faster debug builds. The 2025H2 goal was to push it toward production readiness. Achievements include improved runtime performance (closer to LLVM for debug builds), better support for Windows, and reduced compile-time overhead. While not yet the default, the backend is now viable for many workflows. Developers are encouraged to test it with --target cranelift on nightly. This could revolutionize the edit-compile-debug cycle for large projects. Back to top
6. Parallel Front End: Faster Compilation via Multithreading
Rust's compiler still largely runs single-threaded. The parallel front end goal aims to change that by introducing multithreading into name resolution, type checking, and macro expansion. In 2025H2, the team integrated early parallelism experiments into nightly, yielding speedups of 20–50% on multi-core machines for smaller crates. The challenge is maintaining correctness with Rust's complex dependency graph. Continued work focuses on stability and scaling. Back to top
7. Ergonomic Reference Counting: RFC Decision and Preview
Reference counting (Rc/Arc) is powerful but verbose. The RFC to add ergonomic ref-counting features—such as implicit cloning for moves—was reviewed by the lang team in 2025H2. The decision leaned toward a cautious preview, allowing opt-in usage to gather real-world feedback. This could reduce boilerplate in multithreaded code and enable more natural data sharing. A nightly feature flag is now available for early adopters. Back to top
8. Stabilizing Cargo Scripts for One-Off Programs
Cargo scripts allow single-file Rust programs with dependencies declared inline. After years of experimentation, the feature is nearing stabilization. In 2025H2, the team finalized the syntax (#!/usr/bin/env cargo + metadata) and resolved outstanding issues with workspace integration. This will make Rust a viable scripting language for small automation tasks without committing to a full project structure. Expect it in stable Rust soon. Back to top
9. Next-Generation Trait Solver: Chalk Integration Advances
Rust's trait system is the backbone of generics and type-checking. The next-generation solver (Chalk) aims to replace the current implementation with a more robust, performant engine. Progress in 2025H2 included better handling of associated types and higher-ranked trait bounds. A substantial portion of the standard library now compiles with Chalk on nightly, demonstrating correctness. Full integration is still a work in progress, but the foundations are solid. Back to top
10. Stabilizable Polonius Support on Nightly
Polonius, Rust's next-generation borrow checker, promises simpler and more precise lifetime analysis. In 2025H2, the team achieved a major milestone: a nightly feature flag (-Z polonius) that is stable enough for broader testing. It correctly handles cases like two-phase borrows and extends the set of accepted programs. Feedback from nightly users will shape the final stabilization. This is a huge step toward making Rust's borrow rules more intuitive. Back to top
These 10 highlights only scratch the surface of the 41 goals tackled. Many other efforts—from improved test infrastructure to Linux kernel integration and const generics—also made significant headway. The Rust team thanks every contributor for their dedication. As we move into the 2026 cycle, these advancements pave the way for a safer, faster, and more ergonomic Rust. Stay tuned for the next set of goals!