What Are the Top 10 Challenges Facing Rust Today and Tomorrow?

Microsoft senior engineer Nick Cameron, a former Rust core team member, published a blog describing the ten major challenges Rust faces now and in the next few years, along with preliminary ideas for solutions.

Governance Challenges

1. Guiding development while preserving Rust’s openness.

As the community grows and Mozilla’s direct support ends, tensions arise between what benefits the project and what volunteers want to work on. Limited manpower and resources make it hard to maintain essential but less attractive work.

Prioritize immediate work over starting new projects.

Focus on tools, libraries, and non‑technical tasks alongside language and compiler work.

Target low‑cost, high‑impact tasks that can yield large benefits.

Maintaining Rust’s core characteristics while scaling, ensuring transparent decision‑making, and welcoming new contributors and leaders are also critical.

2. Diversity and inclusion.

Rust’s diversity is poor; many contributors leave due to negative experiences or burnout. Inclusive cultures must tolerate differing opinions and avoid a consensus‑only mindset that can stifle diversity and lead to dysfunctional governance.

3. Avoiding rigid, inefficient processes.

Rapid language growth has outpaced its processes, creating organizational debt. Accepting management (people, project, product) as a core part of leadership and delegating authority are needed to introduce better workflows.

Ecosystem Challenges

4. Navigating the crate ecosystem.

Rust balances a minimal standard library with a thriving crate ecosystem, but the sheer number of crates makes discovery and contribution difficult, especially as non‑core users increase.

5. The async ecosystem.

Async programming is vital for Rust, yet the ecosystem is fragmented across runtimes, with slow progress and risk of adding poorly accepted features to the standard library.

Technical Challenges

6. Expanding appeal without losing core focus.

Rust’s safety, ergonomics, and performance are strengths, but its steep learning curve limits adoption. Simplifying the language—reducing explicit lifetimes, improving the borrow checker, and streamlining the trait system—could broaden impact.

7. Memory model and unsafe code.

Supporting developers who need unsafe code requires deeper understanding of Rust’s memory model and better tools, libraries, and language features, despite political and technical resistance.

8. Evolving the standard library.

The standard library grows monotonically; deprecations are rare, leading to bloat and conservative stability policies. More granular versioning and selective use of core versus full libraries could help.

9. Major compiler changes.

rustc is a massive, complex codebase with technical debt, especially around compile times. Incremental and parallel compilation are ongoing efforts, but large, high‑impact changes remain difficult.

10. Macros.

Macros are one of Rust’s least mature features. Declarative macros introduce a new sub‑language, while procedural macros are heavyweight and hard to master. Issues like macro hygiene lack community expertise, and macro work often receives low priority.

Despite the daunting nature of these challenges, Cameron believes they are solvable with focused effort, and that addressing them will enable Rust to continue thriving.