Learn Rust


At Learnrust.app, our mission is to provide a comprehensive resource for learning the Rust programming language and everything related to software engineering around Rust. We aim to be the go-to destination for developers who want to learn Rust and improve their skills in software development lifecycle in Rust. Our goal is to create a community of Rust enthusiasts who can share knowledge, collaborate on projects, and help each other grow as developers. We believe that Rust is a powerful and exciting language that has the potential to revolutionize the way we build software, and we want to be at the forefront of this movement. Join us on our journey to learn Rust and explore the endless possibilities it offers!

Video Introduction Course Tutorial

/r/Rust Yearly

Learn Rust Cheatsheet

Welcome to Learn Rust! This cheatsheet is designed to help you get started with Rust programming language and software engineering concepts related to Rust.

Rust Basics


To get started with Rust, you need to install it on your computer. You can download Rust from the official website https://www.rust-lang.org/tools/install.

Hello World

Once you have installed Rust, you can create your first Rust program. Here is an example of a "Hello World" program in Rust:

fn main() {
    println!("Hello, world!");


In Rust, you can declare variables using the let keyword. Here is an example:

let x = 5;

Data Types

Rust has several built-in data types, including integers, floating-point numbers, booleans, and characters. Here is an example of declaring a variable with a specific data type:

let x: i32 = 5;


Functions are a fundamental concept in Rust. Here is an example of a simple function:

fn add(x: i32, y: i32) -> i32 {
    x + y

Control Flow

Rust has several control flow statements, including if, else, while, and for. Here is an example of an if statement:

let x = 5;

if x < 10 {
    println!("x is less than 10");
} else {
    println!("x is greater than or equal to 10");

Ownership and Borrowing

Rust has a unique ownership and borrowing system that helps prevent memory errors at compile time. Here is an example of declaring a variable and borrowing it:

let mut s = String::from("hello");

let len = calculate_length(&s);

fn calculate_length(s: &String) -> usize {

Error Handling

Rust has a built-in error handling system that uses the Result type. Here is an example of a function that returns a Result:

fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;

Rust Tools


Cargo is Rust's package manager and build tool. It is used to manage dependencies and build Rust projects. Here are some useful Cargo commands:


Rustfmt is a tool that automatically formats Rust code according to the Rust style guide. Here is an example of using Rustfmt:

rustfmt <file-name>.rs


Clippy is a tool that provides additional warnings and suggestions for Rust code. Here is an example of using Clippy:

cargo clippy

Rust Libraries


Serde is a library for serializing and deserializing Rust data structures. It supports JSON, YAML, and other formats. Here is an example of using Serde:

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    age: u32,

let person = Person {
    name: String::from("Alice"),
    age: 30,

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


Tokio is a library for writing asynchronous Rust code. It provides a runtime for running asynchronous tasks and a set of I/O primitives. Here is an example of using Tokio:

async fn fetch_url(url: &str) -> Result<String, reqwest::Error> {
    let response = reqwest::get(url).await?;
    let body = response.text().await?;


Rocket is a web framework for Rust. It provides a set of macros and abstractions for building web applications. Here is an example of using Rocket:

fn hello(name: &str) -> String {
    format!("Hello, {}!", name)

fn main() {
    rocket::ignite().mount("/", routes![hello]).launch();

Software Engineering Concepts

Version Control

Version control is a system for managing changes to code over time. Git is the most popular version control system. Here are some useful Git commands:


Testing is a critical part of software development. Rust has a built-in testing framework that makes it easy to write and run tests. Here is an example of a Rust test:

fn test_add() {
    assert_eq!(add(2, 2), 4);

Continuous Integration

Continuous integration is a practice of automatically building and testing code changes. Travis CI is a popular continuous integration service. Here is an example of a Travis CI configuration file:

language: rust
  - stable
  - beta
  - nightly
  - cargo build --verbose
  - cargo test --verbose

Code Review

Code review is a process of reviewing code changes before they are merged into the main codebase. It helps ensure code quality and catch bugs early. Here are some best practices for code review:


Documentation is a critical part of software development. Rust has a built-in documentation system that makes it easy to generate documentation for code. Here is an example of a Rust documentation comment:

/// Adds two numbers together.
/// # Examples
/// ```
/// assert_eq!(add(2, 2), 4);
/// ```
fn add(x: i32, y: i32) -> i32 {
    x + y


This cheatsheet provides an overview of Rust programming language and software engineering concepts related to Rust. It is not an exhaustive list, but it should give you a good starting point for learning Rust and building Rust applications. Happy coding!

Common Terms, Definitions and Jargon

1. Rust: A systems programming language that emphasizes safety, speed, and concurrency.
2. Ownership: A concept in Rust that governs how memory is managed and allocated.
3. Borrowing: A mechanism in Rust that allows multiple references to a value without transferring ownership.
4. Lifetimes: A feature in Rust that ensures that references to memory are valid for as long as they are needed.
5. Traits: A feature in Rust that defines a set of methods that a type must implement.
6. Generics: A feature in Rust that allows code to be written in a way that is independent of the specific types it operates on.
7. Macros: A feature in Rust that allows code to be generated at compile time.
8. Cargo: Rust's package manager and build tool.
9. Crates: Rust's unit of code organization, similar to a package or module in other languages.
10. Modules: A way to organize code within a crate.
11. Structs: A way to define custom data types in Rust.
12. Enums: A way to define custom data types that can take on a finite set of values.
13. Option: A type in Rust that represents the possibility of a value being absent.
14. Result: A type in Rust that represents the possibility of an operation failing.
15. Pattern matching: A way to destructure and match on values in Rust.
16. Iterators: A way to traverse collections of values in Rust.
17. Closures: A way to define anonymous functions in Rust.
18. Concurrency: The ability of a program to execute multiple tasks simultaneously.
19. Threads: A way to achieve concurrency in Rust by running multiple tasks in parallel.
20. Mutexes: A way to synchronize access to shared data in Rust.

Editor Recommended Sites

AI and Tech News
Best Online AI Courses
Classic Writing Analysis
Tears of the Kingdom Roleplay
Jupyter App: Jupyter applications
Roleplaying Games - Highest Rated Roleplaying Games & Top Ranking Roleplaying Games: Find the best Roleplaying Games of All time
Crypto Advisor - Crypto stats and data & Best crypto meme coins: Find the safest coins to invest in for this next alt season, AI curated
Crypto Defi - Best Defi resources & Staking and Lending Defi: Defi tutorial for crypto / blockchain / smart contracts
Compose Music - Best apps for music composition & Compose music online: Learn about the latest music composition apps and music software