POLL: Which version of Rust do you use, and why?


(I hope polls like this are okay! I couldn’t find any fancy official polling mechanism, so I settled for an uncategorized forum post requesting responses…)

Which version of Rust do you use?

  • Nightly** because (…)
  • Beta** because (…)
  • Stable** because (…)
  • Version x.x.x because (…)
  • Actually, I write raw LLVM IR because it’s easier than dealing with the borrow checker.
    **Kept reasonably up-to-date

For example, my answer is:

Stable because I guessed that that was the best thing to target when you are trying to teach others. I’m creating a Rust course on Udemy. I hope I made the best choice…there seems to be an awful lot of people using nightly!


Nightly because there’s a lot of unstable APIs and features that I need to test to ensure they work properly before they get stabilized. Also in case there’s any breaking changes so I can complain about them.


Right now, I use Stable because…

  1. As long as I’m learning the language, I want as robust an implementation as possible.
  2. Ultimately, I want my library to reach as wide a user/developer base as possible

Longer-term, I contemplate running my CI on Nightly in order to catch incompatibilities early on and provide feedback to upstream as early as possible.

As a happy OpenSUSE Tumbleweed user, I fail to see the point of a public Beta channel. If your automated testing is good enough, early adopters will go directly for Nightly and stability-minded people will want Stable, which leaves little incentive for people who aren’t working on Rust itself to try out something in-between.

To me, Beta is most useful for internal Rust team use, where people are ready to merge in feature branches which aren’t release-ready yet and clean them up after the fact. Some examples of situations where this compromise is acceptable include:

  • Translations (can’t expect your contributors to speak every language)
  • Usability testing (it takes significant resources to do it well, again not every contributor may have them)


Locally, I prefer the latest stable version for several reasons:

  • Stability. I’ve had issues with nightly before, and it’s one less thing to think about.
  • Others. I’m currently in the phase of showing others Rust, and offering my experience on a stable version makes that simpler.

I use the latest stable version because there are still so many (great!) features being added to Rust lately (? operator, custom derive, macros 1.1, etc) and for the toy programs I work on, there’s very little benefit trying to support older versions of Rust.

The one exception is that clippy is an awesome tool and requires nightly Rust, so I will use nightly Rust just to run it (cargo +nightly clippy), but leave everything else to stable Rust. Eventually clippy could get distributed directly with a stable release of Rust and this wouldn’t be needed.

On Travis/Appveyor, I test stable, beta, and nightly.


I use version 1.10.0 because is the one shipped in the Ubuntu Repository and I’m too lazy to install another version manually and keep it up to date.


I use nightly for clippy, because that’s the only Rust it works with – for now.

I also have a current stable for testing & benchmarking.


Stable, usually because I’m too lazy to keep nightly up to date. Besides, while I don’t have popular projects with a lot of users, I’d still prefer them to compile in 6 months and I figure that the easies way to refrain using unstable features without being frustrated ("damn I like this unstable feature and have become accustomed to it but I can’t use it in this project :cry: ") is not using nightly :slight_smile: I still sometimes use nightly punctually when I run clippy, want to bench something, or want to install some cool Rust crate that requires nightly; or sometimes when I’m doing a lot of compiling on a project that is drastically faster to compile on nightly. I generally use the latest stable because there is usually at least something in the changelog that makes me want to upgrade, and I rely on travis to tell me if I accidentally use a feature that I shouldn’t use in a given project because I want to support older versions.


I use nightly for the most part since I’m still learning and people are often talking about features that are only available in nightly (and sometimes not even then). + clippy requires it. I want to start contributing properly at some point, and that basically requires nightly.


My Rustup install has all three loaded, and my system-wide update script remembers to call rustup update.

I use stable for projects I want to show off at work, and since 1.15 landed I honestly don’t know what I would need in nightly that isn’t stabilized. I use nightly for personal projects, since it has all the goodies.

Poor beta; does it do anything besides serve as a holding period between “alright we think this is stable” and “alright this is for real stable”?


I use beta, because it has fewer bugs than stable.

Beta gets bug fixes backported and is getting fixed quicker than stable (e.g. currently workspaces are broken in stable. I run into compiler panics in stable, which were already fixed in beta, etc.).


Stable or even a previous stable (currently 1.14), because that’s easily available on the platforms I use (mainly Fedora and FreeBSD), and because I want to make the crates i create as widely available as possible.


I am still using 1.14.0, hoping that the Arch repo will finally update it to latest stable :frowning: Confidence is slipping and I’ll use rustup if this takes much longer.

Edit: Finally Arch updated to 1.15.1 - Half an hour later I wanted to try out Tokamak which requires rustup which in turn conflicts with the arch rust package. So now I’m on rustup default stable.


I use nightly currently, because I’m playing with embedded Rust and need to implement language items and use the occasional inline assembly. When I do more desktop-oriented things, I tend to run latest Stable.


I use nightly on my laptop because it allows me to use some features not yet available on stable. For example categories and badges in Cargo.toml (for crates.io). However, I program exclusively for stable and run only stable in production.

Stable because I guessed that that was the best thing to target when you are trying to teach others. I’m creating a Rust course on Udemy. I hope I made the best choice…there seems to be an awful lot of people using nightly!

Yes that’s indeed the best choice for teaching. Stable has a subset of nightly features. So while some code that run only on nightly can’t compile on beta and stable, anything that compiles on stable will compile just fine on beta and nightly.


Stable, because while I want to stay up to date (and am loving the performance and error message improvements!) I’m mostly writing small specialised data converters that I’d like to be able to come back to and recompile with latest in six months, without having to do much maintenance when I do.


Devs on nightly because I need benches.
Then stable and beta on travis/appveyor.

Plus stable if I need to cross compile.


On CI I use two versions, nightly and the oldest stable I currently support. I never bump the stable to a newer version unless I increase the major version, because which version of Rust your crate supports is part of its public API because if you get a newer semver compatible version of that crate and it doesn’t work with your current Rust, then that is a breaking change which violates semver.


I use stable because at the moment stability is more important for me than the newest features.
But in the near future I would also like to work with clippy and for this I must use the nightly version.


I use nightly, because developing an operating system (Robigalia) needs some unstable (and probably rightly so) features, like inline assembly (external assembly/C doesn’t benefit from inlining, which would be a perf problem for seL4 syscalls).


I alternate between stable and nightly a lot.