Why Rust Keeps Winning Over Developers

Rust keeps winning because it delivers memory safety without a garbage collector — the compiler proves, before your program ever runs, that a whole class of crashes and vulnerabilities can’t happen, at zero runtime cost. Its long streak atop “most admired language” surveys is the visible part. The more telling signal is behavioral: the organizations with the most expensive failures keep choosing Rust for infrastructure, where “winning” means shipped systems rather than survey affection.

What “winning” concretely looks like

• AWS wrote Firecracker — the microVM monitor underneath Lambda and Fargate — in Rust.
• Microsoft began shipping Rust inside Windows after years of publicly cataloging what C and C++ were costing it.
• Google made Rust a first-class language for Android’s native code, and has reported memory-safety vulnerabilities falling sharply as new Rust code displaced new C++.
• Cloudflare built Pingora, the Rust proxy framework it created to replace NGINX in its own infrastructure, then open-sourced it.
• The Linux kernel — a C codebase for three decades — merged support for writing kernel code in Rust.
• Developer tooling keeps getting rewritten in it: SWC and Turbopack in the JavaScript world, Ruff and uv in Python’s, all chasing order-of-magnitude speedups for interpreted-language ecosystems.

These are conservative codebases run by teams that don’t rewrite for fun. Something is paying for those rewrites.

The 70 percent problem

That something is a famous, stable statistic: both Microsoft’s security engineers and the Chrome team have long reported that roughly 70 percent of their serious security vulnerabilities are memory-safety bugs — use-after-frees, buffer overflows, dangling pointers. These aren’t exotic attacks; they’re the same bug classes C and C++ codebases have produced for decades, patched one CVE at a time.

Rust’s pitch to those teams isn’t “fewer bugs” — it’s “this category ceases to exist.” No amount of patching gets you there. The limit is worth stating too: memory safety does nothing about logic flaws, misconfiguration, or supply-chain attacks. It removes the single largest bucket, not the whole list.

Ownership, in plain English

Languages have historically offered two memory strategies. C and C++ trust the programmer to manage memory correctly — fast, and reliably the source of the bugs above. Garbage-collected languages like Go or Java clean up at runtime — safe, but you pay in pauses and overhead. Rust’s ownership system is the third path: every value has exactly one owner, references (“borrows”) are tracked by the compiler, and you can have many readers or one writer — never both at once. Violations aren’t runtime crashes; they’re compile errors.

fn main() {
    let mut scores = vec![1, 2, 3];
    let first = &scores[0]; // immutable borrow of `scores`
    scores.push(4);         // error[E0502]: cannot borrow `scores` as
                            // mutable because it is also borrowed
    println!("{first}");    // the borrow is still in use here
}

The compiler rejects this because push may reallocate the vector’s storage, leaving first pointing at freed memory. The equivalent C++ compiles cleanly and might crash — or, worse, pass every test and silently corrupt memory in production. The same rules prevent data races: code where two threads could mutate the same data unsynchronized simply doesn’t compile. “Fearless concurrency” is marketing language, but the mechanism behind it is real. And because none of this requires a runtime, Rust also compiles to lean WebAssembly with nothing extra to drag along.

What Rust actually costs

The case for Rust is only credible if you name the bill.

• The learning curve is real. The borrow checker rejects programs that would run fine in any other language, and the first weeks are largely arguments with the compiler. Budget a productivity dip measured in weeks to months, not days.
• Compile times are slow. All that compile-time proof isn’t free. The edit-build-test loop is noticeably slower than Go’s near-instant builds, and it compounds as codebases grow.
• The talent pool is smaller. There are far fewer experienced Rust engineers than Go, Java, or TypeScript engineers. You’ll train people or pay a premium.
• Iteration can be slower. Ownership constraints make some refactors sprawl across a codebase, and async Rust carries conceptual weight — lifetimes interacting with futures — that Go’s goroutines simply don’t have.

Notice the pattern: Rust’s costs are front-loaded into development, while its benefits are back-loaded into operations — fewer pages, fewer memory CVEs, no garbage-collector tuning. That trade only pays off when failure is expensive.

Where Rust is the wrong choice

• Typical CRUD apps. When the work is HTTP handlers, validation, and database queries, the database is the bottleneck. A garbage-collected language ships faster, and the runtime difference disappears into the noise.
• Quick scripts, prototypes, and internal tools. Throwaway code doesn’t need compile-time proofs of memory safety.
• Teams optimizing for hiring and onboarding. Go was explicitly designed for that trade-off, and it remains the better tool for it.
• Low-level work that wants less machinery. Zig stakes out different ground — C-level control and simplicity without a borrow checker — and suits some systems niches better.

Rust vs Go vs C++ at a glance

	Rust	Go	C++
Memory safety	Guaranteed at compile time	Garbage collector	Programmer discipline plus tooling
Runtime overhead	None	GC pauses, bigger footprint	None
Learning curve	Steep	Deliberately gentle	Steep, plus decades of legacy
Compile speed	Slow	Fast	Slow
Hiring pool	Small	Large	Large
Sweet spot	Infrastructure, systems, performance-critical services	Network services, CLIs, team velocity	Existing codebases, games, HPC

The takeaway

Rust keeps winning because it deleted a trade-off systems programming had treated as permanent: you no longer choose between a garbage collector and a steady stream of memory-corruption CVEs. The evidence is where it runs — Firecracker, Windows, Android, Cloudflare’s proxies, the Linux kernel — infrastructure whose failure costs justify a steep learning curve. The costs are just as concrete: slow compiles, a small hiring pool, and weeks spent arguing with the borrow checker. Choose Rust where failure is expensive and performance is non-negotiable; choose something friendlier where it isn’t.