The writing has been on the wall for many months now, but I think the time has come when we can officially declare it.
Stable Rust is dead. Nightly Rust is the only Rust.
If you’re out of the loop, Rust is this newfangled system programming language. Rust is meant to fit in the niches normally occupied by C, so its domain includes performance-sensitive and safety-critical applications. Embedded programming, OS kernels, databases, servers, and similar low-level pieces of computing and networking infrastructure are all within its purview.
Of course, this “replacing C” thing is still an ambition that’s years or decades away. But in theory, there is nothing preventing it from happening. The main thing Rust would need here is time: time to buy trust of developers by having been used in real-world, production scenarios without issues.
To facilitate this (and for other reasons), Rust has been using three release channels with varying frequency of updates. There are the stable, beta, and nightly Rust. Of those, beta is pretty much an RC for a future stable release, so there aren’t many differences at all between the first two channels.
This cannot be said about nightly.
In fact, nightly Rust is essentially its own language.
First, there is a number of exclusive language features that are only available on nightly.
They are all guarded by numerous
which are required to activate them.
Because stable Rust doesn’t accept any such directive,
trying to compile code that uses them will fail on a non-nightly compiler.
This has been justified as a necessary step for testing out new features
in real scenarios, or at least those that resemble (stable) reality as close as possible.
Indeed, many features did eventually land in stable Rust by going through this route
— a recent example would be the
an error-handling measure analogous to the
Secondly, and most importantly, there is at least one feature that won’t get stabilized ever:
And it’s all by design.
plugin switch is what’s necessary to include
Those in turn activate compiler plugins:
user-provided additions to the compiler itself.
Plugins operate against the API provided directly by
and enhance its capabilities beyond what the language normally provides.
Although it sounds rather ominous, the vast majority of plugins in the wild serve a singular purpose: code generation. They are written with the sole purpose of combating Rust’s rigidity, including the (perfectly expected) lack of dynamic runtime capabilities and the (disappointingly) stiff limits of its wanting macro system.
Why compiler plugins can never be stable, though? It’s because the internal API they are coded against goes too deep into the compiler bowels to ever get stabilized. If it were, it would severely limit the ability to further develop the language without significant breakage of the established plugins.
“Wait,” you may ask, “how do we even talk about «established» compiler plugins? Shouldn’t they be, by their very definition, unstable?”
Well… yes. They definitely should. And therein lies the crux of the problem.
Turns out, plugins & nightly Rust are only mostly treated as unstable.
In reality, the comfort and convenience provided by nightly versions of many libraries — all of which rely on compiler plugins — is difficult to overstate. While their stable approximations are available, they at best require rather complicated setup.
What’s always involved is a custom build step, and usually a separate file for the relevant code symbols and declarations. In the end, we get a bunch of autogenerated modules whose prior non-existence during development may also confuse IDEs and autocompletion tools.
For all those reasons and more, an ecosystem has developed where several popular libraries are “nightly but pseudo-stable”. This includes some key components in many serious applications, like the aforementioned ORM & serialization crates.
And so has been the state of affairs until very recently. The nightly Rust has been offering some extremely enticing features, but the stable channel was at least paid a lip service to. However, the mentality among library authors that “nightly-first” is an acceptable policy had been strong for a long time now.
No wonder it has finally shifted towards “nightly-only”.
Meet Rocket, the latest contestant in the already rich lineup of Rust web frameworks. Everything about it is really slick: a flashy designer website; approachable and comprehensive documentation; and concise, Flask-like API for routing and response handling. Predictably, it’s been making quite a buzz on Reddit and elsewhere.
There is just an itty bitty little problem: Rocket only works on nightly. No alternatives, no codegen shims… and no prospects of any change in the foreseeable future. Yet, there doesn’t seem to be many people concerned about this, so clearly this is (a new?) norm.
The Rusts split
In essence, Rust is now two separate languages.
The stable-nightly divide has essentially evolved into something that closely resembles the early stages of the 2.x vs. 3.x split in the Python world. The people still “stuck” on 2.7 (i.e. stable) were “holdouts”, and the future was with 3.x (nightly). Sure, there have been some pithy backports (feature stabilizations), but the interesting stuff has been happening on the other side.
It’s astonishing that Rust managed to replicate this phenomenon without any major version bumps, and with no backwards-incompatible releases. Technically, everything is still version 1.x.. Not even Cargo, the Rust package manager, recognizes the stable-nightly distinction.
But that’s hardly any consolation when you try to install a nightly-only crate on stable Rust.
You will download it just fine, and get all the way to compiling its code,
only to have it error out due to unsupported
The natural question is, can this situation be effectively addressed?
I hope it’s obvious why stable Rust cannot suddenly start supporting compiler plugins.
Given that they rely on
rustc internals which aren’t standardized,
doing so would be contrary to the very definition of a “stable” release channel.
The other option is to fully embrace nightly as de facto recommended toolchain. This has been informally happening already, despite the contrary recommendations in the official docs.
The downsides are obvious here, though: nightly Rust is not a misnomer at all. The compiler is in active development and its build breaks often. Some of those breakages make it into nightly releases with unsatisfying regularity.
Of course, there was also another option: stick to the intended purpose of release channels and don’t build castles on the sand by publishing nightly-first or nightly-only crates. This ship seems to have sailed by now, as the community has collectively decided otherwise.
It’s just a little ironic that in a language that is so focused on safety, everyone is perfectly happy with an unstable compiler.