Rust Get Started

Let’s get Rust running on your machine and build your first program. If you’d rather not install anything yet, you can follow along in the Rust Playground and come back to this page later.

Step 1: Install Rust with rustup

The official way to install Rust is a tool called rustup. It installs the Rust compiler, the cargo build tool, and keeps everything up to date.

Go to rustup.rs and follow the instructions for your system:

• Windows — download and run rustup-init.exe, then accept the default options.

• macOS / Linux — paste this into your terminal:

  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Note

On Windows, Rust needs the C++ build tools. If the installer prompts you, let it install the “Visual Studio C++ Build Tools” — Rust uses them to link your programs.

Step 2: Check it worked

Close and reopen your terminal, then run:

rustc --version
cargo --version

You should see version numbers like rustc 1.xx.0. If you do, you’re ready to go.

• rustc is the Rust compiler (it turns your code into a program).
• cargo is Rust’s all-in-one tool for building, running, testing, and managing projects. You’ll use cargo for almost everything.

Step 3: Create your first project

Instead of creating files by hand, let cargo set up a project for you:

cargo new hello_rust
cd hello_rust

This creates a folder called hello_rust with everything a Rust project needs:

hello_rust/
├── Cargo.toml      # project settings and dependencies
└── src/
    └── main.rs     # your code goes here

• Cargo.toml describes your project (its name, version, and any libraries it uses).
• src/main.rs is the starting file — cargo even fills it with a Hello World for you.

Step 4: Run it

From inside the project folder, run:

cargo run

You’ll see cargo compile the project and then print:

Hello, world!

That’s it — you just built and ran a Rust program.

Understanding the code

Open src/main.rs and you’ll find:

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

• fn main() { ... } defines the main function — every Rust program starts running here.
• println!("...") prints a line of text to the screen.

Try changing the message and running cargo run again:

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

Output:

Hello from my first Rust program!

▶ Try it Yourself

cargo run vs cargo build

Two commands you’ll use constantly:

Command	What it does
cargo run	Compiles and runs your program (best while developing)
cargo build	Just compiles it — the program lands in target/debug/
cargo build --release	Compiles an optimized, faster version for shipping

When something goes wrong: reading compiler errors

You will see compiler errors, every day, even after years of Rust. They’re not a sign you’re bad at this. They’re the compiler doing its job. Let’s make one on purpose so it’s less scary the first time.

Remove the ! from println! in src/main.rs:

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

Run cargo run and you’ll get:

error[E0423]: expected function, found macro `println`
 --> src/main.rs:2:5
  |
2 |     println("Hello, world!");
  |     ^^^^^^^ not a function
  |
help: use `!` to invoke the macro
  |
2 |     println!("Hello, world!");
  |            +

Read it from top to bottom:

1. The first line says what’s wrong: Rust expected a function, but println is a macro (you’ll learn what that means on the next page).
2. --> src/main.rs:2:5 tells you where: file src/main.rs, line 2, column 5.
3. The ^^^^^^^ marks point at the exact piece of code.
4. The help: part often shows the fix. Here it even marks the missing ! with a +.

Put the ! back and everything works again:

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

Output:

Hello, world!

▶ Try it Yourself

A faster check

cargo check looks for errors without building a program to run. It’s much quicker than cargo build on bigger projects, so many people run it constantly while they write code. The code E0423 is searchable too: rustc --explain E0423 prints a longer explanation with examples.

Stuck on an error?

Rust Compiler Errors Explained has a page for each of the most common errors, with the real message, what it means, and fixes you can run.

Step 5: Set up your editor (recommended)

For the best experience, install the rust-analyzer extension in your editor. It gives you autocompletion, inline error messages, and type hints as you type.

• VS Code — install the rust-analyzer extension
• Most other editors (JetBrains, Neovim, etc.) support rust-analyzer too.

Tip

Keep the compiler’s error messages visible while you learn. Rust’s errors are famously helpful — they usually explain what went wrong and how to fix it.

Going further

Want the full toolbox? Rust Tools & Setup covers editors, debugging, clippy, rustfmt, what each operating system needs, and handy extra cargo tools.

Practice

1. Three lines

Make your program print three lines: your name, your favorite food, and I just ran Rust!. Hint: one println! prints one line, so use three of them.

Show solution

fn main() {
    println!("My name is Sam");
    println!("I like pizza");
    println!("I just ran Rust!");
}

Output:

My name is Sam
I like pizza
I just ran Rust!

▶ Try it Yourself

2. A tiny banner

Print a small banner like the one below, with a line of = signs above and below a title. Then break it on purpose by deleting a !, run cargo run, read the error, and fix it. Hint: the = lines are just text inside println!, like any other message.

Show solution

fn main() {
    println!("==============");
    println!("  HELLO RUST");
    println!("==============");
}

Output:

==============
  HELLO RUST
==============

▶ Try it Yourself

Recap

• Install Rust with rustup from rustup.rs.
• Verify with rustc --version and cargo --version.
• Create a project with cargo new, run it with cargo run.
• A project has a Cargo.toml (settings) and src/main.rs (your code).
• Read compiler errors top to bottom: what, where, and often a help: with the fix.
• Install rust-analyzer in your editor for a much smoother ride.

Quick check

Quick check

1. What tool installs the Rust compiler, cargo, and keeps them updated?

rustup cargo rustc

2. Which file describes a Rust project's name, version, and dependencies?

src/main.rs target/debug/ Cargo.toml

3. Which command only compiles your program without running it?

cargo run cargo build cargo new

Score: 0 / 3

Read more

• Installation — The Rust Book: installing on every platform, updating with rustup update, and troubleshooting.
• Hello, Cargo! — The Rust Book: a closer look at cargo new, cargo build, cargo run and cargo check.
• First Steps with Cargo — The Cargo Book: what cargo new creates and what each line of Cargo.toml means.
• The rustup book: installing extra toolchains, updating Rust, and switching between stable and nightly.
• rust-analyzer: setup guides for VS Code, Neovim, Emacs and other editors.