Rust (programming language)

Rust is a general-purpose language for software in which predictable performance, low-level control, and memory safety are central requirements. Its development began with Graydon Hoare and later received substantial support from Mozilla Research; Rust 1.0 was released in 2015.¹ The language occupies territory traditionally associated with C and C++, but it aims to prevent classes of dangling-pointer, double-free, and data-race errors through compile-time analysis rather than a tracing garbage collector.

Rust is developed as an open-source project with a community governance structure and a nonprofit Rust Foundation supporting its infrastructure and ecosystem.² The language specification is complemented by an extensive standard library and official tooling, making the compiler, package manager, formatter, and documentation generator parts of a coherent development environment.

Rust's ownership system makes each value have a responsible owner, with borrowing rules governing temporary access to that value. A value can be moved, copied when its type permits copying, or borrowed immutably or mutably under rules checked by the compiler.³ These rules let programs manage memory without routine manual deallocation and without imposing garbage-collection pauses.

Traits provide shared interfaces and support generic programming, while algebraic data types, pattern matching, and the Option and Result types make absence and failure explicit. Rust also separates safe code from unsafe code: unsafe blocks permit operations such as raw-pointer dereferencing, but they place additional proof obligations on the programmer. The RustBelt project formalized important claims about the soundness of Rust's type and ownership foundations.⁴

The Cargo package manager is the practical center of Rust development: it builds projects, resolves dependencies, runs tests, and publishes packages to the crates.io registry. The standard workflow also includes rustfmt for formatting and rustdoc for generating API documentation.¹ Rust's compiler can target multiple operating systems and architectures, and its interoperability with C makes gradual adoption possible in existing systems.

Rust is used for command-line tools, operating-system components, network services, embedded software, browser infrastructure, and WebAssembly. Its concurrency model combines threads and message passing with type-checked sharing, allowing many synchronization mistakes to be rejected before execution. The language can still express low-level techniques, but abstractions such as iterators and zero-cost generics are designed to compile without a mandatory runtime penalty.

Rust's safety guarantees are conditional rather than absolute: compiler correctness, library soundness, foreign-function interfaces, and carefully reviewed unsafe code remain part of a program's trusted computing base. The language reference therefore distinguishes normative language behavior from conventions supplied by the standard library and Cargo ecosystem.³

Rust has also influenced software engineering beyond its own syntax. Its ownership and borrowing vocabulary has informed discussions of linear and affine types, while tools such as Miri can detect certain undefined behaviors during interpretation and testing. The community's edition mechanism allows source-language changes to be introduced without forcing all existing crates to migrate simultaneously. Rust's permissive MIT and Apache-2.0 licensing, together with its public governance, has helped it appear in both commercial products and major open-source infrastructure.²

Ownership

Rust's rule that each value has one controlling owner responsible for determining when the value is dropped.

Borrowing

Temporary access to a value through a reference, constrained by Rust's aliasing and lifetime rules.

Trait

A collection of methods or associated behavior that types can implement, analogous in some uses to an interface.

Cargo

Rust's official build system and package manager.

Unsafe code

Code using operations that the compiler cannot fully verify, such as raw-pointer dereferencing, and whose safety must be established by the programmer.