<div id="readability-page-1" class="page"><div><img src="https://devstarsj.github.io/assets/https://images.unsplash.com/photo-1542903660-eedba2cda473?w=1200">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.<hr><h2 id="where-rust-won-decisively">Where Rust Won Decisively</h2><h3 id="systems-and-infrastructure">Systems and Infrastructure</h3>The original bet paid off. Rust now powers critical infrastructure at nearly every major cloud provider:<ul><li>AWS: Firecracker (Lambda’s microVM), parts of S3, the Nitro Hypervisor components</li><li>Microsoft: Windows kernel drivers, Azure’s MSAL auth libraries, parts of VS Code’s backend</li><li>Google: Android’s Bluetooth stack, parts of ChromeOS, Fuchsia’s core</li><li>Meta: Folly’s Rust bindings, parts of the Hack runtime</li></ul>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.<img src="https://images.unsplash.com/photo-1558494949-ef010cbdcc31?w=900" alt="Rust systems programming illustration"> Photo by Jordan Harrison on Unsplash<h3 id="cli-tooling">CLI Tooling</h3>The “rewrite it in Rust” movement for CLI tools produced genuine winners:<div><pre><code># 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
</code></pre></div>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.<h3 id="webassembly-runtime">WebAssembly Runtime</h3>Rust is the dominant language for writing WebAssembly runtimes and tooling:<ul><li>Wasmtime (Bytecode Alliance) — the reference WASM runtime</li><li>Wasmer — alternative runtime with multi-backend JIT</li><li>wasm-pack — toolchain for Rust → browser WASM</li></ul>And for writing WASM modules that need performance, Rust competes strongly with C/C++ while being dramatically safer.<hr><h2 id="where-rust-struggled">Where Rust Struggled</h2><h3 id="web-application-backends">Web Application Backends</h3>The async story in Rust has improved enormously — <code>tokio</code> is mature, <code>axum</code> 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.<div><pre><code>// 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&lt;PgPool&gt;,
 axum::extract::Path(user_id): axum::extract::Path&lt;i64&gt;,
) -&gt; Result&lt;Json&lt;User&gt;, AppError&gt; {
 let user = sqlx::query_as!(User, "SELECT id, name FROM users WHERE id = $1", user_id)
 .fetch_one(&amp;db)
 .await?;
 Ok(Json(user))
}
</code></pre></div>The code is clean. But ORM choices (<code>sqlx</code> vs <code>diesel</code> vs <code>sea-orm</code>), auth libraries, and middleware stories are less settled than competing ecosystems. Teams routinely spend a week just picking their database layer.<h3 id="compile-times">Compile Times</h3>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. <code>cargo build --timings</code> helps identify bottlenecks. Splitting monoliths into workspace crates helps. But it’s still a paper cut that never quite heals.<h3 id="learning-curve">Learning Curve</h3>The borrow checker is genuinely different from anything else. Most developers hit the same walls:<ol><li>Ownership confusion — “why can’t I use this value twice?”</li><li>Lifetime annotations — “when do I actually need <code>'a</code>?”</li><li>Async lifetimes — “why is my future not <code>Send</code>?”</li><li>Error type ergonomics — <code>Box&lt;dyn Error&gt;</code> vs <code>anyhow</code> vs custom error enums</li></ol>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.<hr><h2 id="whats-new-in-rust-2024-edition-and-beyond">What’s New in Rust 2024 Edition and Beyond</h2>The Rust 2024 Edition (released late 2024) brought meaningful ergonomic improvements:<h3 id="gen-blocks-for-generators"><code>gen</code> blocks for generators</h3><div><pre><code>use std::ops::Generator;

fn fibonacci() -&gt; impl Iterator&lt;Item = u64&gt; {
 gen {
 let (mut a, mut b) = (0u64, 1u64);
 loop {
 yield a;
 (a, b) = (b, a + b);
 }
 }
}
</code></pre></div><h3 id="impl-trait-in-let-bindings"><code>impl Trait</code> in <code>let</code> bindings</h3><div><pre><code>// Before: had to box or use turbofish
let handler: Box&lt;dyn Fn(i32) -&gt; i32&gt; = Box::new(|x| x * 2);

// After: clean
let handler: impl Fn(i32) -&gt; i32 = |x| x * 2;
</code></pre></div><h3 id="better-async-closures">Better async closures</h3><div><pre><code>// Async closures that actually work intuitively now
let fetch = async |url: &amp;str| -&gt; reqwest::Result&lt;String&gt; {
 reqwest::get(url).await?.text().await
};
</code></pre></div><hr>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:<ul><li>Candle (Hugging Face) — ML framework in pure Rust, runs on CPU/CUDA/Metal</li><li>Burn — ergonomic ML framework targeting embedded and edge</li><li>Ort — Rust bindings for ONNX Runtime</li><li>vLLM-rs — Rust-based LLM serving layer experiments</li></ul>The pitch: Python handles model development; Rust handles the serving infrastructure that runs at 3am in production.<div><pre><code>use candle_core::{Device, Tensor};
use candle_nn::{linear, Linear, Module, VarBuilder};

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

impl Module for MLP {
 fn forward(&amp;self, xs: &amp;Tensor) -&gt; candle_core::Result&lt;Tensor&gt; {
 let xs = self.fc1.forward(xs)?.relu()?;
 self.fc2.forward(&amp;xs)
 }
}
</code></pre></div><hr><h2 id="should-you-use-rust-in-2026">Should You Use Rust in 2026?</h2>Yes, if:<ul><li>You’re building performance-critical infrastructure (databases, runtimes, network proxies)</li><li>You’re writing CLI tools that need to be fast, safe, and ship as single binaries</li><li>You’re targeting WebAssembly</li><li>You’re writing kernel-adjacent code</li><li>Your team has or wants to build Rust expertise</li></ul>Probably not yet, if:<ul><li>You’re building a CRUD web app and your team doesn’t know Rust</li><li>You need to ship fast and iterate weekly</li><li>Your main bottleneck is database latency, not CPU cycles</li></ul>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.<hr>References: <a href="https://doc.rust-lang.org/book/">The Rust Programming Language Book</a>, <a href="https://doc.rust-lang.org/edition-guide/">Rust 2024 Edition Guide</a>, <a href="https://blog.rust-lang.org/">State of Rust Survey 2025</a> <div>이 글이 도움이 되셨다면 공감 및 광고 클릭을 부탁드립니다 :) </div></div></div>

Dev Note

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:
Ownership confusion — “why can’t I use this value twice?”
Lifetime annotations — “when do I actually need 'a?”
Async lifetimes — “why is my future not Send?”
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

Rust in 2026: Where It Won, Where It Struggled, and What's Next

댓글