Rust

A systems language that frees memory without a garbage collector, because the compiler checks ownership and borrowing rules before the program runs.

What it is: Programming languages (compiled to machine code)
Type: Open source
Made by: Rust Project, supported by the Rust Foundation
License: MIT or Apache 2.0 (your choice)
Facts checked: 8 October 2026

What it is

Rust compiles to machine code, with no garbage collector and no heavy runtime, so its libraries can stand in for C. Memory safety comes from three ownership rules the compiler enforces: each value has one owner, there is only one owner at a time, and the value is dropped (freed) when its owner goes out of scope. Code can borrow a value through references instead of taking it, but at any moment there may be either one mutable reference or any number of immutable ones. The borrow checker applies these rules at compile time, with no cost at run time, and the same rules rule out data races between threads. Code that needs to break them, to call C or touch raw pointers, goes in an unsafe block, which unlocks exactly five extra operations and marks where to look when something goes wrong.

A new stable compiler ships every six weeks, and Rust 1.0 (May 2015) began a promise that stable code keeps compiling. Changes that would break old code, such as new keywords, go into editions instead: 2015, 2018, 2021 and 2024, the last stabilized with Rust 1.85 in February 2025. Each crate picks its edition in Cargo.toml, crates of different editions link together freely, and Cargo’s migration tooling rewrites most code automatically. Cargo, the bundled build tool and package manager, pulls dependencies from crates.io.

Why teams pick it

Memory safety and freedom from data races without a garbage collector, checked by the compiler rather than discovered in production
Low-level control with no garbage collector or runtime, so a Rust library can be a drop-in replacement for one written in C
Cargo, the bundled build tool and package manager, crates.io and rustfmt make dependencies and code style consistent across the ecosystem
Editions let the language change without splitting the ecosystem: old and new crates link together

Watch out for

Slow compilation tops the list of productivity complaints in the project’s own 2024 user survey
The borrow checker is deliberately conservative: it rejects some valid programs, so some designs need restructuring or unsafe to compile
Async Rust is a frequent source of struggle in survey answers, and users worry the language is growing too complex
unsafe blocks and C libraries reached through FFI are not checked by the compiler, so safety rests on reviewing them

Alternatives

What all compiled to machine code have in common →

COpen sourceThe small, portable systems language from Bell Labs that Unix, most operating systems and many databases are written in, with memory you allocate and free yourself.

C++Open sourceC with classes, templates and destructors: a language for writing abstractions that compile down to code as fast as hand-written C.

GoOpen sourceA small, statically typed language from Google that compiles in seconds to one static binary, with goroutines, channels and a garbage collector built in.

HaskellOpen sourceA purely functional, lazily evaluated language with type classes, compiled to native code by GHC.

RacketOpen sourceA descendant of Scheme built for language-oriented programming: every module names its language on a `#lang` line, and new languages are just libraries.

ZigOpen sourceA pre-1.0 systems language and toolchain with no hidden control flow or allocations, compile-time code in plain Zig, and a built-in C compiler that cross-compiles anywhere.

How it fits with other technologies

What Rust uses

What uses Rust

Borrowing a value, then moving it · rust

fn longest(words: &[String]) -> &str {
    // borrows the vector; returns a reference into it
    words.iter().max_by_key(|w| w.len()).map(|w| w.as_str()).unwrap_or("")
}

fn main() {
    let words = vec![String::from("stack"), String::from("ownership")];
    println!("{}", longest(&words)); // ownership

    let moved = words; // ownership moves to `moved`
    // println!("{}", words.len()); // compile error: value used after move
    println!("{} words", moved.len()); // 2 words
} // `moved` goes out of scope here and the memory is freed

See it in a real stack

No architecture uses Rust yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2006–2025

In 2006 Graydon Hoare, a programmer at Mozilla, came home to find the elevator in his Vancouver building broken again, its software crashed. Many such crashes come from memory bugs in C and C++. Hoare started Rust as a side project to get the speed of those languages without their memory errors.

Mozilla saw that Rust could help it build a safer browser engine and began sponsoring it officially in 2009, paying a team of engineers that included Patrick Walton, Niko Matsakis and Felix Klock. They built the ownership system that lets the compiler prove memory is used safely. Hoare stepped back in 2013. Rust 1.0 came out on 15 May 2015, ending years of breaking changes, and Mozilla used the language for its Servo engine and for the CSS engine in Firefox.

In February 2021 Mozilla handed Rust’s trademarks and infrastructure, including the crates.io registry, to the new Rust Foundation, a non-profit founded with AWS, Huawei, Google, Microsoft and Mozilla. The project itself stays independent and run by its own teams.

Why it’s built this way

Ownership checked at compile time instead of a garbage collector: Rust wanted C’s control and speed for code like browser engines. Tracking who owns each value lets the compiler insert the frees itself, so there is no collector and no pause, yet no use-after-free or double free.
One mutable reference or many readers, never both: The same rule that prevents dangling pointers also rules out data races, which is what the Rust team called “fearless concurrency”: threads can share data only in ways the compiler can check.
Stability without stagnation: six-week releases and editions: After 1.0, breaking changes were mostly out of scope. Releases follow a train model like Firefox and Chrome, and changes that would break code, such as the async keyword, wait for an opt-in edition.
An unsafe escape hatch: Some code, such as calling C or writing low-level data structures, can’t be checked. Rust allows it inside marked blocks, so the unchecked parts are small and easy to find.

Timeline

2006
Graydon Hoare starts Rust as a personal project
2009
Mozilla begins sponsoring the project
2015
Rust 1.0 released on 15 May; releases every six weeks after that
2018
Rust 2018, the first new edition, ships with Rust 1.31
2021
Rust Foundation founded in February; Rust 2021 edition in 1.56
2025
Rust 2024 edition stable with Rust 1.85 in February

Sources14 · facts checked 8 October 2026

Improve this page on GitHub