A forward-looking operating system built from scratch for the AI era.

X OS is a clean-slate microkernel operating system designed for a world where intelligent agents and human users work together. It asks a simple question: what would an OS look like if it were designed today — for agentic programming, programmatic interaction, and human-AI collaboration?

X OS running in QEMU with GPU-accelerated rendering — menu bar, dock with app icons, compositor surfaces, and desktop at 2560×1600.

Why

Software is changing. AI agents don't just call APIs — they read code, write code, run commands, debug, and iterate. They need an environment that is observable, scriptable, and mutable at a level that current operating systems weren't designed to provide.

X OS starts from a different premise. The system is built so that every service is inspectable, every component is replaceable, and every interaction is programmable — not through tooling layered on top, but as a first-class architectural principle. The microkernel exposes IPC ports that any process (human or agent) can use to query, control, and extend the system in real time.

Principles

• AI-native architecture — the OS assumes agents are first-class users. IPC, service discovery, and system introspection are designed for programmatic use from day one.
• Microkernel by design — the kernel handles scheduling, memory, IPC, and hardware. Everything else — display, filesystem, networking, shell — is a userspace service that can be inspected, modified, or replaced while the system runs.
• Everything is observable — services communicate over IPC ports with a nameserver for discovery. Any process can query the system state, subscribe to events, or intervene. This is not a debugging feature; it is the architecture.
• Clean slate — no decades-old ABI to maintain, no legacy cruft. The system is free to make the right decision for today and for what comes next.
• Forward-looking — designed for what's ahead: agentic workflows, programmatic interaction, and human-AI collaboration.

Vision

The core idea is fixed: a forward-looking operating system built for the AI era, designed for agentic workflows and intelligent users. That will not change.

Everything else is open. The architecture, the UI, the technologies, the priorities — all will evolve as the project grows and as the landscape of AI-native computing takes shape. Design decisions made today may be revised tomorrow. Components may be rewritten, replaced, or removed. That's not a risk; that's the point.

The desktop environment aims to feel familiar — a menu bar, a dock, windows, a cursor. We lean into known conventions because they work and users already understand them. But this is not a commitment. If we discover something fundamentally better, we will explore it. The goal is to build an interface that is intuitive today and open to reinvention tomorrow.

What Exists Today

X OS boots on real hardware (via Limine) and in QEMU, with a working desktop environment:

• Microkernel — ~90 syscalls covering scheduling, memory management, IPC ports, timers, GPU/virtio drivers, NVMe storage, and networking
• Userspace composer — hardware-accelerated display server with surface compositing, dirty rectangles, window decorations, cursor management, and GPU rendering via virgl (OpenGL ES)
• Menu bar — top panel with app menus, dropdowns, and focus tracking
• Dock — bottom panel with app icons, hover effects, and app launch/close
• Context menu — right-click popup service powered by egui (Rust, no_std)
• Shell — embedded zsh port running as a userspace process
• File manager (Xplorer) — draggable window app
• Networking — XNU BSD network stack ported to the microkernel: TCP/UDP sockets, virtio-net driver, POSIX socket API
• Filesystem — custom XFS filesystem with NVMe block device support
• GPU acceleration — virtio-gpu with virglrenderer for OpenGL ES 3D compositing; custom GPU command stream for textured quad rendering with alpha blending
• egui integration — egui 0.35 ported to no_std/x86_64-unknown-none with a custom CPU rasterizer (scanline glyph renderer) and software backend for immediate-mode UI rendering

Architecture

How It Works

The kernel is a minimal microkernel: it handles CPU scheduling, physical/virtual memory, IPC message ports, and hardware drivers (NVMe, virtio-gpu, virtio-net, PS/2 input, PCI, timers). It does not contain filesystem code, display logic, or networking — those are userspace services.

All userspace binaries (init, composer, dock, menubar, menu, shell) are compiled as ELF binaries and embedded directly into the kernel image as byte arrays. The kernel spawns them at boot — no disk loading, no bootloader chain for userspace.

Services communicate via IPC ports. The composer registers a well-known port; apps send surface creation requests, dirty rectangles, and mouse events over IPC. The nameserver (sys_ns_register / sys_ns_lookup) provides service discovery.

GPU compositing uses virgl (OpenGL ES via virtio-gpu 3D). Each app surface gets a GPU texture; the composer submits a 3D command stream that draws textured quads with alpha blending onto a framebuffer-backed render target that is also the scanout source.

Requirements (macOS)

Tested on macOS with Apple Silicon. You need:

• Xcode Command Line Tools (provides clang, make, git)

• Homebrew — https://brew.sh

• lld (LLVM linker)

• xorriso (for building the bootable ISO)

• QEMU — install via Homebrew or build from source. The Makefile auto-detects the path.

  Option A — Homebrew (quickest):

  Option B — build QEMU v11 from source with virgl/ANGLE GPU rendering (recommended for GPU acceleration on Apple Silicon):

  # Install the startergo tap for virgl/ANGLE dependencies
  brew tap startergo/homebrew-qemu-virgl
  brew trust startergo/qemu-virgl
  brew install libangle libepoxy-angle virglrenderer spice-protocol spice-server \
    meson ninja glib pixman pkg-config dtc vde libssh
  
  # Build QEMU v11.0.2 with Cocoa + virgl + OpenGL ES
  bash tools/build-qemu-virgl.sh
  

  This builds QEMU v11.0.2 with virtio-gpu-gl-pci support, Cocoa display, and OpenGL ES rendering via ANGLE/virglrenderer. The script handles patching, building, installing to /opt/qemu-head, fixing dylib paths, and code-signing with HVF entitlements.

  The Makefile checks /opt/qemu-head first, then the Homebrew qemu-virgl prefix, then the Homebrew qemu prefix, then falls back to qemu-system-x86_64 in your PATH.

Build

One-time setup (downloads the Limine bootloader):

Build the bootable ISO:

This produces x-os.iso in the project root.

Run

BIOS mode (SeaBIOS):

UEFI mode (OVMF):

QEMU is launched with:

• Machine: q35
• 512 MB RAM, 1 SMP
• virtio-gpu-pci at 2560x1600, Cocoa display
• NVMe disk (disk.img, created automatically if missing)
• Serial output forwarded to stdio

Project Layout

x/
├── boot/               # Limine bootloader config and handoff structures
├── kernel/             # Microkernel source
│   ├── arch/x86_64/       # GDT, IDT, syscall entry, context switch
│   ├── memory/            # Physical page allocator, VMM, heap
│   ├── sched/             # Round-robin scheduler
│   ├── ipc/               # Port-based message passing
│   ├── proc/              # ELF loader; embedded userspace blobs
│   ├── hal/               # NVMe, virtio GPU, virtio-net, PS/2 input, PCI, timers
│   ├── fs/                # Custom XFS filesystem
│   ├── bsd/               # XNU BSD syscall implementations (sockets, fork, exec, pipe)
│   └── entry/             # kmain() boot sequence
├── bsd/                # XNU BSD networking stack (TCP/IP, sockets, virtio-net)
├── userspace/          # Ring-3 code
│   ├── init/              # PID 1
│   ├── runtime/           # Syscall wrappers (shared C library)
│   ├── shell/             # zsh port
│   ├── lib/
│   │   ├── xgfx/          # Graphics library (paths, fills, text, scaled text)
│   │   ├── thorvg/        # ThorVG vector graphics engine (SVG rendering)
│   │   ├── wm/            # Window manager IPC protocol library
│   │   └── cpp_runtime/   # C++ runtime support for freestanding environment
│   └── services/
│       ├── composer/      # Display server + GPU compositing
│       ├── dock/          # Bottom dock panel
│       ├── menubar/       # Top menu bar panel
│       ├── menu/          # Right-click context menu (egui, Rust no_std)
│       └── xplorer/       # File manager app
├── third_party/       # Vendored dependencies
│   ├── egui/              # egui 0.35 (ported to no_std/x86_64-unknown-none)
│   ├── egui_software_backend/  # CPU rasterizer for egui primitives
│   └── llvm-project-libcxx/    # libc++ for freestanding C++ runtime
├── tools/             # Build scripts (QEMU virgl build, etc.)
├── Makefile
└── disk.img           # Raw block device image (auto-created)

Cleaning Up

make clean       # remove build artifacts and ISO
make distclean   # also remove fetched Limine directory

License

Business Source License 1.1

X OS is source-available under the BSL. This means:

• Free for contributors — you can fork, modify, build, and send pull requests.
• Free for personal, educational, and research use.
• Commercial use requires a paid license — if you want to sell it, offer it as a service, or embed it in a product, contact the copyright holder.
• All commercial rights reserved — the copyright holder controls all commercial licensing and may grant or deny commercial use at their sole discretion.

This model lets the community grow the project while keeping all commercial and acquisition paths fully controlled by the copyright holder. See LICENSE for full terms.

For commercial licensing, partnership, or acquisition inquiries, contact the copyright holder.