Rust
v1.68.2
Loading editor...
Loading terminal...
Rust
v1.68.2
Rust is a statically typed systems programming language that originated as a Mozilla project led by Graydon Hoare, reaching its stable 1.0 release in 2015. Its defining feature is the ownership and borrowing model, which guarantees memory safety and data-race freedom at compile time without a garbage collector. Rust is multi-paradigm, blending imperative, functional, and zero-cost abstractions.
Today Rust is popular for performance-critical and safety-sensitive software, including operating system components, web assembly, networking, and command-line tools, and has been adopted in the Linux kernel. Its package manager Cargo and the crates.io registry make dependency management straightforward. This compiler runs Rust 1.68.2, so you can use the ownership system, traits, pattern matching, and the standard library in your programs.
fn main() {
println!("Hello, World!");
}use std::io;
fn main() {
let mut name = String::new();
io::stdin().read_line(&mut name).unwrap();
println!("Hello, {}!", name.trim());
}fn main() {
let fruits = vec!["apple", "banana", "cherry"];
for (i, fruit) in fruits.iter().enumerate() {
println!("{} {}", i + 1, fruit);
}
}fn factorial(n: u64) -> u64 {
if n <= 1 { 1 } else { n * factorial(n - 1) }
}
fn main() {
println!("{}", factorial(5));
}fn parse(s: &str) -> Result<i32, std::num::ParseIntError> {
s.parse::<i32>()
}
fn main() {
match parse("abc") {
Ok(n) => println!("Got {}", n),
Err(e) => println!("Error: {}", e),
}
}use std::collections::HashMap;
fn main() {
let mut counts: HashMap<char, i32> = HashMap::new();
for c in "banana".chars() {
*counts.entry(c).or_insert(0) += 1;
}
for (ch, n) in &counts {
println!("{}: {}", ch, n);
}
}fn main() {
let mut nums = vec![3, 1, 4, 1, 5];
nums.sort();
let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
println!("{:?}", doubled);
}struct Person {
name: String,
age: u32,
}
impl Person {
fn describe(&self) -> String {
format!("{} ({})", self.name, self.age)
}
}
fn main() {
let p = Person { name: String::from("Ada"), age: 36 };
println!("{}", p.describe());
}enum Shape {
Circle(f64),
Square(f64),
}
fn area(s: &Shape) -> f64 {
match s {
Shape::Circle(r) => 3.14159 * r * r,
Shape::Square(side) => side * side,
}
}
fn main() {
println!("{}", area(&Shape::Square(3.0)));
}trait Greet {
fn hello(&self) -> String;
}
struct Dog;
impl Greet for Dog {
fn hello(&self) -> String {
String::from("Woof")
}
}
fn main() {
let d = Dog;
println!("{}", d.hello());
}Yes. CompileBytes compiles and runs Rust in your browser without installing rustc or Cargo locally.
It runs Rust 1.68.2, so you can use the ownership system, traits, iterators, and the standard library from that release.
Read with std::io::stdin().read_line(&mut buf) and type your input into the stdin box before running.
Yes, compiling and running Rust on CompileBytes is completely free.
The standard library is always available; using external crates depends on whether the build environment fetches dependencies via Cargo.