After installing Rust successfully, the next step is to write and run your first Rust program.
The traditional first program in almost every programming language is Hello, World!. It is a very small program, but it helps you understand the basic process of creating a source file, writing Rust code, compiling it, and running the final program.
In this beginner-friendly guide, you will learn how to:
- Check whether Rust is installed
- Create your first Rust file
- Write a Hello World program
- Understand the basic code
- Compile Rust using
rustc - Run the compiled program
- Create and run the same program using Cargo
- Fix common beginner errors
Let’s start with the simplest possible Rust program.
Before Creating Your First Rust Program
Before writing any Rust code, make sure Rust is installed correctly on your computer.
Open Terminal, Command Prompt, PowerShell, or Windows Terminal and run:
rustc --version
If Rust is installed correctly, you should see output containing the installed Rust version.
For example:
rustc 1.x.x
The exact version number may be different depending on the Rust version installed on your computer.
You can also check Cargo:
cargo --version
If both commands display version information, your Rust environment is ready.
If rustc is not recognized, install Rust first before continuing.
What Is a Hello World Program?
A Hello World program is a simple program that displays:
Hello, world!
on the screen.
It is commonly used as the first program when learning a programming language because it confirms that:
- The programming language is installed
- Your source code can be compiled
- The program can run successfully
- Your development environment is working
In Rust, the complete Hello World program requires only a few lines of code.
Your First Rust Hello World Program
Here is the complete program:
fn main() {
println!("Hello, world!");
}
When you run this program, the output will be:
Hello, world!
Before running it, let’s understand what each part means.
Understanding the Hello World Code
Our program contains:
fn main() {
println!("Hello, world!");
}
There are two important parts to understand.
fn main()
The first line is:
fn main() {
In Rust, fn is used to define a function.
main is the special function where execution of a Rust executable program begins.
So:
fn main()
means that we are defining the main function.
The opening curly brace:
{
marks the beginning of the function body.
The closing curly brace:
}
marks the end of the function body.
Our code therefore has this basic structure:
fn main() {
// Program code goes here
}
Understanding println!
Inside the main function, we have:
println!("Hello, world!");
println! displays text in the terminal and then moves the cursor to a new line.
The text:
Hello, world!
is placed inside quotation marks because it is text that we want to print.
The semicolon:
;
ends the statement.
Therefore:
println!("Hello, world!");
tells Rust to print:
Hello, world!
to the terminal.
Why Does println! Have an Exclamation Mark?
You may notice that Rust uses:
println!
instead of:
println
The ! indicates that println! is a Rust macro.
For your first Rust program, you do not need to understand macros in detail.
Just remember that when you want to print a line of text in a basic Rust program, you can use:
println!("Your text");
For example:
println!("Learning Rust");
Output:
Learning Rust
Method 1: Run Your First Rust Program Using rustc
The simplest way to understand how Rust code works is to create a .rs file and compile it directly using rustc.
Step 1: Create a Folder for Your Rust Program
First, create a folder for the program.
You can name it:
hello_rust
Using a separate folder helps keep your Rust files organized.
You can create the directory from the terminal.
On Windows, macOS, and Linux:
mkdir hello_rust
Move into the folder:
cd hello_rust
Now your terminal is working inside the hello_rust directory.
Step 2: Create a Rust File
Rust source files use the:
.rs
file extension.
Create a file named:
main.rs
Your folder should now look like:
hello_rust/
└── main.rs
You can create and edit main.rs using any text editor or code editor.
For example, you can use:
- Visual Studio Code
- Notepad
- Notepad++
- Sublime Text
- Vim
- Nano
- Any other plain-text code editor
The important thing is that the file must be saved as:
main.rs
and not something like:
main.rs.txt
Step 3: Write the Hello World Code
Open main.rs and add:
fn main() {
println!("Hello, world!");
}
Save the file.
Your first Rust source file is now ready.
Step 4: Compile the Rust Program
Open your terminal inside the folder containing main.rs.
Run:
rustc main.rs
The rustc command starts the Rust compiler.
Here:
rustc
means use the Rust compiler, while:
main.rs
is the source file that should be compiled.
If there are no errors in your code, the compiler may finish without displaying any message.
That is normal.
Step 5: Check the Compiled File
After running:
rustc main.rs
Rust creates an executable program.
On Windows, you will normally see something similar to:
main.exe
On macOS and Linux, you will normally see:
main
Your directory may now look like this on Windows:
hello_rust/
├── main.rs
└── main.exe
On macOS or Linux:
hello_rust/
├── main.rs
└── main
main.rs is your source code.
The other main file is the compiled executable.
Step 6: Run the Rust Program on Windows
If you are using Windows Command Prompt, you can run:
main.exe
Depending on your terminal, you can also use:
.\main.exe
The output should be:
Hello, world!
Congratulations! You have successfully compiled and executed your first Rust program.
Step 7: Run the Rust Program on macOS
On macOS, compile the program first:
rustc main.rs
Then run:
./main
Output:
Hello, world!
The ./ tells the terminal to run the main executable located in the current directory.
Step 8: Run the Rust Program on Linux
The process on Linux is similar to macOS.
Compile:
rustc main.rs
Then run:
./main
Output:
Hello, world!
Your first Rust program is now running successfully.
Complete rustc Process
The entire process looks like this:
main.rs
↓
rustc main.rs
↓
Executable File
↓
Run Executable
↓
Hello, world!
For example, on macOS or Linux:
mkdir hello_rust
cd hello_rust
rustc main.rs
./main
After adding the Hello World code to main.rs, the final output is:
Hello, world!
Change the Printed Message
Now that your program works, you can change the text.
For example:
fn main() {
println!("Hello, Rust!");
}
Compile the program again:
rustc main.rs
Then run it.
Windows:
.\main.exe
macOS/Linux:
./main
Output:
Hello, Rust!
Whenever you change a Rust source file when using rustc directly, compile it again before running the updated executable.
Printing Multiple Lines in Rust
You can use multiple println! statements.
Example:
fn main() {
println!("Hello, world!");
println!("I am learning Rust.");
println!("This is my first Rust program.");
}
Output:
Hello, world!
I am learning Rust.
This is my first Rust program.
Each println! prints its content followed by a new line.
Method 2: Create Your First Rust Program Using Cargo
Rust also comes with Cargo.
Cargo is Rust’s official build system and package manager.
For a simple one-file example, using rustc directly is useful because it clearly shows the compile-and-run process.
For normal Rust projects, Cargo provides a convenient project structure and commands for building and running your application.
Step 1: Check Cargo Installation
Run:
cargo --version
If Cargo is installed, you should see version information.
Cargo is normally installed automatically when Rust is installed using rustup.
Step 2: Create a New Rust Project
Open your terminal and run:
cargo new hello_rust
Cargo creates a new directory named:
hello_rust
Move into it:
cd hello_rust
Understanding the Cargo Project Structure
After running:
cargo new hello_rust
you will get a structure similar to:
hello_rust/
├── Cargo.toml
└── src/
└── main.rs
There are two important parts here.
Cargo.toml
The:
Cargo.toml
file contains basic information and configuration for the Rust package.
src/main.rs
Your Rust program is stored inside:
src/main.rs
Open this file.
Cargo automatically creates a Hello World program for a new binary project.
It will look similar to:
fn main() {
println!("Hello, world!");
}
This means you do not even need to type the first Hello World program manually when using cargo new.
Step 3: Run the Rust Project with Cargo
Inside the project directory, run:
cargo run
Cargo will compile the project and then run it.
You should see output that ends with:
Hello, world!
Your first Cargo-based Rust project is now working.
What Does cargo run Do?
When you execute:
cargo run
Cargo essentially handles two basic tasks for you:
- Builds the current Rust project
- Runs the resulting executable
This makes it convenient while learning and developing Rust programs.
Instead of manually using:
rustc main.rs
and then running the executable separately, you can often use:
cargo run
inside a Cargo project.
How to Build Without Running
If you only want to compile the Cargo project without running it, use:
cargo build
Cargo will build the project.
After a normal development build, generated files are placed inside the project’s:
target/
directory.
You do not need to manually create this folder.
Cargo creates and manages it automatically.
rustc vs cargo run
Beginners often wonder which command they should use.
| Command | Purpose |
|---|---|
rustc main.rs | Directly compile a Rust source file |
cargo new project_name | Create a new Cargo project |
cargo build | Build a Cargo project |
cargo run | Build and run a Cargo project |
For understanding your very first program, rustc is useful.
For regular Rust projects, you will commonly work with Cargo.
Common Beginner Errors
When running your first Rust program, you may encounter a few simple errors.
Error 1: rustc Command Not Found
You may see:
rustc: command not found
or on Windows:
'rustc' is not recognized as an internal or external command
First, check whether Rust has been installed.
Restart your terminal and try:
rustc --version
If the command still does not work, your Rust installation or PATH configuration may need to be fixed.
Error 2: File Not Found
Suppose you run:
rustc main.rs
and Rust cannot find main.rs.
Check your current directory.
On Windows:
dir
On macOS/Linux:
ls
Make sure main.rs exists in the directory where you are running the command.
Error 3: Missing Semicolon
Incorrect:
fn main() {
println!("Hello, world!")
}
For this statement, write:
fn main() {
println!("Hello, world!");
}
Notice the semicolon:
;
after println!.
Error 4: Incorrect Function Name
Incorrect:
fn Main() {
println!("Hello, world!");
}
Correct:
fn main() {
println!("Hello, world!");
}
Rust is case-sensitive.
Therefore:
main
and:
Main
are not the same identifier.
The executable entry function should be:
fn main()
Error 5: Missing Curly Braces
Incorrect:
fn main()
println!("Hello, world!");
Correct:
fn main() {
println!("Hello, world!");
}
The code belonging to the function must be placed inside its curly braces.
Error 6: Running cargo run from the Wrong Directory
If you create a project using:
cargo new hello_rust
you should first enter the project:
cd hello_rust
Then run:
cargo run
Cargo expects to find the project’s Cargo.toml file.
Useful Commands for Your First Rust Program
Here are the main commands used in this guide.
| Command | Purpose |
|---|---|
rustc --version | Check the Rust compiler |
cargo --version | Check Cargo |
mkdir hello_rust | Create a directory |
cd hello_rust | Enter the directory |
rustc main.rs | Compile a Rust source file |
./main | Run compiled program on macOS/Linux |
.\main.exe | Run compiled program from Windows PowerShell |
cargo new hello_rust | Create a new Rust project |
cargo build | Build the Cargo project |
cargo run | Build and run the Cargo project |
Frequently Asked Questions
What File Extension Does Rust Use?
Rust source code files use the:
.rs
extension.
For example:
main.rs
What Is the Main Function in Rust?
The main function is the starting point of a normal executable Rust program.
Example:
fn main() {
println!("Hello!");
}
How Do I Print Hello World in Rust?
Use:
fn main() {
println!("Hello, world!");
}
Output:
Hello, world!
How Do I Compile a Rust File?
Use the Rust compiler:
rustc main.rs
This compiles the main.rs source file.
How Do I Run a Rust Program on Windows?
After compiling main.rs, you can run the generated executable.
In PowerShell:
.\main.exe
How Do I Run a Rust Program on macOS or Linux?
Compile it:
rustc main.rs
Then run:
./main
What Is Cargo in Rust?
Cargo is Rust’s build system and package manager.
For your first program, the most useful Cargo commands are:
cargo new hello_rust
cargo run
Should Beginners Use rustc or Cargo?
It is useful to try rustc at least once because it shows you how a Rust source file is directly compiled into an executable.
After that, using Cargo is convenient for creating and running normal Rust projects.
Conclusion
Running your first Rust program is an important first step after installing Rust.
The simplest Rust program is:
fn main() {
println!("Hello, world!");
}
You can save it as:
main.rs
compile it using:
rustc main.rs
and then run the generated executable.
On Windows PowerShell:
.\main.exe
On macOS and Linux:
./main
You can also create a Rust project using Cargo:
cargo new hello_rust
cd hello_rust
cargo run
If the terminal displays:
Hello, world!
your first Rust program has successfully compiled and run.
You now understand the basic workflow of creating a Rust source file, writing a simple program, compiling it, and running it.
