Top 45 Rust Interview Questions 2026

Last Updated: June 2026 | Level: Freshers to 3 Years Experience | Read Time: ~22 min

Rust is the most loved systems language for memory safety without garbage collection. Candidates report that ownership, borrowing, and lifetimes are the most heavily tested topics in Rust interviews, followed by traits and error handling. This guide covers 45 questions with complete code answers.

Pair with Go Interview Questions 2026 for backend language comparison. Confirm current interview requirements on the official careers portal of your target company.

Table of Contents

1. Ownership and Borrowing (Q1-Q15)
2. Types, Traits, and Generics (Q16-Q26)
3. Error Handling (Q27-Q31)
4. Concurrency (Q32-Q38)
5. Advanced Topics (Q39-Q45)
6. Mock Interview: 5 Questions
7. FAQ

Ownership and Borrowing

Q1. What is Rust's ownership system? Easy

fn main() {
    let s1 = String::from("hello");  // s1 owns the string
    let s2 = s1;  // ownership MOVED to s2, s1 is invalid
    // println!("{}", s1);  // compile error: s1 moved
    println!("{}", s2);  // ok: "hello"
}

Three rules:

1. Each value has one owner
2. Only one owner at a time
3. When owner goes out of scope, value is dropped

Q2. What is the difference between Copy and Move? Easy

// Copy types: cheap to copy, both variables remain valid
let x: i32 = 5;
let y = x;  // COPY (i32 implements Copy)
println!("{} {}", x, y);  // both valid

// Non-Copy types: ownership moves
let s1 = String::from("hello");
let s2 = s1;  // MOVE
// println!("{}", s1);  // error: moved

// Types that implement Copy: i32, f64, bool, char, tuples of Copy types
// Types that do NOT: String, Vec, Box, heap-allocated types

Q3. What is borrowing? Easy

fn calculate_length(s: &String) -> usize {  // borrows s
    s.len()
}

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s);  // pass reference, not ownership
    println!("'{}' has length {}", s, len);  // s still valid
}

References have borrowing rules:

• Multiple immutable references at the same time: OK
• One mutable reference at a time: OK
• Immutable and mutable simultaneously: NOT OK

Q4. What is mutable borrowing and its rules? Medium

fn main() {
    let mut s = String::from("hello");
    
    let r1 = &s;      // immutable borrow
    let r2 = &s;      // another immutable borrow (ok)
    println!("{} {}", r1, r2);
    // r1 and r2 no longer used after this point
    
    let r3 = &mut s;  // mutable borrow (ok now - r1, r2 are done)
    r3.push_str(", world");
    println!("{}", r3);
}

The borrow checker uses Non-Lexical Lifetimes (NLL) to determine when references are last used.

Q5. What are dangling references and how does Rust prevent them? Medium

// This would be a dangling reference in C - freed memory
fn dangle() -> &String {  // COMPILE ERROR
    let s = String::from("hello");
    &s  // s is dropped here, reference would point to freed memory
}

// Correct: return the value itself
fn no_dangle() -> String {
    let s = String::from("hello");
    s  // ownership moved out, no drop
}

Rust's borrow checker catches this at compile time, impossible at runtime.

Q6. What are slices? Easy

let s = String::from("hello world");

let hello = &s[0..5];   // string slice: "hello"
let world = &s[6..11];  // "world"

// Array slice
let a = [1, 2, 3, 4, 5];
let slice: &[i32] = &a[1..3];  // [2, 3]

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &b) in bytes.iter().enumerate() {
        if b == b' ' { return &s[0..i]; }
    }
    &s[..]
}

Q7. What are lifetimes? Advanced

// Lifetime annotation: 'a means "both parameters and return live at least as long as 'a"
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let s1 = String::from("long string");
    let result;
    {
        let s2 = String::from("xyz");
        result = longest(s1.as_str(), s2.as_str());
        println!("{}", result);
    }
    // Can't use result here - s2 dropped
}

Q8. What is the 'static lifetime? Medium

// 'static: reference lives for the entire program
let s: &'static str = "I live forever";  // string literal in binary

// Functions requiring static lifetimes (e.g., thread::spawn)
use std::thread;
thread::spawn(|| {
    // closure must be 'static (no borrowed references that might expire)
    println!("from thread");
});

// Make a String 'static with Box::leak (rarely needed)
let leaked: &'static str = Box::leak(String::from("leaked").into_boxed_str());

Q9. What is Clone vs Copy? Medium

// Copy: implicit, cheap bitwise copy (stack types)
let x = 5i32;
let y = x;  // copy

// Clone: explicit, potentially expensive deep copy
let s1 = String::from("hello");
let s2 = s1.clone();  // deep copy of heap data
println!("{} {}", s1, s2);  // both valid

#[derive(Clone, Debug)]
struct User { name: String, age: u32 }
let u1 = User { name: "Aditya".to_string(), age: 25 };
let u2 = u1.clone();

Q10. What is the Box smart pointer? Medium

// Box: heap allocation, single owner
let b = Box::new(5);
println!("{}", b);  // auto-deref: 5

// Useful for:
// 1. Recursive types (otherwise unknown size)
enum Tree {
    Leaf(i32),
    Node(Box<Tree>, Box<Tree>),  // Box breaks infinite recursion
}

// 2. Trait objects (dynamic dispatch)
let b: Box<dyn Animal> = Box::new(Dog {});

// 3. Large data, avoid stack overflow
let large = Box::new([0u8; 1_000_000]);

Q11. What is Rc and RefCell? Advanced

use std::rc::Rc;
use std::cell::RefCell;

// Rc: multiple owners (single-threaded only)
let a = Rc::new(5);
let b = Rc::clone(&a);  // increment reference count
println!("{}", Rc::strong_count(&a));  // 2

// RefCell: interior mutability (runtime borrow checking)
let data = RefCell::new(vec![1, 2, 3]);
data.borrow_mut().push(4);  // mutable borrow at runtime
println!("{:?}", data.borrow());  // immutable borrow

// Rc<RefCell<T>>: shared mutable data (single-threaded)
let shared = Rc::new(RefCell::new(Vec::new()));

Q12. What is Arc and Mutex? Advanced

use std::sync::{Arc, Mutex};
use std::thread;

// Arc: atomic reference counting (thread-safe Rc)
// Mutex: thread-safe interior mutability
let counter = Arc::new(Mutex::new(0));

let handles: Vec<_> = (0..10).map(|_| {
    let counter = Arc::clone(&counter);
    thread::spawn(move || {
        let mut num = counter.lock().unwrap();
        *num += 1;
    })
}).collect();

for h in handles { h.join().unwrap(); }
println!("count: {}", *counter.lock().unwrap());  // 10

Q13. Predict the output: Medium

fn main() {
    let v = vec![1, 2, 3];
    let v2 = v;
    // println!("{:?}", v);  // would be compile error
    println!("{:?}", v2);
}

Output: [1, 2, 3]

Explanation: Vec does not implement Copy. The assignment v2 = v moves ownership. v is no longer valid. The commented line would cause a compile error.

Q14. What is Drop trait? Medium

struct Resource { name: String }

impl Drop for Resource {
    fn drop(&mut self) {
        println!("Dropping: {}", self.name);
    }
}

fn main() {
    let _r1 = Resource { name: "first".to_string() };
    let _r2 = Resource { name: "second".to_string() };
    println!("Resources created");
}
// Output:
// Resources created
// Dropping: second  (LIFO order)
// Dropping: first

Q15. What are raw pointers in Rust? Advanced

let x = 5;
let r1 = &x as *const i32;  // raw immutable pointer
let mut y = 10;
let r2 = &mut y as *mut i32;  // raw mutable pointer

// Dereferencing raw pointers requires unsafe
unsafe {
    println!("r1: {}", *r1);
    *r2 = 20;
    println!("r2: {}", *r2);
}

Raw pointers skip the borrow checker. Only use them in unsafe blocks when interfacing with C or low-level hardware.

Types, Traits, and Generics

Q16. What are Rust traits? Medium

trait Animal {
    fn name(&self) -> &str;
    fn sound(&self) -> &str;
    fn describe(&self) -> String {  // default implementation
        format!("{} says {}", self.name(), self.sound())
    }
}

struct Dog { name: String }
impl Animal for Dog {
    fn name(&self) -> &str { &self.name }
    fn sound(&self) -> &str { "Woof" }
}

struct Cat { name: String }
impl Animal for Cat {
    fn name(&self) -> &str { &self.name }
    fn sound(&self) -> &str { "Meow" }
}

fn make_noise(animal: &dyn Animal) {
    println!("{}", animal.describe());
}

Q17. What is the difference between impl Trait and dyn Trait? Advanced

// impl Trait: static dispatch (zero-cost, monomorphized at compile time)
fn make_noise(a: impl Animal) -> impl Animal {
    println!("{}", a.describe());
    a
}

// dyn Trait: dynamic dispatch (vtable, small runtime cost)
fn make_noise_dyn(a: &dyn Animal) {
    println!("{}", a.describe());
}

// dyn: required for heterogeneous collections
let animals: Vec<Box<dyn Animal>> = vec![
    Box::new(Dog { name: "Rex".into() }),
    Box::new(Cat { name: "Luna".into() }),
];

Q18. What are Rust generics? Medium

// Generic function with trait bound
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut l = &list[0];
    for item in list {
        if item > l { l = item; }
    }
    l
}

// Generic struct
struct Pair<T> {
    first: T,
    second: T,
}

impl<T: std::fmt::Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.first >= self.second {
            println!("first: {}", self.first);
        } else {
            println!("second: {}", self.second);
        }
    }
}

Q19. What are common standard traits? Medium

Q20. What are enums in Rust? Medium

// Enums with associated data (algebraic data types)
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(u8, u8, u8),
}

fn process(msg: Message) {
    match msg {
        Message::Quit => println!("quit"),
        Message::Move { x, y } => println!("move to {},{}", x, y),
        Message::Write(s) => println!("write: {}", s),
        Message::ChangeColor(r, g, b) => println!("color: {},{},{}", r, g, b),
    }
}

Q21. What are Rust structs? Easy

#[derive(Debug, Clone, PartialEq)]
struct User {
    name: String,
    age: u32,
    email: String,
    active: bool,
}

// Struct update syntax
let user1 = User { name: "Aditya".into(), age: 25, email: "[email protected]".into(), active: true };
let user2 = User { name: "Bob".into(), ..user1 };  // borrow remaining from user1

// Tuple struct
struct Color(u8, u8, u8);
let red = Color(255, 0, 0);
println!("{}", red.0);  // 255

Q22. What are closures in Rust? Medium

let x = 5;
let add_x = |n| n + x;  // captures x by reference
println!("{}", add_x(10));  // 15

// Explicit capture mode
let s = String::from("hello");
let greeting = move || println!("{}", s);  // moves s into closure
greeting();
// println!("{}", s);  // error: s moved into closure

// Closure traits
// Fn: borrows immutably (can be called multiple times)
// FnMut: borrows mutably
// FnOnce: consumes captured values (called once)

Q23. What is pattern matching in Rust? Medium

// Match on values
match (1, true, "hello") {
    (1, true, s) => println!("one, true, {}", s),
    (n, false, _) if n > 0 => println!("positive false"),
    _ => println!("other"),
}

// if let (concise single-pattern match)
if let Some(value) = find_user(1) {
    println!("{}", value);
}

// while let
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
    println!("{}", top);  // 3, 2, 1
}

Q24. What are iterators in Rust? Advanced

let nums = vec![1, 2, 3, 4, 5];

// Lazy iterator chain
let sum: i32 = nums.iter()
    .filter(|&&n| n % 2 == 0)
    .map(|&n| n * n)
    .sum();  // 20 (2^2 + 4^2)

// Consuming adapters: collect, sum, count, any, all, find
// Lazy adapters: map, filter, take, skip, flat_map, chain, zip

let doubled: Vec<i32> = nums.iter().map(|&n| n * 2).collect();
let pairs: Vec<(usize, &i32)> = nums.iter().enumerate().collect();

// Custom iterator
struct Counter { count: u32 }
impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        self.count += 1;
        if self.count <= 5 { Some(self.count) } else { None }
    }
}

Q25. What is the String vs &str distinction? Medium

// &str: immutable string slice (borrowed, usually 'static or from String)
let s1: &str = "hello";  // string literal, 'static
let s2: &str = &s1[0..3];  // slice

// String: owned, growable heap allocation
let mut owned = String::from("hello");
owned.push_str(" world");

// Convert
let borrowed: &str = &owned;  // deref coercion
let new_owned: String = s1.to_string();
let also_owned: String = s1.to_owned();

// Function parameters: prefer &str for flexibility
fn greet(name: &str) { println!("Hello, {}", name); }
greet("Aditya");          // &str
greet(&owned);            // &String coerces to &str

Q26. Predict the output: Medium

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    println!("{}", first);
    v.push(4);  // would this compile?
}

Output: Compile error if first is used after v.push(4). In this code as-written, println! uses first before push, so it compiles if you move the print before the push.

Corrected explanation: The borrow checker would error if you tried to use first after v.push(4) because push may reallocate the vector, invalidating the reference. Since println! uses first before push, this exact code compiles successfully and prints 1.

Error Handling

Q27. What is Result<T, E> in Rust? Medium

use std::num::ParseIntError;

fn parse_age(s: &str) -> Result<u32, ParseIntError> {
    s.trim().parse::<u32>()
}

// Pattern matching
match parse_age("25") {
    Ok(age) => println!("Age: {}", age),
    Err(e)  => println!("Error: {}", e),
}

// Chaining with ?
fn process(input: &str) -> Result<u32, ParseIntError> {
    let age = parse_age(input)?;  // returns early on error
    Ok(age * 2)
}

Q28. What is the ? operator? Medium

use std::fs;
use std::io;

fn read_file(path: &str) -> Result<String, io::Error> {
    let contents = fs::read_to_string(path)?;  // if Err, return early
    Ok(contents.trim().to_string())
}

// Equivalent to:
fn read_file_verbose(path: &str) -> Result<String, io::Error> {
    let contents = match fs::read_to_string(path) {
        Ok(v) => v,
        Err(e) => return Err(e),
    };
    Ok(contents.trim().to_string())
}

Q29. What is Option<T>? Medium

fn find_user(id: u32) -> Option<String> {
    if id == 1 { Some("Aditya".to_string()) } else { None }
}

// Methods
find_user(1).unwrap()                    // panics if None
find_user(1).expect("user must exist")   // panics with message
find_user(1).unwrap_or("Anonymous".to_string())
find_user(1).unwrap_or_else(|| expensive_default())
find_user(1).map(|s| s.to_uppercase())
find_user(1).filter(|s| s.len() > 3)
find_user(1).and_then(|s| if s.starts_with('A') { Some(s) } else { None })
find_user(1).is_some()
find_user(99).is_none()

Q30. What is the anyhow and thiserror pattern? Advanced

// thiserror: define custom error types (library code)
use thiserror::Error;

#[derive(Error, Debug)]
enum AppError {
    #[error("database error: {0}")]
    Database(#[from] DbError),
    #[error("not found: {id}")]
    NotFound { id: u32 },
    #[error("io error")]
    Io(#[from] std::io::Error),
}

// anyhow: ergonomic error handling (application code)
use anyhow::{Result, Context};

fn run() -> Result<()> {
    let config = std::fs::read_to_string("config.toml")
        .context("failed to read config.toml")?;
    Ok(())
}

Q31. Predict the output: Medium

fn main() {
    let v: Vec<i32> = vec![1, 2, 3];
    let result = v.get(10);
    println!("{:?}", result);
    
    let value = v.get(1).unwrap_or(&0);
    println!("{}", value);
}

Output:

None
2

Explanation: v.get(10) returns None (out of bounds, no panic). v.get(1) returns Some(&2), unwrap_or provides 2.

Concurrency

Q32. What is Rust's concurrency model? Medium

• Send: a type can be transferred across thread boundaries
• Sync: a type can be referenced from multiple threads (T: Sync means &T: Send)

use std::thread;

let v = vec![1, 2, 3];
let handle = thread::spawn(move || {  // move takes ownership
    println!("{:?}", v);
});
handle.join().unwrap();
// println!("{:?}", v);  // error: v moved into thread

Q33. How does Mutex<T> work in Rust? Medium

use std::sync::{Arc, Mutex};
use std::thread;

let data = Arc::new(Mutex::new(0));

let handles: Vec<_> = (0..5).map(|_| {
    let data = Arc::clone(&data);
    thread::spawn(move || {
        let mut guard = data.lock().unwrap();  // acquire lock
        *guard += 1;
    })  // guard dropped here, lock released
}).collect();

for h in handles { h.join().unwrap(); }
println!("{}", *data.lock().unwrap());  // 5

Q34. What are channels in Rust? Medium

use std::sync::mpsc;  // multiple producer, single consumer
use std::thread;

let (tx, rx) = mpsc::channel::<String>();
let tx2 = tx.clone();  // multiple senders

thread::spawn(move || tx.send("hello".to_string()).unwrap());
thread::spawn(move || tx2.send("world".to_string()).unwrap());

for received in rx.iter().take(2) {
    println!("{}", received);
}

Q35. What is async/await in Rust? Advanced

use tokio;

#[tokio::main]
async fn main() {
    let result = fetch_data("https://api.example.com").await;
    println!("{:?}", result);
}

async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    let response = reqwest::get(url).await?;
    response.text().await
}

// Concurrent: run multiple futures simultaneously
let (r1, r2) = tokio::join!(
    fetch_data("https://api.example.com/a"),
    fetch_data("https://api.example.com/b"),
);

Q36. What is Tokio? Advanced

• Async I/O (TCP, UDP, Unix sockets)
• Timers
• Task spawning (green threads)
• Work-stealing scheduler

// Spawn concurrent tasks
let handle = tokio::spawn(async {
    tokio::time::sleep(Duration::from_secs(1)).await;
    42
});
let result = handle.await.unwrap();

// Timeout
tokio::time::timeout(
    Duration::from_secs(5),
    fetch_data(url)
).await

Q37. What is RwLock? Advanced

use std::sync::RwLock;

let lock = RwLock::new(vec![1, 2, 3]);

// Multiple concurrent readers
{
    let r1 = lock.read().unwrap();
    let r2 = lock.read().unwrap();
    println!("{:?} {:?}", r1, r2);
}  // read guards dropped

// Single writer (blocks readers)
{
    let mut w = lock.write().unwrap();
    w.push(4);
}

Use RwLock when reads are frequent and writes are rare.

Q38. What is std::sync::atomic? Advanced

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

let counter = Arc::new(AtomicUsize::new(0));

let handles: Vec<_> = (0..1000).map(|_| {
    let c = Arc::clone(&counter);
    std::thread::spawn(move || {
        c.fetch_add(1, Ordering::SeqCst);
    })
}).collect();

for h in handles { h.join().unwrap(); }
println!("{}", counter.load(Ordering::SeqCst));  // 1000

Advanced Topics

Q39. What is unsafe Rust? Advanced

1. Dereference raw pointers
2. Call unsafe functions
3. Access/modify mutable static variables
4. Implement unsafe traits
5. Access union fields

let mut x = 5;
let r = &mut x as *mut i32;

unsafe {
    *r = 10;  // raw pointer dereference
    println!("{}", *r);
}

// FFI: calling C from Rust
extern "C" {
    fn abs(n: i32) -> i32;
}
unsafe { println!("{}", abs(-5)); }  // 5

Q40. What is Cargo and the Rust toolchain? Easy

cargo new my_project    # create new project
cargo build             # compile
cargo run               # compile and run
cargo test              # run tests
cargo fmt               # format code
cargo clippy            # lint
cargo doc --open        # generate and open docs
cargo add serde         # add dependency (via cargo-edit)

# Cargo.toml dependencies
[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

Q41. What are Rust macros? Advanced

// Declarative macro
macro_rules! vec_of_strings {
    ($($x:expr),*) => {
        vec![$($x.to_string()),*]
    };
}
let v = vec_of_strings!["hello", "world"];

// Built-in macros
println!("{:?}", value);  // debug print
assert_eq!(1 + 1, 2);    // test assertion
todo!("implement this");  // panics with message
unreachable!()            // marks unreachable code paths
dbg!(x + 1)              // prints and returns value (great for debugging)

// Procedural macros (derive macros)
#[derive(Debug, Clone, Serialize, Deserialize)]
struct Config { name: String }

Q42. What is WebAssembly with Rust? Advanced

// Cargo.toml: wasm-bindgen dependency
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn add(a: u32, b: u32) -> u32 {
    a + b
}

#[wasm_bindgen]
extern "C" {
    fn alert(s: &str);
}

#[wasm_bindgen]
pub fn greet(name: &str) {
    alert(&format!("Hello, {}!", name));
}

Compile with wasm-pack build --target web. Rust+WASM is used for performance-critical browser code.

Q43. What is serde? Medium

use serde::{Deserialize, Serialize};
use serde_json;

#[derive(Serialize, Deserialize, Debug)]
struct User {
    name: String,
    age: u32,
    #[serde(rename = "email_address")]
    email: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    phone: Option<String>,
}

// Serialize
let user = User { name: "Aditya".into(), age: 25, email: "[email protected]".into(), phone: None };
let json = serde_json::to_string(&user).unwrap();
// {"name":"Aditya","age":25,"email_address":"[email protected]"}

// Deserialize
let user2: User = serde_json::from_str(&json).unwrap();

Q44. What is the Newtype pattern? Medium

// Wrap a type to add meaning and prevent mixing
struct Meters(f64);
struct Kilograms(f64);

fn calculate_force(mass: Kilograms, accel: f64) -> f64 {
    mass.0 * accel
}

// Type safety: cannot accidentally pass Meters where Kilograms expected
let force = calculate_force(Kilograms(70.0), 9.8);
// calculate_force(Meters(70.0), 9.8);  // compile error

Q45. Predict the output: Advanced

fn main() {
    let x = Some(5);
    let y = Some(10);
    
    let result = x.zip(y).map(|(a, b)| a + b);
    println!("{:?}", result);
    
    let z: Option<i32> = None;
    let result2 = x.zip(z).map(|(a, b)| a + b);
    println!("{:?}", result2);
}

Output:

Some(15)
None

Explanation: zip combines two Options into Option<(A, B)>. If either is None, the result is None.

Mock Interview: 5 Questions

1. Implement a stack data structure in Rust using a Vec<T> with push, pop, and peek methods.
2. Explain why this code does not compile and fix it: let v = vec![1,2,3]; let r = &v[0]; v.push(4); println!("{}", r);
3. Write an async function that makes two HTTP requests concurrently and returns both results.
4. What is the difference between String::from("hello") and "hello".to_owned()?
5. Implement fibonacci as an iterator in Rust.

FAQ

Q: Why is Rust so popular despite being hard to learn? A: Rust eliminates memory safety bugs at compile time - no segfaults, no buffer overflows, no use-after-free. For systems software and cloud infrastructure, this is transformative. Once the ownership model clicks, the compiler becomes your co-programmer.

Q: How long does it take to become productive in Rust? A: Candidates report spending 2-4 weeks on ownership/borrowing before feeling comfortable. The compiler errors are verbose but helpful. "Fighting the borrow checker" is a normal phase.

Q: Should I learn Rust or Go for backend development? A: Go is easier to learn and has broader adoption for web services. Rust is better for systems programming, performance-critical paths, and WebAssembly. For most web backend roles, Go is the pragmatic choice. For infrastructure and CLI tools, Rust is excellent.

Related reading: Go Interview Questions 2026 | C++ Interview Questions 2026 | System Design Interview Questions 2026 | AWS Interview Questions 2026