History & Evolution of Rust
Trace Rust's origin story from Graydon Hoare's personal project through Mozilla sponsorship, the 1.0 stability promise, editions, and the Rust Foundation.
Introduction
Rust didn't appear fully-formed — it went through years of experimentation and even removed major features before reaching a stable 1.0. Understanding that history explains a lot about how carefully Rust's stability guarantees are treated today.
This lesson walks through the timeline: Rust's beginnings as a side project, Mozilla's sponsorship, the significant redesigns before 1.0, the stability promise that shipped with it, the "editions" system that lets Rust evolve without breaking old code, and the Rust Foundation that stewards the language today.
A Personal Project (2006)
Rust began around 2006 as a personal side project of Graydon Hoare, a software engineer working at Mozilla. Hoare was frustrated by a familiar problem: languages like C and C++ gave excellent performance but left memory management entirely up to the programmer, which regularly produced crashes and security vulnerabilities in large codebases like Firefox.
The name "Rust" is often associated with rust fungi, which are notably robust — though Hoare has also noted it may simply be a reference to how "rust" is one of the more robust and resilient forms of iron oxide, playing on the idea of a robust, resilient language.
Mozilla Sponsorship & Public Announcement
Mozilla began officially sponsoring Rust's development in 2009, giving the project real engineering resources. Rust was announced publicly in 2010, and Mozilla began using it experimentally in Servo, an entirely new, parallel browser rendering engine designed to prove that a memory-safe, highly concurrent browser engine was possible.
Pre-1.0: A Language That Changed Shape
Early Rust looked quite different from the language you'll learn in this course. Pre-1.0 Rust included a built-in garbage collector, "green threads" (lightweight, runtime-managed threads similar to goroutines), and a more complex type system with typestates. Through the early 2010s, the Rust team progressively removed these features, converging instead on the ownership and borrowing model — compile-time memory safety with zero runtime cost — that became Rust's defining feature.
Rust 1.0 and the Stability Promise (2015)
Rust 1.0 was released on May 15, 2015, marking the language's first stable version. Alongside it came a strong backward-compatibility commitment: code that compiles on stable Rust 1.0 is guaranteed to keep compiling on every future stable Rust release.
Before 1.0, Rust changed frequently in backward-incompatible ways as the language found its final shape, which discouraged serious production use. The stability promise gave companies the confidence to build production systems on Rust, knowing an upgrade to a newer compiler would not silently break their code.
Editions: 2015, 2018, 2021, 2024
To keep evolving without breaking the stability promise, Rust introduced "editions" — opt-in bundles of new syntax and defaults that a crate can adopt by declaring `edition = "2021"` in its `Cargo.toml`. Crates on different editions can still be compiled together and linked into the same program, so nothing in the ecosystem is left behind.
| Year | Milestone |
|---|---|
| 2006 | Graydon Hoare begins Rust as a personal project. |
| 2009 | Mozilla begins officially sponsoring development. |
| 2010 | Rust is announced publicly. |
| 2015 | Rust 1.0 ships in May, with the stability promise and the 2015 edition. |
| 2018 | The 2018 edition ships with a simplified module system and non-lexical lifetimes. |
| 2021 | The 2021 edition ships; the independent Rust Foundation is founded in February. |
| 2024 | The 2024 edition ships with further ergonomic refinements. |
The Rust Foundation (2021)
In February 2021, stewardship of the Rust project moved from an informal Mozilla-led core team to the independent, non-profit Rust Foundation. Founding members included AWS, Google, Huawei, Microsoft, and Mozilla — a signal that Rust had grown from a single company's experiment into shared, industry-wide infrastructure.
Rust Today
Rust has topped Stack Overflow's "most loved programming language" survey for multiple years running. Adoption has expanded well beyond browsers into cloud infrastructure (AWS, Cloudflare), the Linux kernel (which began accepting Rust code for drivers starting with Linux 6.1 in December 2022), and major companies including Microsoft, Google, and Meta, who use it for performance- and safety-critical components.
Common Mistakes
- Assuming Rust is a brand-new, unproven language — it has been stable since 2015 and battle-tested in production at major companies for years.
- Confusing an "edition" with a language version — editions are opt-in syntax bundles within the same Rust compiler, not separate incompatible languages.
- Thinking Rust is a Mozilla-only project today — it is stewarded by the independent Rust Foundation with many corporate members.
- Assuming old Rust tutorials from before 2018 use current idiomatic syntax — always check whether an example predates the 2018 or 2021 edition.
Best Practices
- Always set `edition = "2021"` (or newer) in new `Cargo.toml` files to get the latest ergonomics and defaults.
- Prefer recent official documentation and "The Rust Book" over very old blog posts, since idiomatic style has evolved since 2015.
- Understand that stable Rust's backward-compatibility promise means code you write today will very likely still compile years from now.
- Follow the official Rust blog or release notes occasionally — new stable releases ship roughly every six weeks with small, genuinely useful additions.
Frequently Asked Questions
The team initially explored several memory-management strategies before settling on the compile-time ownership model; the GC and green threads were removed once ownership and borrowing proved sufficient on their own.
An opt-in set of new syntax and default behaviors a crate can adopt via its Cargo.toml, without breaking compatibility with crates on older editions.
Yes, Mozilla remains an active contributor and a founding member of the Rust Foundation, but the language is no longer solely Mozilla-governed.
Yes — starting with Linux 6.1 (released December 2022), the kernel officially accepts Rust code for writing certain drivers and modules alongside traditional C.
Key Takeaways
- Rust began as Graydon Hoare's personal project around 2006 and was sponsored by Mozilla starting in 2009.
- Pre-1.0 Rust removed major features like a garbage collector and green threads in favor of ownership and borrowing.
- Rust 1.0 shipped May 15, 2015, with a strong backward-compatibility promise still honored today.
- Editions (2015, 2018, 2021, 2024) let the language evolve ergonomically without breaking old code.
- The independent Rust Foundation, founded in 2021, now stewards the language with major industry backing.
Summary
You now know where Rust came from, how it changed shape before reaching 1.0, and how it continues to evolve safely today through editions and the Rust Foundation. Next, you'll get Rust and Cargo installed on your own machine and run your first project from the command line.