Overview
Rust evolves through the most formalized public process of the three languages on this shelf: every significant change starts as an RFC debated in the open, is implemented behind a nightly feature gate, and rides a six-week release train to stable only after an explicit stabilization decision. Governance is neither Oracle-led committers nor one company's core team but a federation of project teams under an elected Leadership Council, with the Rust Foundation handling money and trademarks — never technical decisions. The result trades speed for legitimacy: slow, visible, and hard to capture.
Key points
- The RFC process: substantial changes get a design document PR on rust-lang/rfcs — motivation, design, drawbacks, alternatives. Discussion is public; the relevant team disposes via FCP (final comment period): a formal merge/close proposal each team member checks off, with registered concerns blocking until resolved.
- Teams own domains: lang (the language), libs-api (stdlib API), compiler, cargo, and dozens more with sub-teams. Membership is earned by contribution and spans employers — no single company holds a majority anywhere, by design and by history (the 2021 governance crisis produced the current Leadership Council, RFC 3392, of team-delegated representatives).
- The Rust Foundation (2021; AWS, Google, Microsoft, Huawei, Meta among founding members) funds infrastructure, security engineering (crates.io provenance, the security initiative) and holds the trademark — explicitly not a technical body; the teams answer to the project, not the Foundation.
- Accepted ≠ shipped: an accepted RFC is implemented on nightly behind
#![feature(...)]; only a later stabilization report + FCP — often years later, sometimes never — makes it stable. Async/await took three years from RFC to stable; specialization has been nightly-only for a decade. - Feature gates beat previews: where Java previews are complete features soliciting feedback across 2–3 releases and Go's GOEXPERIMENT gates behaviour flips, nightly features are unbounded works-in-progress — usable today, promised nothing. The channel split is what lets stable Rust make a hard stability promise while the language still moves fast.
- The train: a new stable every six weeks, small and boring by construction; no LTS from the project (Ferrocene sells qualified long-support toolchains for the regulated niche). Point releases only for serious regressions.
- Editions bundle the breaking bits: roughly every three years, per-crate opt-in — the mechanism that lets the train stay compatible forever; deep dive in Editions.
- Reading the process from outside: the RFC repo and tracking issues on
rust-lang/rust; "This Week in Rust" for the firehose, the Inside Rust blog for
team announcements, the main blog for releases;
#[unstable]docs on doc.rust-lang.org list every gate and its tracking issue.
Details
Contrast with OpenJDK and Go, one line each
- Authority: federated teams + elected council vs Oracle-led multi-vendor committers vs one Google-employed team.
- Unit of change: RFC → feature gate → stabilization FCP vs JEP vs proposal issue
- design doc.
- Cadence: 6 weeks vs 6 months (vendor LTS) vs 6 months (no LTS).
- Breaking changes: editions, per-crate opt-in vs "almost never" vs Go 1 promise
- GODEBUG.
- Money vs merit: Foundation funds but doesn't decide vs Oracle leads and funds vs Google employs and decides.
Community organs
- Zulip (rust-lang.zulipchat.com) — where team work actually happens, in the open; the internals forum (internals.rust-lang.org) for pre-RFC design discussion.
- users.rust-lang.org and the unofficial-but-huge Reddit/Discord — the user-facing venues.
- RustConf plus the regional/domain conferences (RustFest lineage, EuroRust, RustLab) — smaller than GopherCon/JavaOne ever were; the ecosystem's center of gravity is genuinely online.
- The Rustonomicon, std docs and the Book — project-maintained; documentation as a first-class team (docs.rust-lang.org is governed like code).
Related
- Deep dive Rust — the language this process shaped, feature gate by feature gate.
- Editions — the compatibility instrument the train relies on.
- Rust compilers & the language definition — the single implementation every RFC ultimately lands in.
- rustup & the channels — the mechanism that delivers nightly's feature gates and the train to your machine.
- OpenJDK & the JEP process — the mirror governance note on the JVM side.
- How Go evolves — the mirror note on the Go side; same transparency, opposite trust model.
Citations
[1] The RFC process (rust-lang/rfcs README) [2] RFC 3392 — Leadership Council [3] Rust Foundation