I wrote C++ for eleven years before I touched Rust. The first two weeks were miserable. The borrow checker rejected everything I tried. Code that would’ve compiled fine in C++ just wouldn’t build. I wanted to throw my laptop out a window roughly once per hour. Then something clicked around week three, and I realized the compiler wasn’t fighting me — it was catching bugs that C++ would’ve let me ship to production. I haven’t started a new C++ project since.
But that disagreement isn’t really what I want to talk about. What’s more interesting is how we got here — how a side project from one Mozilla engineer turned into a language that the Linux kernel maintainers, Amazon, Microsoft, Google, and Discord all bet real money on. That story plays out over about twenty years, and tracing it helps explain why Rust keeps gaining ground even though C++ isn’t standing still.
2006-2009: One Person, One Problem
Graydon Hoare started Rust in 2006. Personal project. He was frustrated with the kinds of bugs that kept showing up in systems code — dangling pointers, data races, use-after-free errors. The usual suspects. Mozilla noticed what he was doing around 2009 and started funding it, probably because Firefox’s C++ codebase was a constant source of exactly those bugs. Memory corruption in a web browser isn’t an academic concern. It’s a security hole that millions of people are exposed to.
At that point, Rust didn’t look like much. Experimental syntax. Tiny community. No ecosystem to speak of. Most people in the broader programming world hadn’t heard of it, and those who had were skeptical. Fair enough. New languages show up constantly, and most of them fade away. There wasn’t an obvious reason to think this one would be different.
2010-2014: Servo and the Proving Ground
Mozilla did something smart. Instead of just sponsoring a language and hoping developers would show up, they built a major project in it. Servo was a new web rendering engine written from scratch in Rust, and it served as both a test and a showcase. Could Rust handle the complexity of parsing HTML, laying out CSS, compositing layers, and doing all of it across multiple threads without the data races that plagued every other browser engine?
Turns out, it could. Servo demonstrated that Rust’s ownership model — where every value has exactly one owner, and borrowing is tracked by the compiler — wasn’t just a theoretical nicety. It caught real concurrency bugs during compilation that would’ve been nightmares to debug in C++. And the performance was competitive. Not “good for a safe language” competitive. Actually competitive with C++ implementations that had years of optimization behind them.
During this period, the language itself changed a lot. Features got added, removed, redesigned. The community was small but opinionated (in a productive way, mostly). Lifetimes, traits, pattern matching, the borrow checker — all of these took shape through real-world feedback from the Servo project and early adopters who were willing to put up with a moving target.
2015: Version 1.0 and a Stability Promise
Rust 1.0 shipped on May 15, 2015. Big deal. Not because the language was finished — languages are never finished — but because it came with a stability guarantee. Code written for Rust 1.0 would compile on every future version. For a language trying to attract production users, that promise matters more than any individual feature. Nobody’s going to rewrite critical infrastructure in something that might break their code with the next release.
The reception was cautious. Some C++ developers dismissed it. Others were curious. Stack Overflow’s developer survey that year showed Rust as the most loved language — a ranking it would hold for years afterward. “Most loved” doesn’t mean “most used,” though. Adoption was still tiny compared to C++, Java, Python, or really any mainstream language. But the people who tried it kept coming back, and they were vocal about why.
2016-2018: Real Companies, Real Code
Dropbox made one of the early high-profile moves. They rewrote parts of their file synchronization engine in Rust, replacing Python code that couldn’t handle the performance demands of syncing billions of files across hundreds of millions of user accounts. Their engineers talked publicly about the experience — how Rust’s type system caught bugs during development that would’ve become production incidents in their previous stack. Not minor bugs, either. The kind that corrupt user data or cause silent failures.
Around the same time, smaller companies and open-source projects started picking Rust for new work. Networking tools, command-line utilities, embedded systems experiments. Nothing earth-shattering individually, but collectively they built out an ecosystem. Crates.io (Rust’s package registry) grew from a few thousand packages to tens of thousands. Libraries for async I/O, serialization, HTTP, cryptography — the gaps were filling in.
Cargo deserves a mention here because it’s probably one of Rust’s biggest practical advantages over C++. One build system. One package manager. Works the same on Linux, macOS, and Windows. Adding a dependency is a single line in a TOML file. Compare that to the C++ world where you might be dealing with CMake, Conan, vcpkg, Bazel, Make, or some custom horror show, and the difference in developer experience is hard to overstate. I think this alone convinced a lot of people to give Rust a serious look.
2019-2020: Discord, Performance, and Garbage Collection
Discord’s engineering team published a blog post in early 2020 about rewriting a service from Go to Rust. It got a lot of attention. Their problem was specific: Go’s garbage collector caused latency spikes during collection pauses, and for a real-time communication platform serving millions of concurrent users, those spikes were unacceptable. Rust doesn’t have a garbage collector. Memory gets freed deterministically when owners go out of scope. No pauses. No surprises.
The Rust version was faster. More predictable. And the type system caught concurrency bugs during development — bugs that would’ve been extremely difficult to reproduce and fix in production. Discord didn’t stop there. They used Rust for their read states service, message indexing, and other performance-sensitive components. Each time, the story was roughly the same: better performance, fewer bugs, more confidence when refactoring.
From what I’ve seen, Discord’s posts might have done more to legitimize Rust in the industry than any other single thing. Not because Discord is the biggest company using it, but because they showed concrete numbers. Before-and-after latency graphs. Throughput comparisons. Memory usage. Engineers at other companies could look at those posts and make a business case to their managers.
2020-2021: The Big Players Show Up
Amazon Web Services built Firecracker in Rust — the lightweight microVM technology that powers Lambda and Fargate. When AWS builds core infrastructure in your language, people pay attention. Microsoft started exploring Rust for Windows components after acknowledging that about 70% of their security vulnerabilities came from memory safety issues. That’s not a small number. It’s not an edge case. Seven out of ten security bugs in one of the world’s largest software products could’ve been prevented by the kind of compile-time checks Rust provides.
Google adopted Rust for parts of Android and Chrome OS. Cloudflare built significant portions of their edge computing platform in it. The Rust Foundation was established in February 2021, with backing from AWS, Google, Huawei, Microsoft, and Mozilla. Having a foundation with corporate sponsors doesn’t make a language good, but it does signal long-term commitment and funding stability. It means the language probably won’t disappear because one company changes priorities.
By this point, the “Rust is too immature” argument was getting harder to sustain. Crates.io hosted over 70,000 packages. Tokio (the async runtime) was battle-tested across major production deployments. Serde (serialization) had become one of those libraries that people just assumed would be available. Actix and later Axum offered web frameworks that could compete with Go and Java on throughput benchmarks.
Late 2022: Rust Enters the Linux Kernel
Linux 6.1 merged initial Rust support. Hard to overstate what this means. The Linux kernel is maybe the single most important piece of software running today — phones, servers, embedded devices, supercomputers, cars, refrigerators. Linus Torvalds is not someone who adopts new things because they’re trendy. The kernel community spent years debating whether to allow a second language alongside C, and they decided yes.
Kernel developers can now write modules in Rust. The safety guarantees don’t disappear at the kernel level — if anything, they matter more there, where a memory bug can crash an entire system or create a privilege escalation vulnerability. Early kernel Rust code focused on driver development, where bugs are common and the consequences are severe. It seems like this is the area where Rust will probably have the most immediate impact in the kernel.
What Rust Actually Does Differently
Ownership. That’s the core of it. Every value in Rust has one owner. When the owner goes out of scope, the value is dropped. No garbage collector. No reference counting (unless you deliberately opt into it). The compiler enforces this at compile time, so there’s zero runtime cost for these safety checks. Your binary runs as fast as an equivalent C++ binary. Sometimes faster, because the compiler can make optimizations that aren’t safe without ownership guarantees.
Borrowing extends this. You can lend a reference to a value — either one mutable reference, or any number of immutable references, but never both at the same time. Sounds restrictive. It is. But those restrictions mean data races can’t happen. Not “probably won’t happen” or “our static analyzer didn’t find any.” Can’t happen. The code won’t compile if there’s a possibility of one.
Error handling works through Result and Option types instead of exceptions. A function that might fail returns a Result. A value that might be absent is an Option. You have to handle both cases — the compiler won’t let you ignore them. C++ exceptions have well-known problems: unclear control flow, performance overhead in some implementations, and the constant question of which functions can throw and which can’t. Rust sidesteps all of that.
Pattern matching, algebraic data types, traits instead of inheritance, zero-cost abstractions — there’s a lot going on under the hood. But ownership and the borrow checker are what set Rust apart from everything else. Other languages have good type systems. Other languages have pattern matching. Only Rust prevents memory bugs and data races at compile time without a garbage collector.
Where C++ Still Holds Ground
Ecosystem size. If you need a library for some obscure signal processing algorithm or a specific hardware interface, a C++ implementation probably exists. A Rust one might not. Interop with C is trivial in C++ and requires more ceremony in Rust (though tools like cxx and bindgen help). And if you’re sitting on ten million lines of C++, nobody’s suggesting you rewrite it all. That would take years and cost a fortune.
Compile times are a legitimate gripe. Rust compiles slower than C++ for comparable projects. The borrow checker, monomorphization of generics, and LLVM-based code generation all add time. Incremental compilation helps for day-to-day work, but clean builds of large projects can be painfully slow. The compiler team is working on it — each release tends to be a bit faster — but it’s not solved yet.
Embedded systems and real-time programming still lean heavily toward C and C++. Rust’s embedded ecosystem has grown (Embassy is an impressive async embedded framework), but the tooling, hardware support libraries, and institutional knowledge around embedded C and C++ are deeper. Could be wrong, but I’d guess it’ll take another three to five years before Rust is a default choice for most embedded work.
2023-2025: The Government Gets Involved
Something shifted in the policy world. The White House Office of the National Cyber Director released a report urging software developers to adopt memory-safe languages. CISA published similar guidance. These reports specifically named C and C++ as sources of preventable vulnerabilities and pointed to Rust as an alternative. Government reports don’t force anyone to do anything, but they influence procurement decisions, compliance requirements, and corporate risk assessments.
This matters because it changed the conversation from “Rust is cool” to “memory safety is a national security concern, and Rust addresses it.” Defense contractors, financial institutions, healthcare companies — organizations in regulated industries started paying attention. Not all of them are writing Rust yet, but more of them are evaluating it, and some have started pilot projects.
Meanwhile, the ecosystem kept growing. Crates.io passed 130,000 packages. Async Rust got smoother with each release. IDE support through rust-analyzer reached a level where it could compete with what Java and TypeScript developers are used to. Clippy (the linter) catches hundreds of common mistakes and suggests more idiomatic code. Rustfmt enforces consistent formatting across the entire ecosystem, so you don’t waste time arguing about brace placement.
The Learning Curve
It’s real. Won’t pretend otherwise. The borrow checker will reject code that looks perfectly fine to a C++ programmer, and the error messages — while genuinely good, often suggesting exact fixes — still require understanding concepts that don’t exist in most other languages. Lifetimes in particular trip people up. Trait bounds can get complex. Generic code sometimes produces error messages that take a minute to parse.
Most developers I’ve talked to say the frustration peaks around week two or three, then drops off sharply. Something clicks. You start thinking about data ownership before you write code, not after the compiler yells at you. Your designs get cleaner because Rust forces you to be explicit about who owns what and how long references live. After maybe a month or two, productivity is comparable to C++. Probably better, since you’re not spending time debugging memory corruption.
“The Rust Programming Language” (known as “the book”) is available free online and covers everything from basics to advanced topics. Rustlings provides interactive exercises. The community is, by most accounts, welcoming to newcomers — though it can be enthusiastic to the point of being mildly annoying about how great Rust is. (They’re not wrong. They’re just… a lot sometimes.)
Career and Hiring
Rust positions pay well. Supply of experienced Rust developers is still smaller than demand. Companies that post Rust jobs report getting higher-quality applicants on average, which might be selection bias — the kind of developer who learns Rust tends to care about correctness and is comfortable with complexity. If you’re a C++ developer thinking about your next move, Rust experience on a resume opens doors that didn’t exist five years ago.
Not sure this trend holds forever. As more developers learn Rust, the supply gap will close. But right now, and probably for the next few years, Rust skills carry a premium.
If You’re Thinking About Switching
Start small. A command-line tool. A data processing script. Something self-contained where you can fight the borrow checker without production pressure. Don’t try to write C++ in Rust — the idioms are different, the patterns are different, and forcing C++ habits into Rust’s ownership model produces ugly, frustrating code.
Read the compiler errors. All of them. They’re written to teach, not just reject. When the borrow checker complains, resist cloning everything until compilation succeeds. Take a moment to understand what it’s telling you. Nine times out of ten, there’s a better design hiding behind the error.
And you don’t have to abandon C++. Plenty of teams use both. Write new performance-critical components in Rust. Maintain existing C++ code. Bridge them with FFI where needed. Gradual adoption works fine and is probably the realistic path for most organizations sitting on large C++ codebases.
Where Things Stand Now
Rust’s package registry has over 130,000 crates. The Linux kernel accepts Rust code. AWS, Microsoft, Google, Cloudflare, Discord, and Dropbox all run Rust in production. Government agencies recommend memory-safe languages. The async story is mature. Tooling is strong. The community is large and active. Compile times are still slow, the embedded ecosystem still has gaps, and the learning curve still humbles experienced programmers for a few weeks.
None of that reads like hype to me. It reads like a language that solved a specific, important problem — memory safety without garbage collection — and then spent fifteen years proving it works in practice. C++ isn’t going away. Too much existing code, too much institutional knowledge, too many domains where it’s deeply entrenched. But for new systems programming projects where safety and correctness matter, Rust is the default choice for a growing number of teams. And that number goes up every quarter.
(0) Comments