1.4Variables, mutability, and initialization

Last updated June 11, 2026

In the previous lesson (1.3), we created variables and gave them values. This lesson is about changing those values, and it's the first place Rust's personality really shows.

Assignment

Giving a variable a value at the moment it's created is called initialization (let width = 5;). Giving an existing variable a new value later is called assignment, and it uses =, the assignment operator:

fn main() {
    let mut width = 5;
    println!("width is {width}");
    width = 7;
    println!("width is now {width}");
}

width is 5
width is now 7

Assignment replaces the old value; the 5 is gone, and width's box in memory holds a 7. So far this matches every language you've ever heard of, except for one small word doing big work on the first line: mut.

Variables are immutable by default

Delete the mut and watch what happens:

fn main() {
    let width = 5;
    println!("width is {width}");
    width = 7;
    println!("width is now {width}");
}

error[E0384]: cannot assign twice to immutable variable `width`
 --> src/main.rs:4:5
  |
2 |     let width = 5;
  |         ----- first assignment to `width`
4 |     width = 7;
  |     ^^^^^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut width = 5;
  |         +++

In Rust, a plain let variable is immutable: once initialized, its value cannot be changed. If you want a variable you can assign to, you must say so up front with let mut (mut as in mutable, changeable). The error above is the compiler holding you to that, and notice it's a good error: it shows where the variable was created, where the rule broke, and the exact edit that fixes it.

New programmers usually meet this rule with polite disbelief. A variable that can't vary? But the default earns its keep twice over.

Accidentally assigning to something that shouldn't change is also a classic source of bugs, and in Rust that whole category dies at compile time. You'll notice this is the ownership chapter's pitch in miniature: say what you intend, and the compiler enforces it.

Initialization is enforced

Here's the second rule of this lesson, and it kills an entire genre of bug. You can declare a variable without a value:

let x: i32;

(Note we have to state the type now; with no value, there's nothing to infer from.) But try to use it before it has one:

fn main() {
    let x: i32;
    println!("x is {x}");
}

error[E0381]: used binding `x` isn't initialized
 --> src/main.rs:3:21
  |
2 |     let x: i32;
  |         - binding declared here but left uninitialized
3 |     println!("x is {x}");
  |                     ^ `x` used here but it isn't initialized
  |
help: consider assigning a value
  |
2 |     let x: i32 = 42;
  |                ++++

The rule is precise: Rust doesn't demand a value at the declaration, it demands one before the first use. This compiles fine:

fn main() {
    let x: i32;
    x = 10;
    println!("x is {x}");
}

x is 10

(A fine point you can file away: that x = 10 doesn't need mut, because it's the variable's first value. It's initialization arriving late, not re-assignment.)

Quiz time

Question #1

What's the difference between initialization and assignment?

Question #2

This is the course's first predict the compiler error question, a genre you'll see often: the program below does not compile. What will the compiler complain about, and what's the fix?

fn main() {
    let count = 10;
    count = count + 1;
    println!("{count}");
}

Question #3

What does this program print?

fn main() {
    let mut x = 1;
    println!("{x}");
    x = 2;
    x = 3;
    println!("{x}");
}

1
3

Question #4

Which of these variables needs mut?

let player_name = "Ada";
let high_score = 0;
// ... later in the program:
// high_score = 250;

So variables can change, with permission. Printing them flexibly is next: println! has more tricks than the {x} you've seen so far.