CodeUtility
Making your developer's life easier!

Online Rust Compiler

Write, compile, run, and debug Rust code online in a full-featured browser IDE. Work with multiple files, save your workspace, and share or collaborate in real time.

Pre-installed Libs
🚀 252,702 total executions (135 this month)
Embed
Output

Practice Rust with coding challenges

Solve hands-on problems right in this editor: run the sample tests, submit, and get an AI code review.

All Rust challenges
Easy

Rectangle Perimeter

Compute the perimeter of a rectangle from its sides.

You'll learn ArithmeticReturn values
BeginnerLearning-pathVariables
Python C++ C# Java JavaScript Go Rust Kotlin Swift
12 solved
View solutions (12)
Easy

Distance Between Points

Compute the straight-line distance between two points.

You'll learn Pythagorean theoremSquare roots
BeginnerFunctionsLearning-pathmath
Python C++ C# Swift Java JavaScript Go Rust Kotlin
7 solved
View solutions (7)
Easy

Days in a Month

Return how many days a month has, including leap years.

You'll learn Calendar rulesHelper functions
BeginnerConditionsFunctionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
6 solved
View solutions (6)
Easy

Average of Three

Average three whole numbers.

You'll learn ArithmeticDivision
BeginnerLearning-pathVariables
Python C++ C# Java JavaScript Go Rust Kotlin Swift
6 solved
View solutions (6)
Easy

Dot Product of Two Vectors

Multiply two vectors element by element and add the results: the core operation of every neuron.

You'll learn VectorsDot product
Neural networksaimachine learning
Python C++ C# Java JavaScript Go Rust Kotlin Swift
4 solved
View solutions (4)
Easy

Largest of Three

Pick the largest of three numbers without a built-in max.

You'll learn ComparisonsCombining conditions
BeginnerConditionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
4 solved
View solutions (4)
Easy

Prime Number Check

Decide whether a number is prime.

You'll learn DivisibilityLoop optimization
BeginnerLoopsNumbersStudent-beginner
Kotlin Swift Python C++ C# Java JavaScript Go Rust
3 solved
View solutions (3)
Easy

Number Triangle

Build a triangle of increasing numbers.

You'll learn Growing rowsCounters across rows
BeginnerLearning-pathNested-loopsPatterns
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 solved
View solutions (3)
Easy

Armstrong Number

Check whether a number equals the sum of its digits raised to the digit count.

You'll learn Digit extractionPowers
BeginnerNumbersStudent-beginner
JavaScript Python C++ C# Java Go Rust Kotlin Swift
3 solved
View solutions (3)
Easy

Row Sums

Add up every row of a grid.

You'll learn 2D listsNested loops
BeginnerGridsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 solved
View solutions (3)
Easy

Min and Max Together

Find the smallest and largest value in one pass.

You'll learn Single passMultiple return values
ArraysBeginnerFunctionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 solved
View solutions (3)
Easy

Count Pairs With a Sum

Count pairs of positions whose values add up to a target.

You'll learn Pairs of indexesAvoiding double counts
ArraysBeginnerLearning-pathNested-loops
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 solved
View solutions (3)

🦀 About This Rust Online Executor

The CodeUtility Rust Executor lets you write and run Rust code directly in your browser - no installation, toolchain setup, or local environment required. It’s powered by a secure sandbox that supports real Rust compiler versions 1.70, 1.72, 1.73, and 1.74.

This tool compiles and executes your Rust programs in the cloud using a genuine rustc compiler, ensuring accurate and consistent results. You can experiment with variables, ownership, borrowing, pattern matching, traits, generics, and other modern Rust features with ease.

It’s ideal for learning Rust’s core concepts - especially memory safety, error handling, and concurrency - without needing to install Cargo or any local setup. Everything runs directly in your browser within seconds.

More than a code runner

Use a multi-file editor, an isolated execution terminal, runtime-specific libraries, persistent workspaces, sharing, and real-time collaboration from the same executor.

How to use this executor?

Choose a runtime, open or create a file, write your code, and select Run. Output appears in the terminal, while signed-in users can keep files in a workspace, install libraries, and collaborate through shares.

  1. Select a version and edit the current file or open another workspace file.
  2. Run the code, provide input in the terminal when requested, and review saved run history.
  3. Use libraries, workspace tools, sharing, and chat when your task needs more than one snippet.

💡 Rust Basics & Examples You Can Try Above

1. Declaring Variables and Constants

Use let to declare variables. Use const for constants and mut for mutable variables.

let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;

const MAX_USERS: u32 = 100;

2. Conditionals (if / match)

Rust uses if for conditions and match for pattern matching.

let x = 2;
if x == 1 {
    println!("One");
} else if x == 2 {
    println!("Two");
} else {
    println!("Other");
}

match x {
    1 => println!("One"),
    2 => println!("Two"),
    _ => println!("Other"),
}

3. Loops

Rust supports for, while, and infinite loop.

for i in 0..3 {
    println!("{}", i);
}

let mut n = 3;
while n > 0 {
    println!("{}", n);
    n -= 1;
}

4. Arrays

Fixed-size arrays in Rust use square brackets. Use slices for views.

let nums = [10, 20, 30];
println!("{}", nums[1]);

5. Vectors (Dynamic Arrays)

Vec is used for dynamic arrays.

let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();

for fruit in &fruits {
    println!("{}", fruit);
}

6. Console Input/Output

Use println! for output and std::io for input.

use std::io;

let mut name = String::new();
println!("Enter your name:");
io::stdin().read_line(&mut name).unwrap();
println!("Hello, {}", name.trim());

7. Functions

Functions use fn and can return values using ->.

fn greet(name: &str) -> String {
    format!("Hello, {}", name)
}

println!("{}", greet("Alice"));

8. HashMaps

Use std::collections::HashMap for key-value data.

use std::collections::HashMap;

let mut person = HashMap::new();
person.insert("name", "Bob");
println!("{}", person["name"])

9. Error Handling

Rust handles errors using Result and match or unwrap().

fn fail() -> Result<(), String> {
    Err("Something went wrong".to_string())
}

match fail() {
    Ok(_) => println!("Success"),
    Err(e) => println!("{}", e),
}

10. File I/O

Use std::fs to read and write files.

use std::fs;

fs::write("file.txt", "Hello File").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);

11. String Manipulation

Strings in Rust are heap-allocated and support many methods.

let mut text = String::from(" Hello Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hello", "Hi");
println!("{}", text);

12. Structs & Methods

Rust uses struct for data types and impl for methods.

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("Hi, I'm {}", self.name)
    }
}

let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());

13. References & Borrowing

Rust uses & to borrow values and &mut for mutable references.

fn update(x: &mut i32) {
    *x += 1;
}

let mut value = 10;
update(&mut value);
println!("{}", value);