Rust Online Compiler

Compile and run Rust programs with our modern Rust compiler. Perfect for systems programming, learning memory safety concepts, and building high-performance applications.

rust Online Compiler

fn main() {
    println!("Hello, World!");
    println!("Welcome to Rust Online Compiler");
    
    // Variables and ownership
    let language = "Rust";
    let version = 1.75;
    let is_safe = true;
    
    println!("Language: {}", language);
    println!("Version: {}", version);
    println!("Memory safe: {}", is_safe);
    
    // Vectors and iterators
    let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
    println!("Numbers: {:?}", numbers);
    
    let squares: Vec<i32> = numbers.iter().map(|x| x * x).collect();
    println!("Squares: {:?}", squares);
    
    // Pattern matching
    for number in &numbers {
        match number {
            1 => println!("One"),
            2 => println!("Two"),
            3 => println!("Three"),
            _ => println!("Other: {}", number),
        }
    }
    
    // Structs and methods
    let person = Person {
        name: String::from("Developer"),
        age: 28,
    };
    
    person.introduce();
    
    // Result type for error handling
    match divide(10, 2) {
        Ok(result) => println!("10 / 2 = {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

struct Person {
    name: String,
    age: u32,
}

impl Person {
    fn introduce(&self) {
        println!("Hi, I'm {} and I'm {} years old.", self.name, self.age);
    }
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

Output

Click "Run" to execute your code and see the output here...

struct Person {
    name: String,
    age: u32,
}

impl Person {
    fn introduce(&self) {
        println!("Hi, I'm {} and I'm {} years old.", self.name, self.age);
    }
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

Rust Compiler Features

Latest Rust 1.75 compiler
Memory safety without garbage collection
Ownership and borrowing system
Pattern matching and enums
Zero-cost abstractions

About Rust Programming

Rust is a systems programming language focused on safety, speed, and concurrency. It achieves memory safety without garbage collection through its unique ownership system, making it ideal for performance-critical applications.

Rust prevents common programming errors like null pointer dereferences, buffer overflows, and memory leaks at compile time, while maintaining zero-cost abstractions and excellent performance.

Use our Rust online compiler to learn systems programming concepts, explore ownership and borrowing, or build safe, concurrent applications without worrying about memory management.