Every question is hand-checked, every answer comes with an explanation, and your progress builds into a clear picture of where you stand.
Every Rust question shows its code before you answer, so you are reading real Rust, not a description of it.
Once you attempt a question you get the reasoning, not just a tick. That matters most on Rust, where ownership and moves, borrow lifetimes, interior mutability, send and sync, trait objects versus generics, and where async futures get polled.
Progress is tracked per topic across the 53 Rust topics, so revision points at the gaps instead of the whole list.
566 Rust questions right now: 75 easy, 241 medium and 250 hard. That number is read straight from the question table when this page is built, so it is never a rounded marketing figure.
No. Every Rust question, including its code snippet, its difficulty and its topic, is readable without signing in. You need a free account only to submit an answer, see which option is correct, and read the worked explanation. We keep it that way so the platform stays honest about what you actually got right.
Ownership and moves, borrow lifetimes, interior mutability, Send and Sync, trait objects versus generics, and where async futures get polled.
53 distinct topics are tagged on the Rust questions, including async/await state machine, Rc and Arc, trait objects dyn vs generics, Send and Sync auto traits, Cow clone-on-write, Cell vs RefCell. The topic labels come from the questions themselves, so the list matches what you will actually be asked.
Yes. Reading is free and unlimited. A free account unlocks answering, explanations and progress tracking. Pro (₹199 per month) adds AI explanations and AI-graded guesstimates on top; it is not needed to practise Rust MCQs.
Systems programming, blockchain, browser and OS work, and teams rewriting hot paths out of C++.
These are 12 of the 566 Rust questions in the library, pulled live from the question table. The snippet, the difficulty and the topic are all here. The answer options and the explanation are not. Those need a free account.
Ownership and moves, borrow lifetimes, interior mutability, Send and Sync, trait objects versus generics, and where async futures get polled.
impl<T: Display> ToString for T {
fn to_string(&self) -> String { /* ... */ }
}
struct MyType;
impl ToString for MyType {
fn to_string(&self) -> String { String::from("custom") }
}struct Inner(&'static str);
impl Drop for Inner {
fn drop(&mut self) { println!("drop {}", self.0); }
}
struct Outer { a: Inner, b: Inner }
impl Drop for Outer {
fn drop(&mut self) { println!("drop Outer"); }
}
fn main() {
let _o = Outer { a: Inner("a"), b: Inner("b") };
}fn main() {
let words = vec!["a", "bb", "ccc"];
let n = words.iter().map(|w| w.len()).filter(|&len| len > 1).count();
println!("{}", n);
}fn main() {
let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1);
}fn main() {
let x = 5;
let y = x;
println!("{} {}", x, y);
}fn main() {
let s = String::from("hello");
let r = &mut s;
r.push('!');
}#[derive(Clone)]
struct Point { x: i32, y: i32 }fn main() {
let mut s = String::from("hi");
s.push('!'); // line A
s.push("!!"); // line B
}trait Greet {
fn hello(&self) -> String;
}
struct Dog;
fn main() {
let d = Dog;
println!("{}", d.hello());
}struct Point(i32, i32);
let p = Point(3, 7);mod math {
pub fn add(a: i32, b: i32) -> i32 { a + b }
}
fn main() {
// call add here
}#[derive(/* ? */)]
struct Color { r: u8, g: u8, b: u8 }
fn main() {
let a = Color { r: 1, g: 2, b: 3 };
let b = Color { r: 1, g: 2, b: 3 };
println!("{}", a == b);
}We keep the correct answer, the explanation and the scoring behind sign-in so the platform stays honest, which is why the correct option and the worked explanation for every Rust question stay behind a free account. Signing in is free and takes a few seconds.
Systems programming, blockchain, browser and OS work, and teams rewriting hot paths out of C++.