The history of the Rust language

Rust began as a 2006 hobby: Graydon Hoare, a Mozilla engineer, was irritated by his building's elevator failing because of C software. The name came from the fungus — “overengineered for survival.” Mozilla sponsored it in 2009. Public version 0.1 came out on 20 January 2012. 1.0, on 15 May 2015. On 3 September 2026 the stable release is 1.98.1. No garbage collector. No data races. Linux kernel 6.1 (December 2022) accepted the second language in the project's history: Rust, alongside C.

2006: the elevator and OCaml

Hoare was 29 and worked at Mozilla. His apartment elevator kept failing; he attributed it to memory bugs in the controller. The thesis: C++ performance without undefined behavior is possible. Between 2006 and 2009 the project occupied his spare time. The first compiler had around 38 thousand lines of OCaml. It had things that later disappeared: explicit OOP with obj, typestate analysis, a garbage collector.

The influences, in his words, were “technology from the past to save the future from itself”: CLU, Erlang, Newsqueak, Limbo, Mesa, Sather, Alef. Manish Goregaokar summed it up: decades of research, not a fad.

The name rust refers to fungal rust, not rust on metal. Hostile surface, stubborn organism.

The central idea: ownership and the borrow checker

Before continuing the chronology, it is worth understanding what Rust actually invented — because it is not syntax, but an accounting rule the compiler enforces.

In C you allocate and free manually, and make mistakes: use-after-free, double-free, buffer overflows. In Java or Go, a garbage collector solves this in exchange for pauses and extra memory. Rust chose a third door: neither. Each value has a single owner; when the owner leaves scope, memory is freed — at compile time, with no runtime at all.

fn main() {
    let s1 = String::from("olá");
    let s2 = s1;              // a posse MOVE de s1 para s2
    println!("{s1}");          // erro de compilação: s1 não é mais dono
}

To use it without transferring ownership, you borrow — and here comes the rule that gives the borrow checkerits name: you can have either multiple read-only borrows, or a single writable borrow, never both at once.

let mut v = vec![1, 2, 3];
let primeiro = &v[0];      // empréstimo de leitura
v.push(4);                  // erro: precisaria de empréstimo de escrita
println!("{primeiro}");

It seems nitpicky — and this is exactly where people coming from C++ give up in the first week. But that same rule, applied across threads, is what eliminates data races at compile time. It is not convention, best practice, or code review: the program will not compile. That is why the kernel became interested.

2009–2012: the nerd cave

In 2009 Mozilla made it official. Brendan Eich (then CTO) and Research saw a safe browser engine. Patrick Walton, Niko Matsakis, Felix Klock, and Goregaokar joined. The room became the “nerd cave,” with a sign on the door — Dave Herman's nickname. Ownership was already in the design around 2010. The logo, in 2011, came from a bicycle chainring (chainring): the R inside the gear.

The compiler became self-hosting, targeting LLVM. On 20 January 2012 0.1 came out for Linux, Windows, and macOS — the first public release. Bootstrapping in 2011 took hours.

Up to 1.0: GC disappears, Graydon leaves

From 2012 to 2015 the type system became today's Rust. GC, rare in 2013, was removed. Typestate disappeared, along with pure, special pointers, and channel syntax. Those coming from C++ pushed performance; those from scripting, Cargo; those from ML, types.

In 2013 Hoare stepped away from day-to-day work. Governance became federated: a core team of six, later nine, RFCs starting in March 2014. Andrew Binstock in Dr. Dobb's (jan/2014): an elegant language, slow adoption because it changed every nightly.

On 15 May 2015, 1.0 arrived. A compatibility commitment. Steve Klabnik wrote dozens of documentation pages in the final stretch. A year later: 1.400 compiler contributors, 5 thousand crates. cargo was already the official manager (2014).

Servo, Firefox, the trial by fire

Mozilla and Samsung funded Servo (from 2012 onward): a browser engine in Rust, a laboratory for the language. Firefox 45 (2016) already shipped Rust code. Servo components arrived in 57 (September 2017), the Quantum project. Without the browser, 1.0 would have been a different language.

Early adopters outside Mozilla: Samsung, Facebook, Dropbox, Tilde (Ember). AWS in 2020. The repeated argument: performance, no GC, no data races, a compiler experience that pushes safe code.

Editions: 2018, 2021, 2024

Rust does not break old crates on a new compiler. A crate declares its edition in Cargo.toml and coexists with the current toolchain.

• 2015 — 1.0.
• 2018 (1.31) — modules, ? with better ergonomics, non-lexical lifetimes.
• 2021 (1.56, out/2021) — disjoint capture in closures, prelude resolver.
• 2024 — with 1.85.0, on 20 February 2025.

async/await stabilized in 1.39 (7 November 2019). Without it, web-server Rust would not exist as it does.

2020: Mozilla cuts back, the Foundation is born

In August 2020 Mozilla laid off 250 people — around a quarter of its staff. The Servo team dissolved. The core team announced an independent foundation for trademarks and domains. On 8 February 2021 the Rust Foundationwas born: AWS, Google, Huawei, Microsoft, Mozilla. Meta and ARM joined the same year. In April 2021 Google announced Rust in the Android Open Source Project.

In June 2026 OpenAI joined the Foundation. Trademarks and trademark policy caused a dispute in 2023 (the draft was poorly received). Federated governance is not eternal peace — in November 2021 the moderation team resigned in protest. The language survived both.

The kernel: from the 2022 experiment to the 2025 verdict

Linus pulled Rust infrastructure into the 6.1 merge (Phoronix, 3 October 2022; stable on 11 December). Around 12 thousand lines: build, minimal crates, a module “hello world.” The kernel's second language after C — but explicitly introduced as an experiment: if it did not work out, it would be removed.

In December 2025, at the Maintainers Summit, the session led by Miguel Ojeda declared the experiment a success, and Rust became a core kernel language alongside C and assembly. The figures supporting the decision:

• The Nova driver, for NVIDIA GPUs, with parts already in mainline; Tyr for Mali and the Asahi driver for Apple Silicon on the same path.
• Android's binder rewritten in Rust, integrated in 6.18.
• ashmem in Rust running on Android 16 on kernel 6.12 — millions of real devices with Rust code in the kernel.
• Debian enabled Rust in kernel builds, appearing starting with “forky”.
• The amount of Rust code in the kernel quintupled in one year.

Two compiler fronts also advanced: rustc_codegen_gcc, which grafts GCC's code generator onto rustc, and gccrs, GCC's own Rust compiler — which can already compile the kernel's Rust code. This matters because it frees the kernel from dependence on a single compiler, a long-standing community requirement.

The version policy became pragmatic: the kernel commits to building with the Rust version in Debian stable, raising the minimum 6 to 12 months after each Debian release. For this blog, the message is the same as always: C in the kernel is no longer dogma.

Where Rust already is in your distro

The part that surprises those who have not followed along: Rust stopped being a “language for new projects” and entered the critical path of the system you use.

• Ubuntu 25.10 started shipping sudo through sudo-rs, the Rust reimplementation — with the original sudo still available as an alternative in update-alternatives.
• Ubuntu 26.04 LTS is the first LTS to ship the basic utilities from uutils/coreutils in Rust instead of GNU's: ls, cp, mv and dozens more. Canonical's strategy was the right one — test in interim releases before promoting to LTS.
• In the kernel, the Rust drivers mentioned above; on Android, binder and ashmem.

There is no consensus: part of the community sees replacing GNU coreutils with a permissively licensed reimplementation as a political decision, not a technical one. The other side's argument is direct — ls and cp have processed untrusted input in C for fifty years.

Installing on Linux

The stable series on 3 September 2026 is 1.98.1. The official approach is rustup, not the distro's outdated apt — Rust releases every six weeks and the distro package ages quickly:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
rustc --version
cargo new ola && cd ola && cargo run

rustup manages toolchains side by side — stable, beta, and nightly — and lets you switch channels without breaking anything:

rustup update
rustup toolchain install nightly
cargo +nightly build
rustup component add clippy rustfmt   # linter e formatador oficiais

The other side

A history post that only praises is useless for making decisions. The drawbacks:

• A real learning curve. The borrow checker does not negotiate. The first weeks involve fighting the compiler, and the complaint is legitimate — it only passes once the ownership mental model clicks.
• Compilation time. Large projects with many dependencies compile slowly, and a clean build is painful. It has improved considerably, but remains annoying.
• The async ecosystem is complex. async/await stabilized, but the runtime is not in the standard library: you choose Tokio or async-std and live with the consequences.
• “Rewrite it in Rust” became a meme for a reason. Not every piece of software needs that guarantee; much of what gets rewritten had no relevant memory bug to begin with.
• Governance has friction. In November 2021 the moderation team resigned together; in 2023 the draft trademark policy was rejected by the community. The language survived both, but it is not the serene project the publicity suggests.

That said: dual MIT / Apache-2.0, no single owner, with a foundation. Ferris, the crab, is the community mascot — not the logo. The logo is the bicycle chainring.

Timeline

• 2006 — Graydon Hoare starts the project in his spare time, in OCaml, after an elevator kept failing because of a memory bug.
• 2009 — Mozilla formalizes sponsorship; the “nerd cave” is born.
• 2010 — the ownership model is already in the design.
• 2011 — the compiler becomes self-hosting, targeting LLVM; the bicycle chainring logo appears.
• 20 January 2012 — 0.1, the first public release.
• 2012 — work begins on Servo, a Rust browser engine funded by Mozilla and Samsung.
• 2013 — the garbage collector is removed; Hoare leaves day-to-day work; governance becomes federated.
• March 2014 — the RFC process begins.
• 15 May 2015 — a 1.0, with a compatibility commitment.
• 2016 — Firefox 45 already ships Rust code.
• September 2017 — Firefox 57 (the Quantum project) takes Servo components into production.
• 2018 — 2018 edition, in 1.31: modules, ? with better ergonomics, non-lexical lifetimes.
• 7 November 2019 — async/await stabilizes in 1.39.
• August 2020 — Mozilla lays off 250 people; the Servo team dissolves.
• 8 February 2021 — the birth of the Rust Foundation, with AWS, Google, Huawei, Microsoft, and Mozilla.
• April 2021 — Google announces Rust in the Android Open Source Project.
• October 2021 — 2021 edition, in 1.56.
• 11 December 2022 — Linux kernel 6.1 accepts Rust infrastructure as an experiment.
• 20 February 2025 — 2024 edition, in 1.85.0.
• May 2025 — ten years of stable Rust.
• October 2025 — Ubuntu 25.10 ships sudo through sudo-rs.
• December 2025 — the Maintainers Summit declares the kernel experiment a success; Rust becomes a core language alongside C.
• June 2026 — OpenAI joins the Rust Foundation.
• 2026 — Ubuntu 26.04 LTS brings Rust coreutils; the stable release is 1.98.1.

Where to go from here

This blog's map of languages: The 7 main programming languages. Its 2007 sibling at Google, with the opposite philosophy: The history of the Go language. The kernel that opened the door: Linux turns 35 and The history of Linus Torvalds. Toolchain on Linux: Go and Swift.

Wrap-up

An elevator, OCaml, a nerd cave, 1.0 in 2015, a kernel in 2022, 1.98.1 in 2026. Graydon described the ten-year anniversary (May 2025) as infrastructure he barely recognizes. The message has not changed: memory safety without GC, on bare metal, on Linux.

Site: rust-lang.org · 1.0: 15 May 2015 · 1.98.1: blog.rust-lang.org/releases · Foundation: rustfoundation.org · ten years, in Hoare's words: 10 Years of Stable Rust.