Learn Rust

What Is Rust?

Rust is a statically typed, compiled language originally created at Mozilla Research and now stewarded by the independent Rust Foundation. It was designed to answer a hard question: can a language be as fast and low-level as C++ while making it nearly impossible to write memory bugs like use-after-free, buffer overruns, and data races? Rust's answer is a compile-time checker called the borrow checker, which enforces strict rules about how memory is owned and accessed before your program ever runs.

Why Rust Exists

Traditional systems languages force a trade-off. C and C++ give you manual memory control and top-tier performance, but a single mistake with a pointer can crash your program or open a security hole. Languages like Java, Python, or Go solve memory safety with a garbage collector, but that collector adds runtime overhead and unpredictable pauses. Rust removes the trade-off: its ownership model checks memory safety at compile time, so there is no garbage collector and no runtime safety net needed. The cost is paid up front, by the compiler, not by your users at runtime.

• Memory safety without garbage collection, verified at compile time
• Performance comparable to C and C++ in real-world benchmarks
• A strong static type system that catches bugs before deployment
• Fearless concurrency: the same ownership rules that prevent memory bugs also prevent data races
• A modern toolchain: one command installs the compiler, package manager, formatter, and linter
• Zero-cost abstractions: high-level code compiles down to the same machine code you'd write by hand

Where Rust Is Used

Rust started as a language for building browser engines (Mozilla used it to build parts of Firefox's Servo engine) but has since spread into operating systems, game engines, blockchain platforms, command-line tools, web backends, and embedded devices. Companies including Microsoft, Amazon, Google, Discord, and Dropbox use Rust in production for components where correctness and speed both matter.

A First Look at Rust Code

Every Rust program starts execution in a function named main. The example below is the smallest complete Rust program you can write.

fn main() {
    println!("Hello from Rust!");
}

Notice the exclamation mark after println. That marks it as a macro rather than a regular function; macros generate code at compile time and are a core part of how Rust achieves zero-cost abstractions like formatted printing.

fn main() {
    let language = "Rust";
    let year_created = 2010;
    println!("{} first appeared in {}", language, year_created);
}

fn main() {
    let cores = 8;
    let threads_per_core = 2;
    let total_threads = cores * threads_per_core;
    println!("Total logical threads: {}", total_threads);
}