How to Install Rust and Set Up Your Development Environment

In the previous article, we explored what Rust is, why it was created, where it is used, and why developers are choosing it for high-performance and reliable software development.

Now it's time to get practical.

Before writing serious Rust programs, you need a properly configured development environment.

Fortunately, Rust makes this process relatively simple.

The recommended way to install Rust is through rustup, the official Rust toolchain installer and version manager.

In this article, you'll learn how to:

• Install Rust
• Install rustup
• Verify your Rust installation
• Understand rustc
• Understand Cargo
• Create your first Rust project
• Understand the Rust project structure
• Run a Rust application
• Compile a Rust application
• Use Rust's development workflow
• Troubleshoot common installation problems

By the end, you'll have everything required to start programming in Rust.

What Do You Need to Start Rust Development?

You don't need an expensive computer or complicated setup.

At a minimum, you'll need:

• A computer
• An internet connection
• A terminal or command prompt
• A text editor or IDE
• Rust
• Cargo

Rust supports major operating systems including:

• Windows
• macOS
• Linux

The installation process differs slightly between them, but rustup makes managing Rust versions and toolchains much easier.

What Is Rustup?

Before installing Rust, you should understand rustup.

rustup is the official Rust toolchain installer and manager.

It allows you to:

• Install Rust
• Update Rust
• Switch toolchains
• Install different Rust versions
• Install compilation targets
• Manage Rust components

Instead of manually downloading compiler files, you can use rustup to manage your Rust environment.

This becomes particularly useful when working on multiple projects that require different Rust versions or compilation targets.

Rust Toolchain Explained

A Rust toolchain is the collection of tools required to build Rust programs.

The most important components include:

rustc

The Rust compiler.

It converts Rust source code into executable machine code.

cargo

Rust's build system and package manager.

It manages:

• Projects
• Dependencies
• Builds
• Tests
• Documentation
• Publishing

rustup

The toolchain manager.

It manages Rust installations and versions.

You can think about them like this:

rustup
   ↓
Manages Rust toolchains
   ↓
rustc + cargo
   ↓
Build and manage Rust applications

Installing Rust on macOS and Linux

The recommended installation method for macOS and Linux is rustup.

Open your terminal and run:

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

The installer will guide you through the installation process.

In most cases, the default installation is exactly what you want.

After installation, restart your terminal or reload your shell configuration.

Then check your Rust version:

rustc --version

You should see output similar to:

rustc 1.x.x

The exact version will depend on the current stable Rust release installed on your system.

Installing Rust on Windows

Windows users can also install Rust using rustup.

The official installer provides the necessary setup.

During installation, Rust may require Microsoft's C++ build tools.

These tools are used by Rust for compiling native code on Windows.

After installation, open PowerShell or Command Prompt and run:

rustc --version

Then check Cargo:

cargo --version

If both commands return version information, your installation is working.

Verify Your Rust Installation

After installing Rust, it's a good idea to verify all the important components.

Run:

rustc --version

Then:

cargo --version

And:

rustup --version

You should receive version information for all three.

You can also run:

rustup show

This displays information about your active Rust toolchain.

Understanding rustc

rustc is the Rust compiler.

Suppose you create a file called:

main.rs

with:

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

You can compile it directly using:

rustc main.rs

Rust will compile the source code into an executable.

You can then run that executable.

This demonstrates the basic compilation process:

main.rs
   ↓
rustc
   ↓
Machine code
   ↓
Executable

However, you generally won't want to manage larger projects using rustc directly.

That's where Cargo comes in.

What Is Cargo?

Cargo is one of Rust's biggest productivity advantages.

It is Rust's official:

• Build system
• Package manager
• Project manager
• Test runner
• Documentation tool

Instead of manually compiling individual files, Cargo manages the entire project.

You'll use commands such as:

cargo new
cargo build
cargo run
cargo test
cargo check
cargo fmt
cargo clippy

You'll become very familiar with these commands throughout this series.

Creating Your First Rust Project

Let's create an actual Rust project.

Open your terminal and run:

cargo new hello_rust

Cargo will create a new project named:

hello_rust

Move into the project:

cd hello_rust

Your project will look something like this:

hello_rust/
├── Cargo.toml
└── src/
    └── main.rs

This is the basic structure of a Rust binary application.

Understanding Cargo.toml

Open:

Cargo.toml

You'll see something similar to:

[package]
name = "hello_rust"
version = "0.1.0"
edition = "2024"

[dependencies]

The exact edition or generated metadata can vary with your installed Cargo version.

Let's understand the important parts.

The [package] Section

The [package] section contains information about your Rust package.

For example:

[package]
name = "hello_rust"
version = "0.1.0"
edition = "2024"

name

The name of your package.

version

The current package version.

edition

The Rust language edition used by the project.

Rust editions allow the language to evolve while maintaining compatibility with existing code.

The [dependencies] Section

This section contains external packages your application depends on.

For example:

[dependencies]
serde = "1"

This tells Cargo that the project depends on the serde crate.

Cargo can then download and compile the dependency as part of your project.

We'll explore dependencies and crates in much greater detail later.

For now, remember:

Cargo.toml
    ↓
Project configuration
    ↓
Dependencies + package information

Understanding src/main.rs

Now open:

src/main.rs

Cargo generates a basic program:

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

This is your application's entry point.

Change it to:

fn main() {
    println!("Welcome to Rust!");
}

Save the file.

Now you're ready to run it.

Running Your Rust Program

From the project directory, run:

cargo run

Cargo will compile your program and execute it.

You should see:

Welcome to Rust!

Congratulations.

You've just created and executed your first Cargo-managed Rust application.

What Happens When You Run cargo run?

Several things happen behind the scenes.

Conceptually:

cargo run
    ↓
Read Cargo.toml
    ↓
Resolve dependencies
    ↓
Compile source code
    ↓
Create executable
    ↓
Run executable

Cargo handles the complexity for you.

This becomes extremely useful as your projects grow.

Building Your Project

You can compile your application without running it.

Use:

cargo build

Cargo will compile your project and store the generated build artifacts.

The default development build is placed under:

target/debug/

You may find an executable such as:

target/debug/hello_rust

The exact executable layout differs between operating systems.

Debug vs Release Builds

Rust provides different build profiles.

When you run:

cargo build

Cargo creates a development build.

For production-oriented optimized builds, use:

cargo build --release

The optimized output is placed under:

target/release/

Conceptually:

Development
cargo build
      ↓
target/debug/

Production
cargo build --release
      ↓
target/release/

Release builds enable optimizations that can significantly improve runtime performance.

Why Not Always Use --release?

During development, compilation speed matters.

You frequently change code and rebuild your application.

Debug builds generally prioritize faster compilation and useful debugging information.

Release builds prioritize optimized executable performance.

Therefore, the typical workflow is:

cargo run

while developing.

And:

cargo build --release

when preparing optimized builds.

Using cargo check

One of the most useful Rust commands is:

cargo check

It checks whether your project compiles without producing the final executable.

This makes it very useful during development.

For example:

cargo check

If there are no compilation errors, Cargo reports that the project finished successfully.

You can use this repeatedly while writing code.

cargo run vs cargo build vs cargo check

These commands have different purposes.

A common development cycle looks like:

Write code
   ↓
cargo check
   ↓
Fix errors
   ↓
cargo run
   ↓
Test application

Formatting Rust Code

Rust provides an official formatter called rustfmt.

You can format your project with:

cargo fmt

For example, poorly formatted code like:

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

can be formatted into:

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

Consistent formatting makes code easier to read and maintain.

Why cargo fmt Matters

Formatting may seem like a small detail.

In large teams, however, inconsistent formatting can create unnecessary problems.

Rust's formatter provides a common standard.

Instead of debating:

"How should this code be formatted?"

the team can simply run:

cargo fmt

Everyone gets consistent formatting.

Using Clippy

Rust also provides a powerful linting tool called Clippy.

Clippy identifies patterns that may indicate:

• Bugs
• Inefficient code
• Unnecessary complexity
• Poor idioms
• Potential improvements

You can run it with:

cargo clippy

For example, Clippy might suggest a more idiomatic way of writing a piece of Rust code.

As you become more experienced, Clippy becomes an excellent tool for improving code quality.

Your Recommended Development Toolkit

A productive Rust environment should contain:

Rust

The language and compiler.

rustup

Toolchain manager.

Cargo

Build and dependency management.

rustfmt

Automatic formatting.

Clippy

Linting and code-quality suggestions.

Editor or IDE

A development environment with Rust support.

Together:

rustup
  │
  ├── rustc
  ├── cargo
  ├── rustfmt
  └── clippy

Choosing a Code Editor

You can write Rust in almost any text editor.

However, an editor with Rust language support makes development much easier.

Popular options include:

• Visual Studio Code
• RustRover
• Neovim
• Vim
• Emacs
• Sublime Text

For beginners, Visual Studio Code is a practical option because of its extensive extension ecosystem.

Rust-aware tooling can provide:

• Syntax highlighting
• Autocomplete
• Error diagnostics
• Code navigation
• Refactoring
• Formatting
• Inline compiler feedback

Rust Analyzer

One of the most important tools for Rust development is rust-analyzer.

It provides language-server functionality for Rust editors.

It can provide:

• Autocomplete
• Go-to-definition
• Error detection
• Type information
• Code navigation
• Refactoring
• Documentation hints

Instead of constantly compiling your application to discover basic issues, your editor can often highlight them while you type.

This makes learning Rust significantly more interactive.

A Typical Rust Project

As your projects become more sophisticated, you may encounter structures such as:

my_project/
├── Cargo.toml
├── Cargo.lock
├── src/
│   ├── main.rs
│   ├── lib.rs
│   └── modules/
├── tests/
├── examples/
└── target/

Don't worry if these directories don't make sense yet.

We'll gradually introduce each one.

For now, focus on:

Cargo.toml
src/main.rs

These are the most important pieces of your first application.

What Is Cargo.lock?

When Cargo resolves dependencies, it records the exact versions selected for the project in:

Cargo.lock

This helps make builds reproducible.

For example, your project may depend on a library with version requirements.

Cargo resolves the dependency tree and records the exact versions.

This is particularly important for applications where reproducible builds matter.

Creating a Library Instead of an Application

Cargo can create more than executable applications.

You can create a library with:

cargo new my_library --lib

This produces a structure similar to:

my_library/
├── Cargo.toml
└── src/
    └── lib.rs

The key difference is:

Binary project
src/main.rs

Library project
src/lib.rs

We'll explore libraries later in the series.

Creating a Project Without Entering a Directory

You can also let Cargo create the directory and then enter it:

cargo new rust_project
cd rust_project

This is the standard workflow you'll use repeatedly.

Running Rust Without Manually Compiling

One advantage of Cargo is that you don't need to manually run:

rustc main.rs

every time.

Instead:

cargo run

handles the build process.

This becomes especially useful when your project has:

• Multiple modules
• Dependencies
• Tests
• Build scripts
• Multiple binaries

Cargo understands the project structure and manages the compilation process.

Updating Rust

Rust releases updates regularly.

Because you're using rustup, updating your toolchain is straightforward.

Run:

rustup update

This checks for and installs available toolchain updates.

You can check your active toolchain with:

rustup show

Stable, Beta and Nightly Rust

Rust has different release channels.

The three primary channels are:

Stable

The recommended choice for most developers.

stable

Beta

The upcoming stable release.

beta

Nightly

Contains experimental and unstable features.

nightly

As a beginner, stick with stable Rust.

Nightly becomes relevant later when you need specific unstable features or are experimenting with Rust internals.

Switching Toolchains

Rustup allows you to manage multiple toolchains.

For example:

rustup toolchain install nightly

You could then use nightly for a specific project.

However, don't switch away from stable simply because you're learning Rust.

Most of this series will work with stable Rust.

Checking Your Rust Environment

If you're experiencing problems, these commands are useful:

rustc --version

cargo --version

rustup show

rustup update

You can also check whether Cargo can successfully compile a new project:

cargo new test_project
cd test_project
cargo run

If that produces:

Hello, world!

your Rust environment is ready.

Common Rust Installation Problems

Problem 1: rustc: command not found

This usually means Rust isn't available in your shell's PATH.

Restart your terminal after installing Rust.

If necessary, reload your shell configuration.

Problem 2: Cargo isn't recognized

Try:

cargo --version

If it fails, verify your rustup installation:

rustup show

Then restart your terminal.

Problem 3: Windows Build Tools

On Windows, some Rust projects may require Microsoft C++ build tools.

If compilation complains about missing linker or native build components, install the required Microsoft development tools and try again.

Problem 4: Dependency Compilation Takes Time

The first build of a project can take longer because Cargo may need to download and compile dependencies.

Subsequent builds are often faster because Cargo caches compiled dependencies.

Your First Rust Development Workflow

From now on, you can use this basic workflow:

Step 1 — Create project

cargo new my_project

Step 2 — Enter project

cd my_project

Step 3 — Open the project

Open the directory in your preferred editor.

Step 4 — Write code

Edit:

src/main.rs

Step 5 — Check code

cargo check

Step 6 — Format code

cargo fmt

Step 7 — Run code

cargo run

Step 8 — Check code quality

cargo clippy

This workflow will become second nature.

Practice Exercise

Before moving to the next article, create a project called:

rust_intro

Run:

cargo new rust_intro
cd rust_intro

Replace the generated code with:

fn main() {
    println!("My name is Rust learner.");
    println!("I am starting my Rust journey.");
    println!("I will become a Rust developer.");
}

Then run:

cargo fmt
cargo check
cargo run
cargo clippy

If everything works, your development environment is ready.