Outline of the Rust programming language

The following outline is provided as an overview of and topical guide to Rust:

Rust is a multi-paradigm programming language emphasizing performance, memory safety, and concurrency. Rust was initially developed by Graydon Hoare starting in 2006, later sponsored and maintained by Mozilla Research starting in 2009, and first publicly released in 2010, with version 1.0 released in 2015. Rust is syntactically similar to C++ but guarantees memory safety without requiring a garbage collector. ^{[1] [2] [3] [4]}

What type of language is Rust?

• Programming language — artificial language designed to communicate instructions to a computer
• Compiled language — implemented through compilers rather than interpreters ^[5]
• General-purpose programming language
• Multi-paradigm programming language — supports functional programming, imperative programming, concurrent programming.
• Statically typed programming language — type checking performed at compile time ^[6]
• Systems programming language — designed for low-level programming and operating system development ^[7]
• Memory-safe language — prevents common undefined behavior like dangling pointers and buffer overflows ^[8]

History of Rust

See also: History of Rust

• Graydon Hoare — creator of Rust starting in 2006 ^[9]
• Mozilla — original sponsor and maintainer of Rust starting in 2009
• Cargo (software) — introduced as Rust’s official package manager and build system in 2014
• Rust Foundation — current steward of the Rust project since its inception in 2021

General Rust concepts

See also: Rust syntax

• Asynchronous I/O ^[10]
• Arrays and vectors
• Borrow checker ^[11]
• Closures ^[12]
• Concurrency ^[13]
• Crates and modules ^{[14] [15]}
• Enums in Rust ^{[16] [17]}
• Error handling ^[18]
• Functions ^[19]
• Generics ^[20]
• If statements and booleans ^[21]
• Iterators ^[22]
• Lifetimes
• Macros ^[23]
• Memory management ^[24]
• Ownership ^[25]
• Pattern matching ^[26]
• Serialization ^[27]
• Smart pointers ^[28]
• Strings ^[29]
• Tuples and structs ^[30]
• Traits ^[31]
• Type inference ^[32]
• Variables ^{[33] [34]}
• Unit testing ^[35]

Issues / Limitations

• Compile time performance ^[36]
• Ecosystem maturity

Rust toolchain

See also: List of Rust software and tools

Compilers

See also: List of Rust compilers

• rustc — official Rust compiler
• LLVM — Rust backend uses LLVM for code generation
• mrustc — alternative Rust compiler written in C++ ^[37]
• Cranelift — JIT compiler backend used in Wasmtime ^{[38] [39]}

Build and package management

• Cargo — build system and package manager ^[40]
• Crates.io — official Rust package registry ^[41]

Rust libraries and frameworks

• Rocket — web framework focused on type safety ^[42]
• Serde — framework for serialization and deserialization supporting JSON, YAML, TOML, and more. ^[43]
• Tokio — asynchronous runtime for Rust ^[44]

Testing and benchmarking

• Criterion.rs — benchmarking library ^{[45] [46]}
• Built-in unit testing with Cargo ^[47]

Notable projects written in Rust

• Firefox (partial, via components)
• Alacritty
• Deno
• TiKV

Example source code

• Articles with example Rust code

Rust publications

Books about Rust

• The Rust Programming Language — Steve Klabnik and Carol Nichols
• The Secrets of Rust: Tools — Bitfield Consulting
• Effective Rust — David Drysdale
• Rust for Rustaceans — Jon Gjengset
• Programming Rust — Jim Blandy, Jason Orendorff, and Leonora Tindall
• Rust in Action — Tim McNamara
• Zero to Production in Rust — Luca Palmieri ^[48]

Rust dialects and related languages

• Dyon – rusty dynamically typed scripting language ^[49]
• Fe — inspired by Rust, smart contract language for the Ethereum blockchain ^[50]
• Move — originally developed for the Diem blockchain ^[51]
• Sway — Rust-based language for smart contracts ^[52]

Rust learning resources

See also: List of online integrated development environments

• Getting started with Rust
• Official Rust Learn page
• W3Schools – Rust tutorials
• The Rust Programming Language (online book)
• Rust By Example

Competitive programming

See also: List of online competitive programming platforms

• LeetCode — supports Rust submissions
• HackerRank — includes Rust challenges
• Codeforces — supports Rust in contests

See also

• Outline of computer programming
• Outline of software
• Outline of software engineering
• Outline of C++

External links

• Official Rust website
• Rust documentation
• Rust GitHub repository

References

1. https://www.technologyreview.com/2023/02/14/1067869/rust-worlds-fastest-growing-programming-language/
2. https://doc.rust-lang.org/rust-by-example/
3. https://www.geeksforgeeks.org/rust/introduction-to-rust-programming-language/
4. https://stanford-cs242.github.io/f18/lectures/05-1-rust-memory-safety.html
5. https://medium.com/journey-to-rust/my-first-insight-into-rust-type-system-601cdfd0b81f
6. https://doc.rust-lang.org/rust-by-example/scope/lifetime/static_lifetime.html#static
7. https://medium.com/@autognosi/rust-core-key-concepts-for-getting-started-b827b90d4902
8. https://www.infoworld.com/article/2336661/rust-memory-safety-explained.html
9. https://thenewstack.io/graydon-hoare-remembers-the-early-days-of-rust/
10. https://rust-lang.github.io/async-book/
11. https://doc.rust-lang.org/1.8.0/book/references-and-borrowing.html
12. https://rustwiki.org/en/book/ch13-01-closures.html
13. https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/concurrency.html
14. https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/crates-and-modules.html
15. https://doc.rust-lang.org/rust-by-example/crates.html
16. https://doc.rust-lang.org/rust-by-example/custom_types/enum.html
17. https://www.geeksforgeeks.org/rust/rust-enum/
18. https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/error-handling.html
19. https://doc.rust-lang.org/book/ch03-03-how-functions-work.html
20. https://rustwiki.org/en/book/ch10-01-syntax.html
21. https://doc.rust-lang.org/book/ch03-05-control-flow.html
22. https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/iterators.html
23. https://doc.rust-lang.org/book/ch20-05-macros.html
24. https://google.github.io/comprehensive-rust/memory-management.html
25. https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html
26. https://www.programiz.com/rust/pattern-matching
27. https://docs.rs/serde/latest/serde/trait.Serialize.html
28. https://doc.rust-lang.org/book/ch15-00-smart-pointers.html
29. https://doc.rust-lang.org/rust-by-example/std/str.html
30. https://doc.rust-lang.org/book/ch05-01-defining-structs.html
31. https://doc.rust-lang.org/book/ch10-02-traits.html
32. https://rustc-dev-guide.rust-lang.org/type-inference.html
33. https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html
34. https://www.geeksforgeeks.org/rust/variables-in-rust/
35. https://rustwiki.org/en/rust-by-example/testing/unit_testing.html
36. https://nnethercote.github.io/perf-book/compile-times.html
37. https://github.com/thepowersgang/mrustc
38. https://cranelift.dev/
39. https://github.com/rust-lang/rustc_codegen_cranelift
40. https://doc.rust-lang.org/cargo/
41. https://crates.io/
42. https://rocket.rs/
43. https://serde.rs/
44. https://tokio.rs/
45. https://github.com/bheisler/criterion.rs
46. https://docs.rs/criterion/latest/criterion/
47. https://doc.rust-lang.org/cargo/guide/tests.html
48. https://bitfieldconsulting.com/posts/best-rust-books
49. https://github.com/PistonDevelopers/dyon
50. https://fe-lang.org
51. https://move-language.github.io/move/
52. https://fuellabs.github.io/sway/v0.69.5/book/#the-sway-programming-language