Speaks
Boots on real x86-64 hardware. Every application runs as sandboxed WebAssembly — isolated by design — under a windowed desktop, a full command line, and remote access over SSH.
ruOS boots in a VM or from a USB stick on real hardware; runs its command line, editor and system tools as sandboxed WebAssembly; lets you write and run Lua & Python from an on-board IDE; draws a windowed graphical desktop; speaks TCP/IP; persists to disk; drives USB keyboards and mice; spreads heavy work across CPU cores; can install itself onto an SSD; and serves an interactive shell over SSH.
Instead of retrofitting isolation onto native code, every program is WebAssembly from the start — so isolation isn't a feature, it's the ground the system stands on.
Every application runs inside its own sandbox, with its own memory. It cannot touch the hardware, the system, or another program.
A program sees only the paths and resources it has been given — there is no ambient authority to escalate, and no ../ escape.
Whole classes of memory-corruption vulnerabilities — overflows, use-after-free — are excluded at compile time, across the entire stack.
Per-task budgets on compute and memory. An infinite loop gets killed; it never takes the system down with it.
Everything an app asks of the system passes through a single audited, fuzz-tested boundary.
An internal fault ends in a controlled, diagnosable restart — not a silent hang.
The core is asynchronous end-to-end: I/O never blocks, latencies stay low, and an idle system genuinely rests.
Additional CPU cores run heavy applications truly in parallel — measured at 2.7× on parallel workloads — and even share the work of drawing the screen.
Boot proceeds in ordered, diagnosable phases and lands at a usable prompt in seconds — from a VM, a CD image, or a USB stick.
Intel GPU driver, from scratchruOS drives Intel integrated graphics with its own driver, written from zero in Rust — covering six generations of silicon, from Gen6 (Sandy Bridge) to Gen12 (Tiger Lake / Alder Lake / Raptor Lake). It has one job: move work off the CPU and onto the GPU.
Each window is a separate sandboxed application. The window manager handles focus, drag, raise and close, draws decorations and shadows, and keeps the desktop responsive by compositing across CPU cores.
› Prefer text? A full ANSI console — colors, editing, scrollback — runs alongside the GUI.
A native TCP/IP stack and a built-in SSH server, up from the moment the system boots — no disk required. The remote session is a full interactive shell: the same experience you get at the local console.
Boot it live from a CD image or USB stick — the system stays lean by loading tools on demand from the boot medium. Then, from a running shell, one command writes a bootable copy of the whole system to an SSD. On the next power-on it runs standalone.
No external toolchain needed: ruOS ships 
› The Lua debugger pauses scripts line-by-line while the window stays live, with a variables panel. For Python, Run opens a real shell session and streams the transcript — nothing is simulated.
Applications target WebAssembly with ordinary, unmodified toolchains — write it like a normal program, and it runs on ruOS. Existing command-line code ports with little or no change.
› Verified on real hardware — a modern laptop boots it from a USB stick to a working desktop.
ruOS is one answer: memory-safe from the first line, sandboxed by construction, asynchronous at the core — and small enough that one person can understand the whole thing, top to bottom.
