If you installed Ubuntu 26.04 this year, the sudo you type every day is a Rust program now. Android runs Rust in its system services. Microsoft just gave Rust the same internal status as C++, and the Linux kernel officially stopped calling it an experiment.
That’s a lot of conservative projects switching to Rust in a short time. These are teams that hate change, because change breaks things. So why now?
The short answer is one stubborn class of bug, and finally having hard numbers on how well Rust gets rid of it. The longer answer includes a Cloudflare outage that shows what Rust can’t do.
The Bug That Never Went Away
Most of the software under your apps is written in C or C++: operating systems, browsers, drivers. Those languages are fast because they let programmers manage memory by hand. Ask for a chunk, use it, give it back.
Hand-managed memory goes wrong in predictable ways. A program writes past the end of a chunk (a buffer overflow), or keeps using a chunk after giving it back (a use-after-free). Attackers love these bugs, because a careful one can be turned into running their own code on your machine.
Decades of code reviews, testing tools, and training haven’t fixed it. Microsoft has said since 2019 that about 70% of the security bugs it patches each year are memory safety issues. That same year, two security engineers estimated that around two-thirds of Linux kernel vulnerabilities came from the same source.
What Rust Does Differently
Java, Python, and JavaScript solved this long ago with a garbage collector, a background helper that cleans up memory nobody is using anymore. The catch is that it costs speed and causes small pauses. That’s fine for a website. It’s unacceptable inside a kernel or a phone’s modem.
Rust takes a third route. Every piece of memory has exactly one owner, and the compiler (the tool that turns code into a program) checks the rules before the program ever runs. Borrow something and you have to give it back. Hand it to someone else and you can’t touch it anymore. Break a rule and the code won’t build.
Picture a strict librarian who won’t let you leave with a book that isn’t checked out. It’s annoying when you’re in a hurry. It’s also why the shelves stay in order.
You get C-like speed without a garbage collector, and a whole family of bugs becomes a compile error instead of a security bulletin. The price is a steep learning curve. Fighting the borrow checker, the part of the compiler that enforces those rules, is a rite of passage for every new Rust developer.
Why Big Projects Are Switching to Rust Now
Rust 1.0 came out in 2015, so the language isn’t new. The evidence is.
Google has the best data, because Android has been adding Rust since 2021. In its November 2025 update, Google reported that memory safety bugs fell below 20% of Android’s vulnerabilities for the first time. Its Rust code has roughly 1,000 times fewer memory safety bugs per line than its C and C++ code.
The surprise was speed. Medium and large Rust changes get rolled back about four times less often than similar C++ changes, and Rust changes spend about 25% less time in code review. The safer code was also faster to ship.
That’s Google grading its own homework. It’s also years of data from one of the biggest codebases on Earth, and other projects followed:
| Who | What changed | When |
|---|---|---|
| Linux kernel | Maintainers dropped the “experimental” label for Rust | December 2025 |
| Ubuntu | Rust versions of sudo and the core command-line tools became the default | 25.10, then 26.04 LTS |
| Microsoft | Rust became a Tier-1 internal language, next to C++, C#, and TypeScript | September 2026 |
| Vite | The popular web build tool switched to Rolldown, a Rust bundler | March 2026 |
Notice the pattern. Nobody is rewriting the whole Linux kernel. Rust goes into new code and the riskiest parts first: drivers, parsers, firmware, anything that reads data from strangers.
The Vite row has a different motive. Web developers rarely lose sleep over memory bugs in their build tools. They want speed, and the Vite team says Rolldown builds 10 to 30 times faster than the JavaScript bundler it replaced.
What Rust Doesn’t Fix
This is the part the fan club skips. Rust stops memory bugs. It doesn’t stop you from being wrong.
On November 18, 2025, a big chunk of the internet went down. Cloudflare’s postmortem traced it to a database permission change that doubled the size of a configuration file. The file blew past a hard limit in the new Rust version of Cloudflare’s proxy, and the code had assumed that could never happen.
It used unwrap(), Rust’s way of saying “this can’t fail,” and the program crashed. Full recovery took almost six hours, and Cloudflare called it its worst outage since 2019.
Rust did its job there. Nothing was corrupted and nothing was exploitable. The program crashed loudly, exactly where the programmer had said it would. The bug was the assumption, and no compiler can check your assumptions about the outside world.
Rewrites bring their own bugs, too. Before shipping the Rust command-line tools in a long-term support release, Canonical paid a security firm to audit them. The audit found 113 issues, and Canonical disclosed 44 CVEs, the official IDs for security vulnerabilities.
Most were fixed in time. Ubuntu 26.04 still kept the old GNU versions of cp, mv, and rm, because of unresolved race conditions: a file can change between the moment a program checks it and the moment it uses it. Canonical’s plan was to finish the switch in 26.10.
A Rust rewrite is still new code. The old C tools have had decades of real-world bug fixing, and the Rust versions start that clock from zero.
Not Every Rewrite Picks Rust
The best counterexample comes from Microsoft. In July it shipped TypeScript 7, a native rewrite of the TypeScript compiler that’s often about 10 times faster. It’s written in Go, not Rust.
The reason is practical. The team wanted a faithful port of the existing code, not a redesign, and that code leans on a garbage collector and on data structures that point at each other in loops. Rust makes both painful. Go handles them the way the original did.
That’s a fair call, and it shows where the line sits. Rust shines when safety is the point and the code is new. When you need to move a huge working codebase fast, a language that matches its shape can win.
What This Means for You
If you just use your computer, mostly nothing. Rust rewrites are meant to be invisible, and the good ones are.
- On Ubuntu 26.04, if an old script suddenly behaves oddly, the Rust tools are a suspect. Canonical keeps the GNU versions available as a fallback.
- If you’re a developer, Rust is worth learning for systems work, command-line tools, and anything performance-heavy. For a typical web backend, your current language is probably fine.
- If you run a team, the Android data argues for writing new, risky components in Rust, not for rewriting stable code that isn’t causing trouble.
Pro Tip: On Ubuntu 26.04, run
sudo --versionin a terminal. If the first line sayssudo-rs, you’ve been running Rust every time you typed your password.
Is the Hype Earned?
Mostly, yes. Rust removes one of the oldest and most expensive kinds of security bug, and Google’s numbers say it makes teams faster, not slower. That combination is rare, and it’s why projects that resist every trend are switching to Rust anyway.
It isn’t magic. It won’t catch a bad assumption, a rewrite still needs years of hardening, and sometimes another language fits the job better. But for new code that handles data from strangers, choosing C in 2026 is getting harder to defend.
Frequently Asked Questions
Is Rust faster than C++?
They’re roughly even. Both compile to native machine code with no garbage collector, so speed depends more on how the code is written than on the language.
Will Rust replace C and C++?
Not any time soon. Huge amounts of C and C++ still run the world, and most projects add Rust to new, high-risk code while leaving stable code alone.
Should I learn Rust in 2026?
If you work on systems software, developer tools, or anything where speed and security both matter, yes. Expect a slower start than with most languages, because the compiler is strict.
