Writing an OS in Rust: 5 Hard Problems You'll Face (And How to Solve Them)

Rust promises memory safety without garbage collection. That's why many of us dream of writing a kernel in it. After several years of building a from‑scratch operating system in Rust, I've collected the real — not theoretical — challenges that will make you question your life choices. Here are the five hardest problems, and the pragmatic solutions that actually work. 1. The unsafe Infection: Your Core is Not Safe The kernel's job is to manage memory, poke hardware registers, and handle interrupts. That means unsafe is not an exception — it's the norm. The problem : A single unsafe block can corrupt state that safe code depends on. In userspace, you isolate unsafe behind a small API. In the kernel, the entire bottom layer is unsafe . A bug in the page fault handler trashes everything. What doesn't work : Pretending that "only 5% of the code is unsafe ". In practice, the scheduler, the memory allocator, the interrupt handlers — they all need unsafe . You can't push it to the edges. What works : Treat unsafe as a capability . Every unsafe function must have a // SAFETY: comment explaining why it's sound. Use static assertions ( const_assert! ) to validate invariants at compile time. Isolate hardware access behind a hal crate where unsafe is contained, but don't cheat — the rest of the kernel still needs unsafe for core operations. Example — writing to a memory-mapped register: /// SAFETY: addr must be a valid MMIO address for this device, /// aligned to 4 bytes, and the caller must hold the device lock. pub unsafe fn mmio_write(addr: *mut u32, value: u32) { addr.write_volatile(value); } The comment doesn't make it safe — it documents the contract so the caller knows what they must guarantee. Memory Allocation Before alloc You want Vec, Box, Arc. But alloc requires a global allocator. The allocator requires a lock. The lock requires a working scheduler. The scheduler requires memory allocation. Classic chicken‑and‑egg. The problem: You can't allocate memory to create th