Rust

The official Rust logo
Paradigms	Multi-paradigm: concurrent, functional, generic, imperative, structured
Designed by	Graydon Hoare
Developer	The Rust Foundation
First appeared	July 7, 2010; 11 years ago (2010-07-07)
Stable release	1.61.0[1]  / May 19, 2022; 5 days ago (May 19, 2022)
Typing discipline	Affine, inferred, nominal, static, strong
Implementation language	Rust
Platform	AMD64, i686, arm, AArch64, armv7, mips, mips64, mipsel, mips64el, powerpc, powerpc64, powerpc64le, risc-v, s390x, WebAssembly[note 1]
OS	Windows, Linux, macOS, FreeBSD, NetBSD, Illumos, Haiku, Android, Redox, iOS, Fuchsia[note 2]
License	MIT or Apache 2.0[2]
Filename extensions	.rs, .rlib
Website	www.rust-lang.org
Influenced by
Alef C# C++ Cyclone[3] Erlang Haskell Limbo Newsqueak OCaml Ruby Scheme Standard ML Swift[4][note 3]
Influenced
Crystal Elm[6] Idris[7] Spark[8] Swift[9] Project Verona[10] Zig PHP[11]

Rust is a multi-paradigm, general-purpose programming language designed for performance and safety, especially safe concurrency.^[12][13] Syntactically similar to C++,^[14] Rust is notable for enforcing memory safety — that is, that all references point to valid memory — without requiring the use of a garbage collector or reference counting like other memory-safe languages.^[15][16] Memory safety is enforced by the compiler's borrow checker, which tracks object lifetime and variable scope as references are passed throughout the program.^[17] Rust is considered a systems programming language^[18] with mechanisms for low-level memory management,^[19] but also offers high-level features such as functional programming.

First appearing in 2010, Rust was designed by Graydon Hoare at Mozilla Research^[20] with contributions from Dave Herman, Brendan Eich, and others.^[21][22] The designers refined the language while writing the Servo experimental browser engine^[23] and the Rust compiler. Rust's major influences include C++, OCaml, Haskell, and Erlang.^[5] Rust has seen adoption in industry by companies including Amazon,^[24][25] Discord,^[26] Dropbox,^[27] Facebook (Meta),^[28] Google (Alphabet),^[29][30] and Microsoft.^[31][32]

Rust has been noted for its growth as a newer language^[33][34] and has been studied academically.^[35][36][37] Rust has been voted the "most loved programming language" in the Stack Overflow Developer Survey every year since 2016, and was used by 7% of the respondents in 2021.^[38]

History

Compiling a Rust program with Cargo

Rust grew out of a personal project begun in 2006 by Mozilla employee Graydon Hoare.^[13] On Internet Relay Chat, Hoare has stated that Rust got its name from rust fungi and as a subsequence of "robust".^[39] Mozilla began sponsoring the project in 2009^[13] and announced the project in 2010.^[40][41] During the same year, work has shifted from the initial compiler written in OCaml to an LLVM-based self-hosting compiler written in Rust.^[42] The compiler named rustc had successfully compiled itself in 2011.^[43]

The first numbered pre-alpha version of the Rust compiler was released in January 2012.^[44]

Along with conventional static typing, before version 0.4, Rust also supported typestates. The typestate system modeled assertions before and after program statements through use of a special check statement. Discrepancies could be discovered at compile time rather than at runtime as with assertions in C or C++ code. The typestate concept was not unique to Rust, as it was introduced in the NIL language.^[45] Typestates were removed because they were little used,^[46] though the same functionality can be achieved by leveraging Rust's move semantics.^[47]

The object system style changed considerably within versions 0.2, 0.3, and 0.4 of Rust. Version 0.2 introduced classes for the first time, and version 0.3 added several features, including destructors and polymorphism through the use of interfaces. In Rust 0.4, traits were added as a means to provide inheritance; interfaces were unified with traits and removed as a separate feature. Classes were also removed and replaced by a combination of implementations and structured types.^[48]

Starting in Rust 0.9 and ending in Rust 0.11, Rust had two built-in pointer types: ~ and @, simplifying the core memory model. It reimplemented those pointer types in the standard library as Box and (the now removed) Gc.

In January 2014, before the first stable release, Rust 1.0, the editor-in-chief of Dr. Dobb's, Andrew Binstock, commented on Rust's chances of becoming a competitor to C++ and to the other up-and-coming languages D, Go, and Nim (then Nimrod). According to Binstock, while Rust was "widely viewed as a remarkably elegant language", adoption slowed because it repeatedly changed between versions.^[49]

Rust 1.0, the first stable version, was released on May 15, 2015.^[50][51]

In August 2020, Mozilla laid off 250 of its 1,000 employees worldwide as part of a corporate restructuring caused by the long-term impact of the COVID-19 pandemic.^[52][53] The team behind Servo, a browser engine written in Rust, was completely disbanded. The event raised concerns about the future of Rust, as some members of the team were active contributors to Rust. ^[54]

In the following week, the Rust Core Team acknowledged the severe impact of the layoffs and announced that plans for a Rust foundation were underway. The first goal of the foundation would be to take ownership of all trademarks and domain names, and take financial responsibility for their costs.^[55]

On February 8, 2021 the formation of the Rust Foundation was officially announced by its five founding companies (AWS, Huawei, Google, Microsoft,^[56][57] and Mozilla).^[58][59]

On April 6, 2021, Google announced support for Rust within Android Open Source Project as an alternative to C/C++.^[60]

Syntax

Here is a "Hello, World!" program written in Rust. The println! macro prints the message to standard output.

fn main() {
    println!("Hello, World!");
}

The syntax of Rust is similar to C and C++, with blocks of code delimited by curly brackets, and control flow keywords such as if, else, while, and for, although the specific syntax for defining functions is more similar to Pascal. Despite the syntactic resemblance to C and C++, the semantics of Rust are closer to that of the ML family of languages and the Haskell language. Nearly every part of a function body is an expression,^[61] even control flow operators. For example, the ordinary if expression also takes the place of C's ternary conditional, an idiom used by ALGOL 60. As in Lisp, a function need not end with a return expression: in this case if the semicolon is omitted, the last expression in the function creates the return value, as seen in the following recursive implementation of the factorial function:

fn factorial(i: u64) -> u64 {
    match i {
        0 => 1,
        n => n * factorial(n-1)
    }
}

The following iterative implementation uses the ..= operator to create an inclusive range:

fn factorial(i: u64) -> u64 {
    (2..=i).product()
}

More advanced features in Rust include the use of generic functions to achieve type polymorphism. The following is a Rust program to calculate the sum of two things, for which addition is implemented, using a generic function:

use std::ops::Add;

fn sum<T: Add<Output = T>>(num1: T, num2: T) -> T {
    num1 + num2
}

fn main() {
    let result1 = sum(10, 20);
    println!("Sum is: {}", result1);
    
    let result2 = sum(10.23, 20.45);
    println!("Sum is: {}", result2);
}

Unlike other languages, Rust does not use null pointers to indicate a lack of data, as doing so can lead to accidental dereferencing. Therefore, in order to uphold its safety guarantees, null pointers cannot be dereferenced unless explicitly declaring the code block unsafe with an unsafe block.^[62] Rust instead uses a Haskell-like Option type, which has two variants, Some(T) (which indicates that a value is present) and None (analogous to the null pointer).^[63] Option values must be handled using syntactic sugar such as the if let construction in order to access the inner value (in this case, a string):

fn main() {
    let name: Option<String> = None;
    // If name was not None, it would print here.
    if let Some(name) = name {
        println!("{}", name);
    }
}

Features

Rust is intended to be a language for highly concurrent and highly safe systems,^[64] and programming in the large, that is, creating and maintaining boundaries that preserve large-system integrity.^[65] This has led to a feature set with an emphasis on safety, control of memory layout, and concurrency.

Memory safety

Rust is designed to be memory safe. It does not permit null pointers, dangling pointers, or data races.^[66][67][68] Data values can be initialized only through a fixed set of forms, all of which require their inputs to be already initialized.^[69] To replicate pointers being either valid or NULL, such as in linked list or binary tree data structures, the Rust core library provides an option type, which can be used to test whether a pointer has Some value or None.^[67] Rust has added syntax to manage lifetimes, which are checked at compile time by the borrow checker. Unsafe code can subvert some of these restrictions using the unsafe keyword.^[17]

Memory management

Rust does not use automated garbage collection. Memory and other resources are managed through the resource acquisition is initialization convention,^[70] with optional reference counting. Rust provides deterministic management of resources, with very low overhead.^[71] Rust favors stack allocation of values and does not perform implicit boxing.

There is the concept of references (using the & symbol), which does not involve run-time reference counting. The safety of such pointers is verified at compile time, preventing dangling pointers and other forms of undefined behavior. Rust's type system separates shared, immutable pointers of the form &T from unique, mutable pointers of the form &mut T. A mutable pointer can be coerced to an immutable pointer, but not vice versa.

Ownership

Rust has an ownership system where all values have a unique owner, and the scope of the value is the same as the scope of the owner.^[72][73] Values can be passed by immutable reference, using &T, by mutable reference, using &mut T, or by value, using T. At all times, there can either be multiple immutable references or one mutable reference (an implicit readers–writer lock). The Rust compiler enforces these rules at compile time and also checks that all references are valid.

Types and polymorphism

Rust's type system supports a mechanism called traits, inspired by type classes in the Haskell language. Traits annotate types and are used to define shared behavior between different types. For example, floats and integers both implement the Add trait because they can both be added; and any type that can be printed out as a string implements the Display or Debug traits. This facility is known as ad hoc polymorphism.

Rust uses type inference for variables declared with the keyword let. Such variables do not require a value to be initially assigned to determine their type. A compile time error results if any branch of code leaves the variable without an assignment.^[74] Variables assigned multiple times must be marked with the keyword mut (short for mutable).

A function can be given generic parameters, which allows the same function to be applied to different types. Generic functions can constrain the generic type to implement a particular trait or traits; for example, an "add one" function might require the type to implement "Add". This means that a generic function can be type-checked as soon as it is defined.

The implementation of Rust generics is similar to the typical implementation of C++ templates: a separate copy of the code is generated for each instantiation. This is called monomorphization and contrasts with the type erasure scheme typically used in Java and Haskell. Rust's type erasure is also available by using the keyword dyn. The benefit of monomorphization is optimized code for each specific use case; the drawback is increased compile time and size of the resulting binaries.

In Rust, user-defined types are created with the struct or enum keywords. These types usually contain fields of data like objects or classes in other languages. The impl keyword can define methods for the types (data and functions are defined separately) or implement a trait for the types. A trait is a contract that a structure has certain required methods implemented. Traits are used to restrict generic parameters and because traits can provide a struct with more methods than the user defined. For example, the trait Iterator requires that the next method be defined for the type. Once the next method is defined the trait provides common functional helper methods over the iterator like map or filter.

Type aliases, including generic arguments, can also be defined with the type keyword.

The object system within Rust is based around implementations, traits and structured types. Implementations fulfill a role similar to that of classes within other languages and are defined with the keyword impl. Traits provide inheritance and polymorphism; they allow methods to be defined and mixed in to implementations. Structured types are used to define fields. Implementations and traits cannot define fields themselves, and only traits can provide inheritance. Among other benefits, this prevents the diamond problem of multiple inheritance, as in C++. In other words, Rust supports interface inheritance but replaces implementation inheritance with composition; see composition over inheritance.

Macros for language extension

It is possible to extend the Rust language using the procedural macro mechanism.^[75]

Procedural macros use Rust functions that run at compile time to modify the compiler's token stream. This complements the declarative macro mechanism (also known as macros by example), which uses pattern matching to achieve similar goals.

Procedural macros come in three flavors:

• Function-like macros custom!(...)
• Derive macros #[derive(CustomDerive)]
• Attribute macros #[custom_attribute]

The println! macro is an example of a function-like macro and serde_derive^[76] is a commonly used library for generating code for reading and writing data in many formats such as JSON. Attribute macros are commonly used for language bindings such as the extendr library for Rust bindings to R.^[77]

The following code shows the use of the Serialize, Deserialize and Debug derive procedural macros to implement JSON reading and writing as well as the ability to format a structure for debugging.

use serde_json::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };

    let serialized = serde_json::to_string(&point).unwrap();
    println!("serialized = {}", serialized);

    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
    println!("deserialized = {:?}", deserialized);
}

Interface with C and C++

Rust has a foreign function interface (FFI) that can be used both to call code written in languages such as C from Rust and to call Rust code from those languages. Rust also has a library, CXX, to allow calling to or from C++.^[78]

Components

Besides the compiler and standard library, the Rust ecosystem includes additional components for software development. Component installation is typically managed by rustup, a Rust toolchain installer developed by the Rust project.^[79]

Cargo

Cargo is Rust's build system and package manager. Cargo downloads, compiles, distributes, and uploads packages, called crates,^[80] maintained in the official registry.^[81] Cargo also wraps Clippy and other Rust components.

Cargo requires projects to follow a certain directory structure, with some flexibility.^[82] Projects using Cargo may be either a single crate or a workspace composed of multiple crates that may depend on each other.^[83]

The dependencies for a crate are specified in a Cargo.toml file along with SemVer version requirements, telling Cargo which versions of the dependency are compatible with the crate using them.^[84] By default, Cargo sources its dependencies from the user-contributed registry crates.io, but Git repositories and crates in the local filesystem can be specified as dependencies, too.^[85]

Rustfmt

Rustfmt is a code formatter for Rust. It takes Rust source code as input and changes the whitespace and indentation to produce code formatted in accordance to the Rust style guide or rules specified in a rustfmt.toml file. Rustfmt can be invoked as a standalone program or on a Rust project through Cargo.^[86][87]

Clippy

Clippy is Rust's built-in linting tool to improve the correctness, performance, and readability of Rust code. It was created in 2014^[88] and named after the eponymous Microsoft Office feature.^[89] As of 2021, Clippy has more than 450 rules,^[90] which can be browsed online and filtered by category.^[91] Some rules are disabled by default.

Versioning system

Following Rust 1.0, new features are developed in nightly versions which release on a daily basis. During each release cycle of six weeks, changes on nightly versions are released to beta, while changes from the previous beta version are released to a new stable version.^[92][93]

Every two to three years, a new "edition" is produced. Editions are released to provide an easy reference point for changes due to the frequent nature of Rust's train release schedule, and to provide a window to make limited breaking changes. Editions are largely compatible and migration to a new edition is trivialized with automated tooling.^[94]

IDE support

The most popular language servers for Rust are rust-analyzer^[95] and RLS.^[96] These projects provide IDEs and text editors with more information about a Rust project. Basic features include linting checks via Clippy and formatting via Rustfmt, among other functions. RLS also provides automatic code completion via Racer, though development of Racer was slowed down in favor of rust-analyzer.^[97]

Performance

Rust aims "to be as efficient and portable as idiomatic C++, without sacrificing safety".^[98] Since Rust utilizes LLVM, any performance improvements in LLVM also carry over to Rust.^[99]

Adoption

Rust has been adopted by major software engineering companies. For example, Dropbox is now written in Rust, as are some components at Amazon,^[25] Microsoft, Facebook,^[100] Discord,^[26] and the Mozilla Foundation. Rust was the third-most-loved programming language in the 2015 Stack Overflow annual survey^[101] and took first place for 2016–2021.^[102][103]

Web browsers and services

• Firefox has two projects written in Rust: the Servo parallel browser engine^[104] developed by Mozilla in collaboration with Samsung;^[105] and Quantum, which is composed of several sub-projects for improving Mozilla's Gecko browser engine.^[106]
• OpenDNS uses Rust in two of its components.^{[107][108][109]}
• Deno, a secure runtime for JavaScript and TypeScript, is built with V8, Rust, and Tokio.^[110]
• Figma, a web-based vector graphics editor, is written in Rust.

Operating systems

• Redox is a "full-blown Unix-like operating system" including a microkernel written in Rust.^[111]
• Theseus, an experimental OS with "intralingual design", is written in Rust.^[112]
• The Google Fuchsia capability-based operating system has components written in Rust,^[113] including a TCP/IP library. ^[114]
• Stratis is a file system manager written in Rust for Fedora^[115] and RHEL 8.^[116]
• exa is a Unix/Linux command line alternative to ls written in Rust.
• Since 2021, there is a patch series for adding Rust support to the Linux kernel.^[117]

Other notable projects and platforms

• Discord uses Rust for portions of its backend, as well as client-side video encoding,^[26] to augment the core infrastructure written in Elixir.^[118]
• Microsoft Azure IoT Edge, a platform used to run Azure services and artificial intelligence on IoT devices, has components implemented in Rust.^[119]
• Polkadot (cryptocurrency) is a blockchain platform written in Rust.
• Ruffle is an open-source SWF emulator written in Rust.^[120]
• TerminusDB, an open source graph database designed for collaboratively building and curating knowledge graphs, is written in Prolog and Rust.^[121]
• Amazon Web Services has multiple projects written in Rust, including Firecracker, a virtualization solution,^[122] and Bottlerocket, a Linux distribution and containerization solution.^[123]

Community

Some Rust users refer to themselves as Rustaceans (a pun on crustacean) and use Ferris (the orange crab above) as their unofficial mascot.^[124]

Conferences

Rust's official website lists online forums, messaging platforms, and in-person meetups for the Rust community.^[125] Conferences dedicated to Rust development include:

• RustConf: an annual conference in Portland, Oregon. Held annually since 2016 (except in 2020 and 2021 because of the COVID-19 pandemic).^[126]
• Rust Belt Rust: a #rustlang conference in the Rust Belt^[127]
• RustFest: Europe's @rustlang conference^[128]
• RustCon Asia^[129]
• Rust LATAM^[130]
• Oxidize Global^[131]

Governance teams

The Rust project is composed of teams that are responsible for different subareas of the development. For example, the Core team is responsible for "Managing the overall direction of Rust, subteam leadership, and any cross-cutting issues," the Compiler team is responsible for "Developing and managing compiler internals and optimizations," and the Language team is responsible for "Designing and helping to implement new language features," according to the official website.^[132]

Rust Foundation

Rust Foundation

Formation	February 8, 2021; 15 months ago (2021-02-08)
Founders	Amazon Web Services Google Huawei Microsoft Mozilla Foundation
Type	Nonprofit organization
Location	United States
Chairperson	Shane Miller
Executive Director	Rebecca Rumbul
Website	foundation.rust-lang.org

The Rust Foundation is a non-profit membership organization incorporated in Delaware, United States, with the primary purposes of supporting the maintenance and development of the language, cultivating the Rust project team members and user communities, managing the technical infrastructure underlying the development of Rust, and managing and stewarding the Rust trademark.

It was established on February 8, 2021, with five founding corporate members (Amazon Web Services, Huawei, Google, Microsoft, and Mozilla).^[133] The foundation's board is chaired by Shane Miller.^[134] Starting in late 2021, its Executive Director and CEO is Rebecca Rumbul.^[135] Prior to this, Ashley Williams was interim executive director.^[136]