This article is from https://blog.rust-lang.org/2025/10/28/project-goals-2025h2
On September 9, 2025, we merged RFC 3849 and officially announced the project goals for the “second half” of 2025—more accurately, the goals for the last three months, as I have been slightly delayed in organizing the goal planning.
1. Flagship Themes
In previous rounds of goal planning, we set some major flagship goals, but since these goals are often multi-year projects, it is difficult to see concrete progress at a glance. Therefore, this time we decided to adopt a different organizational approach: establishing four flagship themes, each covering multiple more specific goals. These themes represent the directions we believe will be the most impactful and will serve as the main focus of the project for the remainder of this year.
The four flagship themes are as follows:
-
Beyond the & Allow users to create user-defined smart pointers that are ergonomically similar to Rust’s built-in reference
<span>&</span>. -
Unblocking dormant traits Expand the core capabilities of the Rust trait system to unlock long-desired features such as language interoperability and lending iteration.
-
Flexible, fast(er) compilation Accelerate the build speed of Rust programs and improve support for special build scenarios such as embedded use and Sanitizer.
-
Higher-level Rust Make higher-level usage patterns in Rust easier to implement.
2. Theme Details
1. Beyond the &
| Goal | Contact Person | Teams and Promoters |
|---|---|---|
| Reborrow traits | Aapo Alasuutari | compiler (Oliver Scherer), lang (Tyler Mandry) |
| Design language features to solve field projection | Benno Lossin | lang (Tyler Mandry) |
| Continue exploring ergonomic improvements for Pin | Frank King | compiler (Oliver Scherer), lang (TC) |
A core value proposition of Rust is that it is a “library-based language”—even if certain abstractions are not built into the language, libraries can construct abstractions that feel as natural as built-in features. For example, <span>Rc</span> and <span>Arc</span> are typical examples that are fully implemented in the standard library yet feel as natural as native language features.
However, Rust’s built-in reference types (<span>&T</span> and <span>&mut T</span>) possess special capabilities that user-defined smart pointers cannot replicate. This creates a “second-class citizen” problem: custom pointer types cannot provide the same syntax and ergonomic experience as built-in references.
The “Beyond the &” initiative aims to share the special capabilities of <span>&</span> so that library authors can create smart pointers that are syntactically and ergonomically indistinguishable from built-in references. This will make cross-language interoperability (such as referencing objects in C++ or Python) and low-level projects like Rust for Linux easier to express specific data structures using smart pointers.
2. Unblocking dormant traits
| Goal | Contact Person | Teams and Promoters |
|---|---|---|
| Evolving trait hierarchy | Taylor Cramer | compiler, lang (Taylor Cramer), libs-api, types (Oliver Scherer) |
| In-place initialization | Alice Ryhl | lang (Taylor Cramer) |
| Next-generation trait solver | lcnr | types (lcnr) |
| Stabilizing Polonius support on nightly | Rémy Rakic | types (Jack Huey) |
| SVE and SME support on AArch64 | David Wood | compiler (David Wood), lang (Niko Matsakis), libs (Amanieu d’Antras), types |
The Rust trait system is one of its most powerful features, but it also has some long-standing limitations that hinder the adoption of new patterns. This class of goals will unlock a range of new capabilities:
- Polonius will enable new borrowing modes, particularly unlocking “lending iteration”. In previous goal cycles, we identified an “alpha” version of Polonius that can solve the most critical issues while remaining relatively simple and optimizable. The goal for the second half of 2025 is to implement this algorithm and prepare for stabilization in 2026.
- Next-generation trait solver is a refactored trait solver that better supports numerous language features (implicit bounds, negative implementations, etc.) while fixing multiple existing bugs and unsound issues. It has evolved from an early prototype to a production environment for consistency checks in previous cycles. The goal for the second half of 2025 is to prepare it for stabilization.
- Evolving trait hierarchy work will allow parts of existing traits to be refactored into new supertraits for independent use. This will unlock many features, particularly support for stabilizing custom receiver types, which was previously blocked by this refactoring project goal. It will also allow for the safe evolution of stable traits in the standard library while providing stable traits in the future.
- Extending Rust’s Sized hierarchy will allow expressing types that are neither
<span>Sized</span>nor<span>?Sized</span>, such as extern types (with no size) or Arm’s Scalable Vector Extension (SVE, whose size is known at runtime but unknown at compile time). This goal is based on RFC #3729 and RFC #3838 proposed in previous project cycles. - In-place initialization allows creating structures and values bound to specific locations in memory. While this is directly useful for advanced C interoperability projects, it also unlocks the ability to extend
<span>dyn Trait</span>to support<span>async fn</span>and<span>-> impl Trait</span><code><span> methods, as compiling these methods requires the caller to return a future of unknown size.</span>
3. Flexible, fast(er) compilation
| Goal | Contact Person | Teams and Promoters |
|---|---|---|
| build-std | David Wood | cargo (Eric Huss), compiler (David Wood), libs (Amanieu d’Antras) |
| Advancing frontend parallelization | Sparrow Li | compiler |
| Making Cranelift backend production-ready | Folkert de Vries | compiler, wg-compiler-performance |
This initiative focuses on improving Rust’s build system to better serve special use cases and everyday development workflows:
- We are enhancing compilation performance by: (1) parallel compilation in the compiler frontend, achieving a 20-30% speedup; (2) making the Cranelift backend production-ready, which improves code generation speed by about 20% in debug builds compared to LLVM.
- We are stabilizing the core MVP version of
<span>-Zbuild-std</span><code><span>, which allows developers to rebuild the standard library using custom compilation flags. This will unlock critical use cases for embedded developers and low-level projects like Rust for Linux, while also supporting building the standard library with sanitizers or debug information.</span>
4. Higher-level Rust
| Goal | Contact Person | Teams and Promoters |
|---|---|---|
| Stabilizing cargo-script | Ed Page | cargo (Ed Page), compiler, lang (Josh Triplett), lang-docs (Josh Triplett) |
| Ergonomic reference counting: RFC decisions and preview | Niko Matsakis | compiler (Santiago Pastorino), lang (Niko Matsakis) |
People often choose Rust for foundational scenarios due to performance or reliability needs. However, once familiar, they often use Rust for higher-level scenarios such as scripting, web services, and even GUI applications. Rust is often “unexpectedly usable” in these higher-level use cases—aside from some specific pain points that affect all Rust users but impact these use cases particularly. We have planned two flagship goals for this period:
- Stabilizing cargo-script: This feature allows single-file Rust programs to embed their dependencies, making it easier to write small tools, share code examples, and create reproducible bug reports without the overhead of a full Cargo project.
- Completing the design of ergonomic reference counting and refining the experimental
<span>impl</span>feature to prepare it for beta testing. This feature makes using reference counting types like<span>Rc</span>and<span>Arc</span>more convenient, especially in closures.
3. What to Expect Next?
In the remaining time of 2025, we will publish monthly blog posts detailing the main progress of the project goals.
From a broader perspective, we have gone through three rounds of goal planning and now hope to evaluate how to operate in the future. To this end, Nandini Sharma from Carnegie Mellon University has begun interviewing project members to help us understand the effectiveness and areas for improvement of the goal planning. We expect to launch the next round of goal planning next year. Regardless of its form, the project manager hired by the Rust leadership council, Tomas Sedovic, will work with me to oversee the operation of this plan.
4. Appendix: Complete List of Project Goals
Below is the complete list of Rust project goals. These goals have been assigned responsible contacts who will drive the work forward and have feasible execution plans.
Invited Goals: The following goals are marked as “invited goals,” meaning that to achieve these goals, someone needs to actively take on the responsibility. Please look for goals marked with “Help wanted” in the table below. Invited goals have reserved resources for relevant teams and mentors, making it a great entry point if you wish to participate in Rust’s development.
| Goal | Contact Person | Teams and Promoters |
|---|---|---|
| Develop the ability to keep the FLS (Ferrocene Language Specification) updated | Pete LeVasseur | bootstrap (Jakub Beránek), lang (Niko Matsakis), opsem, spec (Pete LeVasseur), types |
| Incorporate Rust for Linux into stable Rust: compiler features | Tomas Sedovic | compiler (Wesley Wiser) |
| Incorporate Rust for Linux into stable Rust: language features | Tomas Sedovic | lang (Josh Triplett), lang-docs (TC) |
| Perform borrow checking in a-mir-formality | Niko Matsakis | types (Niko Matsakis) |
| Reborrow traits | Aapo Alasuutari | compiler (Oliver Scherer), lang (Tyler Mandry) |
| build-std | David Wood | cargo (Eric Huss), compiler (David Wood), libs (Amanieu d’Antras) |
| Prototype implementation of Cargo build analysis | Weihang Lo | cargo (Weihang Lo) |
| Refactor Cargo build directory layout | Ross Sullivan | cargo (Weihang Lo) |
| Prototype implementation of a new Cargo “pipeline” command | Help Wanted | cargo |
| Stabilize cargo-script | Ed Page | cargo (Ed Page), compiler, lang (Josh Triplett), lang-docs (Josh Triplett) |
| Continue resolving cargo-semver-checks merge blocking issues | Predrag Gruevski | cargo (Ed Page), rustdoc (Alona Enraght-Moony) |
| Emit Retag in code generation | Ian McCormack | compiler (Ralf Jung), opsem (Ralf Jung) |
| Comprehensive niche checking for Rust | Bastian Kersting | compiler (Ben Kimock), opsem (Ben Kimock) |
| Const Generics | Boxy | lang (Niko Matsakis) |
| Ergonomic reference counting: RFC decisions and preview | Niko Matsakis | compiler (Santiago Pastorino), lang (Niko Matsakis) |
| Evolving trait hierarchy | Taylor Cramer | compiler, lang (Taylor Cramer), libs-api, types (Oliver Scherer) |
| Design language features to solve field projection | Benno Lossin | lang (Tyler Mandry) |
| Complete the std::offload module | Manuel Drehwald | compiler (Manuel Drehwald), lang (TC) |
| Run more tests for the GCC backend in Rust CI | Guillaume Gomez | compiler (Wesley Wiser), infra (Marco Ieni) |
| In-place initialization | Alice Ryhl | lang (Taylor Cramer) |
| C++/Rust interoperability problem space mapping | Jon Bauman | compiler (Oliver Scherer), lang (Tyler Mandry), libs (David Tolnay), opsem |
| Complete libtest JSON output experiment | Ed Page | cargo (Ed Page), libs-api, testing-devex |
| MIR move elimination | Amanieu d’Antras | compiler, lang (Amanieu d’Antras), opsem, wg-mir-opt |
| Next-generation trait solver | lcnr | types (lcnr) |
| Implement Open API namespace support | Help Wanted | cargo (Ed Page), compiler (b-naber), crates-io (Carol Nichols) |
| Advance frontend parallelization | Sparrow Li | compiler |
| Continue exploring ergonomic improvements for Pin | Frank King | compiler (Oliver Scherer), lang (TC) |
| Stabilizing Polonius support on nightly | Rémy Rakic | types (Jack Huey) |
| Make Cranelift backend production-ready | Folkert de Vries | compiler, wg-compiler-performance |
| Stabilize public/private dependencies | Help Wanted | cargo (Ed Page), compiler |
| Extend Rust reference documentation to cover more language features | Josh Triplett | lang-docs (Josh Triplett), spec (Josh Triplett) |
| Reflection and comptime | Oliver Scherer | compiler (Oliver Scherer), lang (Scott McMurray), libs (Josh Triplett) |
| Relink instead of rebuild | Jane Lusby | cargo, compiler |
| Rust vision document | Niko Matsakis | leadership-council |
| rustc-perf improvements | James | compiler, infra |
| Stabilize rustdoc’s doc_cfg feature | Guillaume Gomez | rustdoc (Guillaume Gomez) |
| Develop team charter for the rustdoc team | Guillaume Gomez | rustdoc (Guillaume Gomez) |
| SVE and SME support on AArch64 | David Wood | compiler (David Wood), lang (Niko Matsakis), libs (Amanieu d’Antras), types |
| Stabilize MemorySanitizer and ThreadSanitizer support | Jakob Koschel | bootstrap, compiler, infra, project-exploit-mitigations |
| Type system documentation | Boxy | types (Boxy) |
| Unsafe fields | Jack Wrenn | compiler (Jack Wrenn), lang (Scott McMurray) |
5. Conclusion: Building the Future of Rust Together
The Rust goal planning has entered its third iteration, serving not only as a “roadmap” for the evolution of the Rust language itself but also as a collaborative platform for global developers to participate in and promote the construction of open-source infrastructure.
Whether you are a seasoned compiler developer or a newcomer to Rust, as long as you are interested in a particular project goal, you can:
- Visit the official Rust GitHub
- Join the Rust Zulip chat room
- Subscribe to the Rust internal forum
- Participate in the Rust contributor guide
“Help Wanted” goals are there for you. Every small step is a significant leap towards a better future for the Rust ecosystem.