52 crates · 56 kernel modules · 12 languages · 294,710 lines of Rust · 35 GitHub repos · 0 lines of C

ClaudioOS

A bare-metal operating system for AI coding agents.
No Linux. No POSIX. No JavaScript.

Boots via UEFI on real hardware. Runs Windows binaries via PE loader + Win32 API + .NET CLR. Runs Linux binaries via ELF loader + syscall translation. Vulkan 1.3 GPU driver with DXVK bridge for DirectX 9/10/11. No Windows. No Linux kernel. Drives NVMe, AHCI, Intel NICs, WiFi (WPA2/WPA3), Bluetooth, USB 3.0 (keyboard + mouse + storage + touchpad), and NVIDIA GPUs from Ring 0. Authenticates to claude.ai via OAuth, runs multi-agent sessions with 6 pane types on a 2560x1600 framebuffer with real-time SSE streaming, runtime model selection (Opus/Sonnet/Haiku), and persistent vector store for agent memory and RAG. Ships a native git client, email (SMTP/IMAP), NTP time sync, full-text search, notifications, post-quantum SSH daemon, stateful firewall, disk encryption, swap management, cron scheduler, virtual consoles, clipboard, power management (suspend/battery), inter-agent IPC, 12 native language runtimes, 9 color themes, a text-mode web browser, image viewer, 45+ shell commands, man pages, and a boot splash with chime. Everything is #![no_std] Rust.

Production Hardware Rust nightly x86_64 UEFI SMP Multi-Core AGPL-3.0-or-later
52
Workspace Crates
56
Kernel Modules
294,710
Lines of Rust
12
Languages
35
GitHub Repos
0
Lines of C

// Capabilities

Every driver, protocol, and runtime is written from scratch in #![no_std] Rust. No Linux kernel modules. No libc. No userspace.

Boot & Core

UEFI + SMP Multi-Core

UEFI boot with GDT/IDT, 48 MB heap, ACPI table parsing (MADT/FADT/HPET/MCFG), and symmetric multiprocessing. AP cores started via SIPI with work-stealing scheduler. Boot splash with progress bar and PC speaker chime.

Win32

Windows Binary Compatibility

PE/COFF loader (1,497 lines) + Win32 API layer (10,458 lines): kernel32, user32, gdi32, DirectWrite text rendering, Direct2D graphics, WASAPI audio, XInput gamepad, WIC image decoding. Run Windows .exe files on bare metal.

.NET

.NET CLR + WinRT

.NET Common Language Runtime (5,179 lines): PE/CLI metadata loader, IL bytecode interpreter, mark-sweep garbage collector, Base Class Library stubs. WinRT API projection (1,676 lines) with activation factories and async patterns.

Graphics

Vulkan 1.3 + DXVK

Native Vulkan 1.3 GPU driver (3,811 lines): instance, device, swapchain, command buffers, graphics/compute pipelines, SPIR-V shaders. DXVK bridge (2,039 lines) translates DirectX 9/10/11 calls to Vulkan for game compatibility.

Compat

Linux Binary Compatibility

ELF64 loader with relocation and an in-kernel Linux syscall translation layer (4,090 lines). Runs unmodified Linux binaries on bare metal. /proc emulation, signal dispatch, mmap stubs. No Linux kernel required.

Memory

Vector Store + Agent Memory

In-kernel vector database (1,062 lines) with cosine similarity and KNN search. Powers persistent agent memory (1,849 lines) with embeddings, semantic search, and cross-session recall for RAG workflows.

Streaming

SSE Streaming + Model Select

Real-time token-by-token SSE streaming with backpressure, buffered rendering, and rate limiting. Runtime model switching between Opus, Sonnet, and Haiku with per-agent configuration.

Storage

NVMe + AHCI + SATA

Native NVMe driver with admin/IO queue pairs. AHCI/SATA for legacy disks. VFS layer with auto-detection across ext4, btrfs, NTFS, and FAT32 filesystems.

Networking

Intel NIC + TCP/IP + TLS 1.3

Drivers for e1000, I219-V, and I225-V Intel NICs plus VirtIO-net. smoltcp TCP/IP stack with DHCP and DNS. TLS 1.3 with AES-128-GCM from Ring 0. Intel NIC fully wired to smoltcp with DHCP.

Security

Post-Quantum SSH Server

ML-KEM-768 + X25519 hybrid key exchange. ML-DSA-65 host keys. SSH listener on port 22 with TCP session management. Up to 4 simultaneous sessions. User accounts with SHA-256 password and public key auth.

AI

Claude Multi-Agent Dashboard

OAuth device flow to claude.ai from bare metal. Max subscription integration. SSE streaming of Messages API. Split-pane terminal with 6 pane types. Inter-agent IPC with message bus, named channels, and shared memory. Session auto-refresh with JWT expiry detection.

Shell

AI-Native Shell (45+ Commands)

45+ builtin commands plus natural language passthrough to Claude. Network tools (ping, wget, curl, netstat, traceroute, nslookup), security (fw, cryptsetup), system admin (crontab, swapon, man, battery, suspend). Full pipeline support.

USB

xHCI USB 3.0 + Mouse

Full xHCI host controller driver. USB keyboard events bridged to PS/2 scancode queue. USB HID mouse with XOR crosshair cursor on framebuffer. Device enumeration and endpoint configuration.

GPU

NVIDIA GPU Compute

BAR mapping, command submission, and compute dispatch on NVIDIA GPUs. MMIO register access from bare metal for GPU-accelerated workloads.

Audio

Intel HDA Audio + Boot Chime

High Definition Audio controller driver with codec discovery, widget parsing, and PCM stream output. PC speaker boot chime plays a C5-E5-G5 ascending triad at startup.

Languages

12 Native Languages

Full polyglot development environment on bare metal. Interpreters, compilers, and runtimes for 12 languages -- all #![no_std] Rust, no external dependencies.

Browser

Web Browser Pane

Text-mode web browser as a dashboard pane. HTML parsing via wraith-dom, CSS selectors, HTTP/HTTPS transport over smoltcp. URL bar, link following with numbered references, history, and scroll navigation.

Files

Visual File Manager

Terminal-based file browser as a dashboard pane. Directory listing with color-coded types. Copy, move, rename, delete operations. Search/filter. VFS integration for all mounted filesystems.

Monitor

System Monitor

Real-time system stats in a dashboard pane. CPU usage with progress bar, memory (heap + framebuffer), network counters, per-agent state breakdown (thinking/streaming/tool/idle/error), and uptime. Auto-refreshes every second.

IPC

Inter-Agent Communication

Global message bus with per-agent inboxes. Named data channels (4K ring buffers). Shared memory regions. 8 IPC tools exposed to Claude agents for collaboration: send, receive, broadcast, channels, shared memory.

Themes

9 Color Themes

Runtime theme switching via theme <name>. Built-in: default, solarized-dark, solarized-light, monokai, dracula, nord, gruvbox, claudioos, templeos. ANSI 24-bit true color support.

Screensaver

5 Screensaver Modes

TempleOS-inspired screensavers: 3D starfield, Matrix rain, bouncing "ClaudioOS" logo (DVD style), randomly growing colored pipes, and a large digital clock. Activates after 5 minutes idle.

Init

Init System + Users

Boot configuration via fw_cfg (hostname, log level, auto-mount, SSH, startup scripts). User database with SHA-256 password hashing and SSH public key authentication. Default user with auto-login.

Boot

Boot Splash + Chime

ASCII art "CLAUDIOOS" logo centered on framebuffer with a 4-stage progress bar (Hardware, Network, Auth, Ready). PC speaker boot chime via PIT channel 2: C5 (523 Hz), E5 (659 Hz), G5 (784 Hz).

Editor

Nano-Like Text Editor

Buffer-gap text editor with syntax awareness. Integrated as the edit_file tool for Claude agents. ~400 lines, 11 tests.

WiFi

WiFi Networking

Native Intel AX201/AX200 WiFi driver. IEEE 802.11 frame handling, network scanning, WPA2-Personal and WPA3-SAE authentication. Firmware upload, DMA tx/rx rings, and association management. 3,513 lines.

Bluetooth

Bluetooth Stack

Full Bluetooth stack over USB transport. HCI commands/events, L2CAP channels, GAP discovery and pairing, GATT services and characteristics, HID input reports for keyboards, mice, and gamepads. 3,075 lines.

USB Storage

USB Mass Storage

Bulk-Only Transport (BOT) protocol with SCSI command set. Read/write USB thumb drives and external disks. INQUIRY, READ CAPACITY, READ(10), WRITE(10). Sector-level API. 1,357 lines.

Firewall

Stateful Packet Firewall

Kernel-level stateful packet filtering. Allow/deny rules by IP address and port. Connection tracking for established sessions. Shell commands: fw allow, fw deny, fw list, fw flush. 788 lines.

Encryption

Disk Encryption

LUKS-compatible disk encryption layer. Key derivation, AES block cipher, transparent encrypt/decrypt for persistent storage. Shell command: cryptsetup. 905 lines.

Swap

Swap Management

Virtual memory swap to disk. Configurable swap partitions, page eviction, and reclamation. Shell command: swapon. 499 lines.

Cron

Task Scheduler

Crontab-style periodic task execution. Time-based scheduling with minute/hour/day granularity. Shell command: crontab. 410 lines.

VConsoles

Virtual Consoles

Multiple independent terminal sessions accessible via Ctrl+Alt+F1 through F6. Each console has its own input buffer, output history, and active shell or agent session. 372 lines.

Clipboard

System Clipboard

System-wide copy/paste buffer shared across all panes, virtual consoles, and agent sessions. 108 lines.

Power

Power Management

ACPI S3 suspend-to-RAM and S5 shutdown. Battery status monitoring via ACPI _BST/_BIF methods. Percentage, charging state, time-to-empty. Power profiles (performance/balanced/power-saver). 921 lines.

Touchpad

Touchpad Driver

PS/2 Synaptics/ALPS and USB HID multi-touch touchpad support. Gesture recognition: tap-to-click, two-finger scroll, two-finger tap for right-click. Configurable sensitivity. 734 lines.

NetTools

Network Tools

Full suite of network diagnostic tools: ping, wget, curl, netstat, ifconfig, dns, traceroute, nslookup. All implemented in-kernel over smoltcp. 787 lines.

Man Pages

Built-in Manual

Comprehensive manual pages for all 45+ commands and subsystems. man <command> from the shell. No external docs needed. 674 lines.

Git

Native Git Client

In-kernel git implementation over HTTPS. Clone, commit, push, pull, diff, log, branch, and status. No libgit2, no shelling out. 2,120 lines of pure Rust.

Email

Email Client (SMTP/IMAP)

Send email via SMTP and receive via IMAP, all from bare metal. MIME parsing, email composition, in-kernel mail handling. 967 lines.

NTP

NTP Time Sync

Network Time Protocol client for accurate wall clock synchronization. Drift correction, server polling, and RTC update. 383 lines.

Search

Full-Text Search

In-kernel full-text search across files, conversations, and agent output. Fast pattern matching with ranked results. 494 lines.

Notify

Notifications

System-wide notification framework with priority levels, agent alerts, and toast-style display. Cross-pane notification delivery. 300 lines.

Images

Image Viewer

In-terminal image rendering with dithering for framebuffer display. View images directly in the OS without a GUI toolkit. 413 lines.

// 12 Native Languages

Every language runtime is written from scratch in #![no_std] Rust. No LLVM. No libc. No external toolchains.

Python
Interpreted -- vars, loops, functions, classes (python-lite)
JavaScript
Interpreted -- ES5 core, closures, prototypes (js-lite)
Rust
Compiled -- Cranelift JIT backend (rustc-lite)
Go
Interpreted -- goroutines, channels, interfaces (go-lite)
C++
Interpreted -- classes, templates, RAII, STL subset (cpp-lite)
Lua
Interpreted -- tables, metatables, coroutines (lua-lite)
TypeScript
Interpreted -- type checking, interfaces, generics (ts-lite)
JVM
Bytecode -- class loading, GC, threads (jvm-lite)
WebAssembly
Bytecode -- validation, execution, WASI subset (wasm-runtime)
C
Interpreted -- pointers, structs, malloc/free (cc-lite)
x86 Assembly
Assembled -- Intel syntax, labels, relocations (asm-x86)
Text Editor
Nano-like -- buffer-gap, syntax awareness (editor-nostd)

// Architecture

+------------------------------------------------------------------+
|                     AI-Native Shell (45+ builtins + NL)           |
+------------------------------------------------------------------+
|                     Agent Dashboard (6 pane types)                |
|  +--------+ +--------+ +--------+ +--------+ +--------+ +-----+ |
|  | Agent  | | Shell  | |Browser | |FileMgr | |SysMon  | |Scrn-| |
|  | (Claude| | (45+   | |(wraith | |(visual | |(CPU/   | |saver| |
|  |  +IPC) | |  cmds) | | + TLS) | | dirs)  | | mem)   | |(5x) | |
|  +--------+ +--------+ +--------+ +--------+ +--------+ +-----+ |
+------------------------------------------------------------------+
|  API Client  |     OAuth    |  Terminal   | SSH Daemon            |
|  (Messages   |  (claude.ai  |  (VTE +     | (ML-KEM-768          |
|   API + SSE) |   device     |   2560x1600 |  + ML-DSA-65)        |
|              |   flow)      |   Terminus) |  port 22             |
+--------------+--------------+-------------+----------------------+
|  IPC (msg bus + channels)   | Conversations | Session Refresh    |
+--------------+--------------+-------------+----------------------+
|  Git Client  | Email        | NTP Sync    | Notifications        |
|  (clone/push)| (SMTP/IMAP)  | (drift corr)| (alerts/toasts)     |
+--------------+--------------+-------------+----------------------+
|  VectorDB    | Agent Memory | Streaming   | Model Select         |
|  (cosine/KNN)| (embeddings) | (backpress) | (Opus/Sonnet/Haiku) |
+--------------+--------------+-------------+----------------------+
|  Search      | Image Viewer |             |                      |
|  (full-text) | (dithering)  |             |                      |
+--------------+--------------+-------------+----------------------+
|              Async Executor (interrupt-driven, SMP)               |
+--------------+--------------+-------------+----------------------+
| 12 Languages | Editor       | Wraith      | Init System          |
| py/js/rust   | nano-like    | DOM/render  | Users + Themes       |
| go/c++/lua   |              | transport   | Splash + Chime       |
| ts/jvm/wasm  |              |             | Screensaver          |
| c/asm-x86    |              |             |                      |
+--------------+--------------+-------------+----------------------+
| Firewall     | Encryption   | Swap        | Cron + VConsoles     |
| pkt filter   | LUKS-compat  | disk swap   | Clipboard + Power    |
| IP/port ACL  |              |             | ManPages + NetTools  |
+--------------+--------------+-------------+----------------------+
| Windows Compat (PE loader + Win32 + .NET CLR + WinRT)            |
| Vulkan 1.3 + DXVK (DirectX 9/10/11 -> Vulkan translation)       |
+--------------+--------------+-------------+----------------------+
| Linux Compat (ELF loader + syscall translation)                  |
+--------------+--------------+-------------+----------------------+
|     Networking              |    Filesystems                     |
|  smoltcp TCP/IP + TLS 1.3  |  ext4 + btrfs + NTFS + FAT32      |
|  DHCP + DNS                 |  VFS auto-detection                |
+-----------------------------+------------------------------------+
|  Intel NIC    | VirtIO-net  | NVMe  | AHCI/SATA | xHCI USB 3.0 |
|  WiFi AX201   | Bluetooth   | USB   | Touchpad  | kbd + mouse   |
+---------------+-------------+-------+-----------+---------------+
|  HDA Audio    | GPU Compute | ACPI  | RTC  | PS/2 | PC Speaker  |
+---------------+-------------+-------+------+------+-------------+
|              x86_64 Kernel Core (SMP)                            |
|   paging, 48MB heap, GDT/IDT, APIC, PCI, interrupts             |
+------------------------------------------------------------------+
|              UEFI Boot (bootloader crate v0.11)                  |
+------------------------------------------------------------------+

// 35 Open-Source Repos (52 Crates)

Every crate is #![no_std], published individually, and usable in any bare-metal or embedded Rust project.

Filesystems

Hardware Drivers

Wireless

System & Compatibility

Language Runtimes (12)

Windows Compatibility

Graphics

Web & Browser

Security & Tools

// Built with Claude

ClaudioOS started with a question: What if an AI coding agent didn't need an operating system underneath it? What if it was the operating system?

Every line of this project was written in collaboration with Anthropic's Claude. The kernel boots, initializes hardware via ACPI, starts all CPU cores via SMP, authenticates to claude.ai, and spawns agent sessions that can write code, compile it (via Cranelift), execute Python and JavaScript, edit files, browse the web, manage conversations, communicate with each other via IPC, and SSH into remote machines -- all from bare metal with zero OS dependencies.

The development itself is recursive: Claude helps build the OS that runs Claude. The project has grown from a simple UEFI bootloader to a 52-crate workspace with 56 kernel modules, 294,710 lines of Rust, 12 native languages, and hardware drivers for NVMe, AHCI, Intel NICs, WiFi, Bluetooth, USB 3.0 (keyboard + mouse + storage + touchpad), HDA audio, and NVIDIA GPUs. It loads and runs Linux binaries via an ELF loader and syscall translation layer. It reads ext4, btrfs, and NTFS filesystems. It runs Windows .exe files via a PE loader, Win32 API layer, .NET CLR, and WinRT, with Vulkan 1.3 graphics and a DXVK bridge for DirectX game compatibility. It has a native git client, email (SMTP/IMAP), NTP time sync, an in-kernel vector database for agent memory, real-time SSE streaming with model selection, full-text search, a notification system, a stateful firewall, LUKS-compatible disk encryption, swap management, a cron scheduler, virtual consoles, and power management with battery monitoring. It runs a post-quantum SSH daemon with user accounts. It has its own shell with 45+ commands and natural language understanding, a web browser, a file manager, an image viewer, a system monitor, 9 color themes, 5 screensaver modes, man pages, and a boot splash with chime.

35 repos have been extracted and published as standalone open-source libraries, each usable in any #![no_std] Rust project. The goal isn't just an OS -- it's proving that AI-native systems programming is possible, practical, and productive.

Matt Gates · Ridge Cell Repair LLC · @suhteevah

// Build & Run

# Prerequisites
rustup target add x86_64-unknown-none
cargo install bootimage

# Build the kernel (52 crates, 56 kernel modules, 294k lines)
cargo build

# Create bootable disk images
cargo run --manifest-path tools/image-builder/Cargo.toml -- \
    target/x86_64-unknown-none/debug/claudio-os

# Run in QEMU with full networking + TLS
qemu-system-x86_64 \
    -bios /usr/share/OVMF/OVMF_CODE.fd \
    -drive format=raw,file=target/x86_64-unknown-none/debug/claudio-os-uefi.img \
    -device virtio-net-pci,netdev=net0 \
    -netdev user,id=net0,hostfwd=tcp::5555-:5555 \
    -serial stdio -m 512M -smp 4 -cpu Haswell

-cpu Haswell is required for AES-NI instructions used by TLS 1.3. For real hardware, the OS has been tested on i9-11900K, Supermicro SYS-4028GR-TRT, HP Victus laptop, and Arch Linux boxes.