View source for Rust (programming language)

{{Short description|General-purpose programming language}}
{{Infobox programming language
| name = Rust
| logo = Rust programming language black logo.svg
| logo caption = The official Rust logo
| logo alt = A capitalized letter R set into a sprocket
| paradigms = {{cslist|
  [[Concurrent computing|Concurrent]]|
  [[Functional programming|functional]]|
  [[Generic programming|generic]]|
  [[Imperative programming|imperative]]|
  [[Structured programming|structured]]|
}}
| released = {{Start date and age|2015|05|15}}
| designer = Graydon Hoare
| developer = Rust Foundation
| latest release version = {{wikidata|property|edit|reference|P548=Q2804309|P348}}
| latest release date = {{start date and age|{{wikidata|qualifier|mdy|P548=Q2804309|P348|P577}}}}
| typing = {{cslist|
  Affine|
  [[Type inference|inferred]]|
  [[Nominal type system|nominal]]|
  static|
  [[Strong and weak typing|strong]]|
}}
| programming language = Rust
| platform = [[Cross-platform software|Cross-platform]]{{refn|group=note|Including build tools, host tools, and standard library support for [[X86-64|x86-64]], [[ARM architecture family|ARM]], [[MIPS architecture|MIPS]], [[Engineering:RISC-V|RISC-V]], [[WebAssembly]], [[Engineering:P6 (microarchitecture)|i686]], [[AArch64]], [[PowerPC]], and [[Software:Linux on IBM Z|s390x]].<ref name=CrossPlatform>{{Cite web |title=Platform Support |website=The rustc book |url=https://doc.rust-lang.org/rustc/platform-support.html |access-date=2022-06-27}}</ref>}}
| operating system = [[Cross-platform software|Cross-platform]]{{refn|group=note|Including [[Software:Windows|Windows]], [[Software:Linux|Linux]], [[Software:MacOS|macOS]], [[Software:FreeBSD|FreeBSD]], [[Software:NetBSD|NetBSD]], and [[Software:Illumos|Illumos]]. Host build tools on [[Software:Android (operating system)|Android]], [[Software:IOS|iOS]], [[Software:Haiku (operating system)|Haiku]], [[Software:Redox (operating system)|Redox]], and [[Software:Fuchsia (operating system)|Fuchsia]] are not officially shipped; these operating systems are supported as targets.<ref name="CrossPlatform" />}}
| license = [[Software:MIT License|MIT]] and [[Software:Apache License|Apache 2.0]]{{refn|group=note|Third-party dependencies, e.g., [[Software:LLVM|LLVM]] or MSVC, are subject to their own licenses.<ref>{{cite web |title=The Rust Programming Language |url=https://github.com/rust-lang/rust/blob/master/COPYRIGHT |publisher=The Rust Programming Language |date=19 October 2022}}</ref><ref name="legal" />}}
| file ext = <code>.rs</code>, <code>.rlib</code>
| influenced by = {{cslist|
  [[Alef (programming language)|Alef]]|
  [[C Sharp (programming language)|C#]]<ref name="influences" />|
  [[C++]]<ref name="influences" />|
  [[Cyclone (programming language)|Cyclone]]|
  [[Elm (programming language)|Elm]]<ref>{{Cite web |title=Uniqueness Types |url=https://blog.rust-lang.org/2016/08/10/Shape-of-errors-to-come.html |access-date=2016-10-08 |website= Rust Blog |quote="Those of you familiar with the Elm style may recognize that the updated {{mono|--explain}} messages draw heavy inspiration from the Elm approach."}}</ref>|
  [[Erlang (programming language)|Erlang]]<ref name="influences" />|
  [[Haskell]]<ref name="influences" />|
  [[Limbo (programming language)|Limbo]]|
  [[Social:Newsqueak|Newsqueak]]<ref name="influences" />|
  [[OCaml]]<ref name="influences" />|
  [[Ruby (programming language)|Ruby]]<ref name="influences" />|
  [[Scheme (programming language)|Scheme]]<ref name="influences" />|
  [[Standard ML]]<ref name="influences" />|
  [[Swift (programming language)|Swift]]<ref name="influences" />
}}
| influenced = {{cslist|
  [[Idris (programming language)|Idris]]<ref>{{Cite web |title=Uniqueness Types |url=http://docs.idris-lang.org/en/latest/reference/uniqueness-types.html |access-date=2022-07-14 |website=Idris 1.3.3 documentation |quote="They are inspired by ... ownership types and borrowed pointers in the Rust programming language."}}</ref>|
  <!-- The article was deleted -- can be reinstated in the future if the article topic is deemed notable
  [[Mojo (programming language)|Mojo]]<ref>{{Cite web |last=Claburn |first=Thomas |title=Modular reveals Mojo, Python superset with C-level speed |url=https://www.theregister.com/2023/05/05/modular_struts_its_mojo_a/ |access-date=2023-05-13 |website=The Register |language=en}}</ref>|
  -->
  [[Project Verona]]<ref name="Project Verona" />|
  [[SPARK (programming language)|Spark]]<ref name="Jaloyan" />|
  [[Swift (programming language)|Swift]]<ref name="Lattner" />|
  [[V (programming language)|V]]<ref>{{Cite web |title=V documentation (Introduction) |url=https://github.com/vlang/v/blob/master/doc/docs.md#introduction |access-date=2023-11-04|website=GitHub |language=en}}</ref>|
  [[Zig (programming language)|Zig]]<ref>{{Cite web |last=Yegulalp |first=Serdar |date=2016-08-29 |title=New challenger joins Rust to topple C language |url=https://www.infoworld.com/article/3113083/new-challenger-joins-rust-to-upend-c-language.html |access-date=2022-10-19 |website=InfoWorld |language=en}}</ref>|
}}
}}

'''Rust''' is a [[Programming paradigm|multi-paradigm]], [[General-purpose programming language|general-purpose programming language]] that emphasizes [[Computer performance|performance]], [[Type safety|type safety]], and [[Concurrency (computer science)|concurrency]]. It enforces [[Memory safety|memory safety]]—meaning that all [[Reference (computer science)|references]] point to valid memory—without a [[Garbage collection (computer science)|garbage collector]]. To simultaneously enforce memory safety and prevent data races, its "borrow checker" tracks the [[Object lifetime|object lifetime]] of all references in a program during compilation. Rust was influenced by ideas from [[Functional programming|functional programming]], including [[Immutable object|immutability]], [[Higher-order function|higher-order function]]s, and [[Algebraic data type|algebraic data type]]s. It is popular for [[Systems programming|systems programming]].<ref>{{Cite book |last=Eshwarla |first=Prabhu |url=https://books.google.com/books?id=eEUREAAAQBAJ |title=Practical System Programming for Rust Developers: Build fast and secure software for Linux/Unix systems with the help of practical examples |date=2020-12-24 |publisher=Packt Publishing Ltd |isbn=978-1-80056-201-1 |language=en}}</ref><ref>{{Cite book |last1=Blandy |first1=Jim |url=https://books.google.com/books?id=h8c_DwAAQBAJ |title=Programming Rust: Fast, Safe Systems Development |last2=Orendorff |first2=Jason |date=2017-11-21 |publisher=O'Reilly Media, Inc. |isbn=978-1-4919-2725-0 |language=en}}</ref><ref>{{Cite journal |last1=Blanco-Cuaresma |first1=Sergi |last2=Bolmont |first2=Emeline |date=2017-05-30 |title=What can the programming language Rust do for astrophysics? |url=https://www.cambridge.org/core/journals/proceedings-of-the-international-astronomical-union/article/what-can-the-programming-language-rust-do-for-astrophysics/B51B6DF72B7641F2352C05A502F3D881 |journal=Proceedings of the International Astronomical Union |language=en |volume=12 |issue=S325 |pages=341–344 |doi=10.1017/S1743921316013168 |arxiv=1702.02951 |bibcode=2017IAUS..325..341B |s2cid=7857871 |issn=1743-9213}}</ref>

Software developer Graydon Hoare created Rust as a personal project while working at Mozilla Research in 2006. Mozilla officially sponsored the project in 2009. In the years following the first stable release in May 2015, Rust was adopted by companies including [[Company:Amazon|Amazon]], [[Software:Discord|Discord]], [[Software:Dropbox|Dropbox]], [[Company:Google|Google]] (Alphabet), [[Company:Meta Platforms|Meta]], and [[Company:Microsoft|Microsoft]]. In December 2022, it became the first language other than [[C (programming language)|C]] and [[Assembly language|assembly]] to be supported in the development of the [[Software:Linux kernel|Linux kernel]].

Rust has been noted for its rapid adoption,<ref name="Nature">{{Cite journal |last=Perkel |first=Jeffrey M. |date=2020-12-01 |title=Why scientists are turning to Rust |url=https://www.nature.com/articles/d41586-020-03382-2 |journal=Nature |language=en |volume=588 |issue=7836 |pages=185–186 |doi=10.1038/d41586-020-03382-2 |pmid=33262490 |bibcode=2020Natur.588..185P |s2cid=227251258 |access-date=May 15, 2022 |archive-date=May 6, 2022 |archive-url=https://web.archive.org/web/20220506040523/https://www.nature.com/articles/d41586-020-03382-2 |url-status=live}}</ref> and has been studied in [[Programming language theory|programming language theory]] research.<ref>{{Cite web |title=Computer Scientist proves safety claims of the programming language Rust |url=https://www.eurekalert.org/news-releases/610682 |access-date=2022-05-15 |website=EurekAlert! |language=en |archive-date=February 24, 2022 |archive-url=https://web.archive.org/web/20220224160140/https://www.eurekalert.org/news-releases/610682 |url-status=live}}</ref><ref>{{Cite journal |last1=Jung |first1=Ralf |last2=Jourdan |first2=Jacques-Henri |last3=Krebbers |first3=Robbert |last4=Dreyer |first4=Derek |date=2017-12-27 |title=RustBelt: securing the foundations of the Rust programming language |url=https://doi.org/10.1145/3158154 |journal=Proceedings of the ACM on Programming Languages |volume=2 |issue=POPL |pages=66:1–66:34 |doi=10.1145/3158154 |s2cid=215791659 |access-date=May 15, 2022 |archive-date=June 11, 2022 |archive-url=https://web.archive.org/web/20220611034059/https://dl.acm.org/doi/10.1145/3158154 |url-status=live|doi-access=free |hdl=21.11116/0000-0003-34C6-3 |hdl-access=free }}</ref><ref>{{Cite thesis |last=Jung |first=Ralf |year=2020 |title=Understanding and evolving the Rust programming language |url=https://publikationen.sulb.uni-saarland.de/handle/20.500.11880/29647 |language=en |doi=10.22028/D291-31946 |access-date=May 15, 2022 |archive-date=March 8, 2022 |archive-url=https://web.archive.org/web/20220308050018/https://publikationen.sulb.uni-saarland.de/handle/20.500.11880/29647 |url-status=live |degree=PhD |publisher=[[Organization:Saarland University|Saarland University]]}}</ref>

== History ==
[[File:MozillaCaliforniaHeadquarters.JPG|thumb|right|Mozilla Foundation headquarters in Mountain View, California]]

=== Origins (2006–2012) ===
Rust grew out of a personal project begun in 2006 by Mozilla Research employee Graydon Hoare.<ref name="MITTechReview">{{cite web |url=https://www.technologyreview.com/2023/02/14/1067869/rust-worlds-fastest-growing-programming-language/ |title=How Rust went from a side project to the world's most-loved programming language |last=Thompson |first=Clive |date=2023-02-14 |website=MIT Technology Review |archive-url= |archive-date= |language=en |access-date=2023-02-23}}</ref> Mozilla began sponsoring the project in 2009 as a part of the ongoing development of an experimental browser engine called [[Software:Servo|Servo]],<ref name="infoq2012">{{cite web |last=Avram |first=Abel |date=2012-08-03 |title=Interview on Rust, a Systems Programming Language Developed by Mozilla |url=http://www.infoq.com/news/2012/08/Interview-Rust |url-status=live |archive-url=https://web.archive.org/web/20130724045852/http://www.infoq.com/news/2012/08/Interview-Rust |archive-date=2013-07-24 |access-date=2013-08-17 |publisher=InfoQ}}</ref> which was officially announced by Mozilla in 2010.<ref name="MattAsay">{{Cite web |last=Asay |first=Matt |date=2021-04-12 |title=Rust, not Firefox, is Mozilla's greatest industry contribution |url=https://www.techrepublic.com/article/rust-not-firefox-is-mozillas-greatest-industry-contribution/ |access-date=2022-07-07 |website=TechRepublic |language=en-US}}</ref><ref>{{cite conference |last=Hoare |first=Graydon |title=Project Servo |conference=Mozilla Annual Summit 2010 |date=7 July 2010 |location=Whistler, Canada |url=http://venge.net/graydon/talks/intro-talk-2.pdf |access-date=22 February 2017 |archive-date=11 July 2017 |archive-url=https://web.archive.org/web/20170711131514/http://venge.net/graydon/talks/intro-talk-2.pdf |url-status=live}}</ref> During the same year, work shifted from the initial [[Compiler|compiler]] written in [[OCaml]] to a [[Self-hosting (compilers)|self-hosting compiler]] based on [[Software:LLVM|LLVM]] written in Rust. The new Rust compiler successfully [[Bootstrapping (compilers)|compiled itself]] in 2011.<ref name="infoq2012"/>

=== Evolution (2012–2019) ===

Rust's [[Type system|type system]] underwent significant changes between versions 0.2, 0.3, and 0.4. In version 0.2, which was released in March 2012, [[Class (computer programming)|classes]] were introduced for the first time.<ref>{{Cite web |last=Hoare |first=Graydon |date=2012-03-29 |title=[rust-dev] Rust 0.2 released |url=https://mail.mozilla.org/pipermail/rust-dev/2012-March/001511.html |access-date=2022-06-12 |website=mail.mozilla.org}}</ref> Four months later, version 0.3 added [[Destructor (computer programming)|destructor]]s and [[Polymorphism (computer science)|polymorphism]], through the use of interfaces.<ref>{{Cite web |last=Hoare |first=Graydon |date=2012-07-12 |title=[rust-dev] Rust 0.3 released |url=https://mail.mozilla.org/pipermail/rust-dev/2012-July/002087.html |access-date=2022-06-12 |website=mail.mozilla.org |archive-date=2022-08-24  |archive-url=https://web.archive.org/web/20220824145952/https://mail.mozilla.org/pipermail/rust-dev/2012-July/002087.html |url-status=dead }}</ref> In October 2012, version 0.4 was released, which added [[Trait (computer programming)|traits]] as a means of [[Inheritance (object-oriented programming)|inheritance]]. Interfaces were combined with traits and removed as a separate feature; and classes were replaced by a combination of implementations and [[Record (computer science)|structured types]].<ref>{{cite web |last=Hoare |first=Graydon |title=[rust-dev] Rust 0.4 released |url=https://mail.mozilla.org/pipermail/rust-dev/2012-October/002489.html |url-status=live |archive-url=https://web.archive.org/web/20211031130755/https://mail.mozilla.org/pipermail/rust-dev/2012-October/002489.html |archive-date=October 31, 2021 |access-date=2021-10-31 |website=mail.mozilla.org|date=October 15, 2012 }}</ref>

Through early 2010s, memory management through the ownership system was gradually consolidated to prevent memory bugs. By 2013, Rust's [[Garbage collection (computer science)|garbage collector]] was removed, with the ownership rules in place.<ref name="MITTechReview"/>

In January 2014, the editor-in-chief of ''Dr. Dobb's Journal'', Andrew Binstock, commented on Rust's chances of becoming a competitor to [[C++]], along with [[D (programming language)|D]], [[Go (programming language)|Go]], and [[Nim (programming language)|Nim]] (then Nimrod). According to Binstock, while Rust was "widely viewed as a remarkably elegant language", adoption slowed because it radically changed from version to version.<ref>{{cite news |last=Binstock |first=Andrew |date=January 7, 2014 |title=The Rise And Fall of Languages in 2013 |website=Dr. Dobb's Journal |url=https://www.drdobbs.com/jvm/the-rise-and-fall-of-languages-in-2013/240165192 |url-status=live |archive-url=https://web.archive.org/web/20160807075745/http://www.drdobbs.com/jvm/the-rise-and-fall-of-languages-in-2013/240165192 |archive-date=2016-08-07 |access-date=2022-11-20}}</ref> The first stable release, Rust 1.0, was announced on May 15, 2015.<ref name="Version history">{{cite web |title=Version History |website=[[GitHub]] |url=https://github.com/rust-lang/rust/blob/master/RELEASES.md |access-date=2017-01-01 |archive-date=2015-05-15 |archive-url=https://web.archive.org/web/20150515221302/https://github.com/rust-lang/rust/blob/master/RELEASES.md |url-status=live}}</ref><ref>{{cite web |url=http://blog.rust-lang.org/2015/05/15/Rust-1.0.html |title=Announcing Rust 1.0 |website=Rust Blog |author=The Rust Core Team |date=May 15, 2015 |access-date=2015-12-11 |archive-date=2015-05-15 |archive-url=https://web.archive.org/web/20150515171337/http://blog.rust-lang.org/2015/05/15/Rust-1.0.html |url-status=live}}</ref>

The development of the Servo browser engine continued alongside Rust's own growth. In September 2017, Firefox 57 was released as the first version that incorporated components from Servo, in a project named "Firefox Quantum".<ref>{{Cite web |last=Lardinois |first=Frederic |date=2017-09-29 |title=It's time to give Firefox another chance |url=https://techcrunch.com/2017/09/29/its-time-to-give-firefox-another-chance/ |access-date=2023-08-15 |website=TechCrunch |language=en-US}}</ref>

=== Mozilla layoffs and Rust Foundation (2020–present) ===
In August 2020, Mozilla laid off 250 of its 1,000 employees worldwide, as part of a corporate restructuring caused by the COVID-19 pandemic.<ref>{{cite web |url=https://www.zdnet.com/article/mozilla-lays-off-250-employees-while-it-refocuses-on-commercial-products/ |title=Mozilla lays off 250 employees while it refocuses on commercial products |last=Cimpanu |first=Catalin |publisher=[[ZDNet]] |access-date=2020-12-02 |date=2020-08-11 |archive-date=March 18, 2022 |archive-url=https://web.archive.org/web/20220318025804/https://www.zdnet.com/article/mozilla-lays-off-250-employees-while-it-refocuses-on-commercial-products/ |url-status=live}}</ref><ref>{{cite web |url=https://www.engadget.com/mozilla-firefox-250-employees-layoffs-151324924.html |title=Mozilla lays off 250 employees due to the pandemic |website=[[Software:Engadget|Engadget]] |last=Cooper |first=Daniel |access-date=2020-12-02 |date=2020-08-11 |archive-date=2020-12-13 |archive-url=https://web.archive.org/web/20201213020220/https://www.engadget.com/mozilla-firefox-250-employees-layoffs-151324924.html |url-status=live}}</ref> The team behind Servo was disbanded. The event raised concerns about the future of Rust, as some members of the team were active contributors to Rust.<ref>{{Cite web |last=Tung |first=Liam |title=Programming language Rust: Mozilla job cuts have hit us badly but here's how we'll survive |url=https://www.zdnet.com/article/programming-language-rust-mozilla-job-cuts-have-hit-us-badly-but-heres-how-well-survive/ |access-date=2022-04-21 |publisher=ZDNet |language=en |archive-date=April 21, 2022 |archive-url=https://web.archive.org/web/20220421083509/https://www.zdnet.com/article/programming-language-rust-mozilla-job-cuts-have-hit-us-badly-but-heres-how-well-survive/ |url-status=live}}</ref> 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 [[Social:Trademark|trademark]]s and [[Domain name|domain name]]s, and take financial responsibility for their costs.<ref>{{cite web |url=https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future.html |title=Laying the foundation for Rust's future |website=Rust Blog |access-date=2020-12-02 |date=2020-08-18 |archive-date=2020-12-02 |archive-url=https://web.archive.org/web/20201202022933/https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future.html |url-status=live}}</ref>

On February 8, 2021, the formation of the Rust Foundation was announced by its five founding companies ([[Company:Amazon Web Services|AWS]], [[Company:Huawei|Huawei]], [[Company:Google|Google]], [[Company:Microsoft|Microsoft]], and Mozilla).<ref>{{Cite web |date=2020-02-08 |title=Hello World! |url=https://foundation.rust-lang.org/news/2021-02-08-hello-world/ |access-date=2022-06-04 |website=Rust Foundation |language=en |archive-date=April 19, 2022 |archive-url=https://web.archive.org/web/20220419124635/https://foundation.rust-lang.org/news/2021-02-08-hello-world/ |url-status=live}}</ref><ref>{{Cite web|date=2021-02-09|title=Mozilla Welcomes the Rust Foundation |website=Mozilla Blog |url=https://blog.mozilla.org/blog/2021/02/08/mozilla-welcomes-the-rust-foundation |archive-url=https://web.archive.org/web/20210208212031/https://blog.mozilla.org/blog/2021/02/08/mozilla-welcomes-the-rust-foundation/|archive-date=2021-02-08|access-date=2021-02-09|url-status=live}}</ref> In a blog post published on April 6, 2021, Google announced support for Rust within the Android Open Source Project as an alternative to C/C++.<ref>{{Cite web|last=Amadeo|first=Ron|date=2021-04-07 |title=Google is now writing low-level Android code in Rust |url=https://arstechnica.com/gadgets/2021/04/google-is-now-writing-low-level-android-code-in-rust/ |access-date=2021-04-08|website=Ars Technica|language=en-us|archive-date=2021-04-08|archive-url=https://web.archive.org/web/20210408001446/https://arstechnica.com/gadgets/2021/04/google-is-now-writing-low-level-android-code-in-rust/|url-status=live}}</ref>

On November 22, 2021, the Moderation Team, which was responsible for enforcing community standards and the Code of Conduct, announced their resignation "in protest of the Core Team placing themselves unaccountable to anyone but themselves".<ref name="moderation">{{Cite web |first=Tim |last=Anderson |title=Entire Rust moderation team resigns |url=https://www.theregister.com/2021/11/23/rust_moderation_team_quits/ |date=2021-11-23 |access-date=2022-08-04 |website=The Register |language=en}}</ref> In May 2022, the Rust Core Team, other lead programmers, and certain members of the Rust Foundation board implemented governance reforms in response to the incident.<ref>{{Cite web |title=Governance Update |url=https://blog.rust-lang.org/inside-rust/2022/05/19/governance-update.html |access-date=2022-10-27 |website=Inside Rust Blog |language=en}}</ref>

The Rust Foundation posted a draft for a new [[Social:Trademark|trademark]] policy on April 6, 2023, revising its rules on how the Rust logo and name can be used, which resulted in negative reactions from Rust users and contributors.<ref>{{Cite web |last=Claburn |first=Thomas |title=Rust Foundation apologizes for trademark policy confusion |date=2023-04-17 |url=https://www.theregister.com/2023/04/17/rust_foundation_apologizes_trademark_policy/ |access-date=2023-05-07 |website=The Register |language=en}}</ref>

== Syntax and features ==
Rust's [[Syntax (programming languages)|syntax]] is similar to that of [[C (programming language)|C]] and C++,<ref>{{Cite web |last=Proven |first=Liam |date=2019-11-27 |title=Rebecca Rumbul named new CEO of The Rust Foundation |url=https://www.theregister.com/2021/11/19/rust_foundation_ceo/ |access-date=2022-07-14 |website=The Register |language=en |quote="Both are curly bracket languages, with C-like syntax that makes them unintimidating for C programmers."}}</ref><ref name=":4" /> although many of its features were influenced by [[Functional programming|functional programming]] languages.{{sfn|Klabnik|Nichols|2019|p=263}} Hoare described Rust as targeted at "frustrated C++ developers" and emphasized features such as safety, control of [[Memory map|memory layout]], and [[Concurrency (computer science)|concurrency]].<ref name="infoq2012"/> Safety in Rust includes the guarantees of memory safety, type safety, and lack of data races.

=== Hello World program ===

Below is a "Hello, World!" program in Rust. The {{Rust|fn}} keyword denotes a [[Function (computer programming)|function]], and the <code>println!</code> [[Macro (computer science)|macro]] prints the message to standard output.{{sfn|Klabnik|Nichols|2019|pp=5–6}} [[Statement (computer science)|Statements]] in Rust are separated by semicolons.
<source lang="rust">
fn main() {
    println!("Hello, World!");
}
</source>

=== Keywords and control flow ===
In Rust, blocks of code are delimited by [[Bracket#Curly brackets|curly brackets]], and [[Control flow|control flow]] is implemented by keywords such as <code>[[Conditional (computer programming)|if]]</code>, <code>else</code>, <code>[[While loop|while]]</code>, and <code>[[For loop|for]]</code>.{{sfn|Klabnik|Nichols|2019|pp=49–57}} [[Pattern matching]] can be done using the {{Rust|match}} keyword.{{sfn|Klabnik|Nichols|2019|pp=104–109}} In the examples below, explanations are given in [[Comment (computer programming)|comment]]s, which start with {{code|//}}.{{sfn|Klabnik|Nichols|2019|p=49}}

<source lang="rust">
fn main() {
    // Defining a mutable variable with 'let mut'
    // Using the macro vec! to create a vector
    let mut values = vec![1, 2, 3, 4];

    for value in &values {
        println!("value = {}", value);
    }

    if values.len() > 5 {
        println!("List is longer than five items");
    }

    // Pattern matching
    match values.len() {
        0 => println!("Empty"),
        1 => println!("One value"),
        // pattern matching can use ranges of integers
        2..=10 => println!("Between two and ten values"),
        11 => println!("Eleven values"),
        // A `_` pattern is called a "wildcard", it matches any value
        _ => println!("Many values"),
    };

    // while loop with predicate and pattern matching using let
    while let Some(value) = values.pop() {
        println!("value = {value}"); // using curly brackets to format a local variable
    }
}
</source>

=== Expression blocks ===
{{Main|Expression-oriented programming language}}
Rust is [[Expression-oriented programming language|expression-oriented]], with nearly every part of a function body being an [[Expression (computer science)|expression]], including control-flow operators.{{sfn|Klabnik|Nichols|2019|pp=50–53}} The ordinary <code>if</code> expression is used instead of [[?:|C's ternary conditional]]. With returns being implicit, a function does not need to end with a <code>return</code> expression; if the semicolon is omitted, the value of the last expression in the function is used as the return value,<ref>{{Cite web |last=Tyson |first=Matthew |date=2022-03-03 |title=Rust programming for Java developers |url=https://www.infoworld.com/article/3651362/rust-programming-for-java-developers.html |access-date=2022-07-14 |website=InfoWorld |language=en}}</ref> as seen in the following [[Recursion (computer science)|recursive]] implementation of the [[Factorial|factorial]] function:

<source lang="rust">
fn factorial(i: u64) -> u64 {
    if i == 0 {
        1
    } else {
        i * factorial(i - 1)
    }
}
</source>

The following iterative implementation uses the <code>..=</code> operator to create an inclusive range:

<source lang="rust">
fn factorial(i: u64) -> u64 {
    (2..=i).product()
}
</source>

==== Closures ====
{{excerpt|Anonymous function|Rust|subsections=yes}}

=== Types ===
Rust is strongly typed and statically typed. The types of all variables must be known at compilation time; assigning a value of a particular type to a differently typed variable causes a [[Compilation error|compilation error]]. Variables are declared with the [[Reserved word|keyword]] <code>let</code>, and type inference is used to determine their type.{{sfn|Klabnik|Nichols|2019|pp=24}} Variables assigned multiple times must be marked with the keyword <code>mut</code> (short for mutable).{{sfn|Klabnik|Nichols|2019|pp=32–33}}

The default integer type is {{rust|i32}}, and the default floating point type is {{rust|f64}}. If the type of a [[Literal (computer programming)|literal]] number is not explicitly provided, either it is [[Type inference|inferred]] from the context or the default type is used.{{sfn|Klabnik|Nichols|2019|pp=36–38}}

==== Primitive types ====
{| class="wikitable"
|+Summary of Rust's [[Primitive data type|Primitive Types]]
!Type
!Description
!Examples
|-
|Boolean value
|{{plainlist|
  }}
|-
|Unsigned 8-bit integer (a [[Byte|byte]])
|{{plainlist|
* {{rust|255u8}}<ref group="note" name="ExplicitSuffix">This literal uses an explicit suffix, which is not needed when type can be inferred from the context</ref>
* {{Rust|b'W'}} ([[ASCII]] encoded byte)
  }}
|-
|{{plainlist|
  }}
|Signed integers, up to [[128-bit computing|128 bits]]
|{{plainlist|
* {{rust|7}}<ref group="note" name="Default">Interpreted as {{rust|i32}} by default, or inferred from the context</ref>
* {{rust|7i128}}<ref group="note" name="ExplicitSuffix" />
  }}
|-
|{{plainlist|
  }}
|Unsigned integers, up to [[128-bit computing|128 bits]]
|{{plainlist|
* {{rust|14}}<ref group="note" name="Inferred">Type inferred from the context</ref>
* {{rust|14u128}}<ref group="note" name="ExplicitSuffix" />
  }}
|-
|{{plainlist|
  }}
|[[Pointer (computer programming)|Pointer]]-sized integers (size depends on [[Computing platform|platform]])
|{{plainlist|
* {{rust|14usize}}<ref group="note" name="ExplicitSuffix" />
* {{rust|-2isize}}<ref group="note" name="ExplicitSuffix" />
  }}
|-
|{{plainlist|
  }}
|[[Floating-point arithmetic|Floating-point number]]s
|{{plainlist|
* {{rust|-3f32}}<ref group="note" name="ExplicitSuffix" />
  }}
|-
|{{Plainlist|
* [[UTF-32]] scalar value (occupies 4 bytes)
* A Unicode codepoint that is not a [[Universal Character Set characters#Surrogates|surrogate]]{{sfn|Klabnik|Nichols|2019|pp=39–40}}
  }}
|{{plainlist|
* {{Rust|'🦀'}} ([[Emoji]])
* {{Rust|'\u{200D}'}} (Unicode escape, zero-width joiner)
  }}
|-
|[[UTF-8]]-encoded string slice, the primitive string type. It is usually seen in its borrowed form, {{Rust|&str}}. It is also the type of string literals, {{Rust|&'static str}}<ref>{{Cite web |title=str – Rust |url=https://doc.rust-lang.org/beta/std/primitive.str.html |access-date=2023-06-23 |website=doc.rust-lang.org}}</ref>
|{{plainlist|
  }}
|-
|[[Array (data structure)|Array]] – collection of N objects of the same type T, stored in contiguous memory
|{{plainlist|
  }}
|-
|Slice – a dynamically-sized view into a contiguous sequence<ref>{{Cite web |title=slice – Rust |url=https://doc.rust-lang.org/beta/std/primitive.slice.html |access-date=2023-06-23 |website=doc.rust-lang.org}}</ref>
|{{plainlist|
* {{Rust|let v {{=}} vec![1, 2, 3]; v.as_slice()}}
  }}
|-
|{{plainlist|{{Rust|(T, U, ..)}}}}
|[[Tuple]] – a finite heterogeneous sequence
|{{plainlist|
* {{Rust|()}} (An empty tuple, the [[Unit type|unit type]] in Rust)
* {{Rust|(5,)}} ({{Rust|(5)}} is parsed as an integer)<ref>{{Cite web |title=Tuples |url=https://doc.rust-lang.org/rust-by-example/primitives/tuples.html |access-date=2023-10-01 |website=Rust By Example}}</ref>
  }}
|-
| [[Bottom type|Never type]] (unreachable value)
| {{Rust|let x {{=}} { return 123 };}}
|}

==== Standard library ====
{| class="wikitable"
|+Summary of Rust's types in the [[Standard library|standard library]]
!Type
!Description
!Examples
|-
|A pointer to a heap-allocated value<ref>{{Cite web |title=std::boxed – Rust |url=https://doc.rust-lang.org/std/boxed/index.html |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
| <source lang="rust">
let boxed: Box<u8> = Box::new(5);
let val: u8 = *boxed;
</source>
|-
|UTF-8-encoded strings (dynamic)
|{{plainlist|
  }}
|-
|{{plainlist|
  }}
|Platform-native strings<ref group="note" name="OsString">On Unix systems, this is often UTF-8 strings without an internal 0 byte. On Windows, this is [[UTF-16]] strings without an internal 0 byte. Unlike these, {{Rust|str}} and {{Rust|String}} are always valid UTF-8 and can contain internal zeros.</ref> (borrowed<ref>{{Cite web |title=OsStr in std::ffi – Rust |url=https://doc.rust-lang.org/beta/std/ffi/struct.OsStr.html |access-date=2023-10-02 |website=doc.rust-lang.org}}</ref> and dynamic<ref>{{Cite web |title=OsString in std::ffi – Rust |url=https://doc.rust-lang.org/beta/std/ffi/struct.OsString.html |access-date=2023-10-02 |website=doc.rust-lang.org}}</ref>)
|{{plainlist|
  }}
|-
|{{plainlist|
  }}
|[[Path (computing)|Paths]] (borrowed<ref>{{Cite web |title=Path in std::path – Rust |url=https://doc.rust-lang.org/beta/std/path/struct.Path.html |access-date=2023-10-02 |website=doc.rust-lang.org}}</ref> and dynamic<ref>{{Cite web |title=PathBuf in std::path – Rust |url=https://doc.rust-lang.org/beta/std/path/struct.PathBuf.html |access-date=2023-10-02 |website=doc.rust-lang.org}}</ref>)
|{{plainlist|
  }}
|-
|{{plainlist|
  }}
|[[C (programming language)|C]]-compatible, [[Null-terminated string|null-terminated string]]s (borrowed<ref name="std::boxed – Rust">{{Cite web |title=std::boxed – Rust |url=https://doc.rust-lang.org/std/boxed/index.html |access-date=2023-06-23 |website=doc.rust-lang.org}}</ref> and dynamic<ref name="std::boxed – Rust"/>)
|{{plainlist|
  }}
|-
|[[Dynamic array]]s
|{{plainlist|
  }}
|-
|[[Option type]]
|{{plainlist|
  }}
|-
|[[Exception handling|Error handling]] using a [[Result type|result type]]
|{{plainlist|
  }}
|-
|[[Reference counting]] pointer<ref>{{Cite web |title=Rc in std::rc – Rust |url=https://doc.rust-lang.org/beta/std/rc/struct.Rc.html |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
|<source lang="rust">
let five = Rc::new(5);
let also_five = five.clone();
</source>
|-
|[[Linearizability|Atomic]], [[Thread safety|thread-safe]] reference counting pointer<ref>{{Cite web |title=Arc in std::sync – Rust |url=https://doc.rust-lang.org/beta/std/sync/struct.Arc.html |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
|<source lang="rust">
let foo = Arc::new(vec![1.0, 2.0]);
let a = foo.clone(); // a can be sent to another thread
</source>
|-
|A mutable memory location<ref>{{Cite web |title=Cell in std::cell – Rust |url=https://doc.rust-lang.org/beta/std/cell/struct.Cell.html# |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
|<source lang="rust">
let c = Cell::new(5);
c.set(10);
</source>
|-
|<code>Mutex<T></code>
|A [[Lock (computer science)|mutex lock]] for shared data<ref>{{Cite web |title=Mutex in std::sync – Rust |url=https://doc.rust-lang.org/beta/std/sync/struct.Mutex.html |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
|<source lang="rust">
let mutex = Mutex::new(0_u32);
let _guard = mutex.lock();
</source>
|-
|[[Readers–writer lock]]<ref>{{Cite web |title=RwLock in std::sync – Rust |url=https://doc.rust-lang.org/beta/std/sync/struct.RwLock.html |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
|<source lang="rust">
let lock = RwLock::new(5);
let r1 = lock.read().unwrap();
</source>
|-
|A [[Monitor (synchronization)|conditional monitor]] for shared data<ref>{{Cite web |title=Condvar in std::sync – Rust |url=https://doc.rust-lang.org/beta/std/sync/struct.Condvar.html |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
|<source lang="rust">
 let (lock, cvar) = (Mutex::new(true), Condvar::new());
// As long as the value inside the `Mutex<bool>` is `true`, we wait.
let _guard = cvar.wait_while(lock.lock().unwrap(), |pending| { *pending }).unwrap();

</source>
|-
|Type that represents a span of time<ref>{{Cite web |title=Duration in std::time – Rust |url=https://doc.rust-lang.org/beta/std/time/struct.Duration.html |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
|<source lang="rust">
Duration::from_millis(1) // 1ms
</source>
|-
|[[Hash table]]<ref>{{Cite web |title=HashMap in std::collections – Rust |url=https://doc.rust-lang.org/beta/std/collections/struct.HashMap.html |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
|<source lang="rust">
let mut player_stats = HashMap::new();
player_stats.insert("damage", 1);
player_stats.entry("health").or_insert(100);
</source>
|-
|[[B-tree]]<ref>{{Cite web |title=BTreeMap in std::collections – Rust |url=https://doc.rust-lang.org/beta/std/collections/struct.BTreeMap.html |access-date=2023-06-24 |website=doc.rust-lang.org}}</ref>
|<source lang="rust">
let mut solar_distance = BTreeMap::from([
    ("Mercury", 0.4),
    ("Venus", 0.7),
]);
solar_distance.entry("Earth").or_insert(1.0);

</source>
|}

[[Option type|<code>Option</code>]] values are handled using [[Syntactic sugar|syntactic sugar]], such as the <code>if let</code> construction, to access the inner value (in this case, a string):{{sfn|McNamara|2021}}

<source lang="rust">
fn main() {
    let name1: Option<&str> = None;
    // In this case, nothing will be printed out
    if let Some(name) = name1 {
        println!("{name}");
    }

    let name2: Option<&str> = Some("Matthew");
    // In this case, the word "Matthew" will be printed out
    if let Some(name) = name2 {
        println!("{name}");
    }
}
</source>

==== Pointers ====
{| class="wikitable"
|+Summary of Rust's [[Pointer (computer programming)|pointer]] and [[Reference (computer science)|reference]] primitive types
!Type
!Description
!Examples
|-
|{{plainlist|
  }}
|[[Reference (computer science)|References]] (immutable and mutable)
|{{plainlist|
* {{Rust|let x_ref {{=}} &mut x;}}
  }}
|-
|{{plainlist|
  }}
|{{plainlist|
* Option wrapped reference
* Possibly null reference
  }}
|{{plainlist|
* {{Rust|let x_ref {{=}} Some(&x);}}
* {{Rust|let x_ref {{=}} Some(&mut x);}}
  }}
|-
|{{Plain list|* {{Rust|Box<T>}}
* {{Rust|Option<Box<T>>}}}}
|A pointer to heap-allocated value
(or possibly null pointer if wrapped in option)<ref name="std::boxed – Rust"/>
|{{Plain list|* {{Rust|let boxed {{=}} Box::new(0);}}
* {{Rust|let boxed {{=}} Some(Box::new("Hello World"));}}}}
|-
|{{Plainlist|
  }}
|{{Plainlist|
* Raw pointers (immutable and mutable)
* Possibly [[Null pointer|null]]; {{Rust|unsafe}} to dereference
  }}
|{{Plainlist|
* {{Rust|let x_ptr {{=}} &x as *const T;}}
* {{Rust|let x_ptr {{=}} &mut x as *mut T;}}
  }}
|}

Rust does not use [[Null pointer|null pointer]]s to indicate a lack of data, as doing so can lead to [[Null pointer#Null dereferencing|null dereferencing]]. Accordingly, the basic <code>&</code> and <code>&mut</code> references are guaranteed to not be null. Rust instead uses <code>Option</code> for this purpose: <code>Some(T)</code> indicates that a value is present, and <code>None</code> is analogous to the null pointer.{{sfn|Klabnik|Nichols|2019|pp=101–104}} <code>Option</code> implements a "null pointer optimization", avoiding any spatial overhead for types that cannot have a null value (references or the <code>NonZero</code> types, for example).<ref>{{Cite web |title=std::option - Rust |url=https://doc.rust-lang.org/std/option/index.html#representation |access-date=2023-11-12 |website=doc.rust-lang.org}}</ref>

Unlike references, the raw pointer types <code>*const</code> and <code>*mut</code> may be null; however, it is impossible to dereference them unless the code is explicitly declared unsafe through the use of an <code>unsafe</code> block. Unlike dereferencing, the creation of raw pointers is allowed inside of safe Rust code.{{sfn|Klabnik|Nichols|2019|pp=418–427}}

==== User-defined types ====
User-defined types are created with the <code>struct</code> or <code>enum</code> keywords. The <code>struct</code> keyword is used to denote a [[Record (computer science)|record type]] that groups multiple related values.{{sfn|Klabnik|Nichols|2019|p=83}} <code>enum</code>s can take on different variants at runtime, with its capabilities similar to algebraic data types found in functional programming languages.{{sfn|Klabnik|Nichols|2019|p=97}} Both structs and enums can contain [[Field (computer science)|fields]] with different types.{{sfn|Klabnik|Nichols|2019|pp=98–101}} Alternative names for the same type can be defined with the <code>type</code> keyword.{{sfn|Klabnik|Nichols|2019|pp=438–440}}

The <code>impl</code> keyword can define methods for a user-defined type (data and functions are defined separately). Implementations fulfill a role similar to that of classes within other languages.{{sfn|Klabnik|Nichols|2019|pp=93}}

==== Type conversion ====
{{excerpt|Type conversion|Rust}}

=== Ownership and lifetimes ===
Rust's ownership system consists of rules that ensure memory safety without using a garbage collector. At compile time, each value must be attached to a variable called the ''owner'' of that value, and every value must have exactly one owner.{{sfn|Klabnik|Nichols|2019|pp=59–61}} Values are moved between different owners through assignment or passing a value as a function parameter.  Values can also be ''borrowed,'' meaning they are temporarily passed to a different function before being returned to the owner.{{sfn|Klabnik|Nichols|2019|pp=63–68}} With these rules, Rust can prevent the creation and use of dangling pointers:{{sfn|Klabnik|Nichols|2019|pp=63–68}}{{sfn|Klabnik|Nichols|2019|pp=74–75}}

<source lang="rust">
fn print_string(s: String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("Hello, World");
    print_string(s); // s consumed by print_string
    // s has been moved, so cannot be used any more
    // another print_string(s); would result in a compile error
}
</source>

Because of these ownership rules, Rust types are known as ''linear'' or ''affine'' types, meaning each value can be used exactly once. This enforces a form of software fault isolation as the owner of a value is solely responsible for its correctness and deallocation.<ref name="BeyondSafety">{{Cite book |last1=Balasubramanian |first1=Abhiram |last2=Baranowski |first2=Marek S. |last3=Burtsev |first3=Anton |last4=Panda |first4=Aurojit |last5=Rakamarić |first5=Zvonimir |last6=Ryzhyk |first6=Leonid |title=Proceedings of the 16th Workshop on Hot Topics in Operating Systems |chapter=System Programming in Rust |date=2017-05-07 |chapter-url=https://doi.org/10.1145/3102980.3103006 |series=HotOS '17 |location=New York, NY, US |publisher=Association for Computing Machinery |pages=156–161 |doi=10.1145/3102980.3103006 |isbn=978-1-4503-5068-6 |s2cid=24100599 |access-date=June 1, 2022 |archive-date=June 11, 2022 |archive-url=https://web.archive.org/web/20220611034046/https://dl.acm.org/doi/10.1145/3102980.3103006 |url-status=live}}</ref>

''Lifetimes'' are usually an implicit part of all [[Reference (computer science)|reference types]] in Rust. Each lifetime encompasses a set of locations in the code for which a variable is valid. For example, a reference to a local variable has a lifetime corresponding to the block it is defined in:{{sfn|Klabnik|Nichols|2019|p=194}}

<source lang="rust">
fn main() {
    let r = 9;                              // ------------------+- Lifetime 'a
                                            //                   |
    {                                       //                   |
        let x = 5;                          // -+-- Lifetime 'b  |
        println!("r: {}, x: {}", r, x);     //  |                |
    }                                       //  |                |
                                            //                   |
    println!("r: {}", r);                   //                   |
}                                           // ------------------+
</source>

The borrow checker in the Rust compiler uses lifetimes to ensure that the values a reference points to remain valid. It also ensures that a mutable reference exists only if no immutable references exist at the same time.{{sfn|Klabnik|Nichols|2019|pp=75,134}}<ref>{{Cite web |last=Shamrell-Harrington |first=Nell |title=The Rust Borrow Checker – a Deep Dive |url=https://www.infoq.com/presentations/rust-borrow-checker/ |access-date=2022-06-25 |website=InfoQ |language=en}}</ref> In the example above, the subject of the reference (variable {{code|x}}) has a shorter lifetime than the lifetime of the reference itself (variable {{code|r}}), therefore the borrow checker errors, preventing {{code|x}} from being used from outside its scope.{{sfn|Klabnik|Nichols|2019|pp=194-195}} Rust's memory and ownership system was influenced by [[Region-based memory management|region-based memory management]] in languages such as [[Cyclone (programming language)|Cyclone]] and ML Kit.<ref name="influences" />

Rust defines the relationship between the lifetimes of the objects created and used by functions, using ''lifetime parameters'', as a signature feature.{{sfn|Klabnik|Nichols|2019|pp=192–204}}

When a stack or temporary variable goes out of scope, it is ''dropped'' by running its [[Destructor (computer programming)|destructor]]. The destructor may be programmatically defined through the <code>drop</code> function. This technique enforces the so-called [[Resource acquisition is initialization|resource acquisition is initialization]] (RAII) design pattern, in which resources, such as file descriptors or network sockets, are tied to the lifetime of an object: when the object is dropped, the resource is closed.<ref>{{cite web |title=Drop in std::ops – Rust |url=https://doc.rust-lang.org/std/ops/trait.Drop.html |website=doc.rust-lang.org |access-date=16 July 2022}}</ref><ref>{{cite book |last1=Gomez |first1=Guillaume |last2=Boucher |first2=Antoni |title=Rust programming by example |date=2018 |publisher=Packt Publishing |location=Birmingham, UK |isbn=9781788390637 |page=358 |edition=First |chapter=RAII}}</ref>

The example below parses some configuration options from a string and creates a struct containing the options. The struct only contains references to the data; so, for the struct to remain valid, the data referred to by the struct must be valid as well. The function signature for <code>parse_config</code> specifies this relationship explicitly. In this example, the explicit lifetimes are unnecessary in newer Rust versions, due to lifetime elision, which is an algorithm that automatically assigns lifetimes to functions if they are trivial.{{sfn|Klabnik|Nichols|2019|pp=201–203}}

<source lang="rust">
use std::collections::HashMap;

// This struct has one lifetime parameter, 'src. The name is only used within the struct's definition.
#[derive(Debug)]
struct Config<'src> {
    hostname: &'src str,
    username: &'src str,
}

// This function also has a lifetime parameter, 'cfg. 'cfg is attached to the "config" parameter, which
// establishes that the data in "config" lives at least as long as the 'cfg lifetime.
// The returned struct also uses 'cfg for its lifetime, so it can live at most as long as 'cfg.
fn parse_config<'cfg>(config: &'cfg str) -> Config<'cfg> {
    let key_values: HashMap<_, _> = config
        .lines()
        .filter(|line| !line.starts_with('#'))
        .filter_map(|line| line.split_once('='))
        .map(|(key, value)| (key.trim(), value.trim()))
        .collect();
    Config {
        hostname: key_values["hostname"],
        username: key_values["username"],
    }
}

fn main() {
    let config = parse_config(
        r#"hostname = foobar
username=barfoo"#,
    );
    println!("Parsed config: {:#?}", config);
}
</source>

[[File:Rust 101.webm|thumb|A presentation on Rust by Emily Dunham from Mozilla's Rust team (linux.conf.au conference, Hobart, 2017)]]

=== Memory safety ===
Rust is designed to be memory safe. It does not permit null pointers, [[Dangling pointer|dangling pointer]]s, or data races.<ref name="cnet">{{cite web |url=http://reviews.cnet.com/8301-3514_7-57577639/samsung-joins-mozillas-quest-for-rust/ |title=Samsung joins Mozilla's quest for Rust |last=Rosenblatt |first=Seth |date=2013-04-03 |publisher=CNET |access-date=2013-04-05 |archive-date=2013-04-04 |archive-url=https://web.archive.org/web/20130404142333/http://reviews.cnet.com/8301-3514_7-57577639/samsung-joins-mozillas-quest-for-rust/ |url-status=live}}</ref><ref name="lwn">{{cite web |url=https://lwn.net/Articles/547145/ |title=A taste of Rust |last=Brown |first=Neil |date=2013-04-17 |access-date=2013-04-25 |archive-date=2013-04-26 |archive-url=https://web.archive.org/web/20130426010754/http://lwn.net/Articles/547145/ |url-status=live}}</ref><ref name="The Rustonomicon">{{Cite web|url=https://doc.rust-lang.org/nomicon/races.html|title=Races – The Rustonomicon|website=doc.rust-lang.org|access-date=2017-07-03|archive-date=2017-07-10|archive-url=https://web.archive.org/web/20170710194643/https://doc.rust-lang.org/nomicon/races.html|url-status=live}}</ref> Data values can be initialized only through a fixed set of forms, all of which require their inputs to be already initialized.<ref name="lang-faq">{{cite web  |title=The Rust Language FAQ |website=static.rust-lang.org |url=http://static.rust-lang.org/doc/master/complement-lang-faq.html |url-status=dead |archive-url=https://web.archive.org/web/20150420104147/http://static.rust-lang.org/doc/master/complement-lang-faq.html |archive-date=2015-04-20 |year=2015 |access-date=2017-04-24}}</ref>

Unsafe code can subvert some of these restrictions, using the <code>unsafe</code> keyword.{{sfn|Klabnik|Nichols|2019|pp=418–427}} Unsafe code may also be used for low-level functionality, such as [[Volatile (computer programming)|volatile memory access]], architecture-specific intrinsics, [[Type punning|type punning]], and inline assembly.{{sfn|McNamara|2021|p=139, 376–379, 395}}

=== Memory management ===
Rust does not use [[Garbage collection (computer science)|garbage collection]]. Memory and other resources are instead managed through the "resource acquisition is initialization" convention,<ref>{{Cite web|title=RAII – Rust By Example|url=https://doc.rust-lang.org/rust-by-example/scope/raii.html|access-date=2020-11-22|website=doc.rust-lang.org|archive-date=2019-04-21|archive-url=https://web.archive.org/web/20190421131142/https://doc.rust-lang.org/rust-by-example/scope/raii.html|url-status=live}}</ref> with optional [[Reference counting|reference counting]]. Rust provides deterministic management of resources, with very low [[Overhead (computing)|overhead]].<ref>{{Cite web|url=https://blog.rust-lang.org/2015/05/11/traits.html|title=Abstraction without overhead: traits in Rust|website=Rust Blog|access-date=October 19, 2021|archive-date=September 23, 2021|archive-url=https://web.archive.org/web/20210923101530/https://blog.rust-lang.org/2015/05/11/traits.html|url-status=live}}</ref> Values are [[Stack-based memory allocation|allocated on the stack]] by default, and all dynamic allocations must be explicit.<ref>{{Cite web |title=Box, stack and heap |url=https://doc.rust-lang.org/stable/rust-by-example/std/box.html |access-date=2022-06-13 |website=Rust By Example}}</ref>

The built-in reference types using the <code>&</code> symbol do not involve run-time reference counting. The safety and validity of the underlying pointers is verified at compile time, preventing dangling pointers and other forms of [[Undefined behavior|undefined behavior]].{{sfn|Klabnik|Nichols|2019|pp=70–75}} Rust's type system separates shared, [[Immutable object|immutable]] references of the form <code>&T</code> from unique, mutable references of the form <code>&mut T</code>. A mutable reference can be coerced to an immutable reference, but not vice versa.{{sfn|Klabnik|Nichols|2019|p=323}}

=== Polymorphism ===
==== Generics ====
Rust's more advanced features include the use of generic functions. A generic function is given [[Generic programming|generic]] [[Parameter (computer programming)|parameters]], which allow the same function to be applied to different variable types. This capability reduces [[Duplicate code|duplicate code]]{{sfn|Klabnik|Nichols|2019|pp=171–172}} and is known as [[Parametric polymorphism|parametric polymorphism]].

The following program calculates the sum of two things, for which addition is implemented using a generic function:

<source lang="rust">
use std::ops::Add;

// sum is a generic function with one type parameter, T
fn sum<T>(num1: T, num2: T) -> T
where  
    T: Add<Output = T>,  // T must implement the Add trait where addition returns another T
{
    num1 + num2  // num1 + num2 is syntactic sugar for num1.add(num2) provided by the Add trait
}

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

    let result2 = sum(10.23, 20.45);
    println!("Sum is: {}", result2); // Sum is: 30.68
}
</source>

At compile time, polymorphic functions like <code>sum</code> are [[Instance (computer science)|instantiated]] with the specific types the code requires; in this case, sum of integers and sum of floats.

Generics can be used in functions to allow implementing a behavior for different types without repeating the same code. Generic functions can be written in relation to other generics, without knowing the actual type.{{sfn|Klabnik|Nichols|2019|pp=171–172,205}}

==== Traits ====
Rust's type system supports a mechanism called traits, inspired by [[Type class|type class]]es in the [[Haskell]] language,<ref name="influences"/> to define shared behavior between different types. For example, the <code>Add</code> trait can be implemented for floats and integers, which can be added; and the <code>Display</code> or <code>Debug</code> traits can be implemented for any type that can be converted to a string. Traits can be used to provide a set of common behavior for different types without knowing the actual type. This facility is known as [[Ad hoc polymorphism|ad hoc polymorphism]].

Generic functions can constrain the generic type to implement a particular trait or traits; for example, an <code>add_one</code> function might require the type to implement <code>Add</code>. This means that a generic function can be type-checked as soon as it is defined. The implementation of 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|monomorphization]] and contrasts with the [[Type erasure|type erasure]] scheme typically used in Java and Haskell. Type erasure is also available via the keyword <code>dyn</code> (short for dynamic).{{sfn|Klabnik|Nichols|2019|pp=181,182}} Because monomorphization duplicates the code for each type used, it can result in more optimized code for specific-use cases, but compile time and size of the output binary are also increased.{{sfn|Gjengset|2021|p=25}}

In addition to defining methods for a user-defined type, the <code>impl</code> keyword can be used to implement a trait for a type.{{sfn|Klabnik|Nichols|2019|pp=93}} Traits can provide additional derived methods when implemented.{{sfn|Klabnik|Nichols|2019|pp=182–184}} For example, the trait <code>Iterator</code> requires that the <code>next</code> method be defined for the type. Once the <code>next</code> method is defined, the trait can provide common functional helper methods over the iterator, such as <code>map</code> or <code>filter</code>.{{sfn|Klabnik|Nichols|2019|pp=281–283}}

Traits follow the [[Composition over inheritance|composition over inheritance]] design principle.<ref>{{Cite book |last=Milanesi |first=Carlo |url=https://www.worldcat.org/oclc/1029604209 |title=Beginning Rust: from novice to professional |page=283 |date=2018 |isbn=978-1-4842-3468-6 |publisher=Apress |location=Berkeley, CA |oclc=1029604209}}</ref> That is, traits cannot define fields themselves; they provide a restricted form of inheritance where methods can be defined and [[Mixin|mixed in]] to implementations.

==== Trait objects ====
Rust traits are implemented using [[Static dispatch|static dispatch]], meaning that the type of all values is known at compile time; however, Rust also uses a feature known as ''trait objects'' to accomplish [[Dynamic dispatch|dynamic dispatch]] (also known as [[Duck typing|duck typing]]).<ref name=TraitObjectsBook>{{Cite web |title=Using Trait Objects That Allow for Values of Different Types – The Rust Programming Language |url=https://doc.rust-lang.org/book/ch17-02-trait-objects.html |access-date=2022-07-11 |website=doc.rust-lang.org}}</ref> Dynamically dispatched trait objects are declared using the syntax <code>dyn Tr</code> where <code>Tr</code> is a trait. Trait objects are dynamically sized, therefore they must be put behind a pointer, such as <code>Box</code>.{{sfn|Klabnik|Nichols|2019|pp=441–442}} The following example creates a list of objects where each object can be printed out using the <code>Display</code> trait:

<source lang="Rust">
use std::fmt::Display;

let v: Vec<Box<dyn Display>> = vec![
    Box::new(3),
    Box::new(5.0),
    Box::new("hi"),
];

for x in v {
    println!("{x}");
}
</source>

If an element in the list does not implement the <code>Display</code> trait, it will cause a compile-time error.{{sfn|Klabnik|Nichols|2019|pp=379–380}}

=== Iterators ===
[[For loop]]s in Rust work in a functional style as operations over an [[Iterator|iterator]] type. For example, in the loop

<source lang="rust">
for x in 0..100 {
   f(x);
}
</source>

<code>0..100</code> is a value of type <code>Range</code> which implements the <code>Iterator</code> trait; the code applies the function <code>f</code> to each element returned by the iterator. Iterators can be combined with functions over iterators like <code>map</code>, <code>filter</code>, and <code>sum</code>. For example, the following adds up all numbers between 1 and 100 that are multiples of 3:

<source lang="rust">
(1..=100).filter(|&x| x % 3 == 0).sum()
</source>

=== Macros ===
It is possible to extend the Rust language using macros.

==== Declarative macros ====
A declarative macro (also called a "macro by example") is a macro that uses pattern matching to determine its expansion.<ref name="Rust Ref. – Macros By Example">{{cite web |title=Macros By Example |url=https://doc.rust-lang.org/reference/macros-by-example.html |archive-url= |archive-date= |url-status= |website=The Rust Reference |access-date=21 April 2023}}</ref>{{sfn|Klabnik|Nichols|2019|pp=446–448}}

==== Procedural macros ====
Procedural macros are Rust functions that run and modify the compiler's input token stream, before any other components are compiled. They are generally more flexible than declarative macros, but are more difficult to maintain due to their complexity.<ref name="rust-procedural-macros">{{cite web |url=https://doc.rust-lang.org/reference/procedural-macros.html |title=Procedural Macros |website=The Rust Programming Language Reference |access-date=23 Mar 2021 |archive-date=7 November 2020 |archive-url=https://web.archive.org/web/20201107233444/https://doc.rust-lang.org/reference/procedural-macros.html |url-status=live}}</ref>{{sfn|Klabnik|Nichols|2019|pp=449–455}}

Procedural macros come in three flavors:
* Function-like macros <code>custom!(...)</code>
* Derive macros <code>#[derive(CustomDerive)]</code>
* Attribute macros <code>#[custom_attribute]</code>

The <code>println!</code> macro is an example of a function-like macro. The<code>serde_derive</code> macro<ref>{{cite web|url=https://serde.rs/derive.html|title=Serde Derive|website=Serde Derive documentation|access-date=23 Mar 2021|archive-date=17 April 2021|archive-url=https://web.archive.org/web/20210417114849/https://serde.rs/derive.html|url-status=live}}</ref> provides 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 <code>extendr</code> library for Rust bindings to [[R (programming language)|R]].<ref>{{cite web|url=https://extendr.github.io/extendr/extendr_api/index.html|title=extendr_api – Rust|website=Extendr Api Documentation|access-date=23 Mar 2021|archive-date=May 25, 2021|archive-url=https://web.archive.org/web/20210525082129/https://extendr.github.io/extendr/extendr_api/index.html|url-status=live}}</ref>

The following code shows the use of the <code>Serialize</code>, <code>Deserialize</code>, and <code>Debug</code>-derived procedural macros
to implement JSON reading and writing, as well as the ability to format a structure for debugging.
[[File:Rust serde UML diagram.svg|thumb|A UML diagram depicting a Rust struct named Point.]]
<source lang="rust">
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);
}
</source>

==== Variadic macros ====
{{excerpt|Variadic function|In Rust|subsections=yes}}

=== Interface with C and C++ ===
Rust has a [[Foreign function interface|foreign function interface]] (FFI) that can be used both to call code written in languages such as [[C (programming language)|C]] from Rust and to call Rust code from those languages. As of 2023, a external library called CXX exists for calling to or from C++.<ref>{{Cite web|title=Safe Interoperability between Rust and C++ with CXX|url=https://www.infoq.com/news/2020/12/cpp-rust-interop-cxx/|date=2020-12-06|access-date=2021-01-03|website=InfoQ|language=en|archive-date=January 22, 2021|archive-url=https://web.archive.org/web/20210122142035/https://www.infoq.com/news/2020/12/cpp-rust-interop-cxx/|url-status=live}}</ref> Rust and C differ in how they lay out structs in memory, so Rust structs may be given a <code>#[repr(C)]</code> attribute, forcing the same layout as the equivalent C struct.<ref>{{cite web |title=Type layout – The Rust Reference |url=https://doc.rust-lang.org/reference/type-layout.html#the-c-representation |website=doc.rust-lang.org |access-date=15 July 2022}}</ref>

== Components ==
[[File:Rustc building paru with cargo screenshot.png|thumb|right|Compiling a Rust program with Cargo]]

The Rust ecosystem includes its compiler, its [[Standard library|standard library]], and additional components for software development. Component installation is typically managed by {{code|rustup}}, a Rust toolchain installer developed by the Rust project.<ref>{{Cite web |last=樽井 |first=秀人 |date=2022-07-13 |title=「Rust」言語のインストーラー「Rustup」が「Visual Studio 2022」の自動導入に対応／Windows/Mac/Linux、どのプラットフォームでも共通の手順でお手軽セットアップ |url=https://forest.watch.impress.co.jp/docs/news/1424702.html |access-date=2022-07-14 |website=窓の杜 |language=ja}}</ref>
<!-- Add Miri Compiler? -->

=== Compiler ===
The Rust compiler is named <code>rustc</code>. Internally, <code>rustc</code> is a frontend to various backends that are used for further device-specific and platform-specific binary code files (e.g. [[Executable and Linkable Format|ELF]] or [[WebAssembly|WASM]] binary) generation (compilation). The most mature and most used backend in <code>rustc</code> is the [[Software:LLVM|LLVM]] intermediate representation (bytecode) compiler,<ref>{{Cite web |last=Yegulalp |first=Serdar |date=2020-03-11 |title=What is LLVM? The power behind Swift, Rust, Clang, and more |url=https://www.infoworld.com/article/3247799/what-is-llvm-the-power-behind-swift-rust-clang-and-more.html |access-date=2023-06-02 |website=InfoWorld |language=en}}</ref>{{better source needed|date=November 2023}} but a [[Software:Cranelift|Cranelift]]-based backend and a [[Software:GNU Compiler Collection|GCC]]-based backend are also available in nightly builds of the compiler.<ref>{{Cite web |title=Overview of the compiler – Rust Compiler Development Guide |url=https://rustc-dev-guide.rust-lang.org/overview.html#code-generation |access-date=2023-06-02 |website=rustc-dev-guide.rust-lang.org}}</ref>

=== Standard library ===
The Rust standard library defines and implements many widely used custom data types, including core data structures such as {{code|Vec}}, {{code|Option}}, and {{code|HashMap}}, as well as [[Smart pointer|smart pointer]] types. Rust also provides a way to exclude most of the standard library using the attribute {{rust|#![no_std]}}; this enables applications, such as embedded devices, which want to remove dependency code or provide their own core data structures. Internally, the standard library is divided into three parts, {{code|core}}, {{code|alloc}}, and {{code|std}}, where {{code|std}} and {{Code|alloc}} are excluded by {{rust|#![no_std]}}.{{sfn|Gjengset|2021|p=213-215}}

[[File:Crates.io website.png|thumb|right|Screenshot of crates.io in June 2022]]

=== Cargo ===
Cargo is Rust's [[Software:Build automation|build system]] and [[Package manager|package manager]]. It downloads, compiles, distributes, and uploads packages—called ''crates''—that are maintained in an official registry. It also acts as a front-end for Clippy and other Rust components.<ref name="Nature" />

By default, Cargo sources its dependencies from the user-contributed registry ''crates.io'', but [[Software:Git|Git]] repositories and crates in the local filesystem, and other external sources can also be specified as dependencies.<ref>{{Cite web |last=Simone |first=Sergio De |date=2019-04-18 |title=Rust 1.34 Introduces Alternative Registries for Non-Public Crates |url=https://www.infoq.com/news/2019/04/rust-1.34-additional-registries |access-date=2022-07-14 |website=InfoQ |language=en}}</ref>

=== Rustfmt ===
Rustfmt is a code formatter for Rust. It formats whitespace and [[Indentation style|indentation]] to produce code in accordance with a common [[Programming style|style]], unless otherwise specified. It can be invoked as a standalone program, or from a Rust project through Cargo.{{sfn|Klabnik|Nichols|2019|pp=511–512}}

[[File:Cargo clippy hello world example.png|thumb|right|Example output of Clippy on a hello world Rust program]]

=== Clippy ===
Clippy is Rust's built-in linting tool to improve the correctness, performance, and readability of Rust code. It was created in 2014<ref>{{Cite web|title=Create README.md · rust-lang/rust-clippy@507dc2b|url=https://github.com/rust-lang/rust-clippy/commit/507dc2b7ec30cf94554b441d4fcb1ce113f98a16|access-date=2021-11-22|website=GitHub|language=en|archive-date=November 22, 2021|archive-url=https://web.archive.org/web/20211122205459/https://github.com/rust-lang/rust-clippy/commit/507dc2b7ec30cf94554b441d4fcb1ce113f98a16|url-status=live}}</ref>{{Better source needed|date=November 2023}} and named after [[Office Assistant|Microsoft Office's assistant]], an anthropomorphized paperclip of the same name.<ref>{{Cite web|url=https://zsiciarz.github.io/24daysofrust/book/vol2/day1.html|title=24 days of Rust: Day 1: Cargo subcommands|access-date=2021-11-22|website=zsiciarz.github.io|archive-date=April 7, 2022|archive-url=https://web.archive.org/web/20220407183227/https://zsiciarz.github.io/24daysofrust/book/vol2/day1.html|url-status=live}}</ref> {{as of|2024}}, it has more than 700 rules,<ref>{{Citation |title=Clippy |date=2023-11-30 |url=https://github.com/rust-lang/rust-clippy |access-date=2023-11-30 |publisher=The Rust Programming Language}}</ref><ref>{{Cite web |title=Clippy Lints |url=https://rust-lang.github.io/rust-clippy/master/index.html |access-date=2023-11-30 |website=rust-lang.github.io}}</ref> which can be browsed online and filtered by category.<ref>{{cite web |title=ALL the Clippy Lints |url=https://rust-lang.github.io/rust-clippy/ |access-date=May 22, 2021 |archive-date=May 22, 2021 |archive-url=https://web.archive.org/web/20210522090805/https://rust-lang.github.io/rust-clippy/ |url-status=live}}</ref>{{sfn|Klabnik|Nichols|2019|pp=513–514}}

=== Versioning system ===
Following Rust 1.0, new features are developed in ''nightly'' versions which are released daily. During each six-week release cycle, changes to nightly versions are released to beta, while changes from the previous beta version are released to a new stable version.<ref name="Rust Book G">{{harvnb|Klabnik|Nichols|2019|loc=Appendix G – How Rust is Made and "Nightly Rust"}}</ref>

Every two or three years, a new "edition" is produced. Editions are released to allow making limited breaking changes, such as promoting {{code|await}} to a keyword to support async/await features. Crates targeting different editions can interoperate with each other, so a crate can upgrade to a new edition even if its callers or its dependencies still target older editions. Migration to a new edition can be assisted with automated tooling.{{sfn|Blandy|Orendorff|Tindall|2021|pp=176–177}}

=== IDE support ===
The most popular [[Language Server Protocol|language server]] for Rust is ''Rust Analyzer'', which officially replaced the original language server, ''RLS'', in July 2022.<ref>{{Cite web |first=Tim |last=Anderson |date=2022-07-05 |title=Rust team releases 1.62, sets end date for deprecated language server |url=https://devclass.com/2022/07/05/rust-team-releases-1-62-sets-end-date-for-deprecated-language-server/ |access-date=2022-07-14 |website=DEVCLASS |language=en-GB}}</ref> Rust Analyzer provides [[Integrated development environment|IDE]]s and [[Software:Text editor|text editor]]s with information about a Rust project; basic features including autocompletion, and the display of compilation errors while editing.{{sfn|Klabnik|Nichols|2023|p=623}}

== Performance ==
In general, Rust's memory safety guarantees do not impose a runtime overhead.{{sfn|McNamara|2021|p=11}} A notable exception is [[Array (data structure)|array indexing]] which is checked at runtime, though this often does not impact performance.<ref>{{Cite journal |last1=Popescu |first1=Natalie |last2=Xu |first2=Ziyang |last3=Apostolakis |first3=Sotiris |last4=August |first4=David I. |last5=Levy |first5=Amit |date=2021-10-15 |title=Safer at any speed: automatic context-aware safety enhancement for Rust |url=https://doi.org/10.1145/3485480 |journal=Proceedings of the ACM on Programming Languages |volume=5 |issue=OOPSLA | quote="We observe a large variance in the overheads of checked indexing: 23.6% of benchmarks do report significant performance hits from checked indexing, but 64.5% report little-to-no impact and, surprisingly, 11.8% report improved performance ... Ultimately, while unchecked indexing can improve performance, most of the time it does not." |quote-page=5 |at=Section 2 |doi=10.1145/3485480|s2cid=238212612|doi-access=free }}</ref> Since it does not perform garbage collection, Rust is often faster than other memory-safe languages.<ref>{{Cite web |last=Anderson |first=Tim |title=Can Rust save the planet? Why, and why not |url=https://www.theregister.com/2021/11/30/aws_reinvent_rust/ |access-date=2022-07-11 |website=The Register |language=en}}</ref><ref>{{Cite book |last1=Balasubramanian |first1=Abhiram |last2=Baranowski |first2=Marek S. |last3=Burtsev |first3=Anton |last4=Panda |first4=Aurojit |last5=Rakamarić |first5=Zvonimir |last6=Ryzhyk |first6=Leonid |title=Proceedings of the 16th Workshop on Hot Topics in Operating Systems |chapter=System Programming in Rust |date=2017-05-07 |chapter-url=https://dl.acm.org/doi/10.1145/3102980.3103006 |language=en |location=Whistler BC Canada |publisher=ACM |pages=156–161 |doi=10.1145/3102980.3103006 |isbn=978-1-4503-5068-6|s2cid=24100599 }}</ref><ref>{{Cite web |last=Yegulalp |first=Serdar |date=2021-10-06 |title=What is the Rust language? Safe, fast, and easy software development |url=https://www.infoworld.com/article/3218074/what-is-rust-safe-fast-and-easy-software-development.html |access-date=2022-06-25 |website=InfoWorld |language=en}}</ref>

Rust provides two "modes": safe and unsafe. Safe mode is the "normal" one, in which most Rust is written. In unsafe mode, the developer is responsible for the code's memory safety, which is useful for cases where the compiler is too restrictive.<ref>{{Cite web |last=Wróbel |first=Krzysztof |date=April 11, 2022 |title=Rust projects – why large IT companies use Rust? |url=https://codilime.com/blog/rust-projects-why-large-it-companies-use-rust/ |url-status=live |archive-url=https://web.archive.org/web/20221227212821/https://codilime.com/blog/rust-projects-why-large-it-companies-use-rust/ |archive-date=2022-12-27}}</ref>

Many of Rust's features are so-called ''zero-cost abstractions'', meaning they are optimized away at compile time and incur no runtime penalty.{{sfn|McNamara|2021|p=19, 27}} The ownership and borrowing system permits [[Zero-copy|zero-copy]] implementations for some performance-sensitive tasks, such as [[Parsing|parsing]].<ref>{{Cite book |last=Couprie |first=Geoffroy |title=2015 IEEE Security and Privacy Workshops |chapter=Nom, A Byte oriented, streaming, Zero copy, Parser Combinators Library in Rust |date=2015 |chapter-url=https://ieeexplore.ieee.org/document/7163218 |pages=142–148 |doi=10.1109/SPW.2015.31|isbn=978-1-4799-9933-0 |s2cid=16608844 }}</ref> Static dispatch is used by default to eliminate method calls, with the exception of methods called on dynamic trait objects.{{sfn|McNamara|2021|p=20}} The compiler also uses [[Inline expansion|inline expansion]] to eliminate function calls and statically-dispatched method invocations.<ref>{{Cite web |title=Code generation – The Rust Reference |url=https://doc.rust-lang.org/reference/attributes/codegen.html |access-date=2022-10-09 |website=doc.rust-lang.org}}</ref>

Since Rust utilizes [[Software:LLVM|LLVM]], any performance improvements in LLVM also carry over to Rust.<ref name="how-fast-is-rust">{{cite web |url=https://doc.rust-lang.org/1.0.0/complement-lang-faq.html#how-fast-is-rust? |title=How Fast Is Rust? |website=The Rust Programming Language FAQ |access-date=11 April 2019 |archive-date=28 October 2020 |archive-url=https://web.archive.org/web/20201028102013/https://doc.rust-lang.org/1.0.0/complement-lang-faq.html#how-fast-is-rust? |url-status=live}}</ref> Unlike C and C++, Rust allows for reordering struct and enum elements<ref>{{Cite book |url=https://dlnext.acm.org/doi/abs/10.1145/3445814.3446724 |access-date=2022-07-12 |year=2021 |language=en |doi=10.1145/3445814.3446724|quote=... While some compilers (e.g., Rust) support structure reordering [82], C & C++ compilers are forbidden to reorder data structures (e.g., struct or class) [74] ...|last1=Farshin |first1=Alireza |last2=Barbette |first2=Tom |last3=Roozbeh |first3=Amir |last4=Maguire Jr |first4=Gerald Q. |last5=Kostić |first5=Dejan |title=Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems |chapter=PacketMill: Toward per-Core 100-GBPS networking |pages=1–17 |isbn=9781450383172 |s2cid=231949599}}</ref> to reduce the sizes of structures in memory, for better memory alignment, and to improve [[CPU cache|cache]] access efficiency.<ref>{{Cite web |title=Type layout |url=https://doc.rust-lang.org/reference/type-layout.html |access-date=2022-07-14 |website=The Rust Reference}}</ref>

== Adoption ==
<!--
IMPORTANT:
Please add entries only with independent published sources, e.g., news articles, not GitHub projects with no secondary source(s). For specific guidelines, see: Wikipedia:Identifying reliable sources
-->
[[File:Home page servo v0.01.png|thumb|right|Early homepage of Mozilla's Servo browser engine]]
Rust has been used in software spanning across different domains. Rust was initially funded by Mozilla as part of developing Servo, an experimental [[Parallel computing|parallel]] [[Software:Browser engine|browser engine]], in collaboration with [[Company:Samsung|Samsung]].<ref>{{cite news|last=Lardinois|first=Frederic|date=2015-04-03|title=Mozilla And Samsung Team Up To Develop Servo, Mozilla's Next-Gen Browser Engine For Multicore Processors|work=TechCrunch|url=https://techcrunch.com/2013/04/03/mozilla-and-samsung-collaborate-on-servo-mozillas-next-gen-browser-engine-for-tomorrows-multicore-processors/|access-date=2017-06-25|archive-date=2016-09-10|archive-url=https://web.archive.org/web/20160910211537/https://techcrunch.com/2013/04/03/mozilla-and-samsung-collaborate-on-servo-mozillas-next-gen-browser-engine-for-tomorrows-multicore-processors/|url-status=live}}</ref> Components from the Servo engine were later incorporated in the [[Software:Gecko|Gecko]] browser engine underlying Firefox.<ref>{{Cite web |last=Keizer |first=Gregg |date=2016-10-31 |title=Mozilla plans to rejuvenate Firefox in 2017 |url=https://www.computerworld.com/article/3137050/mozilla-plans-to-rejuvenate-firefox-in-2017.html |access-date=2023-05-13 |website=Computerworld |language=en}}</ref> In January 2023, Google (Alphabet) announced support for third party Rust libraries in [[Software:Chromium (web browser)|Chromium]] and consequently in the [[Software:ChromeOS|ChromeOS]] code base.<ref>{{Cite web |title=Supporting the Use of Rust in the Chromium Project |url=https://security.googleblog.com/2023/01/supporting-use-of-rust-in-chromium.html |access-date=2023-11-12 |website=Google Online Security Blog |language=en}}</ref>

Rust is used in several [[Frontend and backend|backend]] software projects of large web services. [[Company:OpenDNS|OpenDNS]], a [[Domain Name System|DNS]] resolution service owned by [[Company:Cisco|Cisco]], uses Rust internally.<ref>{{Cite web |last=Shankland |first=Stephen |date=2016-07-12 |title=Firefox will get overhaul in bid to get you interested again |url=https://www.cnet.com/tech/services-and-software/firefox-mozilla-gets-overhaul-in-a-bid-to-get-you-interested-again/ |access-date=2022-07-14 |publisher=CNET |language=en}}</ref><ref>{{Cite web |author=Security Research Team |date=2013-10-04 |title=ZeroMQ: Helping us Block Malicious Domains in Real Time |url=https://umbrella.cisco.com/blog/zeromq-helping-us-block-malicious-domains |access-date=2023-05-13 |website=Cisco Umbrella |language=en-US}}</ref> Amazon Web Services began developing projects in Rust as early as 2017,<ref name=":2">{{Cite web|date=2021-03-03|title=How our AWS Rust team will contribute to Rust's future successes|url=https://aws.amazon.com/blogs/opensource/how-our-aws-rust-team-will-contribute-to-rusts-future-successes/|access-date=2022-01-02|website=Amazon Web Services|language=en-US|archive-date=January 2, 2022|archive-url=https://web.archive.org/web/20220102233211/https://aws.amazon.com/blogs/opensource/how-our-aws-rust-team-will-contribute-to-rusts-future-successes/|url-status=live}}</ref> including [[Software:Firecracker|Firecracker]], a virtualization solution;<ref>{{Cite web|date=2018-11-26|title=Firecracker – Lightweight Virtualization for Serverless Computing|url=https://aws.amazon.com/blogs/aws/firecracker-lightweight-virtualization-for-serverless-computing/|access-date=2022-01-02|website=Amazon Web Services|language=en-US|archive-date=December 8, 2021|archive-url=https://web.archive.org/web/20211208100629/https://aws.amazon.com/blogs/aws/firecracker-lightweight-virtualization-for-serverless-computing/|url-status=live}}</ref> Bottlerocket, a [[Software:Linux distribution|Linux distribution]] and [[Containerization (computing)|containerization]] solution;<ref>{{Cite web |date=2020-08-31 |title=Announcing the General Availability of Bottlerocket, an open source Linux distribution built to run containers |url=https://aws.amazon.com/blogs/opensource/announcing-the-general-availability-of-bottlerocket-an-open-source-linux-distribution-purpose-built-to-run-containers/ |url-status=live |archive-url=https://web.archive.org/web/20220102233213/https://aws.amazon.com/blogs/opensource/announcing-the-general-availability-of-bottlerocket-an-open-source-linux-distribution-purpose-built-to-run-containers/ |archive-date=January 2, 2022 |access-date=2022-01-02 |website=Amazon Web Services |language=en-US}}</ref> and [[Software:Tokio|Tokio]], an asynchronous networking stack.<ref>{{Cite web |date=2020-11-24 |title=Why AWS loves Rust, and how we'd like to help |url=https://aws.amazon.com/blogs/opensource/why-aws-loves-rust-and-how-wed-like-to-help/ |access-date=2022-04-21 |website=Amazon Web Services |language=en-US |archive-date=December 3, 2020 |archive-url=https://web.archive.org/web/20201203170127/https://aws.amazon.com/blogs/opensource/why-aws-loves-rust-and-how-wed-like-to-help/ |url-status=live}}</ref> [[Software:Microsoft Azure|Microsoft Azure]] IoT Edge, a platform used to run Azure services on [[Internet of things|IoT]] devices, has components implemented in Rust.<ref>{{Cite web|url=https://www.theregister.co.uk/2018/06/27/microsofts_next_cloud_trick_kicking_things_out_of_the_cloud_to_azure_iot_edge/|title=Microsoft's next trick? Kicking things out of the cloud to Azure IoT Edge|last=Nichols|first=Shaun|date=27 June 2018|website=The Register|language=en|access-date=2019-09-27|archive-date=2019-09-27|archive-url=https://web.archive.org/web/20190927092433/https://www.theregister.co.uk/2018/06/27/microsofts_next_cloud_trick_kicking_things_out_of_the_cloud_to_azure_iot_edge/|url-status=live}}</ref> Microsoft also uses Rust to run containerized modules with [[WebAssembly]] and [[Software:Kubernetes|Kubernetes]].<ref>{{Cite web |last=Tung |first=Liam |title=Microsoft: Why we used programming language Rust over Go for WebAssembly on Kubernetes app |url=https://www.zdnet.com/article/microsoft-why-we-used-programming-language-rust-over-go-for-webassembly-on-kubernetes-app/ |access-date=2022-04-21 |publisher=ZDNet |language=en |archive-date=April 21, 2022 |archive-url=https://web.archive.org/web/20220421043549/https://www.zdnet.com/article/microsoft-why-we-used-programming-language-rust-over-go-for-webassembly-on-kubernetes-app/ |url-status=live}}</ref> [[Company:Cloudflare|Cloudflare]], a company providing [[Content delivery network|content delivery network]] services uses Rust for its [[Firewall (computing)|firewall]] pattern matching engine.<ref>{{Cite web |date=2019-03-04 |title=How we made Firewall Rules |url=http://blog.cloudflare.com/how-we-made-firewall-rules/ |access-date=2022-06-11 |website=The Cloudflare Blog |language=en}}</ref><ref>{{Cite web |date=2019-01-22 |title=Enjoy a slice of QUIC, and Rust! |url=http://blog.cloudflare.com/enjoy-a-slice-of-quic-and-rust/ |access-date=2022-06-11 |website=The Cloudflare Blog |language=en}}</ref>

In operating systems, the Rust for Linux project was begun in 2021 to add Rust support to the [[Software:Linux kernel|Linux kernel]].<ref>{{Cite web |first=Tim |last=Anderson |date=2021-12-07 |title=Rusty Linux kernel draws closer with new patch |url=https://www.theregister.com/2021/12/07/rusty_linux_kernel_draws_closer/ |access-date=2022-07-14 |website=The Register |language=en}}</ref> Support for Rust (along with support for [[C (programming language)|C]] and [[Assembly language]]) was officially added in version 6.1.<ref>{{Cite web |title=A first look at Rust in the 6.1 kernel [LWN.net] |url=https://lwn.net/Articles/910762/ |access-date=2023-11-11 |website=lwn.net}}</ref> [[Company:Microsoft|Microsoft]] announced in 2020 that parts of [[Software:Windows|Microsoft Windows]] are being rewritten in Rust. {{as of|2023}}, DWriteCore, a system library for text layout and glyph render, has about 152,000 lines of Rust code and about 96,000 lines of C++ code, and saw a performance increase of 5 to 15 percent in some cases.<ref>{{Cite web |last=Claburn |first=Thomas |title=Microsoft is rewriting core Windows libraries in Rust |url=https://www.theregister.com/2023/04/27/microsoft_windows_rust/ |date=2023-04-27 |access-date=2023-05-13 |website=The Register |language=en}}</ref> Google announced support for Rust in the [[Software:Android (operating system)|Android operating system]] also in 2021.<ref name=":1">{{Cite web |title=Rust in the Android platform |url=https://security.googleblog.com/2021/04/rust-in-android-platform.html |access-date=2022-04-21 |website=Google Online Security Blog |language=en |archive-date=April 3, 2022 |archive-url=https://web.archive.org/web/20220403015852/https://security.googleblog.com/2021/04/rust-in-android-platform.html |url-status=live}}</ref><ref>{{Cite web |last=Amadeo |first=Ron |date=2021-04-07 |title=Google is now writing low-level Android code in Rust |url=https://arstechnica.com/gadgets/2021/04/google-is-now-writing-low-level-android-code-in-rust/ |access-date=2022-04-21 |website=Ars Technica |language=en-us |archive-date=April 8, 2021 |archive-url=https://web.archive.org/web/20210408001446/https://arstechnica.com/gadgets/2021/04/google-is-now-writing-low-level-android-code-in-rust/ |url-status=live}}</ref> Other operating systems written in Rust include [[Software:Redox (operating system)|Redox]], a "Unix-like" operating system and [[Microkernel|microkernel]],<ref>{{cite news |last=Yegulalp |first=Serdar |title=Rust's Redox OS could show Linux a few new tricks |url=http://www.infoworld.com/article/3046100/open-source-tools/rusts-redox-os-could-show-linux-a-few-new-tricks.html |access-date=21 March 2016 |work=InfoWorld |archive-date=21 March 2016 |archive-url=https://web.archive.org/web/20160321192838/http://www.infoworld.com/article/3046100/open-source-tools/rusts-redox-os-could-show-linux-a-few-new-tricks.html |url-status=live}}</ref> and Theseus, an experimental operating system with modular state management.<ref>{{Cite web |first=Tim |last=Anderson |date=2021-01-14 |title=Another Rust-y OS: Theseus joins Redox in pursuit of safer, more resilient systems |url=https://www.theregister.com/2021/01/14/rust_os_theseus/ |access-date=2022-07-14 |website=The Register |language=en}}</ref><ref>{{Cite book |last1=Boos |first1=Kevin |last2=Liyanage |first2=Namitha |last3=Ijaz |first3=Ramla |last4=Zhong |first4=Lin |date=2020 |title=Theseus: an Experiment in Operating System Structure and State Management |url=https://www.usenix.org/conference/osdi20/presentation/boos |language=en |pages=1–19 |isbn=978-1-939133-19-9}}</ref> Rust is also used for command-line tools and operating system components, including [[Software:Stratis (configuration daemon)|stratisd]], a [[File system|file system]] manager<ref>{{cite web |url=https://www.marksei.com/fedora-29-new-features-startis/ |title=Fedora 29 new features: Startis now officially in Fedora |last=Sei |first=Mark |date=10 October 2018 |website=Marksei, Weekly sysadmin pills |access-date=2019-05-13 |archive-date=2019-04-13 |archive-url=https://web.archive.org/web/20190413075055/https://www.marksei.com/fedora-29-new-features-startis/ |url-status=live}}</ref><ref>{{Cite web |last=Proven |first=Liam |date=2022-07-12 |title=Oracle Linux 9 released, with some interesting additions |url=https://www.theregister.com/2022/07/12/oracle_linux_9/ |access-date=2022-07-14 |website=The Register |language=en}}</ref> and COSMIC, a [[Software:Desktop environment|desktop environment]] by [[Company:System76|System76]].<ref name="FOSSN_()">{{cite web |last1=Patel |first1=Pratham |title=I Tried System76's New Rust-based COSMIC Desktop! |url=https://news.itsfoss.com/system76-rust-cosmic-desktop/ |website=It's FOSS News – Development Updates |date=January 14, 2022 |publisher=It's FOSS News |access-date=10 January 2023}}</ref><ref name="S76_(2023)">{{cite web |title=Pop!_OS by System76 |url=https://pop.system76.com/ |website=pop.system76.com |publisher=System76, Inc. |access-date=10 January 2023 |language=en}}</ref>

[[File:Ruffle.rs demo (1).png|thumb|Ruffle, a web emulator for [[Software:Adobe Flash|Adobe Flash]] [[SWF|SWF]] files]]

In web development, the [[Software:Npm|npm package manager]] started using Rust in production in 2019.<ref>{{Cite web |title=NPM Adopted Rust to Remove Performance Bottlenecks |url=https://www.infoq.com/news/2019/03/rust-npm-performance/ |access-date=2023-11-20 |website=InfoQ |language=en}}</ref><ref>{{Citation |last=Lyu |first=Shing |title=Welcome to the World of Rust |date=2020 |url=https://doi.org/10.1007/978-1-4842-5599-5_1 |work=Practical Rust Projects: Building Game, Physical Computing, and Machine Learning Applications |pages=1–8 |editor-last=Lyu |editor-first=Shing |access-date=2023-11-29 |place=Berkeley, CA |publisher=Apress |language=en |doi=10.1007/978-1-4842-5599-5_1 |isbn=978-1-4842-5599-5}}</ref><ref>{{Citation |last=Lyu |first=Shing |title=Rust in the Web World |date=2021 |url=https://doi.org/10.1007/978-1-4842-6589-5_1 |work=Practical Rust Web Projects: Building Cloud and Web-Based Applications |pages=1–7 |editor-last=Lyu |editor-first=Shing |access-date=2023-11-29 |place=Berkeley, CA |publisher=Apress |language=en |doi=10.1007/978-1-4842-6589-5_1 |isbn=978-1-4842-6589-5}}</ref> [[Software:Deno|Deno]], a secure runtime for [[JavaScript]] and [[TypeScript]], is built with [[Software:V8 (JavaScript engine)|V8]], Rust, and Tokio.<ref>{{Cite web |first=Vivian |last=Hu |date=2020-06-12 |title=Deno Is Ready for Production |url=https://www.infoq.com/news/2020/06/deno-1-ready-production/ |access-date=2022-07-14 |website=InfoQ |language=en}}</ref> Other notable adoptions in this space include [[Software:Ruffle|Ruffle]], an open-source [[SWF]] emulator,<ref>{{Cite web |last=Abrams|first=Lawrence|date=2021-02-06|title=This Flash Player emulator lets you securely play your old games|url=https://www.bleepingcomputer.com/news/software/this-flash-player-emulator-lets-you-securely-play-your-old-games/|access-date=2021-12-25|website=BleepingComputer|language=en-us}}</ref> and [[Finance:Polkadot (cryptocurrency)|Polkadot]], an open source [[Finance:Blockchain|blockchain]] and [[Finance:Cryptocurrency|cryptocurrency]] platform.<ref>{{Cite web |date=October 17, 2020 |title=Ethereum Blockchain Killer Goes By Unassuming Name of Polkadot |url=https://www.bloomberg.com/news/articles/2020-10-17/ethereum-blockchain-killer-goes-by-unassuming-name-of-polkadot |url-access=subscription |access-date=July 14, 2021 |publisher=Bloomberg L.P.}}</ref>

[[Software:Discord|Discord]], an [[Social:Instant messaging|instant messaging]] social platform uses Rust for portions of its backend, as well as client-side video encoding.<ref name=":3">{{cite web |last=Howarth |first=Jesse |date=2020-02-04 |title=Why Discord is switching from Go to Rust |url=https://discord.com/blog/why-discord-is-switching-from-go-to-rust |url-status=live |archive-url=https://web.archive.org/web/20200630181517/https://blog.discord.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f |archive-date=2020-06-30 |access-date=2020-04-14}}</ref> In 2021, [[Software:Dropbox|Dropbox]] announced their use of Rust for a screen, video, and image capturing service.<ref>{{Cite web |last=The Dropbox Capture Team |title=Why we built a custom Rust library for Capture |url=https://dropbox.tech/application/why-we-built-a-custom-rust-library-for-capture |access-date=2022-04-21 |website=Dropbox.Tech |language=en |archive-date=April 6, 2022 |archive-url=https://web.archive.org/web/20220406142301/https://dropbox.tech/application/why-we-built-a-custom-rust-library-for-capture |url-status=live}}</ref> [[Company:Facebook|Facebook]] ([[Company:Meta Platforms|Meta]]) used Rust for Mononoke, a server for the [[Software:Mercurial|Mercurial]] version control system.<ref>{{Cite web |date=2021-04-29 |title=A brief history of Rust at Facebook |url=https://engineering.fb.com/2021/04/29/developer-tools/rust/ |access-date=2022-04-21 |website=Engineering at Meta |language=en-US |archive-date=January 19, 2022 |archive-url=https://web.archive.org/web/20220119012056/https://engineering.fb.com/2021/04/29/developer-tools/rust/ |url-status=live}}</ref>

In the 2023 [[Stack Overflow]] Developer Survey, 13% of respondents had recently done extensive development in Rust.<ref name="SO-2023-survey">{{Cite web |title=Stack Overflow Developer Survey 2023 |url=https://survey.stackoverflow.co/2023/ |access-date=2023-06-25 |website=Stack Overflow}}</ref> The survey also named Rust the "most loved programming language" every year from 2016 to 2023 (inclusive), based on the number of developers interested in continuing to work in the same language.<ref>{{Cite web |last=Claburn |first=Thomas |date=2022-06-23 |title=Linus Torvalds says Rust is coming to the Linux kernel |url=https://www.theregister.com/2022/06/23/linus_torvalds_rust_linux_kernel/ |access-date=2022-07-15 |website=The Register |language=en}}</ref>{{refn|group=note|That is, among respondents who have done "extensive development work [with Rust] in over the past year" (13.05%), Rust had the largest percentage who also expressed interest to "work in [Rust] over the next year" (84.66%).<ref name="SO-2023-survey"/>}} In 2023, Rust was the 6th "most wanted technology", with 31% of developers not currently working in Rust expressing an interest in doing so.<ref name="SO-2023-survey" />

== Community ==
[[File:Rustacean-orig-noshadow.svg|alt=A bright orange crab icon|thumb|Some Rust users refer to themselves as Rustaceans (a pun on [[Biology:Crustacean|crustacean]]) and have adopted an orange crab, Ferris, as their unofficial mascot.<ref>{{cite web |title=Getting Started |url=https://www.rust-lang.org/learn/get-started#ferris |website=rust-lang.org |access-date=11 October 2020 |archive-date=1 November 2020 |archive-url=https://web.archive.org/web/20201101145703/https://www.rust-lang.org/learn/get-started#ferris |url-status=live}}</ref>]]

=== Rust Foundation ===
{{Infobox organization
| name = Rust Foundation
| logo = Rust Foundation logo.png
| formation = {{Start date and age|2021|02|08}}
| founders = {{unbulleted list|[[Company:Amazon Web Services|Amazon Web Services]]|[[Company:Google|Google]]|[[Company:Huawei|Huawei]]|[[Company:Microsoft|Microsoft]]|[[Organization:Mozilla Foundation|Mozilla Foundation]]}}
| type = [[Engineering:Nonprofit organization|Nonprofit organization]]
| location_country = {{wipe|United States}}
| leader_title = [[Social:Chairperson|Chairperson]]
| leader_name = Shane Miller
| leader_title2 = Executive Director
| leader_name2 = Rebecca Rumbul
| website = {{URL|https://foundation.rust-lang.org}}
}}

The '''Rust Foundation''' is a [[Engineering:Nonprofit organization|non-profit]] [[Organization:Membership organization|membership organization]] incorporated in {{wipe|United States}}, with the primary purposes of backing the technical project as a legal entity and helping to manage the trademark and infrastructure assets.<ref>{{Cite web |first=Liam |last=Tung |date=2021-02-08 |title=The Rust programming language just took a huge step forwards |url=https://www.zdnet.com/article/the-rust-programming-language-just-took-a-huge-step-forwards/ |access-date=2022-07-14 |publisher=ZDNet |language=en}}</ref><ref name=":4">{{Cite web |last=Brandon Vigliarolo |date=2021-02-10 |title=The Rust programming language now has its own independent foundation |url=https://www.techrepublic.com/article/the-rust-programming-language-now-has-its-own-independent-foundation/ |access-date=2022-07-14 |website=TechRepublic |language=en-US}}</ref>

It was established on February 8, 2021, with five founding corporate members (Amazon Web Services, Huawei, Google, Microsoft, and Mozilla).<ref>{{cite news|first=Paul|last=Krill|title=Rust language moves to independent foundation|url=https://www.infoworld.com/article/3606774/rust-language-moves-to-independent-foundation.html|work=InfoWorld|access-date=10 April 2021|archive-date=10 April 2021|archive-url=https://web.archive.org/web/20210410161528/https://www.infoworld.com/article/3606774/rust-language-moves-to-independent-foundation.html|url-status=live}}</ref> The foundation's board is chaired by Shane Miller.<ref>{{cite news|first=Steven J.|last=Vaughan-Nichols|date=9 April 2021|title=AWS's Shane Miller to head the newly created Rust Foundation|url=https://www.zdnet.com/article/awss-shane-miller-to-head-the-newly-created-rust-foundation/|publisher=[[ZDNet]]|access-date=10 April 2021|archive-date=10 April 2021|archive-url=https://web.archive.org/web/20210410031305/https://www.zdnet.com/article/awss-shane-miller-to-head-the-newly-created-rust-foundation/|url-status=live}}</ref> Starting in late 2021, its Executive Director and CEO is Rebecca Rumbul.<!--Q109621019--><ref>{{Cite news|url=https://www.zdnet.com/article/rust-foundation-appoints-rebecca-rumbul-as-executive-director/|title=Rust Foundation appoints Rebecca Rumbul as executive director|publisher=[[ZDNet]]|first=Steven J.|last=Vaughan-Nichols|date=17 November 2021|access-date=18 November 2021|archive-date=November 18, 2021|archive-url=https://web.archive.org/web/20211118062346/https://www.zdnet.com/article/rust-foundation-appoints-rebecca-rumbul-as-executive-director/|url-status=live}}</ref> Prior to this, Ashley Williams was interim executive director.<ref>{{Cite news|title=The Rust programming language now has its own independent foundation|url=https://www.techrepublic.com/article/the-rust-programming-language-now-has-its-own-independent-foundation/|date=February 10, 2021|access-date=2021-11-18|website=TechRepublic|language=en|archive-date=November 18, 2021|archive-url=https://web.archive.org/web/20211118143514/https://www.techrepublic.com/article/the-rust-programming-language-now-has-its-own-independent-foundation/|url-status=live}}</ref>

=== Governance teams ===
The Rust project is composed of ''teams'' that are responsible for different subareas of the development. The compiler team develops, manages, and optimizes compiler internals; and the language team designs new language features and helps implement them. The Rust project website lists 9 top-level teams {{as of|January 2024|lc=y}}.<ref>{{Cite web |title=Governance |url=https://www.rust-lang.org/governance |access-date=2022-05-07 |website=The Rust Programming Language |language=en-US |archive-date=May 10, 2022 |archive-url=https://web.archive.org/web/20220510225505/https://www.rust-lang.org/governance |url-status=live}}</ref> Representatives among teams form the Leadership council, which oversees the Rust project as a whole.<ref>{{Cite web |title=Introducing the Rust Leadership Council |url=https://blog.rust-lang.org/2023/06/20/introducing-leadership-council.html |access-date=2024-01-12 |website=Rust Blog |language=en}}</ref><!--<ref>{{Cite web |first=Tim |last=Anderson |date=2021-11-23 |title=Entire Rust moderation team resigns |url=https://www.theregister.com/2021/11/23/rust_moderation_team_quits/ |access-date=2024-01-12 |website=The Register |language=en}}</ref>-->

== See also ==
* [[Comparison of programming languages]]
* [[History of programming languages]]
* [[List of programming languages]]
* [[List of programming languages by type]]

== Notes ==
{{Reflist|group=note}}

== References ==
=== Book sources ===
{{refbegin}}
* {{Cite book |last=Gjengset |first=Jon |url=https://www.worldcat.org/oclc/1277511986 |title=Rust for Rustaceans |date=2021 |publisher=No Starch Press |isbn=9781718501850 |edition=1st |oclc=1277511986 |language=en}}
* {{Cite book|last1=Klabnik|first1=Steve|url=https://books.google.com/books?id=0Vv6DwAAQBAJ|title=The Rust Programming Language (Covers Rust 2018)|last2=Nichols|first2=Carol|date=2019-08-12|publisher=No Starch Press|isbn=978-1-7185-0044-0|language=en}}
* {{Cite book|last1=Blandy|first1=Jim|last2=Orendorff|first2=Jason|last3=Tindall|first3=Leonora F. S.|url=https://www.worldcat.org/oclc/1289839504|date=2021|edition=2nd|title=Programming Rust: Fast, Safe Systems Development|publisher=O'Reilly Media|isbn=978-1-4920-5254-8 |language=en|oclc=1289839504}}
* {{Cite book|last1=McNamara|first1=Tim|url=https://www.worldcat.org/oclc/1153044639|title=Rust in Action|oclc=1153044639|date=2021|publisher=Manning Publications|isbn=978-1-6172-9455-6|language=en}}
* {{Cite book |last1=Klabnik |first1=Steve |last2=Nichols |first2=Carol |url=https://www.worldcat.org/oclc/1363816350 |title=The Rust programming language |date=2023 |publisher=No Starch Press |isbn=978-1-7185-0310-6 |edition=2nd |oclc=1363816350}}
{{refend}}

=== Others ===
{{reflist|refs=
<ref name="legal">{{cite web |url=https://www.rust-lang.org/policies/licenses |title=Rust Legal Policies |access-date=2018-04-03 |website=Rust-lang.org |archive-date=2018-04-04 |archive-url=https://web.archive.org/web/20180404073350/https://www.rust-lang.org/en-US/legal.html |url-status=live}}</ref>
<ref name="influences">{{cite web |title=Influences - The Rust Reference |url=https://doc.rust-lang.org/reference/influences.html |website=The Rust Reference |access-date=December 31, 2023 |archive-date=November 26, 2023 |archive-url=https://web.archive.org/web/20231126231034/https://doc.rust-lang.org/reference/influences.html |url-status=live}}</ref>
<ref name="Jaloyan">{{Cite arXiv|last=Jaloyan |first=Georges-Axel |date=19 October 2017 |title=Safe Pointers in SPARK 2014 |class=cs.PL |eprint=1710.07047}}</ref>
<ref name="Lattner">{{cite web |url=http://nondot.org/sabre/ |title=Chris Lattner's Homepage |last=Lattner |first=Chris |date=<!--Undated--> |website=Nondot.org |access-date=2019-05-14 |archive-date=2018-12-25 |archive-url=https://web.archive.org/web/20181225175312/http://nondot.org/sabre/ |url-status=live}}</ref>
<ref name="Project Verona">{{cite web|url=https://www.zdnet.com/article/microsoft-opens-up-rust-inspired-project-verona-programming-language-on-github/|title=Microsoft opens up Rust-inspired Project Verona programming language on GitHub|publisher=[[ZDNet]]|access-date=2020-01-17|archive-date=2020-01-17|archive-url=https://web.archive.org/web/20200117143852/https://www.zdnet.com/article/microsoft-opens-up-rust-inspired-project-verona-programming-language-on-github/|url-status=live}}</ref>
}}

==Further reading==
* {{Cite book|last1=Blandy|first1=Jim|last2=Orendorff|first2=Jason|last3=Tindall|first3=Leonora F. S.|date=2021-07-06|title=Programming Rust: Fast, Safe Systems Development|publisher=O'Reilly Media|isbn=978-1-4920-5259-3 |language=en|ref=none}}

== External links ==

{{Programming languages}}
{{Mozilla}}

[[Category:Rust (programming language)| ]]
[[Category:Concurrent programming languages]]
[[Category:Free compilers and interpreters]]
[[Category:Free software projects]]
[[Category:Functional languages]]
[[Category:High-level programming languages]]
[[Category:Multi-paradigm programming languages]]
[[Category:Pattern matching programming languages]]
[[Category:Procedural programming languages]]
[[Category:Software using the Apache license]]
[[Category:Statically typed programming languages]]
[[Category:Systems programming languages]]
[[Category:Organizations (Software)]]
[[Category:Organizations|Software]]

{{Sourceattribution|Rust (programming language)}}