Rust has had one of the most interesting trajectories in programming language history. It started as a Mozilla research project for writing safe browser internals, survived the Firefox layoffs, became the language of choice for systems programming, entered the Linux kernel, and is now showing up in machine learning runtimes, cloud infrastructure, and web backends. This is a state-of-the-language post: where Rust actually won, where it hit walls, and where it’s heading in 2026.

Where Rust Won Decisively

Systems and Infrastructure

The original bet paid off. Rust now powers critical infrastructure at nearly every major cloud provider:

• AWS: Firecracker (Lambda’s microVM), parts of S3, the Nitro Hypervisor components
• Microsoft: Windows kernel drivers, Azure’s MSAL auth libraries, parts of VS Code’s backend
• Google: Android’s Bluetooth stack, parts of ChromeOS, Fuchsia’s core
• Meta: Folly’s Rust bindings, parts of the Hack runtime

The Linux kernel story is especially notable. Rust is now used in production kernel modules — GPU drivers, filesystem components, and network subsystems. Linus Torvalds’ cautious endorsement has become practical reality.

Photo by Jordan Harrison on Unsplash

CLI Tooling

The “rewrite it in Rust” movement for CLI tools produced genuine winners:

# These have largely replaced their C/Python originals in new setups
fd        # replaces find
ripgrep   # replaces grep
bat       # replaces cat
eza       # replaces ls
starship  # replaces old shell prompts
delta     # git diff pager
tokei     # code statistics
just      # task runner

The performance and cross-platform packaging story for Rust CLIs is just better than Python or Go for many use cases. Single static binaries with good error messages.

WebAssembly Runtime

Rust is the dominant language for writing WebAssembly runtimes and tooling:

• Wasmtime (Bytecode Alliance) — the reference WASM runtime
• Wasmer — alternative runtime with multi-backend JIT
• wasm-pack — toolchain for Rust → browser WASM

And for writing WASM modules that need performance, Rust competes strongly with C/C++ while being dramatically safer.

Where Rust Struggled

Web Application Backends

The async story in Rust has improved enormously — tokio is mature, axum is genuinely pleasant to use — but the ecosystem hasn’t converged on a single dominant framework the way Python has Django/FastAPI or JavaScript has Express/Fastify.

// axum is nice, but the ecosystem around it is still fragmented
use axum::{
    routing::get,
    Router,
    extract::State,
    Json,
};
use serde::{Deserialize, Serialize};

#[derive(Serialize)]
struct User {
    id: i64,
    name: String,
}

async fn get_user(
    State(db): State<PgPool>,
    axum::extract::Path(user_id): axum::extract::Path<i64>,
) -> Result<Json<User>, AppError> {
    let user = sqlx::query_as!(User, "SELECT id, name FROM users WHERE id = $1", user_id)
        .fetch_one(&db)
        .await?;
    Ok(Json(user))
}

The code is clean. But ORM choices (sqlx vs diesel vs sea-orm), auth libraries, and middleware stories are less settled than competing ecosystems. Teams routinely spend a week just picking their database layer.

Compile Times

This remains the most common complaint. A fresh build of a medium-sized Rust project (100k lines) takes 3-5 minutes. Incremental builds are better — typically 15-30 seconds — but they still break frequently enough to cause frustration.

The Rust team is working on it. cargo build --timings helps identify bottlenecks. Splitting monoliths into workspace crates helps. But it’s still a paper cut that never quite heals.

Learning Curve

The borrow checker is genuinely different from anything else. Most developers hit the same walls:

1. Ownership confusion — “why can’t I use this value twice?”
2. Lifetime annotations — “when do I actually need 'a?”
3. Async lifetimes — “why is my future not Send?”
4. Error type ergonomics — Box<dyn Error> vs anyhow vs custom error enums

The good news: the learning resources are excellent now. The Rust Book is free and good. Rust for Rustaceans covers advanced patterns well. The compiler’s error messages have become arguably the best in any language.

What’s New in Rust 2024 Edition and Beyond

The Rust 2024 Edition (released late 2024) brought meaningful ergonomic improvements:

gen blocks for generators

use std::ops::Generator;

fn fibonacci() -> impl Iterator<Item = u64> {
    gen {
        let (mut a, mut b) = (0u64, 1u64);
        loop {
            yield a;
            (a, b) = (b, a + b);
        }
    }
}

impl Trait in let bindings

// Before: had to box or use turbofish
let handler: Box<dyn Fn(i32) -> i32> = Box::new(|x| x * 2);

// After: clean
let handler: impl Fn(i32) -> i32 = |x| x * 2;

Better async closures

// Async closures that actually work intuitively now
let fetch = async |url: &str| -> reqwest::Result<String> {
    reqwest::get(url).await?.text().await
};

Rust in AI Tooling

This is the emerging story of 2025-2026. Python owns the AI research space (PyTorch, JAX, transformers), but Rust is increasingly used for the infrastructure around AI:

• Candle (Hugging Face) — ML framework in pure Rust, runs on CPU/CUDA/Metal
• Burn — ergonomic ML framework targeting embedded and edge
• Ort — Rust bindings for ONNX Runtime
• vLLM-rs — Rust-based LLM serving layer experiments

The pitch: Python handles model development; Rust handles the serving infrastructure that runs at 3am in production.

use candle_core::{Device, Tensor};
use candle_nn::{linear, Linear, Module, VarBuilder};

struct MLP {
    fc1: Linear,
    fc2: Linear,
}

impl Module for MLP {
    fn forward(&self, xs: &Tensor) -> candle_core::Result<Tensor> {
        let xs = self.fc1.forward(xs)?.relu()?;
        self.fc2.forward(&xs)
    }
}

Should You Use Rust in 2026?

Yes, if:

• You’re building performance-critical infrastructure (databases, runtimes, network proxies)
• You’re writing CLI tools that need to be fast, safe, and ship as single binaries
• You’re targeting WebAssembly
• You’re writing kernel-adjacent code
• Your team has or wants to build Rust expertise

Probably not yet, if:

• You’re building a CRUD web app and your team doesn’t know Rust
• You need to ship fast and iterate weekly
• Your main bottleneck is database latency, not CPU cycles

The honest verdict: Rust has earned its place. It’s not hype anymore — it’s production infrastructure at scale. But it’s a serious investment, and you should make it deliberately.

References: The Rust Programming Language Book, Rust 2024 Edition Guide, State of Rust Survey 2025

이 글이 도움이 되셨다면 공감 및 광고 클릭을 부탁드립니다 :)