What is Motor OS

Motor OS is a microkernel-based operating system, written in Rust, that targets virtualized workloads exclusively. It runs in x86-64 KVM virtual machines under QEMU, Cloud Hypervisor, and Firecracker.

In short: serving static HTTP and HTTPS works out of the box, SSH and SFTP work, Rust programs built on the standard library and on Tokio run, and the developer image can compile C, C++, and Rust programs natively. Motor OS is beta quality: under active development, hardened over weeks of systematic review in 2026 (the networking stack above all), and used to serve this website from inside Motor OS VMs.

The shape of the system

Rust is the language of Motor OS. The kernel, the runtime, the services, and the programs are Rust, and the system interface that programs use is Rust as well: a per-process runtime object, rt.vdso, exposes a versioned table of functions, and Rust's standard library calls into it through the small moto-rt crate. There is no C ABI at the system boundary and no dynamic linking; a C library exists for ported C and C++ code, and it sits on top of the same runtime.

The kernel is small and lives in high memory. It manages address spaces, threads, scheduling, capabilities, and wait/wake objects. Everything that touches hardware or implements a service runs in userspace: sys-io owns the VirtIO block and network devices, the filesystem, and the TCP/IP stack; sys-init starts services; sys-tty drives the serial console; strobe collects logs and metrics; dns-resolver resolves names; russhd serves SSH. The Architecture page describes each piece.

What works

Boot and kernel

• Boots via MBR (QEMU) or PVH (Cloud Hypervisor, Firecracker) in about 200 ms.
• A high-memory microkernel with four syscalls, cooperative in-kernel scheduling (the kernel never blocks, so it does not need to be preemptible), and preemptive userspace scheduling with a 10 ms tick.
• SMP with per-CPU ready queues and work stealing, up to 16 vCPUs.
• 4 KiB pages, guarded lazily-allocated stacks, page faults handled in userspace mappings, and admission control that keeps the machine out of physical memory exhaustion (see Memory).

I/O, in userspace

• VirtIO block and network drivers (modern VirtIO over PCI, MSI-X), with checksum and TSO offload on transmit.
• Motor FS, a journaling filesystem with per-role permissions and advisory file locks (see Filesystem).
• moto-netstack, the Motor OS networking stack: IPv4 and IPv6, DHCPv4, ARP and neighbor discovery, TCP with CUBIC congestion control, SACK, RACK-TLP loss recovery, timestamps and window scaling, SYN cookies, and rate limits; UDP; ICMP echo. Host-to-guest TCP throughput is about 10 Gbps (see Networking).
• A DNS resolver service with hosts-file and resolv.conf support, UDP with TCP fallback, and strict response validation (see DNS resolver).

Userspace and Rust

• Multiple processes with preemption, threads, and thread-local storage.
• Rust's standard library is ported: programs that use std and do not depend, directly or indirectly, on Unix or Windows APIs cross-compile for x86_64-unknown-motor and run (see Rust on Motor OS).
• The Tokio runtime, and the Tokio and mio asynchronous TCP and UDP APIs, work, including asynchronous child processes and stdio.
• rustls (with ring), hyper, axum, and russh have been ported or work with small patches; TLS serving and SSH serving are built on them.
• A C library (mlibc) and a Clang/LLVM toolchain that targets Motor OS directly, so C and C++ are supported as well; Lua ships on the developer image (see C/C++ on Motor OS).

Programs

• rush, a POSIX-style shell, on the serial console and over SSH.
• rmux, a tmux-like terminal multiplexer.
• Two editors: red, which behaves like vi, and kibim, a small and simple one.
• An SSH server, russhd, with password and public-key authentication, interactive shells, command execution, and SFTP.
• Two static web servers with TLS: httpd, a small hand-written one, and httpd-axum, built on axum and Tokio.
• The usual commands: ls, cat, cp, mv, rm, find, wc, less, ps, top, free, ss, ping, stats, and more (see Commands), plus ripgrep.

The developer image

• A native Clang/LLVM toolchain with mlibc, libc++, and compiler-rt, so cc hello.c works inside the VM.
• A native rustc with a full Motor OS sysroot.
• Lorry, a smaller, stricter Cargo replacement for security-sensitive environments: it takes the same Cargo.toml and Cargo.lock and aims for byte-identical binaries, but builds offline, with every dependency fetched once, checked, and approved before it is built (see Lorry).
• Gears, an agent harness for LLM-assisted work, and curl for HTTPS downloads.
• The test suites and mdbg, a stack-dumping debugger. See Developer image.