Rinux is a new kernel, written in Rust and designed for servers. It runs already compiled Linux binaries, as they are, inside domains: each one with its own memory, CPU, root and faults. When something goes down inside a domain, the rest of the machine does not notice.
Press a domain to trigger a fault in it: the kernel restarts it with the next generation and the others keep running. The session is real, copied from the VM's serial port and from SSH.
committed transactions still there after a power cut under load
from kernel entry until it is ready to work
system calls implemented, each with its status written down
Rinux is the operating system, not something that runs on top of one. It boots directly on the server or the cloud VM, in place of Linux.
Debian 13, from an OCI image verified layer by layer with SHA-256, boots with systemd in a Rinux domain. Over SSH, apt installs packages and curl speaks HTTPS. Everything they do underneath is handled by Rinux.
A domain is not a namespace trick on top of a shared kernel. It is an object of the kernel itself, which owns its resources and answers for its faults.
Docker needs a Linux underneath, and its containers share that kernel. Here there is no Linux: Rinux takes Docker images as they are and runs each one in a domain isolated by the kernel itself.
There is no guest Linux per workload. A single kernel isolates all the domains, and it boots in 129 ms.
Debian, systemd, apt and sshd do not know they are not on Linux, because Rinux speaks the same system call language.
This page and other sites of ours run on a Rinux node in Google Cloud. The same machine runs the Mentat control plane, which decides which workload goes where, and Cóndor, the proxy that terminates TLS and obtains the Let's Encrypt certificates. Each site lives in its own domain.
Hard reset of the VM from Google Cloud, with a probe to each domain every half second: six came back at 15 s and the heaviest, at 60 MB, at 21 s. The 463 ms is the median of 20 new connections, with a 148 ms round trip to the cloud.
A new kernel boots once on trial and, if the node does not confirm it, the loader goes back to the previous one. It only accepts signed images.
Each domain opens only the ports and the egress it is granted. A workload with internet egress cannot reach the metadata server.
A workload reaches only the destinations it is given by name; the kernel also filters its DNS queries. Every attempt to go elsewhere is refused and reaches a phone as a warning within seconds. In production, a test workload insisted six times in a minute: it lost its egress and kept serving. No workload on the node has open egress to the internet.
Three bugs, each with its test: a TCP segment held back, a lock that made a thread spin, and a control plane that was slow to bring workloads back.
We deployed a test workload of our own on the production node and made it act like an attacker that had already taken over an application. Nobody broke in from outside: the workload is ours, and the point was to see what it can do from its domain. It tried to reach the internet, the metadata server —where the node's keys live—, the other workloads, even just to see them. It could do none of it.
The workload was granted egress to a single destination. It tried the internet by address and by name, the metadata server, the gateway, the ports of the other workloads and of the control plane, and reading their data: the kernel refused it all and counted every attempt; on the sixth in a minute, Mentat took its egress away while it kept serving. What we proved is that a workload already taken over cannot move or take anything out. How an application gets taken over in the first place depends on the application, not the kernel — that is a different test, not this one.
OxideStore, our S3-compatible store, runs here as three domains with Raft between them. We copied 1,147 objects into it from three Linux virtual machines. The copy found what the tests had not: kernel limits that only show up with real data, each one fixed and covered by a test.
to copy the 7.8 GB with four parallel uploads, with the same objects and sizes on all three nodes
to write, read back and assemble 100 MiB on a network disk, before and after the fix
the memory limit of one store node, raised and lowered back by Mentat without restarting it
The file system asked the disk for 4 KiB per request, and on a network disk each request costs half a millisecond. It now reads the neighboring blocks of a file in a single request. Completing a 92 MiB upload went from 13 s to 3 s.
Reserving memory no longer costs anything: each page is charged to the domain when it is touched, and what a program gives back stops counting. At rest, each store node shows 43 MB instead of 92.
The kernel allows the limit of a running domain to be changed, and counts every time it denies the domain memory. Mentat looks at this every 5 seconds: it raises the limit of a workload that gets close to it and lowers it back when usage drops.
When it stops it releases everything: its in-memory file system and, as of this kernel, also the System V shared memory and semaphores that nobody removed. After the fuzzer, a domain with no processes was still charged 55 MiB; now all stopped domains together add up to less than half a MiB.
Finished processes stayed recorded until someone listed their domain, and that cleanup stalled the rest of the node. Now each process leaves the table when it exits: after 2,000 that start and die, 2 entries remain, not 2,002.
Each fix went through the 40 tests on aarch64 and through an x86_64 Rinux node in Google Cloud before getting here. The disk fixes were measured with disks identical to the ones on this node.
A database is the hardest test for a kernel: every committed transaction waits for an fsync, and that data has to be there after any power loss. PostgreSQL 17 from Debian runs unmodified in a Rinux domain, and we cut its power under full load.
committed transactions that survive the power cut under load
transactions per second with 50 clients in Google Cloud, without a single failed one
per transaction with one client: almost all of it is the disk fsync
With pgbench writing, 200 marked transactions are committed and the VM is powered off without warning. When it comes back, all 200 marks are there, the balances add up and pg_amcheck finds no corruption. On x86_64 and aarch64.
The main process is frozen: the port stays open but nobody answers. The kernel's liveness check detects it and restarts the domain. It comes back with all 200 marks in under a minute.
Hard reset of the VM from the Google Cloud console: 200 of 200 marks, balances that add up over almost 80,000 transactions and a clean pg_amcheck.
Seven kernel bugs, each with its test: System V shared memory, vectored I/O, stacked mounts, per-domain local networking and a disk read that failed under load.
n2-standard-2 with a pd-balanced disk, pgbench scale 10: 133 tps with 1 client, about 314 with 8 and 368 with 50.
Oracle is among the most demanding things you can ask of a kernel that is not Linux: a 434 MB executable, dozens of processes that share memory, threads that notify each other with signals and a listener that inspects the node's network before accepting anyone. Oracle Free 26ai runs in a Rinux domain from its container image, with its own user, and opens the database.
rows written and read back through the listener, over TCP
from domain start to the database opened, used and shut down cleanly
of memory at peak usage, with a limit of 6.5
It boots the machine, waits for Oracle to open the database, creates a table, inserts 1,000 rows through the listener and reads them. If startup fails, it leaves the Oracle alert log on the console. Today it runs on aarch64.
Each process had its private copy of the program, and one larger than 256 MiB would not start. Now its pages are taken from the file system cache and only the ones the process writes are copied, as Linux does.
Each new Oracle thread reads its own entry in /proc. Rinux answered per process, not per thread: the thread gave up and Oracle reported that it could not create it. It was the hardest bug to see.
The image's user for the first process, a /dev/shm that anyone can write to, signals that carry a value, the node's addresses over netlink and over ioctl, and sending several messages in a single call.
In the test, not in production. Of the 5.5 GiB, 2.9 are the image layers, which are still kept in memory: moving them to disk is what comes next.
At the end of each test, the kernel checks its own accounting. If something does not add up, the test fails even if the program inside finished correctly. This way every real workload that runs on Rinux also tests the kernel.
boot tests on aarch64 that end with a clean kernel verdict
that a stopped domain was still charged: the first thing it found
identical runs of a three-node cluster on the deterministic kernel
It walks each whole volume and compares it with its block map: no block lost, none used twice, every name with its file. That what is charged to the domains does not exceed the node's memory. That every process is in the domain it belongs to.
After the fuzzer, a domain with no processes kept the System V shared memory that nobody had removed. It now returns it on exit. The fix already runs on the node that serves this page.
On the deterministic kernel, the same seed has to give the same execution. A cluster with systemd gave one trace before the top of the hour and another one after it: the first process of each domain was reading the machine's clock without going through the kernel.
With that closed, 100 runs with one seed gave the same trace of 844,211 events. Half of them were done with the machine's clock set to dates between 2024 and 2032. Since then every deterministic test is repeated with a different clock.
Before production, seven tests and the deterministic fuzzer ran on a Rinux node in Google Cloud: all with a clean verdict, and two boots of the same disk with the same trace.
Rinux targets nodes that nobody can go to: the network starts closed and everything goes through the control plane. A node like that has to come back on its own from whatever takes it out of service.
from kernel entry until it is ready to work
until SSH on Debian, with PostgreSQL and the encrypted disk
from a failure to SSH again: the Debian domain restarts completely, on its own
Copy-on-write and an intent log: a power cut leaves the last committed state, never a mix.
Each volume has its own key, sealed in the TPM. Deleting a domain destroys its key.
If the new kernel fails to boot properly twice, or crashes three times in 10 minutes, the loader goes back to the previous one on its own.
A CPU stuck in the kernel for 20 seconds is detected, the reason is left in the log and the node is restarted.
Every 10 seconds the kernel verifies that the service accepts connections. A hung one is restarted. One stopped on purpose is not.
The hardware one restarts the VM if the kernel freezes. Each domain has its own /dev/watchdog for systemd.
A second SSH in an independent domain answers when Debian does not. fail2ban blocks in the kernel itself.
Thousands of half-open connections do not leave the node without SSH: they expire, and the oldest one gives up its place.
Each domain pays for the memory it uses, not the memory it reserves. If it goes over its limit, only the process that touched the extra page dies. The rest of the node does not notice.
Nothing counts as done until a test boots Rinux in QEMU, on x86_64 and on aarch64, runs real Linux programs inside a domain and verifies the result from the inside.
Linux 6.12 system calls on x86_64, each with its status written down
on aarch64, with that architecture's own syscall number table
full boot tests, on both architectures
| Test | What it verifies | Checks | x86_64 | aarch64 |
|---|---|---|---|---|
| boot | UEFI, signed envelope, rinuxd in user mode, shutdown | 1 | passes | passes |
| mm | frames, heap, paging, faults, scheduler, timer | 8 | passes | passes |
| elf-static | 64 static processes on 4 CPUs | 1 | passes | passes |
| domains | fault isolation, capabilities, memory and CPU limits | 8 | passes | passes |
| vfs | tmpfs, devfs, procfs, file syscalls | 10 | passes | passes |
| proc | fork, execve, wait4, pipes, posix_spawn, /proc/self/exe | 17 | passes | passes |
| signals | handlers, masks, Linux signal frames | 11 | passes | passes |
| tty | terminals, pseudoterminals, job control | 11 | passes | passes |
| dynamic | dynamically linked BusyBox from Alpine as init | 15 | passes | passes |
| alpine | OCI image from a virtio disk, tampered digest rejected | 21 | passes | passes |
| threads | pthread, futex, copy-on-write, lazy pages, TLB, mremap, growing stack | 15 | passes | passes |
| ipc | shared mmap, FIFOs, permissions, System V shared memory and semaphores, vectored I/O, native AIO | 18 | passes | passes |
| events | epoll, eventfd, timerfd, signalfd, POSIX timers | 15 | passes | passes |
| sockets | AF_UNIX, descriptor passing, credentials, netlink | 12 | passes | passes |
| system | stacked mounts, tmpfs options, sysfs, cgroup2, inotify | 15 | passes | passes |
| systemd | Debian 13 with systemd as init, journal, login, node name, key-only SSH, memory according to the node, process start time, watchdog, license notices | 15 | passes | passes |
| net | virtio-net, DHCP, ARP, ICMP, TCP | 3 | passes | passes |
| inet | TCP and UDP sockets, network closed by default, DNS, netlink, inbound connections, each domain's own local network, egress to metadata only | 17 | passes | passes |
| gce | Google Cloud image: PCI without MCFG, legacy virtio, login, SSH and a real update | 4 | passes | n/a |
| blkw | disk writes over virtio-blk, virtio-scsi and NVMe, verified from the host | 3 | passes | passes |
| rfs | our own on-disk file system, checked from the host at shutdown | 9 | passes | passes |
| crypt-persist | encrypted volumes that survive restarts and are destroyed with their key | 13 | passes | passes |
| tpm | keys sealed in the TPM, across three boots | 11 | passes | passes |
| loader | our own loader with A/B slots | 1 | passes | passes |
| update | live update, signature, a kernel that does not boot and automatic rollback | 18 | passes | passes |
| load | 128 processes writing at once to an encrypted volume | 2 | passes | passes |
| persist | Debian installed on disk: changes survive a restart | 27 | passes | passes |
| pg | PostgreSQL 17 with a power cut under full load, and hung on purpose | 15 | passes | passes |
| lockup | a stuck CPU is detected and the node restarts on its own | 2 | passes | passes |
| unstable | a kernel that crashes three times goes back to the previous one on its own | 13 | passes | passes |
| health | a hung service is restarted; a healthy or stopped one is not; per-domain watchdog | 6 | passes | passes |
| watchdog | the whole kernel frozen: the hardware watchdog restarts the machine | 1 | passes | passes |
| syn | a scan of half-open connections does not leave the port unserved | 1 | passes | passes |
| keys | SSH keys from the metadata server, users, live changes | 12 | passes | passes |
| hv | image for Proxmox and KVM: without a TPM it explains why; with a TPM it installs encrypted and boots again | 3 | passes | passes |
| sysfuzz | 144,000 system calls with random number and arguments from a seed: the kernel does not panic or lock up, and keeps serving | 4 | passes | passes |
| sysfuzz-det | the same fuzzer on the deterministic kernel: the same seed gives the same kernel trace, call by call | 2 | passes | passes |
| oracle | Oracle Free 26ai from its container image: opens the database, and 1,000 rows written and read through the listener | 1 | untested | passes |
| cluster-det | three nodes with systemd and a load generator on the deterministic kernel: the same seed gives the same trace, with the machine's clock set to another date | 2 | untested | passes |
Rust does not stop you from touching hardware. It makes you declare it. In Rinux, everything that needs unsafe (page tables, device registers, DMA, context switching) is in a single crate with its invariants written down. The rest of the kernel is forbidden from using it.
unsafe33,149 lines in the kernel, with #![forbid(unsafe_code)]Unmodified Linux programs, with musl or glibc, and rinuxd, the node controller. They run in user mode.
ring 3 on x86_64, EL0 on aarch64Virtual memory, multiprocessor scheduler, domains and capabilities, file system, sockets, TCP/IP networking, signals and the Linux personality that translates each syscall.
ring 0 / EL1, no unsafePaging, interrupts, CPU context, MMIO and DMA, exposed to the kernel as safe types.
the only crate with unsafeUEFI boots a single image, RINUX.EFI. The kernel discovers the machine through ACPI and verifies the Ed25519 signature of the boot envelope before executing anything.
x86_64 and aarch64 from the same sourceWhen a domain restarts, its generation advances and every old permission stops working.
CPU and memory quotas. Going over is an error of the domain, never of the node.
What is not allowed is denied with the error Linux would give, and is recorded in the trace.
Each domain has its own localhost. None can reach the local network of another.
Rinux boots as the operating system of the virtual machine. It is not published yet: the code and the images come out with the first release, under the MPL-2.0 license.
Today on n2-standard-2 VMs, with a signed boot disk and updates with rollback. C3, C4 and N4 need the gVNIC driver, which is coming.
Image ready: three qcow2 disks and a virtual TPM, tested on x86_64 and aarch64.
On the way. AWS needs the ENA driver. Azure needs the Hyper-V devices.
The image ships with no keys or passwords: it takes them from the metadata server.
Each piece runs in its own domain, with its own authority, on the same node.