Another Rust Kernel Drops
Moss is a Linux ABI-compatible kernel written in Rust, and it's gotten surprisingly far in just three months. The goal? Run actual Linux binaries without reimplementing the entire universe.
The GitHub repo is refreshingly honest about what it is: "an experimental kernel focused on exploring asynchronous design and Linux ABI compatibility in Rust." Translation: someone wanted to see if async Rust could work for kernel primitives, and decided to find out by building a whole kernel.
What Actually Works
Moss can run basic Linux userspace programs. Think shell utilities, not Firefox. The architecture is clean enough that multiple devs are calling it "Rust xv6" – high praise for readability in a space where most kernel code looks like cursed assembly.
The async-first design is the interesting part. Most kernels treat async as an afterthought bolted onto synchronous primitives. Moss flips this: everything's async by default. Whether this makes the code better or just different remains to be seen, but it's a genuine architectural choice rather than "Rust for Rust's sake."
The Linux-Compatible Club
Moss isn't alone. Asterinas is further along – a framekernel OS with Linux ABI compatibility and a smaller trusted computing base. Both projects bet that Linux binary compat is non-negotiable if you want adoption.
As one commenter put it: "If something is going to succeed Linux, it needs Linux binary compatibility." Hard agree. Nobody's recompiling their stack because your kernel is 10% faster.
The Driver Problem Nobody Wants to Talk About
Here's the catch: drivers. Always drivers.
Moss has basically none. Neither does Asterinas. Neither did every "new kernel" project that died quietly. Linux has 30+ years of driver accumulation. You can't match that by writing fresh Rust.
The only real solution is Linux driver compatibility – run actual Linux driver code somehow. VM it, wrap it, compatibility-layer it, whatever. Until someone figures this out, these projects stay in "cool demo" territory.
Why This Matters (Maybe)
The code quality is notably high. The async primitives could inform actual kernel development. And having multiple projects explore "what if we started over with memory safety" generates useful data.
Will Moss replace Linux? Nah. Could it become a teaching kernel? Maybe. Could some of its ideas end up in Linux or other projects? Absolutely.
The MIT license is interesting – more permissive than Linux's GPL, which could matter for embedded use cases. Though if you're an embedded hacker, copyleft protections might be worth more than license flexibility.
The Verdict
Moss is a solid experiment in async kernel design with Linux compatibility. It's not production-ready (duh), but it's further along than most "I'm rewriting the kernel" projects get.
If you're into kernel dev or want to see what idiomatic Rust looks like at the syscall boundary, it's worth a look. Just don't expect to boot your laptop with it anytime soon.
The Reddit thread has more discussion, including the maintainer answering questions about design choices.
Three months in and it's already more functional than most kernel rewrites ever get. Respect to the hustle.
Related: Asterinas, Rust pattern types, Rust v0 mangling