Scrolls
5 min read
On this page

Staying Current

Rust evolves faster than most systems languages but with remarkable backward compatibility. New features land every six weeks, editions collect breaking changes every three years, and the community produces a steady stream of learning resources. Staying current means knowing how the release process works and where to find information.

The Six-Week Release Cycle

Rust releases a new stable version every six weeks. The process uses a train model:

nightly  -->  beta  -->  stable
  (daily)     (6 weeks)   (6 weeks)

Features are developed on nightly. Every six weeks, nightly becomes the new beta. The previous beta becomes stable. This means every feature gets at least six weeks of beta testing before it reaches stable users.

# Check your current version
rustc --version

rustc 1.83.0 (2024-11-28)

# Update to the latest stable
rustup update stable

The six-week cadence means small, incremental releases rather than large, risky updates. Most releases require no changes to your code.

Rust Editions

Editions are Rust's mechanism for making changes that would otherwise break existing code. An edition is a coherent set of language changes that you opt into per crate.

The editions so far:

  • 2015 — the original Rust. async/await did not exist. Error handling patterns were still forming.
  • 2018 — module system simplification, async/await, NLL (Non-Lexical Lifetimes), dyn Trait syntax.
  • 2021 — disjoint capture in closures, IntoIterator for arrays, new prelude items.
  • 2024 — gen blocks, unsafe_op_in_unsafe_fn lint, updated formatting rules.

Set your edition in Cargo.toml:

[package]
name = "my-project"
version = "0.1.0"
edition = "2021"

Key facts about editions:

  • Editions are per-crate, not per-toolchain. A 2021-edition crate can depend on a 2018-edition crate. They interoperate seamlessly.
  • Old editions are never removed. Code written for the 2015 edition still compiles on the latest compiler.
  • Editions never change the semantics of existing valid code. They only change what is valid syntax and what is accepted.

Migrating Between Editions

Rust provides automated migration:

# Check what needs to change
cargo fix --edition

# Update the edition in Cargo.toml
# Change: edition = "2021" -> edition = "2024"

# Verify everything still works
cargo build
cargo test

cargo fix --edition automatically applies the necessary code changes. Most migrations are trivial — renaming a keyword that became reserved, adjusting an import. Run the tests after migration to confirm nothing broke.

Nightly Features

Some features are only available on nightly Rust:

# Install nightly
rustup toolchain install nightly

# Use nightly for a specific project
rustup override set nightly

# Or run a single command with nightly
cargo +nightly build

To use a nightly feature:

#![feature(portable_simd)]

use std::simd::prelude::*;

Nightly features are unstable and may change. Use them in experiments and personal projects. For production code, wait for stabilization.

This Week in Rust

TWIR is a weekly newsletter that curates the best Rust content:

  • New crate releases
  • Blog posts and tutorials
  • RFC updates
  • Upcoming events
  • Call for participation in open source

Subscribe at this-week-in-rust.org. It is the single best way to stay informed about the Rust ecosystem without spending hours reading every blog and forum.

The Rust Blog

The official Rust blog (blog.rust-lang.org) announces:

  • Stable releases with changelogs
  • Major feature stabilizations
  • Edition announcements
  • Security advisories
  • Governance updates

Read the release posts when a new version comes out. They summarize what changed and why.

RFCs: The Future of Rust

RFCs (Requests for Comments) are how new features are proposed and designed:

rust-lang/rfcs repository on GitHub

Each RFC includes:

  • Motivation — why the feature is needed
  • Detailed design — how it works
  • Drawbacks — what could go wrong
  • Alternatives — other approaches considered

You do not need to read every RFC. But when a feature you care about is being discussed — async closures, generators, const generics improvements — the RFC is the authoritative source.

Key RFCs to know about:

  • RFC 2091 — implicit caller location (where panic! happened)
  • RFC 2394 — async/await syntax
  • RFC 3498 — lifetime capture rules 2024
  • RFC 3668 — gen blocks for iterators

Rust Release Channels

Track what is coming:

# See what features are stabilized in the next release
rustup doc --std  # opens standard library docs

# Check the release notes
# https://releases.rs  — tracks every release with changelogs

The Rust Forge (forge.rust-lang.org) provides the release calendar and upcoming milestones.

Upgrading Dependencies

Keep your dependencies current:

# Check for outdated dependencies
cargo outdated

# Upgrade compatible versions
cargo update

# Upgrade to new major versions (requires cargo-edit)
cargo upgrade

cargo update updates within semver-compatible ranges (your Cargo.lock changes but Cargo.toml stays the same). cargo upgrade bumps the version requirements in Cargo.toml.

For large upgrades:

# See what changed in a dependency
cargo changelog serde  # if you have cargo-changelog installed

# Check for breaking changes
cargo build
cargo test
cargo clippy

For staying sharp with Rust:

  • The Rustonomicon — deep dive into unsafe Rust and advanced topics
  • Rust for Rustaceans by Jon Gjengset — intermediate-to-advanced concepts
  • docs.rs — documentation for every published crate
  • Rust Playground (play.rust-lang.org) — test code snippets in the browser
  • Rust Users Forum (users.rust-lang.org) — ask questions, get answers

Common Pitfalls

  • Ignoring edition migrations. Staying on an old edition means missing language improvements. Migration is usually painless — do it.
  • Using nightly features in production. Nightly features can change without notice. Wait for stabilization unless you have a compelling reason.
  • Not running cargo update regularly. Dependencies accumulate security patches and bug fixes. Update at least monthly.
  • Skipping release notes. New stable releases often stabilize features that simplify your code. A five-minute read of the changelog can save hours of workarounds.
  • Learning only from old resources. Rust has changed significantly since 2015. Tutorials that use extern crate, old-style module paths, or manual impl Future are outdated. Check the publication date.

Key Takeaways

  • Rust releases every six weeks with a stable, beta, nightly train model. Updates are incremental and rarely breaking.
  • Editions collect breaking changes every few years. Migration is automated with cargo fix --edition.
  • This Week in Rust is the best single source for ecosystem news.
  • RFCs describe future features in detail. Read them for features you care about.
  • Keep dependencies current with cargo update and cargo outdated. Security patches arrive through dependency updates.
  • Use stable Rust for production. Nightly is for experiments and features that are not yet stabilized.