Remember that feeling? You just finished tweaking a line of code, hit compile with anticipation, and then… the waiting begins. Enough time to brew coffee, scroll through social media, or even take a quick nap. Rust’s compilation time, especially the linking phase, felt like an endurance test for developers.

But here’s the good news! Rust 1.90 is like a timely rain shower specifically designed to solve this headache. This isn’t one of those updates packed with flashy language features - it’s a practical optimization of the edit-compile-test loop we face every day.

Three Improvements That Will Make Your Day

Let me give you the highlights first - these three improvements are absolute game-changers:

  1. rustc now uses LLD by default - On x86_64-unknown-linux-gnu, linking speeds are dramatically faster, incremental builds feel lightning quick
  2. Native cargo publish --workspace support - No more fragile publish scripts, one-command publishing of entire workspace in dependency order
  3. Platform support adjustments - x86_64-apple-darwin demoted to tier 2, time to consider ARM architecture migration

If I had to summarize this release in one sentence: faster local development cycles, smoother publishing workflows, clearer platform expectations.

Why This Release Feels So Exciting?

Language features are important, but developer efficiency is king. Most teams spend more time linking, waiting, and publishing than writing new features. Rust 1.90 specifically targets these pain points.

This linker improvement isn’t just theoretical. For some large projects, the linker becomes a bottleneck where half the compile time is spent waiting for linking to finish. Switching to a faster default linker significantly reduces friction in daily development and CI. The Rust team’s real-world measurements are impressive enough to change your development habits: ripgrep’s incremental link time dropped by 7x, overall incremental compile time improved by about 40%; fresh debug builds showed ~20% end-to-end improvement.

Real-World Analogy: From Steam Train to Bullet Train

Imagine Rust compilation used to be like riding a steam train - you knew it would eventually reach the destination, but the speed was painfully slow. Every code change felt like waiting for the train to slowly pull into the station, then waiting for all the carriages to be connected.

Now with Rust 1.90, it’s like switching to a bullet train. The linking step - that “connecting carriages” process - becomes incredibly fast. The whole compilation process flows smoothly like a high-speed train accelerating. You make a change and see results almost immediately. This kind of experience improvement feels more substantial than any new syntax feature.

What Actually Changed? Practical Checklist

  • LLD becomes default linker - Much faster linking for large binaries and debug builds on x86_64-unknown-linux-gnu. Opt-out supported
  • Workspace publishing - cargo publish --workspace now publishes crates in correct dependency order, no more brittle scripts
  • Target tier changes - x86_64-apple-darwin moved to Tier 2 with host tools. Time to plan CI transitions
  • Const context and small API improvements - Various small but useful stabilizations including integer/float helpers and trait implementations

Hands-On: Experience the Linker Magic

Problem: Compiling large binaries or debug builds feels too slow. Each edit results in long waits, linker often becomes the compilation bottleneck.

Change: Rust 1.90 ships rust-lld as default linker for x86_64-unknown-linux-gnu. This brings modern parallelism and faster object processing to the default toolchain.

Quick test method:

  1. Update to 1.90:
# Use stable toolchain containing 1.90
rustup update stable
rustup default stable
  1. Measure cold build and incremental rebuild. Use medium-to-large codebase for clearer results (like ripgrep or similar CLI tools):
# Measure full build
time cargo build --bin your_bin

# Make small change then measure incremental
time cargo build --bin your_bin

Expected results: In ripgrep example, Rust team reported 7x reduction in link time for incremental rebuilds, ~40% reduction in end-to-end incremental compile time. Full debug builds showed ~20% end-to-end improvement.

How to opt out (if corner cases break):

# .cargo/config.toml
[target.x86_64-unknown-linux-gnu]
rustflags = ["-Clinker-features=-lld"]

Or set RUSTFLAGS:

export RUSTFLAGS="-Clinker-features=-lld"

Detailed note: Opt-out is rare; team expects LLD to be safe drop-in replacement in vast majority of cases.

Code Example: Workspace Publishing (Clear, Concise Example)

Problem: Publishing multiple interdependent crates required manual ordering or fragile scripts.

Change: cargo publish --workspace publishes crates in correct dependency order and runs usual publish checks across workspace.

Example workspace:

Cargo.toml at workspace root:

[workspace]
members = ["crate-a", "crate-b"]

crate-a/Cargo.toml:

[package]
name = "crate-a"
version = "0.1.0"

crate-b/Cargo.toml:

[package]
name = "crate-b"
version = "0.1.0"

[dependencies]
crate-a = { path = "../crate-a" }

Publish command:

# This publishes crate-a first, then crate-b
cargo publish --workspace

Result: Cargo validates workspace publish as unit and publishes crates in dependency order. Publish verification runs build across full set as if published. Network failures can still lead to partially published workspaces (publishes not atomic).

Before Rust 1.90

+-----------+      +-------------+      +---------+
 | rustc     | ---> | object files| ---> | system  |
 | (compile) |      | (.o/.rlib)  |      | linker  |
 +-----------+      +-------------+      +---------+
                              |
                              v
                         slow serial linker

Rust 1.90 (with LLD)

+-----------+      +-------------+      +---------+
 | rustc     | ---> | object files| ---> | rust-lld|
 | (compile) |      | (.o/.rlib)  |      | (parallel) |
 +-----------+      +-------------+      +---------+
                              |
                              v
                    faster parallel linking -> binary

Honest Advice for Developers

Ship less slowly. The faster your edit-build-test loop, the more courage you’ll have to refactor, test, and iterate. Use the new linker to reclaim those few minutes every day. Those minutes compound into more experiments and better products.

When updating toolchains, test both locally and in CI. If rare edge cases break, revert linker changes with the rustflags shown earlier and open an issue on Rust trackers.

If building for Intel Apple machines, start planning for reduced upstream coverage. Consider adding aarch64 macOS builds or validating your actual host matrix needs.

Final Thoughts

Rust 1.90 is a practical multiplier. It doesn’t change the syntax daily code uses, but it changes the time between thought and verification. If iteration speed matters to your team, this release hits exactly where it needs to. Test on beta, flip the switch, measure results, and enjoy writing more while waiting less. If something breaks, revert and report. The Rust community learns quickly from concrete feedback.

If you found this article helpful, feel free to follow my column for more practical development tips and experiences!