In Rust, what are the stable, beta and nightly release channels, and how does a change travel from one to the next?
answer
- one main branch, three channels
- a build every night
- beta forks every six weeks
- unstable gates stay on nightly
basics
~20 sNightly is built every night from Rust's main branch. Every six weeks beta forks from it, and the previous beta ships as the next stable release. Unstable features work only on nightly, behind #![feature] gates.
solid answer
~40 sRust ships from one main branch on a **train model**. **Nightly** is built from it every night and is the only channel that accepts `#![feature(...)]` gates for unstable work. Every six weeks the **beta** branch forks from main, is tested for six weeks while fixes reach it only by backport, and then becomes the next **stable** release as a new beta forks. So when 1.99 is stable, beta is 1.100 and nightly is 1.101, and a change merged today normally reaches stable two releases later, six to twelve weeks out. Stable releases come every six weeks with occasional point releases such as 1.99.1, and the project supports only the latest stable.
code
console · 4 lines$ rustc --version
rustc 1.99.1 (58cf8f9c3 2026-10-13)
$ rustc +nightly --version
rustc 1.101.0-nightly (76456a688 2026-10-25)go deeper
Name the three channels, say that stable ships every six weeks, and say that unstable features need a nightly compiler and a #![feature] attribute.
Walk a change from main to nightly, through the beta fork and backports, to stable, and explain why it usually lands two releases after the current stable.
Show how a team uses the channels: build on stable, test on beta to catch regressions early, keep any nightly job advisory, and plan for only the latest stable being supported.
Frame the train as a trade: fixed six-week cadence and a frozen beta buy predictable upgrades, at the cost that a feature which misses a fork waits a whole cycle.
## One branch, three channels Rust is developed on a single **main branch** of the rust-lang/rust repository, and it is published to users through three **release channels**. A channel is a stream of builds that rustup can install and keep up to date, so a developer can have several side by side and pick one per command or per project. | Channel | Built from | How often | What it is for | |---|---|---|---| | **nightly** | main, as of that night | every night | trying unstable features, testing the newest compiler | | **beta** | a branch forked from main | forked every six weeks, rebuilt as fixes land | the next stable release, under test | | **stable** | the beta that finished its six weeks | every six weeks, plus point releases | everyday development and production | Most teams build on **stable**. Nightly exists so that new work can be used in practice before it is frozen, and beta exists so that the next stable release gets a testing period of its own. ## How the train runs The Rust Book calls this the **train model**: a release leaves the station on a fixed timetable, and whatever is aboard rides it through beta to stable. One cycle looks like this: 1. Every commit merged to main appears in the next **nightly** build. Nightly builds are produced automatically, every day. 2. Every six weeks the **beta branch forks** from main. From then on it receives no new features; a regression found during testing is fixed on main and **backported** to beta, and a new beta build is produced. 3. Six weeks after the fork, that beta becomes the **stable release**, and a new beta forks from main for the next version. Because the schedule is fixed, a feature that misses one train simply takes the next one six weeks later. The Book points out that this removes the pressure to rush half-finished work in just before a deadline. ## Following one change to stable Version numbers make the train visible. While **1.99** is the current stable release, the beta channel is building **1.100** and nightly builds already call themselves **1.101.0-nightly**. A change merged to main today is therefore in tomorrow's nightly, misses the 1.100 beta that has already forked, and ships in **1.101**: two stable releases away, which is between six and twelve weeks depending on where in the cycle it was merged. New language and library features follow the same path, with one extra step: - the implementation lands on main **behind a feature gate**, so only nightly users who write `#![feature(name)]` can use it; - after it has been tried on nightly, the relevant team decides whether to **stabilise** it; - stabilisation removes the gate on main, and from then on the feature rides the train like any other change. ## Point releases and support - **Point releases** such as 1.99.1 ship between the six-weekly releases when a fix cannot wait. Rust 1.99.1 fixed a miscompilation of FFI `bool` return values on x86_64, a missing `wcslen` symbol on UEFI and embedded targets, and an rpath problem in `rust-lld` on macOS. - **Only the latest stable is supported.** When a new stable ships, the previous one reaches end of life, so each release is supported for six weeks. A team that needs fixes takes the next release rather than waiting for a backport to an old one. - **Beta is worth a CI job.** Few people develop on beta, but running a project's tests against it reports a regression while there is still time to fix it before the next stable release. ## What nightly is for, and what it is not Nightly is the channel for **unstable features**: anything still behind a gate can change shape or disappear between two nightlies, and the Book covers only stable features for that reason. A stable or beta compiler rejects any `#![feature]` attribute outright, with error E0554, so a crate cannot quietly depend on unstable work and still build on stable. Projects that need nightly usually **pin a dated nightly** so that their build does not change underneath them, and projects that ship on stable often add a nightly job that is allowed to fail, as an early warning rather than a gate. The result is the trade the Book calls **stability without stagnation**: stable users upgrade every six weeks without fear, while nightly gives the people building and testing new features a place to work.
- Why would a team that ships on stable Rust run its tests against beta in CI?Beta is the next stable release. A regression it exposes in the team's code can be reported to the Rust project and fixed, then backported to beta, before that release reaches stable. The job is an early warning: it costs one extra build per run and turns a surprise on release day into a known issue weeks earlier.
- Can a stable Rust build use a nightly feature by depending on a crate that enables it?No. `#![feature]` is a crate-level attribute, and a stable rustc rejects it with E0554 in whichever crate it appears, dependencies included. Cargo reports that the dependency could not compile, so one unconditionally gated crate anywhere in the graph puts the whole build on nightly.
- What is a Rust point release such as 1.99.1, and when does one ship?A point release is a patch release of the current stable version, shipped between the six-weekly releases when a fix cannot wait for the next train. Rust 1.99.1 fixed a miscompilation of FFI `bool` returns on x86_64, a missing `wcslen` symbol on UEFI and embedded targets, and a `rust-lld` rpath problem on macOS.
A commuter line with a train every six weeks: a passenger who misses one is not stranded, but they cannot board the train that has already left the station.
- Beta is a separate experimental fork that never becomes a stable release.
- Stable accepts #![feature] gates if you enable the matching Cargo feature.
- A change merged to main today ships in the very next stable release.
- Older stable releases keep receiving security fixes for a year or more.
- Rust ships whenever enough features pile up, with no fixed schedule.