Rust (programming language)

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search
Rust programming language black logo.svg
Official Rust logo
ParadigmsMulti-paradigm: concurrent, functional, generic, imperative, structured
Designed byGraydon Hoare
First appearedJuly 7, 2010; 10 years ago (2010-07-07)
Stable release
1.48.0[1] / November 19, 2020; 3 days ago (2020-11-19)
Typing disciplineAffine, inferred, nominal, static, strong
Implementation languageRust
PlatformARM, IA-32, x86-64, MIPS, PowerPC, SPARC, RISC-V[2][3]
OSLinux, macOS, Windows, FreeBSD, OpenBSD,[4] Redox, Android, iOS[5]
LicenseMIT or Apache 2.0[6]
Filename, .rlib (metadata file)
Influenced by
Alef,[7] C#,[7] C++,[7] Cyclone,[7][8] Erlang,[7] Haskell,[7] Limbo,[7] Newsqueak,[7] OCaml,[7] Ruby,[7] Scheme,[7] Standard ML,[7] Swift[7][9]
Crystal, Elm,[10] Idris,[11] Spark,[12] Swift,[13] Project Verona,[14] PHP,[15] Zig

Rust is a multi-paradigm programming language designed for performance and safety, especially safe concurrency.[16][17] Rust is syntactically similar to C++,[18] but can guarantee memory safety by using a borrow checker to validate references.[19] Rust achieves memory safety without garbage collection, and reference counting is optional.[20][21]

Rust was originally designed by Graydon Hoare at Mozilla Research, with contributions from Dave Herman, Brendan Eich, and others.[22][23] The designers refined the language while writing the Servo layout or browser engine,[24] and the Rust compiler. It has gained increasing use in industry, and Microsoft has been experimenting with the language for secure and safety-critical software components.[25][26]

Rust has been voted the "most loved programming language" in the Stack Overflow Developer Survey every year since 2016.[27]


A presentation on Rust by Emily Dunham from Mozilla's Rust team ( conference, Hobart, 2017).

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

Performance of idiomatic Rust[edit]

Performance of idiomatic Rust is comparable to the performance of idiomatic C++.[30][31]


The concrete 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. Not all C or C++ keywords are implemented, however, and some Rust functions (such as the use of the keyword match for pattern matching) will be less familiar to those versed in these languages. Despite the superficial resemblance to C and C++, the syntax of Rust in a deeper sense is closer to that of the ML family of languages and the Haskell language. Nearly every part of a function body is an expression,[32] 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.

Memory safety[edit]

Rust is designed to be memory safe, and it does not permit null pointers, dangling pointers, or data races in safe code.[33][34][35] Data values can be initialized only through a fixed set of forms, all of which require their inputs to be already initialized.[36] To replicate the function in other languages of 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.[34] Rust also introduces added syntax to manage lifetimes, and the compiler reasons about these through its borrow checker. Unsafe code which can subvert some of these restrictions may be written using the language's unsafe keyword.[19]

Memory management[edit]

Rust does not use an automated garbage collection system. Instead, memory and other resources are managed through the resource acquisition is initialization (RAII) convention,[37] with optional reference counting. Rust provides deterministic management of resources, with very low overhead.[citation needed] Rust also 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 using such pointers is verified at compile time by the borrow checker, preventing dangling pointers and other forms of undefined behavior. Additionally, Rust's type system separates shared, immutable pointers of the form &T from unique, mutable pointers of the form &mut T. However, a mutable pointer can be coerced to an immutable pointer, but not vice versa.


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.[38][39] 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]

The type system supports a mechanism similar to type classes, called "traits", inspired directly by the Haskell language. This is a facility for ad hoc polymorphism, achieved by adding constraints to type variable declarations. Other features from Haskell, such as higher-kinded polymorphism, are not yet supported.

Rust features 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 fails to assign a value to the variable.[40] Variables assigned multiple times must be marked with the keyword mut.

Functions can be given generic parameters, which usually require the generic type to implement a certain trait or traits. Within such a function, the generic value can only be used through those traits. This means that a generic function can be type-checked as soon as it is defined. This is in contrast to C++ templates, which are fundamentally duck typed and cannot be checked until instantiated with concrete types. C++ concepts address the same issue and are part of C++20, though they still don't allow the C++ compiler to typecheck a template without concrete instantiation.

However, 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. The benefit of monomorphization is optimized code for each specific use case; the drawback is increased compile time and size of the resulting binaries.

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. Inheritance and polymorphism are provided by traits; 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.


A bright orange crab icon
Some Rust users refer to themselves as Rustaceans (a pun on "crustacean") and use Ferris as their unofficial mascot[41]

The language grew out of a personal project begun in 2006 by Mozilla employee Graydon Hoare,[17] who stated that the project was possibly named after the rust family of fungi.[42] Mozilla began sponsoring the project in 2009[17] and announced it in 2010.[43][44] The same year, work shifted from the initial compiler (written in OCaml) to the self-hosting compiler written in Rust.[45] Named rustc, it successfully compiled itself in 2011.[46] rustc uses LLVM as its back end.

The first numbered pre-alpha release of the Rust compiler occurred in January 2012.[47] Rust 1.0, the first stable release, was released on May 15, 2015.[48][49] Following 1.0, stable point releases are delivered every six weeks, while features are developed in nightly Rust and then tested with beta releases that last six weeks.[50]

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 when a program was running, 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.[51] Typestates were removed because in practice they were little used, though the same function can still be achieved with a branding pattern.[52]

The style of the object system changed considerably within versions 0.2, 0.3 and 0.4 of Rust. Version 0.2 introduced classes for the first time, with version 0.3 adding 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, replaced by a combination of implementations and structured types.[citation needed]

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 to become a competitor to C++ and to the other upcoming 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.[53]

Rust was the third-most-loved programming language in the 2015 Stack Overflow annual survey[54] and took first place for 2016–2020.[55][56][57][58][59]

The language is referenced in The Book of Mozilla as "oxidised metal".[60]


Hello World[edit]

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

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

Factorial function[edit]

Recursive Iterative Using iterators
fn factorial(i: u64) -> u64 {
    match i {
        0 => 1,
        n => n * factorial(n-1)
fn factorial(i: u64) -> u64 {
    let mut acc = 1;
    for num in 2..=i {
        acc *= num;
fn factorial(i: u64) -> u64 {


Web browser[edit]

A Web browser and several related components are being written in Rust, including:

Operating systems[edit]

Many operating systems (OS) and related components are being written in Rust. As of January 2019, the OSes included: BlogOS, intermezzOS, QuiltOS, Redox, RustOS, Rux, Tefflin, and Tock.[65] Wikipedia articles exist on:


  • Magic Pocket – Dropbox's file system that powers their Diskotech petabyte storage machines[69]
  • Firecracker – secure and fast microVMs for serverless computing[70]
  • exa – a "modern replacement for ls"
  • Microsoft Azure IoT Edge – a platform used to run Azure services and artificial intelligence on IoT devices has components implemented in Rust[71]
  • OpenDNS – used in two of its components[72][73][74]
  • Tor – an anonymity network, written in C originally, is experimenting with porting to Rust for its security features[75][76]
  • TiKV – a distributed key-value database first developed by PingCAP, now a Cloud Native Computing Foundation member project[77]
  • Xi – a text editor from Raph Levien,[78] used within the Fuchsia operating system[79]
  • Deno – a secure runtime for JavaScript and TypeScript built with V8, Rust, and Tokio[80]
  • Linkerd 2.x – a 'service mesh' tool for micro-service monitoring is largely written in Rust[81][82]
  • TerminusDB – data structure design and layout
  • Discord — chat service targeted towards gamers that uses Rust for portions of its backend, as well as client-side video encoding[83]
  • rav1e – an experimental AV1 video format encoder[84]
  • Weld – compiler and runtime for improving the performance of data-intensive applications (available for NumPy and Pandas and as a Rust crate)[85]
  • Cleora AI – open-source general-purpose model for efficient, scalable learning of stable and inductive entity embeddings for heterogeneous relational data


See also[edit]


  1. ^ The Rust Release Team (19 November 2020). "Announcing Rust 1.48.0". The Rust Programming Language Blog. Retrieved 19 November 2020.
  2. ^ "Rust Platform Support". Rust Forge. Retrieved 2019-05-19.
  3. ^ "Frequently Asked Questions". Rust Embedded. Retrieved 2019-05-14.
  4. ^ "OpenBSD ports". Retrieved 2018-04-03.
  5. ^ "Building and Deploying a Rust library on iOS". 6 September 2017. Retrieved 11 January 2019.
  6. ^ a b c d e f g h i j k l m "The Rust Reference: Appendix: Influences". Retrieved November 11, 2018. Rust is not a particularly original language, with design elements coming from a wide range of sources. Some of these are listed below (including elements that have since been removed): SML, OCaml [...] C++ [...] ML Kit, Cyclone [...] Haskell [...] Newsqueak, Alef, Limbo [...] Erlang [...] Ruby [...] Swift [...] Scheme [...] C# [...]
  7. ^ "Note Research: Type System". 2015-02-01. Retrieved 2015-03-25. Papers that have had more or less influence on Rust, or which one might want to consult for inspiration or to understand Rust's background. [...] Region based memory management in Cyclone [...] Safe memory management in Cyclone
  8. ^ "RFC for 'if let' expression". Retrieved December 4, 2014.
  9. ^ "Command Optimizations?". 2014-06-26. Retrieved 2014-12-10. I just added the outline of a Result library that lets you use richer error messages. It's like Either except the names are more helpful. The names are inspired by Rust's Result library.
  10. ^ "Idris – Uniqueness Types". Retrieved 2018-11-20.
  11. ^ Jaloyan, Georges-Axel (19 October 2017). "Safe Pointers in SPARK 2014". arXiv:1710.07047. Bibcode:2017arXiv171007047J. Cite journal requires |journal= (help)
  12. ^ Lattner, Chris. "Chris Lattner's Homepage". Retrieved 2019-05-14.
  13. ^ "Microsoft opens up Rust-inspired Project Verona programming language on GitHub". Retrieved 2020-01-17. Microsoft recently created a stir after revealing it was taking some ideas from the popular Rust programming language to create a new language for 'safe infrastructure programming' under the banner Project Verona.
  14. ^ "PHP RFC: Match expression v2". 2020-05-22. Retrieved 2020-08-08.
  15. ^ Hoare, Graydon (2016-12-28). "Rust is mostly safety". Graydon2. Dreamwidth Studios. Retrieved 2019-05-13.
  16. ^ a b c "FAQ – The Rust Project". Archived from the original on 2016-06-09. Retrieved 27 June 2019.
  17. ^ "Rust vs. C++ Comparison". Retrieved 20 November 2018. Rust is syntactically similar to C++, but it provides increased speed and better memory safety
  18. ^ a b "Unsafe Rust". Retrieved 2020-10-17.
  19. ^ "Fearless Security: Memory Safety". Retrieved 4 November 2020. To achieve both performance and memory safety, Rust uses a concept called ownership. More formally, the ownership model is an example of an affine type system.
  20. ^ "Rc<T>, the Reference Counted Smart Pointer". Retrieved 4 November 2020. To enable multiple ownership, Rust has a type called Rc<T>, which is an abbreviation for reference counting. The Rc<T> type keeps track of the number of references to a value which determines whether or not a value is still in use. If there are zero references to a value, the value can be cleaned up without any references becoming invalid.
  21. ^ Noel (2010-07-08). "The Rust Language". Lambda the Ultimate. Retrieved 2010-10-30.
  22. ^ "Contributors to rust-lang/rust". GitHub. Retrieved 2018-10-12.
  23. ^ Bright, Peter (2013-04-03). "Samsung teams up with Mozilla to build browser engine for multicore machines". Ars Technica. Retrieved 2013-04-04.
  24. ^ "Why Rust for safe systems programming". Retrieved 2019-07-22.
  25. ^ "How Microsoft Is Adopting Rust". Retrieved 2020-08-07.
  26. ^ "Stack Overflow Developer Survey 2016 Results". Stack Overflow. Retrieved 2017-03-22.
  27. ^ Avram, Abel (2012-08-03). "Interview on Rust, a Systems Programming Language Developed by Mozilla". InfoQ. Retrieved 2013-08-17. GH: A lot of obvious good ideas, known and loved in other languages, haven't made it into widely used systems languages ... There were a lot of good competitors in the late 1970s and early 1980s in that space, and I wanted to revive some of their ideas and give them another go, on the theory that circumstances have changed: the internet is highly concurrent and highly security-conscious, so the design-tradeoffs that always favor C and C++ (for example) have been shifting.
  28. ^ "Debian package description: rustc".
  29. ^ Walton, Patrick (2010-12-05). "C++ Design Goals in the Context of Rust". Retrieved 2011-01-21. It's impossible to be 'as fast as C' in all cases while remaining safe ... C++ allows all sorts of low-level tricks, mostly involving circumventing the type system, that offer practically unlimited avenues for optimization. In practice, though, C++ programmers restrict themselves to a few tools for the vast majority of the code they write, including stack-allocated variables owned by one function and passed by alias, uniquely owned objects (often used with auto_ptr or the C++0x unique_ptr), and reference counting via shared_ptr or COM. One of the goals of Rust's type system is to support these patterns exactly as C++ does, but to enforce their safe usage. In this way, the goal is to be competitive with the vast majority of idiomatic C++ in performance, while remaining memory-safe ...
  30. ^ "How Fast Is Rust?". The Rust Programming Language FAQ. Retrieved 11 April 2019.
  31. ^ "rust/src/grammar/parser-lalr.y". 2017-05-23. Retrieved 2017-05-23.
  32. ^ Rosenblatt, Seth (2013-04-03). "Samsung joins Mozilla's quest for Rust". Retrieved 2013-04-05. [Brendan Eich] noted that every year browsers fall victim to hacking in the annual Pwn2Own contest at the CanSecWest conference. "There's no free memory reads" in Rust, he said, but there are in C++. Those problems "lead to a lot of browser vulnerabilities" and would be solved by Rust, which is a self-compiling language.
  33. ^ a b Brown, Neil (2013-04-17). "A taste of Rust". Retrieved 2013-04-25. ... Other more complex data structures could clearly be implemented to allow greater levels of sharing, while making sure the interface is composed only of owned and managed references, and thus is safe from unplanned concurrent access and from dangling pointer errors.
  34. ^ "Data Races and Race Conditions".
  35. ^ "The Rust Language FAQ". 2015. Archived from the original on 2015-04-20. Retrieved 2017-04-24.
  36. ^ "RAII - Rust By Example". Retrieved 2020-11-22.
  37. ^ 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. Retrieved 2019-05-14.
  38. ^ "The Rust Programming Language: What is Ownership". Retrieved 2019-05-14.
  39. ^ Walton, Patrick (2010-10-01). "Rust Features I: Type Inference". Retrieved 2011-01-21.
  40. ^ "Getting Started". Retrieved 11 October 2020.
  41. ^ Hoare, Graydon (2014-06-07). "Internet archaeology: the definitive, end-all source for why Rust is named "Rust"". Retrieved 2016-11-03.
  42. ^ "Future Tense". 2011-04-29. Retrieved 2012-02-06. At Mozilla Summit 2010, we launched Rust, a new programming language motivated by safety and concurrency for parallel hardware, the “manycore” future which is upon us.
  43. ^ Hoare, Graydon (7 July 2010). Project Servo (PDF). Mozilla Annual Summit 2010. Whistler, Canada. Retrieved 22 February 2017.
  44. ^ Hoare, Graydon (2010-10-02). "Rust Progress". Archived from the original on 2014-08-15. Retrieved 2010-10-30.
  45. ^ Hoare, Graydon (2011-04-20). "[rust-dev] stage1/rustc builds". Retrieved 2011-04-20. After that last change fixing the logging scope context bug, looks like stage1/rustc builds. Just shy of midnight :)
  46. ^ catamorphism (2012-01-20). "Mozilla and the Rust community release Rust 0.1 (a strongly-typed systems programming language with a focus on memory safety and concurrency)". Retrieved 2012-02-06.
  47. ^ "Version History". Retrieved 2017-01-01.
  48. ^ The Rust Core Team (May 15, 2015). "Announcing Rust 1.0". Retrieved 2015-12-11.
  49. ^ "Scheduling the Trains". Retrieved 2017-01-01.
  50. ^ 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. Retrieved 2010-11-14.
  51. ^ Walton, Patrick (2012-12-26). "Typestate Is Dead, Long Live Typestate!". GitHub. Retrieved 2016-11-03.
  52. ^ Binstock, Andrew. "The Rise And Fall of Languages in 2013". Dr Dobb's.
  53. ^ "Stack Overflow Developer Survey 2015". Retrieved 2016-11-03.
  54. ^ "Stack Overflow Developer Survey 2016 Results". Stack Overflow. Retrieved 2017-03-22.
  55. ^ "Stack Overflow Developer Survey 2017". Stack Overflow. Retrieved 2017-03-22.
  56. ^ "Stack Overflow Developer Survey 2018". Stack Overflow. Retrieved 2018-03-13.
  57. ^ "Stack Overflow Developer Survey 2019". Stack Overflow. Retrieved 2019-04-09.
  58. ^ "Stack Overflow Developer Survey 2020". Stack Overflow. Retrieved 2020-05-27.
  59. ^ "The Book of Mozilla". Mozilla. Retrieved 2019-04-29. The Beast adopted new raiment and studied the ways of Time and Space and Light and the Flow of energy through the Universe. From its studies, the Beast fashioned new structures from oxidised metal and proclaimed their glories. And the Beast’s followers rejoiced, finding renewed purpose in these teachings.
  60. ^ Herman, Dave (2016-07-12). "Shipping Rust in Firefox * Mozilla Hacks – the Web developer blog". Retrieved 2016-11-03.
  61. ^ Yegulalp, Serdar (2015-04-03). "Mozilla's Rust-based Servo browser engine inches forward". InfoWorld. Retrieved 2016-03-15.
  62. ^ Lardinois, Frederic (2015-04-03). "Mozilla And Samsung Team Up To Develop Servo, Mozilla's Next-Gen Browser Engine For Multicore Processors". TechCrunch.
  63. ^ Bryant, David (27 October 2016). "A Quantum Leap for the web". Medium. Retrieved 27 October 2016.
  64. ^ Cantrill, Bryan (2019-01-16). Is It Time to Rewrite the Operating System in Rust? (Video). QCon San Francisco: C4Media. Retrieved 2019-05-13.
  65. ^ Yegulalp, Serdar. "Rust's Redox OS could show Linux a few new tricks". infoworld. Retrieved 21 March 2016.
  66. ^ Sei, Mark (10 October 2018). "Fedora 29 new features: Startis now officially in Fedora". Marksei, Weekly sysadmin pills. Retrieved 2019-05-13.
  67. ^ "RHEL 8: Chapter 8. Managing layered local storage with Stratis". 10 October 2018.
  68. ^ Metz, Cade (2016-03-14). "The Epic Story of Dropbox's Exodus From the Amazon Cloud Empire". Wired. Retrieved 2016-11-03.
  69. ^ Desai, Azhar (2019-01-01). "The Firecracker virtual machine monitor". Retrieved 2019-01-04.
  70. ^ Nichols, Shaun (27 June 2018). "Microsoft's next trick? Kicking things out of the cloud to Azure IoT Edge". The Register. Retrieved 2019-09-27.
  71. ^ Balbaert, Ivo (27 May 2015). Rust Essentials. Packt Publishing. p. 6. ISBN 978-1785285769. Retrieved 21 March 2016.
  72. ^ Frank, Denis (5 December 2013). "Using HyperLogLog to Detect Malware Faster Than Ever". OpenDNS Security Labs. Retrieved 19 March 2016.
  73. ^ Denis, Frank (4 October 2013). "ZeroMQ: Helping us Block Malicious Domains in Real Time". OpenDNS Security Labs. Retrieved 19 March 2016.
  74. ^ Hahn, Sebastian (2017-03-31). "[tor-dev] Tor in a safer language: Network team update from Amsterdam". Retrieved 2017-04-01.
  75. ^ asn (2017-07-05). "The Wilmington Watch: A Tor Network Team Hackfest". Tor Blog. Retrieved 2018-01-03.
  76. ^ cncf (2019-05-21). "TOC Votes to Move TiKV into CNCF Incubator". Cloud Native Computing Foundation. Retrieved 2019-08-28.
  77. ^ Levien, Raph (2018-01-23). "Xi: an editor for the next 20 years". Recurse Center. Retrieved 2018-08-08.
  78. ^ "xi-editor". Google Open Source. Retrieved 2019-01-26. Used as the basis for text editing services in the Fuchsia operating system.
  79. ^ Garbutt, James (27 January 2019). "First thoughts on Deno, the JavaScript/TypeScript run-time". Retrieved 2019-09-27.
  80. ^ Morgan, William. "Linkerd v2: How Lessons from Production Adoption Resulted in a Rewrite of the Service Mesh". InfoQ: Software Development News, Videos & Books. Retrieved 16 October 2019.
  81. ^ "Linkerd Overview". Retrieved 16 October 2019.
  82. ^ Howarth, Jesse (2020-02-04). "Why Discord is switching from Go to Rust". Retrieved 2020-04-14.
  83. ^ "The fastest and safest AV1 encoder". Retrieved 9 April 2018.
  84. ^ "weld - Rust". Retrieved 2020-10-13.
  85. ^ "RustConf".
  86. ^ Rust Belt Rust. Dayton, Ohio. 2019-10-18. Retrieved 2019-05-14.
  87. ^ RustFest. Barcelona, Spain: asquera Event UG. 2019. Retrieved 2019-05-14.
  88. ^ "RustCon Asia 2019 – Beijing". Retrieved 2019-08-28.

External links[edit]