The Origins of Rust: A Side Project That Rewired Systems Programming

Fractional CTO · Founder of Injuria.ai
For about forty years, if you needed software that was fast and close to the hardware, you wrote it in C or C++. You also accepted a tax: whole categories of bugs around memory, the kind that cause crashes and security holes, were yours to catch by hand, and humans are bad at catching them. Rust is the first language in a long time to argue that you can have the speed without the tax, and to make the argument convincing enough that Amazon, Microsoft, Google, and the Linux kernel all signed on.
A personal project with an odd name
Rust started around 2006 as a side project by Graydon Hoare, then an engineer at Mozilla. The story he has told is that the name came from rust fungi, a group of plant pathogens he describes as remarkably over-engineered for survival. He has also noted that rust is a fitting name for a systems language because it evokes bare metal and what happens to bare metal over time. Either way, it was a personal experiment, not a corporate initiative.
Mozilla began officially sponsoring the work in 2009, and the project went public in 2010. Mozilla's interest was practical. Browsers are enormous C++ programs, and C++ memory bugs are a steady source of the security vulnerabilities that make browsers dangerous. A language that kept the performance but removed the most common bug classes would be worth a great deal to a company whose main product was a browser.
The language that got smaller before it got stable
Early Rust looked quite different from the language people use now. It had a garbage collector, lightweight green threads, a feature called typestate, and other ideas that were later cut. The years before the first stable release were spent removing things as much as adding them. The team kept narrowing in on a single powerful idea and letting the rest go.
That idea is ownership. In Rust, every value has exactly one owner, and the compiler tracks how long each value lives and who may read or write it at any moment.[1] You can lend out references, but the rules about borrowing are checked at compile time by a component called the borrow checker. If your code could lead to a dangling pointer, a double free, or two threads writing the same data at once, the program does not compile. There is no garbage collector doing this at runtime, so you pay no runtime cost for the safety. You pay an upfront cost instead, and it has a specific name most introductions skip: lifetimes. A lifetime is the compiler's model of how long a reference stays valid, and sometimes you have to annotate it by hand. Learning to satisfy the borrow checker, and to think in lifetimes, is the famous hard part of Rust, and anyone who tells you otherwise has forgotten their first month with it.
Honest about the escape hatch
It would be a lie to say Rust catches every memory bug, and the language does not claim to. It provides a keyword, unsafe, that lets you step outside the borrow checker's guarantees for the things that genuinely need it: talking to C libraries, touching hardware directly, or building the low-level data structures that safe Rust is then built on top of.[2][8][9] The deal is not that unsafe code is forbidden, it is that unsafe code is rare, clearly marked, and small enough to audit, instead of the entire program being unsafe the way all of C is. That honesty is part of why serious systems people took Rust seriously. It is not magic. It is a well-drawn boundary.
The parts people actually fall in love with
Memory safety is the headline, but it is rarely what makes someone love the language. That is usually the type system, which borrows heavily from the ML and Haskell tradition. Rust has traits, its take on interfaces, which let you describe shared behavior without inheritance. It has enums that carry data and a match expression that forces you to handle every case, so whole classes of "I forgot that could happen" bugs simply do not compile. Combined with ownership, these give Rust what the team called fearless concurrency: the same rules that prevent memory corruption also prevent data races, so you can write multithreaded code without the usual dread.[4][10]
Servo, Cargo, and a credibility nobody could buy
Mozilla did not just fund a language. It funded Servo, an experimental browser engine written in Rust, to prove the language could handle one of the most demanding workloads in software.[6] Parts of Servo later shipped in Firefox through a project called Quantum, putting Rust in front of hundreds of millions of users.
Rust reached its 1.0 release on May 15, 2015, with a strong promise: code that compiles on a stable release should keep compiling on future stable releases.[3] Backing that promise is a piece of infrastructure worth admiring. Before a release, the team runs a tool called Crater that compiles essentially every public package on crates.io against the new compiler to catch regressions before they ship. The day-to-day experience was unusually good too. Cargo, the build tool and package manager, handled dependencies, builds, tests, and publishing with a consistency that startled people coming from C and C++, and the compiler's error messages were written to teach. Rust also introduced editions to let the language evolve without breaking old code. The mechanism arrived in 2018 and retroactively named the 1.0 era the 2015 edition, followed by the 2018, 2021, and 2024 editions, each an opt-in set of changes that interoperate so the ecosystem never has to split.[11][8]
From Mozilla to a foundation
The institutional story took a sharp turn in 2020, when Mozilla laid off staff, including people who worked on Servo and Rust. Rather than leave the language dependent on a single struggling sponsor, the community and industry created the Rust Foundation in 2021, backed by Amazon Web Services, Microsoft, Google, Huawei, and Mozilla.[7] Rust stopped being a Mozilla project and became independent infrastructure with broad corporate support, which is a far healthier place for a critical language to sit.
Why a systems language belongs on a web blog
Rust quietly became part of the web's foundation in three ways. The first is WebAssembly. Rust is one of the best languages for producing it, and the tools that make that practical, wasm-bindgen and web-sys, are what let Rust compiled to WebAssembly talk to JavaScript and the DOM directly, so you can run heavy work like image processing, parsers, and cryptography in the browser.[1][9] The second is tooling: a new generation of web build tools, Turbopack, the swc compiler, and Biome among them, are written in Rust because startup and build speed matter at scale, and front-end developers use them daily without thinking about the language underneath. The third is the back end, where frameworks like Actix and Axum serve fast, safe web services and the Deno runtime is itself built in Rust.
The conservative codebase that said yes
Rust now runs in Firefox, in Amazon's Firecracker virtualization behind much of serverless, in parts of Windows, at Cloudflare and Discord and Dropbox, and inside the Linux kernel, which began accepting Rust in its 6.1 release in December 2022 after decades of being C only.[5] That last one is the signal that matters most. The Linux kernel is the most scrutinized, most conservative codebase in the world, and its maintainers are not sentimental about tools. When they decided a second language was worth the disruption, they were not endorsing Rust's syntax or its fan base. They were conceding the actual argument: that the memory-safety tax C charges is no longer one a serious project should pay by hand when a compiler can collect it for free. You do not have to write Rust to benefit from that verdict. A growing share of the software you rely on already runs on it, and it is there precisely because, for the first time in forty years, speed and safety stopped being a trade.
Sources (11)
- The Rust Programming Language (the official book)
- The Rust Reference
- Announcing Rust 1.0 (official Rust blog, 2015)
- Rust blog: "Fearless Concurrency with Rust"
- Rust for Linux (Linux kernel documentation)
- The Servo browser engine
- The Rust Foundation
- Steve Klabnik, Carol Nichols, Chris Krycho, The Rust Programming Language, 3rd Edition (NO STARCH PRESS, INC, 2026)
- Shing Lyu, Practical Rust Projects (Apress, 2020)
- Brian L. Troutwine, Hands-On Concurrency with Rust (Packt Publishing Ltd, 2018)
- Steve Klabnik, Carol Nichols, The Rust Programming Language (Covers Rust 2018) (No Starch Press, 2019)