   Link: alternate
   Link: license
   Link: canonical

                          Rust (programming language)

   From Wikipedia, the free encyclopedia
   Jump to navigation Jump to search

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

   Rust is a multi-paradigm, general-purpose programming language designed
   for performance and safety, especially safe concurrency.^[12]^[13] Rust is
   syntactically similar to C++,^[14] but can guarantee memory safety by
   using a borrow checker to validate references.^[15] Rust achieves memory
   safety without garbage collection, and reference counting is
   optional.^[16]^[17] Rust has been called a systems programming language,
   and in addition to high-level features such as functional programming it
   also offers mechanisms for low-level memory management.

   First appearing in 2010, Rust was designed by Graydon Hoare at Mozilla
   Research,^[18] with contributions from Dave Herman, Brendan Eich, and
   others.^[19]^[20] The designers refined the language while writing the
   Servo experimental browser engine^[21] and the Rust compiler. Rust's major
   influences include C++, OCaml, Haskell, and Erlang.^[5] It has gained
   increasing use and investment in industry, by companies including Amazon,
   Discord, Dropbox, Facebook (Meta), Google (Alphabet), and Microsoft.

   Rust has been voted the "most loved programming language" in the Stack
   Overflow Developer Survey every year since 2016, and was used by 7% of the
   respondents in 2021.^[22]

Contents

     * 1 History
     * 2 Syntax
     * 3 Features
          * 3.1 Memory safety
          * 3.2 Memory management
          * 3.3 Ownership
          * 3.4 Types and polymorphism
          * 3.5 Macros for language extension
          * 3.6 Interface with C and C++
     * 4 Components
          * 4.1 Cargo
          * 4.2 Rustfmt
          * 4.3 Clippy
          * 4.4 IDE support
     * 5 Performance
     * 6 Adoption
          * 6.1 Web browsers and services
          * 6.2 Operating systems
          * 6.3 Other notable projects and platforms
     * 7 Community
     * 8 Governance
     * 9 See also
     * 10 Explanatory notes
     * 11 References
     * 12 Further reading
     * 13 External links

History[edit]

   [IMG]
   Enlarge
   Compiling a Rust program with Cargo

   The language grew out of a personal project begun in 2006 by Mozilla
   employee Graydon Hoare.^[13] Hoare has stated that the project was
   possibly named after rust fungi and that the name is also a subsequence of
   "robust".^[23] Mozilla began sponsoring the project in 2009^[13] and
   announced it in 2010.^[24]^[25] The same year, work shifted from the
   initial compiler (written in OCaml) to an LLVM-based self-hosting compiler
   written in Rust.^[26] Named rustc, it successfully compiled itself in
   2011.^[27]

   The first numbered pre-alpha release of the Rust compiler occurred in
   January 2012.^[28] Rust 1.0, the first stable release, was released on May
   15, 2015.^[29]^[30] Following 1.0, stable point releases are delivered
   every six weeks, while features are developed in nightly Rust with daily
   releases, then tested with beta releases that last six weeks.^[31]^[32]
   Every two to three years, a new Rust "edition" is produced. This is to
   provide an easy reference point for changes due to the frequent nature of
   Rust's train release schedule, as well as to provide a window to make
   limited breaking changes. Editions are largely compatible.^[33]

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

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

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

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

   In August 2020, Mozilla laid off 250 of its 1,000 employees worldwide as
   part of a corporate restructuring caused by the long-term impact of the
   COVID-19 pandemic.^[39]^[40] Among those laid off were most of the Rust
   team,^[41]^[better source needed] while the Servo team was completely
   disbanded.^[42]^[better source needed] The event raised concerns about the
   future of Rust.^[43]

   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 taking ownership of
   all trademarks and domain names, and also take financial responsibility
   for their costs.^[44]

   On February 8, 2021 the formation of the Rust Foundation was officially
   announced by its five founding companies (AWS, Huawei, Google,
   Microsoft,^[45]^[46] and Mozilla).^[47]^[48]

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

Syntax[edit]

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

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

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

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

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

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

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

 use std::ops::Add;

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

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

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

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

Features[edit]

   File:Rust 101.webmPlay media
   Enlarge
   A presentation on Rust by Emily Dunham from Mozilla's Rust team
   (linux.conf.au conference, Hobart, 2017)

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

  Memory safety[edit]

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

  Memory management[edit]

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

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

  Ownership[edit]

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

  Types and polymorphism[edit]

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

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

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

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

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

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

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

  Macros for language extension[edit]

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

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

   Procedural macros come in three flavors:

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

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

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

 use serde_json::{Serialize, Deserialize};

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

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

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

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

  Interface with C and C++[edit]

   Rust has a foreign function interface (FFI) that can be used both to call
   code written in languages such as C from Rust and to call Rust code from
   those languages. While calling C++ has historically been challenging (from
   any language), Rust has a library, CXX, to allow calling to or from C++,
   and "CXX has zero or negligible overhead."^[67]

Components[edit]

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

  Cargo[edit]

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

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

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

  Rustfmt[edit]

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

  Clippy[edit]

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

  IDE support[edit]

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

Performance[edit]

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

Adoption[edit]

   See also: Category:Rust (programming language) software

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

  Web browsers and services[edit]

     * Firefox has two projects written in Rust: the Servo parallel browser
       engine^[92] developed by Mozilla in collaboration with Samsung;^[93]
       and Quantum, which is composed of several sub-projects for improving
       Mozilla's Gecko browser engine.^[94]
     * OpenDNS uses Rust in two of its components.^[95]^[96]^[97]
     * Deno, a secure runtime for JavaScript and TypeScript, is built with
       V8, Rust, and Tokio.^[98]
     * Figma, a web-based vector graphics editor, is written in Rust.

  Operating systems[edit]

     * Redox is a "full-blown Unix-like operating system" including a
       microkernel written in Rust.^[99]
     * Theseus, an experimental OS with "intralingual design", is written in
       Rust.^[100]
     * The Google Fuchsia capability-based operating system has some^[vague]
       tools written in Rust.^[101]
     * Stratis is a file system manager written in Rust for Fedora^[102] and
       RHEL 8.^[103]
     * exa is a Unix/Linux command line alternative to ls written in Rust.
     * Since 2021, there is a patch series for adding Rust support to the
       Linux kernel.^[104]

  Other notable projects and platforms[edit]

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

Community[edit]

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

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

     * RustConf: an annual conference in Portland, Oregon. Held annually
       since 2016 (except in 2020 and 2021 because of the COVID-19
       pandemic).^[114]
     * Rust Belt Rust: a #rustlang conference in the Rust Belt^[115]
     * RustFest: Europe's @rustlang conference^[116]
     * RustCon Asia^[citation needed]
     * Rust LATAM^[citation needed]
     * Oxidize Global^[117]

Governance[edit]

   Link: mw-deduplicated-inline-style

                                Rust Foundation
   Rust Foundation logo.png
   Formation          February 8, 2021; 14 months ago 
                        * Amazon Web Services         
                        * Google                      
   Founders             * Huawei                      
                        * Microsoft                   
                        * Mozilla Foundation          
   Type               Nonprofit organization          
   Location             * United States               
   Chairperson        Shane Miller                    
   Executive Director Rebecca Rumbul                  
   Website            foundation.rust-lang.org        

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

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

See also[edit]

     * List of programming languages
     * History of programming languages
     * Comparison of programming languages

Explanatory notes[edit]

    1. ^ The list is incomplete; the degree of standard library support
       varies.
    2. ^ Host build tools on Haiku, Android, Redox, iOS, and Fuchsia are not
       officially shipped; these operating systems are supported as targets.
    3. ^ For a complete list, see ^[5].

References[edit]

   Link: mw-deduplicated-inline-style
    1. ^ "Announcing Rust 1.60.0".
    2. ^
       Link: mw-deduplicated-inline-style
       "Rust Legal Policies". Rust-lang.org. Archived from the original on
       April 4, 2018. Retrieved April 3, 2018.
    3. ^
       Link: mw-deduplicated-inline-style
       "Note Research: Type System". GitHub. February 1, 2015. Archived from
       the original on February 17, 2019. Retrieved March 25, 2015.
    4. ^
       Link: mw-deduplicated-inline-style
       "RFC for 'if let' expression". GitHub. Archived from the original on
       March 4, 2016. Retrieved December 4, 2014.
    5. ^ ^a ^b
       Link: mw-deduplicated-inline-style
       "The Rust Reference: Appendix: Influences". Archived from the original
       on January 26, 2019. Retrieved November 11, 2018.
    6. ^
       Link: mw-deduplicated-inline-style
       "Command Optimizations?". June 26, 2014. Archived from the original on
       July 10, 2019. Retrieved December 10, 2014.
    7. ^
       Link: mw-deduplicated-inline-style
       "Idris – Uniqueness Types". Archived from the original on November 21,
       2018. Retrieved November 20, 2018.
    8. ^
       Link: mw-deduplicated-inline-style
       Jaloyan, Georges-Axel (October 19, 2017). "Safe Pointers in SPARK
       2014". arXiv:1710.07047. Bibcode:2017arXiv171007047J.
    9. ^
       Link: mw-deduplicated-inline-style
       Lattner, Chris. "Chris Lattner's Homepage". Nondot.org. Archived from
       the original on December 25, 2018. Retrieved May 14, 2019.
   10. ^
       Link: mw-deduplicated-inline-style
       "Microsoft opens up Rust-inspired Project Verona programming language
       on GitHub". ZDNet. Archived from the original on January 17, 2020.
       Retrieved January 17, 2020.
   11. ^
       Link: mw-deduplicated-inline-style
       "PHP RFC: Shorter Attribute Syntax". June 3, 2020. Archived from the
       original on March 7, 2021. Retrieved March 17, 2021.
   12. ^
       Link: mw-deduplicated-inline-style
       Hoare, Graydon (December 28, 2016). "Rust is mostly safety". Graydon2.
       Dreamwidth Studios. Archived from the original on May 2, 2019.
       Retrieved May 13, 2019.
   13. ^ ^a ^b ^c
       Link: mw-deduplicated-inline-style
       "FAQ – The Rust Project". Rust-lang.org. Archived from the original on
       June 9, 2016. Retrieved June 27, 2019.
   14. ^
       Link: mw-deduplicated-inline-style
       "Rust vs. C++ Comparison". Archived from the original on November 20,
       2018. Retrieved November 20, 2018.
   15. ^ ^a ^b
       Link: mw-deduplicated-inline-style
       "Unsafe Rust". Archived from the original on October 14, 2020.
       Retrieved October 17, 2020.
   16. ^
       Link: mw-deduplicated-inline-style
       "Fearless Security: Memory Safety". Archived from the original on
       November 8, 2020. Retrieved November 4, 2020.
   17. ^
       Link: mw-deduplicated-inline-style
       "Rc<T>, the Reference Counted Smart Pointer". Archived from the
       original on November 11, 2020. Retrieved November 4, 2020.
   18. ^
       Link: mw-deduplicated-inline-style
       "Rust language". Archived from the original on September 6, 2020.
       Retrieved September 9, 2020. Mozilla was the first investor for Rust
       and continues to sponsor the work of the open source project. Mozilla
       also utilizes Rust in many of its core initiatives including Servo and
       key parts of Firefox.
   19. ^
       Link: mw-deduplicated-inline-style
       Noel (July 8, 2010). "The Rust Language". Lambda the Ultimate.
       Archived from the original on November 23, 2012. Retrieved October 30,
       2010.
   20. ^
       Link: mw-deduplicated-inline-style
       "Contributors to rust-lang/rust". GitHub. Archived from the original
       on May 26, 2020. Retrieved October 12, 2018.
   21. ^
       Link: mw-deduplicated-inline-style
       Bright, Peter (April 3, 2013). "Samsung teams up with Mozilla to build
       browser engine for multicore machines". Ars Technica. Archived from
       the original on December 16, 2016. Retrieved April 4, 2013.
   22. ^
       Link: mw-deduplicated-inline-style
       "Stack Overflow Developer Survey 2021". Stack Overflow. Retrieved
       August 3, 2021.{{cite web}}: CS1 maint: url-status (link)
   23. ^
       Link: mw-deduplicated-inline-style
       Hoare, Graydon (June 7, 2014). "Internet archaeology: the definitive,
       end-all source for why Rust is named "Rust"". Reddit.com. Archived
       from the original on July 14, 2016. Retrieved November 3, 2016.
   24. ^
       Link: mw-deduplicated-inline-style
       "Future Tense". April 29, 2011. Archived from the original on
       September 18, 2012. Retrieved February 6, 2012.
   25. ^
       Link: mw-deduplicated-inline-style
       Hoare, Graydon (July 7, 2010). Project Servo (PDF). Mozilla Annual
       Summit 2010. Whistler, Canada. Archived (PDF) from the original on
       July 11, 2017. Retrieved February 22, 2017.
   26. ^
       Link: mw-deduplicated-inline-style
       Hoare, Graydon (October 2, 2010). "Rust Progress". Archived from the
       original on August 15, 2014. Retrieved October 30, 2010.
   27. ^
       Link: mw-deduplicated-inline-style
       Hoare, Graydon (April 20, 2011). "[rust-dev] stage1/rustc builds".
       Archived from the original on July 20, 2011. Retrieved April 20, 2011.
   28. ^
       Link: mw-deduplicated-inline-style
       catamorphism (January 20, 2012). "Mozilla and the Rust community
       release Rust 0.1 (a strongly-typed systems programming language with a
       focus on memory safety and concurrency)". Archived from the original
       on January 24, 2012. Retrieved February 6, 2012.
   29. ^
       Link: mw-deduplicated-inline-style
       "Version History". GitHub. Archived from the original on May 15, 2015.
       Retrieved January 1, 2017.
   30. ^
       Link: mw-deduplicated-inline-style
       The Rust Core Team (May 15, 2015). "Announcing Rust 1.0". Archived
       from the original on May 15, 2015. Retrieved December 11, 2015.
   31. ^
       Link: mw-deduplicated-inline-style
       "Scheduling the Trains". Archived from the original on January 2,
       2017. Retrieved January 1, 2017.
   32. ^
       Link: mw-deduplicated-inline-style
       "G - How Rust is Made and "Nightly Rust" - The Rust Programming
       Language". doc.rust-lang.org. Retrieved May 22, 2021.
   33. ^
       Link: mw-deduplicated-inline-style
       "What are editions? - The Edition Guide". doc.rust-lang.org. Retrieved
       May 22, 2021.
   34. ^
       Link: mw-deduplicated-inline-style
       Strom, Robert E.; Yemini, Shaula (1986). "Typestate: A Programming
       Language Concept for Enhancing Software Reliability" (PDF). IEEE
       Transactions on Software Engineering: 157–171.
       doi:10.1109/TSE.1986.6312929. ISSN 0098-5589. S2CID 15575346. Archived
       (PDF) from the original on July 14, 2010. Retrieved November 14, 2010.
   35. ^
       Link: mw-deduplicated-inline-style
       Walton, Patrick (December 26, 2012). "Typestate Is Dead, Long Live
       Typestate!". GitHub. Archived from the original on February 23, 2018.
       Retrieved November 3, 2016.
   36. ^
       Link: mw-deduplicated-inline-style
       Biffle, Cliff (June 5, 2019). "The Typestate Pattern in Rust".
       Archived from the original on February 6, 2021. Retrieved February 1,
       2021.
   37. ^
       Link: mw-deduplicated-inline-style
       "[rust-dev] Rust 0.4 released". mail.mozilla.org. Retrieved October
       31, 2021.
   38. ^
       Link: mw-deduplicated-inline-style
       Binstock, Andrew. "The Rise And Fall of Languages in 2013". Dr Dobb's.
       Archived from the original on August 7, 2016. Retrieved December 11,
       2015.
   39. ^
       Link: mw-deduplicated-inline-style
       Cimpanu, Catalin (August 11, 2020). "Mozilla lays off 250 employees
       while it refocuses on commercial products". ZDNet. Retrieved December
       2, 2020.
   40. ^
       Link: mw-deduplicated-inline-style
       Cooper, Daniel (August 11, 2020). "Mozilla lays off 250 employees due
       to the pandemic". Engadget. Archived from the original on December 13,
       2020. Retrieved December 2, 2020.
   41. ^
       Link: mw-deduplicated-inline-style
       @tschneidereit (August 12, 2020). "Much of the team I used to manage
       was part of the Mozilla layoffs on Tuesday. That team was Mozilla's
       Rust team, and Mozilla's Wasmtime team. I thought I'd know how to talk
       about it by now, but I don't. It's heartbreaking, incomprehensible,
       and staggering in its impact" (Tweet). Retrieved December 2, 2020 –
       via Twitter.
   42. ^
       Link: mw-deduplicated-inline-style
       @asajeffrey (August 11, 2020). "Mozilla is closing down the team I'm
       on, so I am one of the many folks now wondering what the next gig will
       be. It's been a wild ride!" (Tweet). Retrieved December 2, 2020 – via
       Twitter.
   43. ^
       Link: mw-deduplicated-inline-style
       Kolakowski, Nick (August 27, 2020). "Is Rust in Trouble After Big
       Mozilla Layoffs?". Dice. Archived from the original on November 24,
       2020. Retrieved December 2, 2020.
   44. ^
       Link: mw-deduplicated-inline-style
       "Laying the foundation for Rust's future". Rust Blog. August 18, 2020.
       Archived from the original on December 2, 2020. Retrieved December 2,
       2020.
   45. ^
       Link: mw-deduplicated-inline-style
       "How Microsoft Is Adopting Rust". August 6, 2020. Archived from the
       original on August 10, 2020. Retrieved August 7, 2020.
   46. ^
       Link: mw-deduplicated-inline-style
       "Why Rust for safe systems programming". Archived from the original on
       July 22, 2019. Retrieved July 22, 2019.
   47. ^
       Link: mw-deduplicated-inline-style
       "Rust Foundation". foundation.rust-lang.org. February 8, 2021.
       Archived from the original on February 9, 2021. Retrieved February 9,
       2021.
   48. ^
       Link: mw-deduplicated-inline-style
       "Mozilla Welcomes the Rust Foundation". Mozilla Blog. February 9,
       2021. Archived from the original on February 8, 2021. Retrieved
       February 9, 2021.
   49. ^
       Link: mw-deduplicated-inline-style
       Amadeo, Ron (April 7, 2021). "Google is now writing low-level Android
       code in Rust". Ars Technica. Archived from the original on April 8,
       2021. Retrieved April 8, 2021.
   50. ^
       Link: mw-deduplicated-inline-style
       "rust/src/grammar/parser-lalr.y". GitHub. May 23, 2017. Retrieved May
       23, 2017.
   51. ^
       Link: mw-deduplicated-inline-style
       "Unsafety - The Rust Reference". The Rust Reference.
   52. ^
       Link: mw-deduplicated-inline-style
       "Option in std::option - Rust". The Rust Standard Library.
   53. ^
       Link: mw-deduplicated-inline-style
       Avram, Abel (August 3, 2012). "Interview on Rust, a Systems
       Programming Language Developed by Mozilla". InfoQ. Archived from the
       original on July 24, 2013. Retrieved August 17, 2013.
   54. ^
       Link: mw-deduplicated-inline-style
       "Debian -- Details of package rustc in sid". packages.debian.org.
       Archived from the original on February 22, 2017. Retrieved February
       21, 2017.
   55. ^
       Link: mw-deduplicated-inline-style
       Rosenblatt, Seth (April 3, 2013). "Samsung joins Mozilla's quest for
       Rust". Archived from the original on April 4, 2013. Retrieved April 5,
       2013.
   56. ^ ^a ^b
       Link: mw-deduplicated-inline-style
       Brown, Neil (April 17, 2013). "A taste of Rust". Archived from the
       original on April 26, 2013. Retrieved April 25, 2013.
   57. ^
       Link: mw-deduplicated-inline-style
       "Races - The Rustonomicon". doc.rust-lang.org. Archived from the
       original on July 10, 2017. Retrieved July 3, 2017.
   58. ^
       Link: mw-deduplicated-inline-style
       "The Rust Language FAQ". static.rust-lang.org. 2015. Archived from the
       original on April 20, 2015. Retrieved April 24, 2017.
   59. ^
       Link: mw-deduplicated-inline-style
       "RAII – Rust By Example". doc.rust-lang.org. Archived from the
       original on April 21, 2019. Retrieved November 22, 2020.
   60. ^
       Link: mw-deduplicated-inline-style
       "Abstraction without overhead: traits in Rust". Rust Blog.
   61. ^
       Link: mw-deduplicated-inline-style
       Klabnik, Steve; Nichols, Carol (June 2018). "Chapter 4: Understanding
       Ownership". The Rust Programming Language. San Francisco, California:
       No Starch Press. p. 44. ISBN 978-1-593-27828-1. Archived from the
       original on May 3, 2019. Retrieved May 14, 2019.
   62. ^
       Link: mw-deduplicated-inline-style
       "The Rust Programming Language: What is Ownership". Rust-lang.org.
       Archived from the original on May 19, 2019. Retrieved May 14, 2019.
   63. ^
       Link: mw-deduplicated-inline-style
       Walton, Patrick (October 1, 2010). "Rust Features I: Type Inference".
       Archived from the original on July 8, 2011. Retrieved January 21,
       2011.
   64. ^
       Link: mw-deduplicated-inline-style
       "Procedural Macros". The Rust Programming Language Reference. Archived
       from the original on November 7, 2020. Retrieved March 23, 2021.
   65. ^
       Link: mw-deduplicated-inline-style
       "Serde Derive". Serde Derive documentation. Archived from the original
       on April 17, 2021. Retrieved March 23, 2021.
   66. ^
       Link: mw-deduplicated-inline-style
       "extendr_api - Rust". Extendr Api Documentation. Retrieved March 23,
       2021.
   67. ^
       Link: mw-deduplicated-inline-style
       "Safe Interoperability between Rust and C++ with CXX". InfoQ. December
       6, 2020. Retrieved January 3, 2021.
   68. ^
       Link: mw-deduplicated-inline-style
       rust-lang/rustup, The Rust Programming Language, May 17, 2021,
       retrieved May 17, 2021
   69. ^
       Link: mw-deduplicated-inline-style
       "Packages and Crates - The Rust Programming Language".
       doc.rust-lang.org. Retrieved February 4, 2022.
   70. ^
       Link: mw-deduplicated-inline-style
       "The Cargo Book". Retrieved February 19, 2022.
   71. ^
       Link: mw-deduplicated-inline-style
       "Why Cargo Exists". The Cargo Book. Retrieved May 18, 2021.
   72. ^
       Link: mw-deduplicated-inline-style
       "Workspaces - The Cargo Book". doc.rust-lang.org. Retrieved February
       28, 2022.
   73. ^
       Link: mw-deduplicated-inline-style
       "Dependency Resolution - The Cargo Book". doc.rust-lang.org. Retrieved
       February 28, 2022.
   74. ^
       Link: mw-deduplicated-inline-style
       "Specifying Dependencies - The Cargo Book". doc.rust-lang.org.
       Retrieved May 17, 2021.
   75. ^
       Link: mw-deduplicated-inline-style
       "rust-dev-tools/fmt-rfcs". GitHub. Retrieved September 21, 2021.
   76. ^
       Link: mw-deduplicated-inline-style
       "rustfmt". GitHub. Retrieved May 19, 2021.
   77. ^
       Link: mw-deduplicated-inline-style
       "Create README.md · rust-lang/rust-clippy@507dc2b". GitHub. Retrieved
       November 22, 2021.
   78. ^
       Link: mw-deduplicated-inline-style
       "Day 1 - cargo subcommands | 24 days of Rust". zsiciarz.github.io.
       Retrieved November 22, 2021.
   79. ^
       Link: mw-deduplicated-inline-style
       "rust-lang/rust-clippy". GitHub. Retrieved May 21, 2021.
   80. ^
       Link: mw-deduplicated-inline-style
       "ALL the Clippy Lints". Retrieved May 22, 2021.
   81. ^
       Link: mw-deduplicated-inline-style
       rust-analyzer/rust-analyzer, rust-analyzer, January 2, 2022, retrieved
       January 2, 2022
   82. ^
       Link: mw-deduplicated-inline-style
       "rust-lang/rls". GitHub. Retrieved May 26, 2021.
   83. ^
       Link: mw-deduplicated-inline-style
       "racer-rust/racer". GitHub. Retrieved May 26, 2021.
   84. ^
       Link: mw-deduplicated-inline-style
       Walton, Patrick (December 5, 2010). "C++ Design Goals in the Context
       of Rust". Archived from the original on December 9, 2010. Retrieved
       January 21, 2011.
   85. ^
       Link: mw-deduplicated-inline-style
       "How Fast Is Rust?". The Rust Programming Language FAQ. Archived from
       the original on October 28, 2020. Retrieved April 11, 2019.
   86. ^
       Link: mw-deduplicated-inline-style
       "How our AWS Rust team will contribute to Rust's future successes".
       Amazon Web Services. March 3, 2021. Retrieved January 2, 2022.
   87. ^
       Link: mw-deduplicated-inline-style
       "A brief history of Rust at Facebook". Engineering at Meta. April 29,
       2021. Retrieved January 19, 2022.
   88. ^
       Link: mw-deduplicated-inline-style
       9 Companies That Use Rust in Production, Serokell, November 18, 2020,
       retrieved October 7, 2021
   89. ^
       Link: mw-deduplicated-inline-style
       "Stack Overflow Developer Survey 2015". Stackoverflow.com. Archived
       from the original on December 31, 2016. Retrieved November 3, 2016.
   90. ^
       Link: mw-deduplicated-inline-style
       "Stack Overflow Developer Survey 2019". Stack Overflow. Archived from
       the original on October 8, 2020. Retrieved March 31, 2021.
   91. ^
       Link: mw-deduplicated-inline-style
       "Stack Overflow Developer Survey 2021". Stack Overflow. Retrieved
       August 24, 2021.{{cite web}}: CS1 maint: url-status (link)
   92. ^
       Link: mw-deduplicated-inline-style
       Yegulalp, Serdar (April 3, 2015). "Mozilla's Rust-based Servo browser
       engine inches forward". InfoWorld. Archived from the original on March
       16, 2016. Retrieved March 15, 2016.
   93. ^
       Link: mw-deduplicated-inline-style
       Lardinois, Frederic (April 3, 2015). "Mozilla And Samsung Team Up To
       Develop Servo, Mozilla's Next-Gen Browser Engine For Multicore
       Processors". TechCrunch. Archived from the original on September 10,
       2016. Retrieved June 25, 2017.
   94. ^
       Link: mw-deduplicated-inline-style
       Bryant, David (October 27, 2016). "A Quantum Leap for the web".
       Medium. Archived from the original on December 9, 2020. Retrieved
       October 27, 2016.
   95. ^
       Link: mw-deduplicated-inline-style
       Balbaert, Ivo (May 27, 2015). Rust Essentials. Packt Publishing. p. 6.
       ISBN 978-1785285769. Retrieved March 21, 2016.
   96. ^
       Link: mw-deduplicated-inline-style
       Frank, Denis (December 5, 2013). "Using HyperLogLog to Detect Malware
       Faster Than Ever". OpenDNS Security Labs. Archived from the original
       on August 14, 2017. Retrieved March 19, 2016.
   97. ^
       Link: mw-deduplicated-inline-style
       Denis, Frank (October 4, 2013). "ZeroMQ: Helping us Block Malicious
       Domains in Real Time". OpenDNS Security Labs. Archived from the
       original on August 14, 2017. Retrieved March 19, 2016.
   98. ^
       Link: mw-deduplicated-inline-style
       Garbutt, James (January 27, 2019). "First thoughts on Deno, the
       JavaScript/TypeScript run-time". 43081j.com. Archived from the
       original on November 7, 2020. Retrieved September 27, 2019.
   99. ^
       Link: mw-deduplicated-inline-style
       Yegulalp, Serdar. "Rust's Redox OS could show Linux a few new tricks".
       infoworld. Archived from the original on March 21, 2016. Retrieved
       March 21, 2016.
   100. ^
        Link: mw-deduplicated-inline-style
        "Introduction to Theseus". Theseus OS Book. Retrieved July 11,
        2021.{{cite web}}: CS1 maint: url-status (link)
   101. ^
        Link: mw-deduplicated-inline-style
        "Google Fushcia's source code". Google Git. Retrieved July 2,
        2021.{{cite web}}: CS1 maint: url-status (link)
   102. ^
        Link: mw-deduplicated-inline-style
        Sei, Mark (October 10, 2018). "Fedora 29 new features: Startis now
        officially in Fedora". Marksei, Weekly sysadmin pills. Archived from
        the original on April 13, 2019. Retrieved May 13, 2019.
   103. ^
        Link: mw-deduplicated-inline-style
        "RHEL 8: Chapter 8. Managing layered local storage with Stratis".
        October 10, 2018. Archived from the original on April 13, 2019.
        Retrieved April 13, 2019.
   104. ^
        Link: mw-deduplicated-inline-style
        "rust-for-linux.vger.kernel.org archive mirror". lore.kernel.org.
        Retrieved March 24, 2022.
   105. ^
        Link: mw-deduplicated-inline-style
        Howarth, Jesse (February 4, 2020). "Why Discord is switching from Go
        to Rust". Archived from the original on June 30, 2020. Retrieved
        April 14, 2020.
   106. ^
        Link: mw-deduplicated-inline-style
        Vishnevskiy, Stanislav (July 6, 2017). "How Discord Scaled Elixir to
        5,000,000 Concurrent Users". Discord Blog.
   107. ^
        Link: mw-deduplicated-inline-style
        Nichols, Shaun (June 27, 2018). "Microsoft's next trick? Kicking
        things out of the cloud to Azure IoT Edge". The Register. Archived
        from the original on September 27, 2019. Retrieved September 27,
        2019.
   108. ^
        Link: mw-deduplicated-inline-style
        "Ruffle". Ruffle. Archived from the original on January 26, 2021.
        Retrieved April 14, 2021.
   109. ^
        Link: mw-deduplicated-inline-style
        terminusdb/terminusdb-store, TerminusDB, December 14, 2020, archived
        from the original on December 15, 2020, retrieved December 14, 2020
   110. ^
        Link: mw-deduplicated-inline-style
        "Firecracker – Lightweight Virtualization for Serverless Computing".
        Amazon Web Services. November 26, 2018. Retrieved January 2, 2022.
   111. ^
        Link: mw-deduplicated-inline-style
        "Announcing the General Availability of Bottlerocket, an open source
        Linux distribution built to run containers". Amazon Web Services.
        August 31, 2020. Retrieved January 2, 2022.
   112. ^
        Link: mw-deduplicated-inline-style
        "Getting Started". rust-lang.org. Archived from the original on
        November 1, 2020. Retrieved October 11, 2020.
   113. ^
        Link: mw-deduplicated-inline-style
        "Community". www.rust-lang.org. Retrieved January 3, 2022.
   114. ^
        Link: mw-deduplicated-inline-style
        "RustConf 2020 - Thursday, August 20". rustconf.com. Archived from
        the original on August 25, 2019. Retrieved August 25, 2019.
   115. ^
        Link: mw-deduplicated-inline-style
        Rust Belt Rust. Dayton, Ohio. October 18, 2019. Archived from the
        original on May 14, 2019. Retrieved May 14, 2019.
   116. ^
        Link: mw-deduplicated-inline-style
        RustFest. Barcelona, Spain: asquera Event UG. 2019. Archived from the
        original on April 24, 2019. Retrieved May 14, 2019.
   117. ^
        Link: mw-deduplicated-inline-style
        "Oxidize Global". Oxidize Berlin Conference. Retrieved February 1,
        2021.
   118. ^
        Link: mw-deduplicated-inline-style
        Krill, Paul. "Rust language moves to independent foundation".
        InfoWorld. Archived from the original on April 10, 2021. Retrieved
        April 10, 2021.
   119. ^
        Link: mw-deduplicated-inline-style
        Vaughan-Nichols, Steven J. (April 9, 2021). "AWS's Shane Miller to
        head the newly created Rust Foundation". ZDNet. Archived from the
        original on April 10, 2021. Retrieved April 10, 2021.
   120. ^
        Link: mw-deduplicated-inline-style
        Vaughan-Nichols, Steven J. (November 17, 2021). "Rust Foundation
        appoints Rebecca Rumbul as executive director". ZDNet. Retrieved
        November 18, 2021.
   121. ^
        Link: mw-deduplicated-inline-style
        "The Rust programming language now has its own independent
        foundation". TechRepublic. February 10, 2021. Retrieved November 18,
        2021.

Further reading[edit]

     * Link: mw-deduplicated-inline-style
       Klabnik, Steve; Nichols, Carol (August 12, 2019). The Rust Programming
       Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
       (online version)
     * Link: mw-deduplicated-inline-style
       Blandy, Jim; Orendorff, Jason (2017). Programming Rust: Fast, Safe
       Systems Development. O'Reilly Media. ISBN 978-1-4919-2728-1.

External links[edit]

   Rustat Wikipedia's sister projects
     * Media from Commons
     * Resources from Wikiversity
     * Data from Wikidata
     * Official website Edit this at Wikidata
     * Rust-lang on GitHub

     * v        
     * t        
     * e        
   Programming languages
     * Comparison
     * Timeline 
     * History  
     * Ada      
     * ALGOL    
     * APL      
     * Assembly 
     * BASIC    
     * C        
     * C++      
     * C#       
     * COBOL    
     * Erlang   
     * Forth    
     * Fortran  
     * Go       
     * Haskell  
     * Java     
     * JavaScript
     * Kotlin   
     * Lisp     
     * Lua      
     * ML       
     * Pascal   
     * Perl     
     * PHP      
     * Prolog   
     * Python   
     * R        
     * Ruby     
     * Rust     
     * SQL      
     * Shell    
     * Simula   
     * Smalltalk
     * Swift    
     * more...  
     * Category 
     * Lists: Alphabetical
     * Categorical
     * Generational
     * Non-English-based

   Link: mw-deduplicated-inline-style

   Link: mw-deduplicated-inline-style    
     * v                                 
     * t                                 
     * e                                 
   Mozilla                               
   Projects                              
                     * Bugzilla                                               
                     * ChatZilla                                              
                     * Electrolysis Project                                   
                     * Jetpack                                                
                     * Lightning                                              
                     * Persona                                                
   Mozilla           * Prism                                                  
   Labs              * Raindrop                                               
                     * Skywriter                                              
                     * Sunbird                                                
                     * PDF.js                                                 
                     * Sync                                                   
                     * Tinderbox                                              
                     * Ubiquity                                               
                     * Open Media                                             
                     * Rust                                                   
                     * Servo                                                  
                     * Shumway                                                
   Mozilla           * WebAssembly                                            
   Research          * WebXR                                                  
                     * asm.js                                                 
                     * Daala                                                  
                     * Firefox OS                                             
                     * OpenFlint                                              
                     * Mozilla Location Service                               
                     * SeaMonkey                                              
                     * Thunderbird                                            
                                                                              
                                * Firefox Browser                             
                                    * 1                                       
                                    * 1.5                                     
                                    * 2                                       
                                    * 3                                       
                                    * 3.5                                     
                                    * 3.6                                     
                                    * 4                                       
                   Firefox          * 5–current                               
                                    * Future releases                         
                                    * for Android                             
                                    * for iOS                                 
                                    * Focus                                   
                                * Firefox Lockwise                            
                                * Firefox Monitor                             
                                * Firefox Send                                
                                * Mozilla VPN                                 
                                * Pocket                                      
                                  * Mozilla Application Suite                 
                                  * Netscape Navigator                        
                   Origins        * Netscape Communicator                     
                                  * Netscape Communications                   
                                  * Beonex Communicator                       
                                  * Basilisk                                  
                                  * BurningDog                                
                                  * Classilla                                 
                                  * Flock                                     
                                  * Gnuzilla                                  
   Mozilla                        * Goanna                                    
   Foundation                     * Iceape                                    
                                  * IceCat                                    
                                  * Icedove                                   
                   Forks          * Iceowl                                    
                                  * Miro                                      
                                  * Netscape 9                                
                                  * Pale Moon                                 
                                  * Portable Edition                          
                                  * Swiftfox                                  
                                  * Swiftweasel                               
                                  * TenFourFox                                
                                  * UXP                                       
                                  * Waterfox                                  
                                  * xB Browser                                
                                  * Add-on                                    
                                  * Gecko                                     
                   Frameworks     * Necko                                     
                                  * NPAPI                                     
                                       * XPConnect                            
                                  * Composer                                  
                                  * NSPR                                      
                   Components     * NSS                                       
                                  * Rhino                                     
                                  * SpiderMonkey                              
                                  * Tamarin                                   
                   Typefaces      * Fira Sans                                 
                                  * Zilla Slab                                
                                  * Calendar Project                          
                                  * Camino                                    
                                  * Firefox Home                              
                   Discontinued   * Firefox Send                              
                                  * Grendel                                   
                                  * Minimo                                    
                                  * XUL (XBL, XPCOM, XPInstall, XULRunner)    
   Discontinued projects are in italics. Some projects abandoned by Mozilla
   that are still maintained by third parties are in underline.
   Organization                          
   Foundation            * Former Mozilla Organization   
                         * Mozilla Foundation            
                         * Mozilla Corporation           
   Subsidiaries          * Mozilla Messaging             
                         * Mozilla Online                
                         * Mozilla China                 
   Official affiliates   * Mozilla Europe                
                         * Mozilla Japan                 
                         * Mozilla Taiwan                
                         * Mitchell Baker                
                         * David Baron                   
                         * Sheeri Cabral                 
                         * Tantek Çelik                  
   People                * Brendan Eich                  
                         * John Hammink                  
                         * Robert O'Callahan             
                         * Johnny Stenbäck               
                         * Doug Turner                   
                         * Boris Zbarsky                 
   Community                             
     * mozdev.org                        
     * Mozilla Add-ons                   
     * MDN Web Docs                      
     * MozillaZine                       
     * Spread Firefox                    
   Other topics                          
     * Mozilla Manifesto                 
     * The Book of Mozilla               
     * Code Rush                         
     * Mozilla Public License            
     * Localizations                     
     * Mascot                            
     * Rebranding / forking              
     * Common Voice                      

   Portal:
   [IMG]Computer programming
   Link: mw-deduplicated-inline-style

   Authority control: National libraries Edit this at         * Germany       
   Wikidata                                                   * United States 

   Retrieved from
   "https://en.wikipedia.org/w/index.php?title=Rust_(programming_language)&oldid=1081648680"
   Categories:
     * Rust (programming language)
     * 2010 software
     * Concurrent programming languages
     * Free compilers and interpreters
     * Free software projects
     * Functional languages
     * High-level programming languages
     * Mozilla
     * Multi-paradigm programming languages
     * Pattern matching programming languages
     * Procedural programming languages
     * Programming languages created in 2010
     * Software using the Apache license
     * Software using the MIT license
     * Statically typed programming languages
     * Systems programming languages
   Hidden categories:
     * CS1 maint: url-status
     * Articles with short description
     * Short description matches Wikidata
     * Use mdy dates from May 2021
     * All articles lacking reliable references
     * Articles lacking reliable references from April 2021
     * All Wikipedia articles needing clarification
     * Wikipedia articles needing clarification from August 2021
     * All articles with unsourced statements
     * Articles with unsourced statements from January 2022
     * Pages using Sister project links with hidden wikidata
     * Articles with GND identifiers
     * Articles with LCCN identifiers
     * Articles with example code

Navigation menu

   Personal tools
     * Not logged in
     * Talk
     * Contributions
     * Create account
     * Log in
   Namespaces
     * Article
     * Talk
   [ ] English
   Views
     * Read
     * Edit
     * View history
   [ ] More

  Search

   _____________________ [ Search ] [ Go ]
   Visit the main page
   Navigation
     * Main page
     * Contents
     * Current events
     * Random article
     * About Wikipedia
     * Contact us
     * Donate
   Contribute
     * Help
     * Learn to edit
     * Community portal
     * Recent changes
     * Upload file
   Tools
     * What links here
     * Related changes
     * Upload file
     * Special pages
     * Permanent link
     * Page information
     * Cite this page
     * Wikidata item
   Print/export
     * Download as PDF
     * Printable version
   In other projects
     * Wikimedia Commons
     * Wikiversity
   Languages
     * Afrikaans
     * العربية
     * Azərbaycanca
     * বাংলা
     * Bân-lâm-gú
     * Català
     * Čeština
     * Dansk
     * Deutsch
     * Eesti
     * Español
     * Esperanto
     * فارسی
     * Français
     * 한국어
     * Bahasa Indonesia
     * Íslenska
     * Italiano
     * עברית
     * Latviešu
     * Magyar
     * മലയാളം
     * Bahasa Melayu
     * Nederlands
     * 日本語
     * Norsk bokmål
     * Polski
     * Português
     * Română
     * Русский
     * Simple English
     * Slovenčina
     * Suomi
     * Svenska
     * తెలుగు
     * ไทย
     * Türkçe
     * Українська
     * 粵語
     * 中文
   Edit links
     * This page was last edited on 8 April 2022, at 19:10 (UTC).
     * Text is available under the Creative Commons Attribution-ShareAlike
       License 3.0; additional terms may apply. By using this site, you agree
       to the Terms of Use and Privacy Policy. Wikipedia® is a registered
       trademark of the Wikimedia Foundation, Inc., a non-profit
       organization.
     * Privacy policy
     * About Wikipedia
     * Disclaimers
     * Contact Wikipedia
     * Mobile view
     * Developers
     * Statistics
     * Cookie statement
     * Wikimedia Foundation
     * Powered by MediaWiki
