Rust

Rust is a general-purpose, statically typed, compiled programming language designed for systems programming. It emphasizes memory safety, performance, and concurrency, achieving memory safety without a garbage collector through a compile-time ownership and borrowing system. ^[1:1] Rust was created by Mozilla employee Graydon Hoare in 2006 as a personal project; Mozilla officially sponsored it in 2009, and the first stable release, Rust 1.0, was published on May 15, 2015. ^[2:1][3:1]

Rust has ranked as the most admired programming language in the Stack Overflow Developer Survey every year from 2016 through 2024. ^[4:1] It has seen significant adoption in systems software, web services, embedded development, and security-critical infrastructure, and has been endorsed by the U.S. White House as a preferred memory-safe language. ^[5:1]

History

Origins (2006–2011)

Graydon Hoare began Rust in 2006 while working at Mozilla, reportedly motivated by frustration with software crashes in everyday systems. According to MIT Technology Review, the immediate trigger was a broken elevator in his apartment building whose software had crashed. ^[3:1] He named the language after the rust fungi genus, which he described as "over-engineered for survival." ^[3:2]

During this early period, the compiler was written in OCaml, comprising approximately 36,986 lines across 38 source files. ^[6:1] Hoare described the language as drawing on "technology from the past come to save the future from itself." ^[3:3] The Rust documentation cites a wide range of influences, including SML, OCaml, Haskell, C++, Erlang, Newsqueak, and Swift, among others. ^[7:1] Mozilla officially sponsored the project in 2009, and engineers including Patrick Walton, Niko Matsakis, and Felix Klock joined the effort. The compiler transitioned from OCaml to a self-hosting compiler (written in Rust) targeting LLVM, and the ownership system was in place by 2010. ^[3:4]

Rust 0.1, the first public release, was published on January 20, 2012 for Windows, Linux, and macOS.

Stabilization (2012–2015)

The years 2012 to 2015 were marked by significant changes and simplification of the language. A garbage collector that had been present in early versions was removed by 2013, after which Rust programs ran faster with no periodic halts for memory cleanup. ^[3:5] Features including typestates and specialized pointer types were also removed to simplify the language design. A Request for Comments (RFC) process for new language features was introduced in March 2014.

Graydon Hoare stepped down from the project in 2013. Development continued under a federated governance structure. Rust 1.0 was released on May 15, 2015, the first stable release to promise backward compatibility. ^[2:2] By the following year, the Rust compiler had over 1,400 contributors and the package registry Crates.io hosted over 5,000 libraries. ^[8:1]

Servo, Firefox, and early adoption (2015–2020)

Mozilla developed the Servo browser engine in parallel with Rust, with the two teams collaborating closely. Firefox first shipped Rust code in 2016 (version 48), ^[9:1] and Servo components (including the Stylo CSS engine written in Rust) appeared in Firefox 57 ("Firefox Quantum") in November 2017.

Early corporate adoption came from Samsung, Meta (then Facebook), Dropbox, and Amazon Web Services (AWS). Engineers cited performance, the absence of a garbage collector, and memory safety as key reasons for adopting Rust. ^[3:6]

Mozilla layoffs and the Rust Foundation (2020–present)

In August 2020, Mozilla laid off approximately 250 of its roughly 1,000 employees due to financial pressures related to the COVID-19 pandemic, disbanding the Servo team. The layoffs raised concerns about Rust's future, given Mozilla's central role in the project. The Rust Core Team responded within weeks, announcing plans for an independent foundation.

On February 8, 2021, the Rust Foundation was established by five founding companies: Amazon Web Services, Google, Huawei, Microsoft, and Mozilla. ^[10:1] The foundation took ownership of Rust trademarks and domain names and provides financial support for Rust developers. ^[10:2]

In April 2021, Google announced support for Rust in the Android Open Source Project as an alternative to C and C++. ^[11:1] Rust support was merged into the Linux kernel mainline in version 6.1, released in December 2022. ^[12:1]

In February 2024, the U.S. White House Office of the National Cyber Director published a report urging the software industry to move away from C and C++ toward memory-safe languages, explicitly listing Rust among the recommended alternatives. ^[5:1]

Timeline

Design and key features

Ownership and the borrow checker

Rust's most distinctive design feature is its ownership system, which enforces memory safety at compile time without a garbage collector. Every value in Rust has exactly one owner. When the owner goes out of scope, the value is automatically dropped (freed). Values can be temporarily borrowed — lent to other parts of code via references — without transferring ownership.

The borrow checker, a component of the Rust compiler, tracks lifetimes of all references and rejects programs where a reference could outlive the data it points to (a "dangling pointer") or where mutable and immutable references to the same data coexist in a way that could cause data races. This eliminates entire categories of bugs — null pointer dereferences, use-after-free, double-free — that are common sources of security vulnerabilities in C and C++ programs.

Because safety is enforced at compile time rather than runtime, Rust programs pay no garbage-collection overhead and have predictable, low-latency performance characteristics.

Type system

Rust is statically and strongly typed, with type inference: types of variables are checked at compile time, but often need not be written explicitly. The type system includes:

• Algebraic data types (enums that can carry data in each variant) and structs for grouping data.
• Traits, Rust's mechanism for defining shared behavior, similar to interfaces or typeclasses in other languages. Generics are bounded by traits.
• Option<T> and Result<T, E> types for explicit handling of optional values and errors, eliminating null pointer exceptions by making the possibility of absence part of the type.
• Lifetimes, which are annotations that help the borrow checker verify that references remain valid.

Variables are immutable by default; the mut keyword must be used explicitly to allow mutation.

Performance

Rust compiles to native machine code via LLVM. With no runtime, no garbage collector, and stack allocation by default, Rust programs achieve performance comparable to C and C++. Research has shown Rust programs to be competitive with C in both speed and energy efficiency. ^[3:7]

Unsafe code

Certain low-level operations — raw pointer dereference, calling foreign functions, inline assembly — are not statically verifiable by the borrow checker. Rust allows these in explicitly delimited unsafe blocks, which signal to both the compiler and readers that the programmer is taking responsibility for memory safety in that region. This design contains rather than eliminates unsafe code, making it auditable and localized.

Toolchain

Rust ships with a unified toolchain:

• rustc — the compiler
• Cargo — the package manager and build tool, which also handles dependency resolution via Crates.io, the package registry
• rustfmt — an automatic code formatter
• Clippy — a linter with actionable suggestions
• rustup — a toolchain installer and version manager

Cargo's integration with Crates.io (which hosts hundreds of thousands of open-source packages called crates) has been widely credited with lowering the barrier to starting and sharing Rust projects.

Adoption

Rust has been adopted across a range of domains:

• Web services and infrastructure: Amazon, Microsoft, Cloudflare, Discord, and others use Rust in performance-sensitive backend services.
• Operating systems and kernels: Rust is supported in the Linux kernel (since version 6.1) ^[12:1] and is used in components of Windows and Android. ^[11:1]
• Browsers: Mozilla's Firefox has included Rust-written components since 2016.
• Embedded and WebAssembly: Rust's no_std mode allows targeting bare-metal devices with no operating system, and Rust is a first-class citizen for WebAssembly compilation. ^[1:2]
• Security-critical software: The language's memory-safety guarantees have made it attractive for cryptography, networking, and other security-sensitive code.

Rust has ranked as the most admired programming language in the Stack Overflow Developer Survey continuously from 2016 through 2024 — a streak longer than any other language in that survey's history. ^[4:2]

Governance

Rust is developed by the Rust project, a community-governed effort. Language changes go through a public RFC (Request for Comments) process before being accepted. A Rust Leadership Council coordinates across the project's teams.

The Rust Foundation, an independent nonprofit established in February 2021, holds Rust's trademarks, funds infrastructure, and provides grants to Rust maintainers and contributors. ^[10:2] Founding member companies include Amazon Web Services, Google, Huawei, Microsoft, and Mozilla. ^[10:1] The foundation has grown to include additional corporate members.

Governance disputes

In November 2021, the Rust Moderation Team resigned collectively, citing a lack of accountability of the Core Team to the broader community. ^[13:1][13:2] The resignation statement recommended that the community establish a process for oversight over the Core Team, noting it was "answerable only to themselves, which is a property unique to them in contrast to all other Rust teams." ^[13:3] The incident prompted governance reforms; in June 2023, RFC 3392 was merged, replacing the Core Team with the Leadership Council as the top-level governance body. ^[14:1][14:2]

A separate controversy arose around intellectual property in 2023. A draft trademark policy published by the Rust Foundation on April 6, 2023 drew widespread criticism from contributors and users for imposing restrictions perceived as inconsistent with open-source norms. ^[15:1] The Rust Project Directors acknowledged that the wider project had been insufficiently included in the drafting process and apologized. ^[15:1] The Foundation subsequently acknowledged the draft "clearly needs improvement" and committed to revising it. ^[16:1][16:2]

Memory safety and public policy

Rust has become a focal point in broader debates about software security and memory safety. A large share of vulnerabilities in widely used software — including those affecting operating systems, browsers, and network infrastructure — stem from memory safety bugs in C and C++ code.

In February 2024, the White House Office of the National Cyber Director explicitly recommended that the software industry migrate toward memory-safe languages, naming Rust alongside C#, Go, Java, Python, and Swift as preferred alternatives to C/C++. ^[5:2] Similar guidance has been issued by the U.S. National Security Agency (NSA) and the Cybersecurity and Infrastructure Security Agency (CISA).

Rust is the most prominent memory-safe systems language in this context, because it is the only widely adopted option that provides both manual memory control (no garbage collector) and compile-time memory safety guarantees — properties that make it a viable replacement in performance-sensitive code currently written in C or C++.