Diff — Rust (programming language)

{{infobox

| title = Rust

| image = rust-logo.svg

| caption = The Rust logo (CC BY 4.0, Rust Foundation)

| full_name = Rust

| designed_by = Graydon Hoare

| developer = Rust Foundation (since 2021); previously Mozilla Research

| appeared = 2010 (announced); 15 May 2015 (1.0 stable release)

| typing = Static, strong, inferred, affine (ownership)

| paradigm = Multi-paradigm: imperative, functional, concurrent, generic

| influenced_by = ML, C++, Haskell, Erlang, C#, OCaml, Cyclone, Alef, Limbo, Newsqueak, NIL, Hermes, Sather

| latest = 1.99.0 (1 October 2026)

| mascot = Ferris the crab

}}

[[File:ferris-crab.svg|right|160px|Ferris, the unofficial Rust mascot. CC0 public domain.]]

**Rust** is a systems programming language that achieves what was once considered a contradiction: the raw performance and hardware control of C and C++, combined with the memory safety guarantees that those languages have never been able to provide. It does this without a garbage collector, without a runtime, and without requiring the programmer to manually manage memory through `malloc` and `free`. Instead, Rust enforces safety through a compile-time **ownership and borrowing** system — a set of rules, checked by the compiler, that prevents entire categories of bugs from ever existing.

Since its 1.0 release in 2015, Rust has been voted the **most admired programming language** in the Stack Overflow Developer Survey every year through 2025 — an unprecedented streak. It has been adopted by the Linux kernel, Android, Windows, Cloudflare, Discord, Dropbox, Amazon, Meta, and Microsoft. It is, by most measures, the most important new systems language to emerge in the 21st century.

---

## Origins: a broken elevator and a stubborn idea

Rust began as a personal project by **Graydon Hoare**, a programmer at Mozilla, in 2006. The origin story is famous: Hoare's apartment building's elevator was broken — again — crashed by a software bug. He began thinking about a language that could prevent the kinds of memory errors that plague systems software, and started writing one.

The project was a side project for three years. Hoare described the early period as "years and years of just puttering around in circles, the kind of snowball-rolling that's necessary to go from nothing to 'well .. maybe ..'" The baby Rust of 2006–2009 had no type checker, generated terrible code, and ran on only one platform (32-bit x86)[1].

In late 2009, Mozilla became interested and began funding Hoare to work on Rust full-time. This was the critical inflection point. Mozilla's investment immediately quadrupled the team, and the company sustained its commitment from 2009 to 2020 — over a decade of improbable corporate investment in a programming language that had no users, no ecosystem, and no certainty of success[1].

The name "Rust" comes from the rust fungi — organisms that are robust, distributed, and grow on nearly anything. Hoare has also noted that the name contains a subsequence of every prior language he admired.

### The long road to 1.0

The path from Mozilla side project to stable language took six years of relentless iteration. The language was redesigned multiple times — major features were added, tried, and removed. The original Rust had green threads (like Go's goroutines), a garbage collector, typestate, and a very different syntax. All were removed before 1.0.

Key milestones on the road:

- **2010**: Rust announced at Mozilla Summit in Whistler. The bootstrap compiler was written in OCaml (~38,000 lines). The language at this point was barely recognizable as the Rust that exists today.

- **2011**: The Rust compiler became self-hosting — Rust was now compiled by Rust. Bootstrap builds took hours.

- **2012**: Rust 0.1 released. The regions/lifetimes system — the predecessor of the modern borrow checker — was introduced. This was the conceptual breakthrough that would define the language.

- **2013**: Graydon Hoare stepped back from the project. By this point, the community and the Mozilla team were the primary drivers. The green threads runtime was removed — a decision that was painful but ultimately crucial, as it allowed Rust to be used as a true systems language without a mandatory runtime.

- **2014**: Cargo was released in alpha, transforming the development experience. The community began to grow rapidly.

- **2015, May 15**: **Rust 1.0** released, with a stability guarantee: code that compiles on 1.0 will compile on every future version. The six-week release train began. The churn was over.

The 1.0 release was a bet that the design was good enough. Ten years later, the bet paid off — the language has evolved substantially through editions and stabilized features, but the core ownership model has never needed to be redesigned.

### Servo: the proving ground

Alongside Rust, Mozilla funded **Servo** — an entire web browser engine written in Rust, from 2012 onward. Servo was not just a demonstration project; it was a critical feedback loop. Writing a browser engine exercises every corner of a systems language: concurrency, memory management, performance, FFI, unsafe code, and real-world complexity. Features that Rust lacked or got wrong were discovered through Servo, and the language was adjusted accordingly[1].

Servo's parallel layout engine demonstrated that Rust's ownership system could enable safe parallelism in practice — multiple threads processing different parts of a web page simultaneously, without data races, without locks on the critical path. This was the existence proof that the theory worked at scale.

---

## Before Rust: the memory safety problem

To understand why Rust matters, you need to understand the problem it solves.

C was designed in 1972. C++ appeared in 1985. Between them, they power virtually all operating systems, embedded systems, browsers, databases, game engines, and performance-critical infrastructure on Earth. They are fast because they give the programmer direct control over memory — `malloc` to allocate, `free` to release, pointers to access. They are dangerous for exactly the same reason.

The programmer is responsible for getting it right. Free too early: use-after-free. Free twice: double free. Forget to free: memory leak. Index past the end of an array: buffer overflow. Share a pointer across threads without synchronization: data race. Every one of these is a potential security vulnerability, and every one of them has been exploited in the wild — repeatedly, for decades.

The alternatives — garbage-collected languages like Java, Go, Python, and C# — solve the memory safety problem but sacrifice the low-level control and predictable performance that systems programming requires. You cannot write an operating system kernel in Java. You cannot write a real-time audio driver in Python. The gap between "safe but slow" and "fast but dangerous" persisted for forty years.

Rust closes that gap. It is the first language to offer C-level performance with compile-time memory safety guarantees — no garbage collector, no runtime overhead, no manual memory management, and no entire categories of bugs that have cost the industry billions of dollars and countless security breaches.

The technical achievement is not that Rust prevents bugs — any language with enough restrictions can do that. The achievement is that Rust prevents the bugs **without sacrificing performance**. A Rust program and an equivalent C program, on the same hardware, run at the same speed. The safety is free.

---

## The ownership system

Rust's central innovation is its **ownership system** — a set of compile-time rules that govern how memory is managed. The system is checked entirely by the compiler (specifically, the **borrow checker**), so it has zero runtime cost.

The rules are simple to state:

1. Each value in Rust has exactly one **owner**.

2. There can be only one owner at a time.

3. When the owner goes out of scope, the value is **dropped** (freed).

These three rules, enforced statically, eliminate an entire class of bugs that have plagued C and C++ for fifty years:

| Bug class | How Rust prevents it |

|---|---|

| Use after free | The compiler tracks ownership; once a value is moved, the original name is invalid |

| Double free | Only one owner can drop a value |

| Dangling pointers | References cannot outlive the data they point to (lifetime checking) |

| Data races | You can have **either** one mutable reference **or** any number of immutable references — never both |

| Null pointer dereference | Rust has no null; it uses `Option<T>` instead |

| Buffer overflow | Array access is bounds-checked by default |

### Borrowing

Rather than copying data everywhere, Rust allows **borrowing** — creating references to data without taking ownership. The borrow checker enforces a key invariant: at any given time, you can have either:

- **One** mutable reference (`&mut T`), or

- **Any number** of immutable references (`&T`)

— but never both simultaneously. This single rule prevents data races at compile time, without locks, without runtime checks, without a garbage collector.

```rust

fn main() {

    let mut s = String::from("hello");

    let r1 = &s;      // immutable borrow — OK

    let r2 = &s;      // another immutable borrow — OK

    // let r3 = &mut s; // ERROR: cannot borrow as mutable

    println!("{r1}, {r2}");

}

```

```fact

The borrow checker is Rust's most celebrated and most cursed feature. New Rust programmers routinely describe "fighting the borrow checker" as their biggest frustration. Experienced Rust programmers report that once they internalize the ownership model, the borrow checker catches real bugs that would have been subtle, hard-to-reproduce crashes in C or C++. The learning curve is steep; the payoff is that an entire category of production incidents simply cannot happen.

```

### Lifetimes

When a function takes a reference, Rust needs to know how long that reference is valid. **Lifetimes** are the compiler's way of tracking this. In most cases, the compiler infers lifetimes automatically (a process called **lifetime elision**). When it cannot, the programmer annotates them explicitly:

```rust

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {

    if x.len() > y.len() { x } else { y }

}

```

The `'a` syntax means: "the returned reference lives at least as long as both input references." This is checked at compile time — if you try to use the result after either input has been dropped, the compiler stops you.

---

## The language

Rust is a multi-paradigm language. It supports imperative programming with mutable state, functional programming with closures and iterators, generic programming with traits, and concurrent programming with channels, async/await, and fearless concurrency guarantees.

### What it looks like

```rust

use std::collections::HashMap;

fn word_count(text: &str) -> HashMap<&str, usize> {

    let mut counts = HashMap::new();

    for word in text.split_whitespace() {

        *counts.entry(word).or_insert(0) += 1;

    }

    counts

}

fn main() {

    let text = "the quick brown fox jumps over the lazy dog the fox";

    let counts = word_count(text);

    for (word, count) in &counts {

        println!("{word}: {count}");

    }

}

```

This is idiomatic Rust: pattern matching, iterators, references, and `HashMap` — all with zero garbage collection and zero unsafe memory access.

### Enums and pattern matching

Rust's `enum` type is far more powerful than C's — each variant can carry data. Combined with **pattern matching**, this creates a system where the compiler forces you to handle every case:

```rust

enum Shape {

    Circle(f64),           // radius

    Rectangle(f64, f64),   // width, height

    Triangle(f64, f64, f64), // sides

}

fn area(shape: &Shape) -> f64 {

    match shape {

        Shape::Circle(r) => std::f64::consts::PI * r * r,

        Shape::Rectangle(w, h) => w * h,

        Shape::Triangle(a, b, c) => {

            let s = (a + b + c) / 2.0;

            (s * (s - a) * (s - b) * (s - c)).sqrt()

        }

    }

}

```

If you add a new variant to `Shape` later, every `match` in the program that doesn't handle it will fail to compile. This is **exhaustive matching**, and it eliminates an entire class of "forgot to handle this case" bugs.

### Error handling

Rust does not have exceptions. It uses the `Result<T, E>` type — an enum that is either `Ok(T)` (success) or `Err(E)` (failure). The `?` operator propagates errors concisely:

```rust

fn read_config(path: &str) -> Result<String, std::io::Error> {

    let contents = std::fs::read_to_string(path)?;

    Ok(contents.to_uppercase())

}

```

This forces the programmer to acknowledge every possible failure point. You cannot accidentally ignore an error in Rust the way you can in C (unchecked return values) or C++ (uncaught exceptions). The compiler will not let you.

### Traits

Rust uses **traits** instead of inheritance. A trait defines a set of methods that a type must implement:

```rust

trait Drawable {

    fn draw(&self);

    fn bounding_box(&self) -> (f64, f64, f64, f64);

}

```

Types implement traits explicitly — there is no implicit inheritance hierarchy, no fragile base class problem, and no diamond inheritance. Rust's trait system is heavily influenced by Haskell's type classes and is one of the most expressive generic programming systems in any mainstream language.

---

## Editions

Rust uses an **edition system** to evolve the language without breaking existing code. Every three years, a new edition is released (2015, 2018, 2021, 2024). Each edition can introduce new keywords, change syntax, and modify defaults — but old code compiled under a previous edition continues to work. Different crates in the same project can use different editions and interoperate seamlessly.

| Edition | Key changes |

|---|---|

| 2015 | The 1.0 baseline |

| 2018 | Non-lexical lifetimes (NLL), `async`/`await` preparation, module system overhaul, `dyn Trait` syntax |

| 2021 | Closure capture improvements, `IntoIterator` for arrays, disjoint capture in closures |

| 2024 | `gen` blocks, `unsafe_op_in_unsafe_fn` lint on by default, lifetime elision in `impl Trait`, RPIT lifetime capture changes |

This edition system is unique among major programming languages. It allows Rust to make breaking changes (like reserving new keywords) while guaranteeing that existing code continues to compile indefinitely.

---

## The ecosystem

### Cargo

**Cargo** is Rust's build system and package manager. It handles dependency resolution, compilation, testing, benchmarking, documentation generation, and publishing — in a single tool, out of the box. In the 2025 Stack Overflow survey, Cargo was voted the most admired cloud development and infrastructure tool[2].

A `Cargo.toml` file describes the project:

```toml

[package]

name = "my-project"

version = "0.1.0"

edition = "2024"

[dependencies]

serde = { version = "1.0", features = ["derive"] }

tokio = { version = "1", features = ["full"] }

```

`cargo build`, `cargo test`, `cargo run`, `cargo doc` — the workflow is so clean that it has become the standard against which other language toolchains are measured.

### crates.io

**crates.io** is Rust's package registry. As of 2026, it hosts over 170,000 crates (libraries). The registry added a code browser in 2026, allowing users to inspect the exact files that `cargo` downloads — including diffing between versions — directly on the web. The RustSec advisory database is integrated into crate pages, with warning banners for unmaintained packages[3].

### Testing, documentation, and tooling

Rust's toolchain includes first-class support for testing (`#[test]` attributes, `cargo test`), documentation (`///` doc comments rendered as HTML by `cargo doc`), benchmarking (`cargo bench`), linting (`clippy`), and formatting (`rustfmt`). The philosophy is that these are not afterthoughts — they are part of the language's definition of what a complete development environment looks like.

**Clippy**, Rust's official lint tool, contains over 700 lints for common mistakes, style violations, performance pitfalls, and correctness issues. **Rustfmt** enforces a canonical code style so that formatting debates — the oldest and least productive argument in programming — simply don't happen.

### The six-week train

Rust releases a new stable version every **six weeks**, like clockwork. This "train model" (borrowed from Firefox and Chrome) means that features land in nightly, stabilize in beta, and ship in stable on a predictable schedule. As of October 2026, Rust is at version **1.99.0**, with 1.100.0 scheduled for November 12, 2026[4].

```fact

Rust's release schedule has been almost perfectly consistent since 1.0. In over 600 weeks, the only change was a shift from Friday to Thursday releases starting with version 1.3.0. At the current pace, Rust 1.1000.0 is scheduled for May 11, 2130.

```

---

## Rust in the Linux kernel

The most consequential adoption of Rust in the 2020s has been its introduction into the **Linux kernel**.

In October 2022, Linux 6.1 became the first kernel release to include Rust support infrastructure. The decision was not without controversy — some veteran kernel developers objected to the introduction of a second language, and the debate became one of the most heated in Linux kernel history.

In February 2025, **Linus Torvalds** directly addressed the controversy on the kernel mailing list, firmly backing Rust's inclusion: "If you as a maintainer feel that you control who or what can use your code, YOU ARE WRONG." Torvalds made clear that while no one was forced to write Rust, no maintainer could block others from writing Rust code that interfaced with their subsystems[5].

By late 2025, production Rust drivers were being merged:

| Driver | Subsystem | Status |

|---|---|---|

| Android Binder | IPC | Production; shipped on millions of devices |

| ASIX PHY | Networking | First "Rust reference driver" |

| Nova GPU | Graphics (NVIDIA) | In development |

| Tyr GPU | Graphics | In development |

| DRM Panic QR | Graphics | Merged |

| AMCC QT2025 PHY | Networking | Merged |

Google announced in November 2025: "Android's 6.12 Linux kernel is our first kernel with Rust support enabled and our first production Rust driver" — meaning millions of Android devices are now running Rust code in the kernel[5].

The Debian kernel team enabled Rust support in 2025, making it available in the next Debian Stable release. The trajectory is clear: Rust is becoming a permanent part of the kernel, not an experiment.

```quote

"The biggest change is obviously the choice of programming language. We decided to use Rust because it directly addresses a number of the challenges within Binder that we have faced during the last years. It prevents mistakes with ref counting, locking, bounds checking, and also does a lot to reduce the complexity of error handling." — Android Binder driver commit message

```

---

## Where Rust is used

Rust has moved far beyond its Mozilla origins. A partial list of major adopters:

### Operating systems and infrastructure

- **Linux kernel** — Rust drivers in production (Android, NVIDIA, network PHY)

- **Android** — Rust is a first-class development language; the Bluetooth stack, DNS resolver, and UWB stack are all Rust

- **Windows** — Microsoft has been rewriting core Windows components in Rust; the company described Rust as the "best chance" at addressing memory safety in systems code

- **Cloudflare** — The Pingora HTTP proxy (replacing NGINX) handles over a trillion requests per day

- **AWS** — Firecracker (the microVM behind Lambda and Fargate) is written in Rust

### Applications and services

- **Discord** — Rewrote their Go-based Read States service in Rust; latency dropped from 80ms p99 to under 10ms

- **Dropbox** — Core file sync engine rewritten in Rust

- **1Password** — The credential manager's core is Rust

- **Figma** — The multiplayer syncing engine

- **Vercel/Turbopack** — Next.js bundler successor, written in Rust

- **ripgrep** — The regex search tool faster than grep, ag, and ack; used as a library in VS Code's search

### Web and tooling

- **Deno** — The JavaScript/TypeScript runtime (from Node.js creator Ryan Dahl), built in Rust

- **SWC** — JavaScript/TypeScript compiler, 20-70x faster than Babel

- **Biome** — Linter and formatter replacing ESLint + Prettier, written in Rust

- **uv** — Python package manager, voted most admired Stack Overflow tag technology in 2025, built in Rust

- **Starship** — Cross-shell prompt, written in Rust

- **bat**, **fd**, **exa/eza**, **zoxide**, **delta** — modern replacements for classic Unix tools, all Rust

### Embedded and real-time

Rust has a growing embedded systems community. The `#![no_std]` attribute allows programs to run without Rust's standard library — on bare metal, on microcontrollers, on systems with no operating system at all. The **Embassy** project provides an async runtime for embedded Rust, and the **ESP-RS** project provides first-class support for Espressif microcontrollers (ESP32 family). Ferrocene, a qualified Rust compiler, has been certified for use in safety-critical automotive and industrial systems under ISO 26262 and IEC 61508.

### Game development

While C++ remains the dominant language in game development, Rust has gained traction through projects like **Bevy** (a data-driven ECS game engine), **wgpu** (a cross-platform graphics abstraction over Vulkan/Metal/DX12/WebGPU), and **Veloren** (an open-world multiplayer RPG written entirely in Rust). The Rust community's game development ecosystem is still young compared to C++'s decades of middleware and tooling, but it is growing rapidly.

### Cryptography and security

- **rustls** — A TLS implementation with no C dependencies and zero CVEs since inception

- **Let's Encrypt / ISRG** — The Prossimo project is funding memory-safe replacements for critical Internet infrastructure in Rust (including sudo, NTP, and the Linux kernel's TLS stack)

- **Signal** — Parts of the messaging app's cryptographic core

---

## Unsafe Rust

Rust's safety guarantees have an escape hatch: **`unsafe`** blocks. Inside an `unsafe` block, the programmer can:

- Dereference raw pointers

- Call `unsafe` functions (including C FFI)

- Access mutable static variables

- Implement `unsafe` traits

The key insight is that `unsafe` does not turn off the borrow checker — it only permits a small set of additional operations. The rest of Rust's safety guarantees remain in effect. And critically, `unsafe` is **visible** — it marks exactly the spots in a codebase where the compiler cannot verify safety, allowing code review and auditing to focus on those sections.

```fact

The Rust standard library itself uses `unsafe` internally — you cannot implement a doubly-linked list, a hash map, or a memory allocator in purely safe Rust. The design philosophy is: encapsulate `unsafe` in a well-tested, well-reviewed module and expose a safe API. The standard library's `Vec`, `HashMap`, `String`, and other types are all unsafe inside and safe outside.

```

---

## Async Rust

Rust's async system is built around **futures** — lazy computations that only run when polled. Unlike Go's goroutines (which use a built-in runtime) or JavaScript's promises (which use the event loop), Rust's async is **runtime-agnostic**. The language provides the `async`/`await` syntax; the runtime (scheduler, I/O, timers) is provided by a library.

**Tokio** is the dominant async runtime, powering the majority of Rust's networking ecosystem. It provides a multi-threaded, work-stealing scheduler, an I/O driver built on epoll/kqueue/IOCP, and an extensive set of async primitives.

```rust

use tokio::net::TcpListener;

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {

    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {

        let (socket, addr) = listener.accept().await?;

        tokio::spawn(async move {

            println!("Connection from {addr}");

            // handle socket...

        });

    }

}

```

The zero-cost abstraction principle applies: an `async fn` compiles to a state machine with no heap allocation for the future itself. The generated code is competitive with hand-written event loops.

---

## The community

Rust's governance evolved from a Mozilla-internal project to a community-governed ecosystem:

- **2009–2020**: Mozilla Research funded development

- **2020**: Mozilla's pandemic-era layoffs cut the Servo team and several Rust contributors, creating a governance crisis

- **2021**: The **Rust Foundation** was established (founding members: AWS, Google, Huawei, Microsoft, Mozilla) to steward the language's trademarks, infrastructure, and funding

- **2023**: A **Leadership Council** replaced the previous Core Team, with elected representatives from each top-level team

The community is famously welcoming — the Rust Code of Conduct was one of the earliest in open source — and the RFC (Request for Comments) process ensures that major language changes are publicly debated before implementation.

**Ferris** the crab, the unofficial mascot, has become one of the most recognizable symbols in programming. The name is a play on "ferrous" (relating to iron — which rusts). Ferris is CC0 public domain.

---

## What Rust gets wrong — the honest critique

No language article on this wiki would be honest without acknowledging the costs.

**The learning curve is real.** Rust is harder to learn than almost any mainstream language. The ownership system, lifetimes, traits, generics, macros, and async machinery form a steep wall of concepts that a new programmer must internalize before they can be productive. The borrow checker will reject programs that the programmer knows are correct — because the compiler cannot prove they are correct within its analysis framework. This is a fundamental consequence of the sound-and-incomplete design: the checker never accepts unsafe code, but it sometimes rejects safe code.

**Compile times are slow.** Rust's monomorphization (generating separate code for each concrete instantiation of a generic function), deep type inference, borrow checking, and LLVM-based code generation combine to produce compile times that are significantly slower than C, Go, or Zig. The Rust team has made steady progress — incremental compilation, parallel frontend work, cranelift as an alternative backend — but large projects still measure compile times in minutes.

**Async Rust is complex.** The decision to make async runtime-agnostic means there is no "standard" async runtime. Tokio dominates, but its ecosystem of traits, pinning, `Send`/`Sync` bounds, and runtime-specific APIs creates a secondary learning curve on top of the language itself. The phrase "async Rust is a different language" is only a slight exaggeration.

**The syntax is dense.** Angle brackets, turbofish (`::<>`), lifetime annotations, trait bounds, `where` clauses, and macro invocations can make Rust code visually intimidating. This is a conscious trade-off — Rust surfaces complexity that other languages hide — but it means that reading unfamiliar Rust code requires significant expertise.

**Unsafe is necessary.** Despite the safety story, real-world Rust projects use `unsafe` more than the marketing suggests. FFI with C libraries, performance-critical inner loops, and fundamental data structures all require `unsafe`. The safety guarantee is that `unsafe` is *bounded and visible*, not that it is absent.

These are real costs, and they are why Rust has not replaced C and C++ — and probably never will entirely. The argument for Rust is not that it is easy, but that the bugs it prevents are expensive enough to justify the investment.

---

## The version history

| Version | Date | Landmark |

|---|---|---|

| Pre-history | 2006–2009 | Graydon Hoare's personal project; OCaml bootstrap compiler |

| 0.1 | January 2012 | First numbered release |

| 0.4 | October 2012 | Regions/lifetimes introduced |

| 0.6 | April 2013 | `do` syntax removed; borrow checker overhauled |

| 0.8 | September 2013 | Graydon Hoare steps back from the project |

| 1.0 | 15 May 2015 | **Stable release**; stability guarantee begins |

| 1.15 | February 2017 | Procedural macros (custom derive) stabilized |

| 1.31 | December 2018 | **Edition 2018**; non-lexical lifetimes; `async`/`await` groundwork |

| 1.39 | November 2019 | `async`/`await` stabilized |

| 1.56 | October 2021 | **Edition 2021** |

| 1.85 | February 2025 | **Edition 2024** |

| 1.99 | 1 October 2026 | **Latest stable**; extern "C" variadics (VaList), VecDeque::retain_back |

---

## The elevator pitch — and the real pitch

The elevator pitch is memory safety without garbage collection. The real pitch is broader: Rust lets you write software that is **correct by construction** in ways that were previously impossible without enormous testing effort or formal verification. The borrow checker catches data races, use-after-free, null dereferences, and buffer overflows at compile time. The type system catches missed error cases, unhandled enum variants, and type confusion. The result is software that, when it compiles, has a remarkable tendency to simply work.

This does not mean Rust programs are bug-free — business logic errors, algorithmic mistakes, and design flaws are still the programmer's problem. But the categories of bugs that have caused the majority of CVEs in C and C++ codebases for decades — Microsoft estimated that 70% of its security vulnerabilities are memory safety issues — are structurally eliminated.

```fact

Microsoft, Google, and the NSA have all independently recommended Rust (or memory-safe languages generally) for new systems development. In 2022, the US National Security Agency published a cybersecurity information sheet explicitly recommending organizations transition to memory-safe languages. Google's internal data shows that Rust code has produced zero memory safety vulnerabilities in Android components written in it, compared to a steady stream in C/C++ components.

```

---

## Rust's influence on other languages

Rust's success has reshaped the conversation around memory safety across the industry. Several languages have adopted or are exploring ownership-inspired features:

- **Swift** adopted move-only types and ownership annotations (starting with Swift 5.9/6.0), explicitly citing Rust as an influence.

- **C++** has explored various lifetime and borrow checking proposals (including the "profiles" work), though none have been accepted into the standard.

- **Carbon** (Google's C++ successor experiment) incorporates ownership semantics.

- **Vale**, **Mojo**, **Hylo**, and **Austral** are newer languages that explicitly build on Rust's ownership model.

- **Zig** takes a different approach to the same problem — manual memory management with safety-oriented tooling — and is often discussed alongside Rust as an alternative.

The broader effect is cultural: "memory-safe language" has become a standard requirement in government and enterprise procurement, and Rust is the reason that phrase entered the conversation.

---

## Rust and ALB

The [[AdaLogic BASIC]] project maintains Rust in its ecosystem. The wiki's news section covered the 1.99.0 release in detail in [[Rust_1.99_Variadics|Rust 1.99 Lets You Write printf in Rust]], and the ALB download distribution includes Rust 1.99.0 installers for Windows (32-bit and 64-bit) and Linux. Rust's safety philosophy — proving correctness at compile time rather than discovering bugs at runtime — resonates with ALB's own design goals around typed, safe, compiled code.

---

## See also

- [[Rust_1.99_Variadics|Rust 1.99 Lets You Write printf in Rust]] — the latest Rust release

- [[History of Programming]]

- [[FORTRAN]] · [[COBOL]] · [[LISP]] · [[ALGOL]]

- [[History of AI]] — Rust's role in AI infrastructure (data pipelines, ML tooling, inference servers)

- [[AdaLogic BASIC]] — a modern language carrying BASIC's accessibility with compiled safety

## References

[1] G. Hoare, "10 Years of Stable Rust: An Infrastructure Story," Rust Foundation, May 15, 2025. B. Anderson, "Rust Timeline," github.com/brson/my-rust-lists.

[2] Stack Overflow, "2025 Developer Survey — Technology," survey.stackoverflow.co/2025/technology.

[3] crates.io team, "crates.io: development update," blog.rust-lang.org, July 13, 2026.

[4] Rust release notes, doc.rust-lang.org/stable/releases.html. RELEASES.md, github.com/rust-lang/rust.

[5] L. Torvalds, LKML, "Re: Rust kernel policy," February 20, 2025. Google Security Blog, "Rust in Android: Move Fast, Fix Things," November 2025.

[6] Microsoft Security Response Center, "A proactive approach to more secure code," 2019 (70% of CVEs are memory safety issues). NSA, "Software Memory Safety," November 2022.

[[Category:Languages]]

[[Category:Programming]]