Jump to content

Rust 1.90: The Speed Update — LLD Linker Makes Everything 7x Faster

From JOHNWICK

What if your Rust projects suddenly compiled 40% faster… without changing a single line of code? Released on September 18, 2025, Rust 1.90 brings one of the most impactful performance improvements in recent Rust history. By switching to the LLD linker as the default on Linux, this release dramatically cuts build times — especially for large projects and incremental rebuilds. Add workspace publishing support to Cargo, and you’ve got a release that makes Rust developers significantly more productive. Let’s dive into what makes Rust 1.90 a must-upgrade release.


⚡ The Game-Changer: LLD as Default Linker on Linux The headline feature of Rust 1.90 is the switch to LLD (LLVM Linker) as the default linker for x86_64-unknown-linux-gnu. This isn't just a minor tweak—it's a fundamental performance upgrade that benefits every Linux developer immediately.

Why Linking Matters When you run cargo build, the Rust compiler does two major things:

  • Compiles your Rust code into object files
  • Links those object files into a final binary

For years, linking has been a notorious bottleneck. Traditional linkers like GNU BFD were designed in the single-core era and haven’t kept pace with modern hardware. On a large project, you might spend 50% of your build time just waiting for the linker!

The LLD Solution LLD is LLVM’s modern, parallel linker that takes full advantage of multi-core CPUs. Rust has shipped LLD for WebAssembly and ARM targets for a while, but Rust 1.90 finally brings it to the most popular target: Linux x86–64.


📊 Real-World Performance Numbers Let’s look at concrete numbers from the ripgrep project, a real-world Rust application:

Translation:

  • That incremental rebuild that took 10 seconds? Now it’s 6 seconds.
  • Large project taking 5 minutes? Now it’s 4 minutes.
  • Hours saved every week on large codebases

Who Benefits Most? You’ll see the biggest improvements if you’re working on:

  • Large applications with many dependencies
  • Projects with extensive debug info (development builds)
  • Incremental rebuilds during active development
  • Monorepo workflows with multiple binaries

The performance gains come from parallelism — LLD uses all your CPU cores during linking, whereas older linkers typically use just one.

🔧 How to Use LLD (Spoiler: You Already Are!) The beautiful thing about Rust 1.90? You don’t need to do anything. Just upgrade and enjoy faster builds: 

rustup update stable
cargo build  # Now automatically uses LLD on Linux!

In the vast majority of cases, LLD is backwards compatible with the old linker, so you shouldn’t see any difference other than reduced compilation time.

Opt-Out (If Needed)

If you encounter any issues, you can easily revert: Via environment variable: 

RUSTFLAGS="-C linker-features=-lld" cargo build

Via .cargo/config.toml: 

[target.x86_64-unknown-linux-gnu]
rustflags = ["-C", "linker-features=-lld"]

From extensive testing on CI, crater, benchmarking infrastructure, and nightly builds since May 2024, the Rust team doesn’t expect issues in practice. LLD is a drop-in replacement for the vast majority of cases.

Platform Availability Currently using LLD by default:

  • ✅ x86_64-unknown-linux-gnu (NEW in 1.90!)
  • ✅ wasm32-* targets
  • ✅ aarch64-* targets (some)

Still using system linker:

  • macOS (uses Apple’s linker)
  • Windows (uses MSVC’s linker)
  • Other Linux targets (for now)


📦 Workspace Publishing: One Command to Rule Them All Rust 1.90 adds native support for cargo publish --workspace, automatically publishing all crates in a workspace in the right order, following any dependencies between them.

The Old Way (Painful)

Before Rust 1.90, publishing a multi-crate workspace was tedious: 

# Manual ordering, error-prone
cd my-core-crate
cargo publish
sleep 30  # Wait for crates.io to index

cd ../my-util-crate  
cargo publish
sleep 30
cd ../my-main-crate
cargo publish
# ... repeat for every crate 😫

Or you used external tools like cargo-release or cargo-workspaces.

The New Way (Elegant) 

# One command, proper ordering, verification!
cargo publish --workspace

What This Does:

  • Analyzes dependencies between workspace crates
  • Orders publishing so dependencies come first
  • Runs verification across the full workspace
  • Publishes in sequence with proper error handling

Important Note: Publishes are still not atomic — network errors or server-side failures can still lead to a partially published workspace. But Cargo now handles ordering and verification for you!

Dry Runs for Safety 

# Test the full publishing process without actually publishing
cargo publish --workspace --dry-run

Cargo’s publish verification runs a build across the full set of to-be-published crates as if they were published, including during dry-runs.

🍎 macOS Intel: The Transition Continues As of Rust 1.90, the x86_64-apple-darwin target has been demoted from Tier 1 with host tools to Tier 2 with host tools.

What This Means

For Most Users: Nothing Changes Immediately

  • Rust still fully supports Intel Macs
  • Pre-built binaries still distributed via rustup
  • All existing projects continue working

Over Time: Less Attention

  • Reduced automated testing coverage
  • Potential for platform-specific bugs
  • No guarantees about future compatibility

Why the Demotion?

GitHub will soon discontinue providing free macOS x86_64 runners for public repositories, and Apple has announced plans for discontinuing support for the x86_64 architecture. The Rust project is following the industry’s shift to Apple Silicon. If you’re on Intel Mac:

  • Short term: Everything works fine
  • Medium term: Consider upgrading to Apple Silicon
  • Long term: Intel Mac support will gradually fade

Apple Silicon users: You’re on Tier 1 (aarch64-apple-darwin) and getting full support! 🎉


🔑 Stabilized APIs: Small but Useful Rust 1.90 stabilizes several convenience APIs that make code cleaner: Signed Subtraction for Unsigned Integers 

let unsigned: u32 = 100;
let signed: i32 = -20;

// New in 1.90!
let result = unsigned.checked_sub_signed(signed);  // Some(120)
let result = unsigned.wrapping_sub_signed(signed); // 120
let result = unsigned.saturating_sub_signed(signed); // 120
let result = unsigned.overflowing_sub_signed(signed); // (120, false)

Why This Matters:

  • Common pattern in time calculations, offsets, deltas
  • Previously required manual type conversions
  • Now built-in with overflow checking

CStr/CString Comparisons 

use std::ffi::{CStr, CString};
use std::borrow::Cow;

let c_str = CStr::from_bytes_with_nul(b"hello\0").unwrap();
let c_string = CString::new("hello").unwrap();
let cow: Cow<CStr> = Cow::Borrowed(c_str);
// All these comparisons now work directly!
assert!(c_str == c_string);
assert!(c_str == cow);
assert!(c_string == cow);

Use Case: FFI code becomes much cleaner when comparing C strings in different forms.

Const Float Operations 

// Now usable in const contexts!
const PI_FLOOR: f64 = 3.14159.floor();  // 3.0
const PI_CEIL: f64 = 3.14159.ceil();    // 4.0
const PI_ROUND: f64 = 3.14159.round();  // 3.0
const PI_TRUNC: f64 = 3.14159.trunc();  // 3.0
const PI_FRACT: f64 = 3.14159.fract();  // 0.14159

Impact: Compile-time math operations for lookup tables, constants, and metaprogramming.

🌍 Real-World Impact by Use Case

Web Development Faster iteration cycles:

  • Actix-web, Axum, Rocket projects build 40% faster on incremental rebuilds
  • WASM projects already benefited from LLD, now parity on native
  • Hot-reload development experience improves dramatically

Systems Programming Build time matters in tight loops:

  • Kernel module development with faster test cycles
  • Embedded projects with large binary outputs see big wins
  • Debug builds with extensive symbol info link much faster

CLI Tools and Utilities Rapid development:

  • Tools like ripgrep, fd, bat benefit immediately
  • Quick experimentation and testing workflows
  • CI/CD pipelines complete faster

Enterprise and Monorepos Massive productivity gains:

  • Large workspaces with dozens of crates
  • Publishing workflows streamlined with --workspace
  • Developer happiness improves with faster builds


📈 Under the Hood: Why LLD is Faster Traditional linkers like GNU BFD were designed when computers only had a single core, so they usually tend to be slow on a modern machine.

1. LLD’s Advantages:

  • Parallel Processing
  • Uses all CPU cores during linking
  • Scales with your hardware

2. Modern Architecture

  • Designed for LLVM’s IR
  • Optimized for common patterns in modern code

3. Efficient Memory Usage

  • Better caching strategies
  • Reduced memory fragmentation

4. Cross-Platform

  • Same linker across WASM, ARM, x86
  • Consistent behavior and performance

Some of the big gains in performance come from parallelism, which could be undesirable in resource-constrained environments, or for heavy projects that are already reaching hardware limits.


🚀 Upgrade Guide: Get Fast Builds Now

For Linux Users (the main beneficiaries): 

# 1. Update Rust
rustup update stable

# 2. Verify you're on 1.90
rustc --version
# Should show: rustc 1.90.0 (...)
# 3. Build as normal - LLD is now automatic!
cargo build
# 4. Enjoy your faster builds! 🎉

For Workspace Maintainers: 

# Clean up your old publish scripts!
# Replace them with:
cargo publish --workspace --dry-run  # Test first
cargo publish --workspace             # Then publish

Expected Upgrade Issues: Minimal

Most projects: Zero changes needed, instant speedup Rare edge cases:

  • Custom linker scripts might need adjustments
  • Very niche GNU ld-specific behaviors
  • Resource-constrained CI environments (too much parallelism)

If you hit issues: Use the opt-out flag and report on GitHub


💡 Pro Tips for Maximizing Build Speed

Now that LLD is default, stack these optimizations:

1. Use cargo-nextest for Parallel Testing 

cargo install cargo-nextest
cargo nextest run  # Much faster test execution

2. Enable Incremental Compilation 

# In Cargo.toml
[profile.dev]
incremental = true  # Usually default, but make sure

3. Consider sccache for Shared Builds 

cargo install sccache
export RUSTC_WRAPPER=sccache

4. Optimize Dependencies in Cargo.toml 

[profile.dev.package."*"]
opt-level = 1  # Slightly optimize dependencies

5. Use Workspaces Effectively 

[workspace]
members = ["crate-a", "crate-b"]
resolver = "2"  # Better dependency resolution


🔮 What’s Coming Next

Rust 1.91 (October 30, 2025) is already in beta with:

  • Windows ARM64 (aarch64-pc-windows-msvc) promotion to Tier 1
  • BTreeMap::extract_if stabilization
  • Improved assert! error messages
  • Continued const-context API expansions

Future linker work:

  • Potential LLD default for more targets
  • Continued optimization of linking behavior
  • Better integration with system toolchains

Still in development (nightly):

  • Native async traits (getting close!)
  • try blocks for ergonomic error handling
  • Specialization improvements
  • Generic const expressions


💬 Community Reactions

The Rust community has enthusiastically embraced 1.90’s performance improvements:

“Shaved 2 minutes off our CI pipeline immediately after upgrading to 1.90. LLD is incredible!” — Reddit /r/rust user

“The workspace publish feature is exactly what we needed. No more manual ordering!” — Rust Discord community

“40% faster incremental builds means I iterate 40% faster. This is huge for productivity.” — Rust Gamedev Working Group

“Finally, Rust build times are competitive with Go for rapid development!” — Twitter Rust Community


🎬 The Bottom Line: Upgrade Now

Rust 1.90 is one of those rare releases where everyone wins immediately: ✅ Linux developers get:

  • 20–40% faster builds automatically
  • 7x faster incremental linking
  • Zero configuration required

✅ Workspace maintainers get:

  • One-command publishing
  • Proper dependency ordering
  • Integrated verification

✅ All developers get:

  • More productive workflows
  • Faster iteration cycles
  • Better developer experience

The upgrade cost? Five minutes to run rustup update stable.

The benefit? Hours saved every week, immediately.

This isn’t a release you want to skip. Rust 1.90 makes you faster without making you change anything.


📚 Essential Resources

  • Official Rust 1.90 Release Notes
  • LLD Performance Deep Dive
  • Detailed Changelog
  • Report Issues


🔍 Quick Reference: Rust 1.90 at a Glance

Major Changes:

  • ⚡ LLD linker default on x86_64-unknown-linux-gnu
  • 📦 cargo publish --workspace support
  • 🍎 x86_64-apple-darwin to Tier 2

Performance:

  • 40% faster incremental builds (Linux)
  • 20% faster clean builds (Linux)
  • 7x faster linking in incremental rebuilds

Stabilized APIs:

  • u{n}::*_sub_signed methods
  • CStr/CString comparisons
  • Const float operations

Opt-Out: 

# If you need to disable LLD:
RUSTFLAGS="-C linker-features=-lld" cargo build


Ready to experience the speed? Run rustup update stable and feel the difference! ⚡🦀

Retrieved from "https://johnwick.cc/index.php?title=Rust_1.90:_The_Speed_Update_—_LLD_Linker_Makes_Everything_7x_Faster&oldid=384"