Bare-metal x86_64 · GRUB/Multiboot2 · TCP/IP networking · GUI desktop · Working web browser
Built from absolute zero — not a Linux distro, not a BSD fork. 100% custom kernel, drivers, network stack, and GUI.
I knew this day would come. I just passively evolved a custom operating system.
Not a Linux distro or spin-off. A totally custom OS. It runs. It has a GUI, TCP/IP capacity, and a working web browser. I used free tools. It cost me nothing — all the code was written with the help of LLMs.
This is a hobby OS, built in the open, as an inspiration to anyone who thinks building an operating system is out of reach. It's my personal milestone and a living artifact of how far AI-assisted development has come.
Today — July 18, 2026 — it WORKS. I can browse the web from a completely unique fingerprint, running in VirtualBox on a Linux host.
Every version of this OS is a benchmark for AI capability. The question isn't "can AI write code?" — it's "how autonomously can AI build complex systems?"
2024: "Write me a browser" → generates broken code
2026: "Port NetSurf" → agent tries 50 approaches, returns working diff
2028: "Build me a browser engine" → agent designs architecture, writes spec, implements, verifies
The unit of work changes from "lines of code" to "verified system behaviors."
This project is a data point on that curve. Each AI-assisted capability added to UniqOS (TCP stack, browser parsing, styled rendering) represents a milestone in what AI can achieve when paired with human architecture and verification.
The OS boots from GRUB into a 1024x768 framebuffer with a fully functional GUI desktop environment including a bottom panel and window manager.
An early iteration of the browser — HTTP GET requests fetch web pages and display them with simple tag-stripping (no formatting).
A code editor window with line numbers, blue focused area, white cursor, and typed text input — all rendered in the custom GUI.
A graphical file manager that lists files in the VFS with colored titlebar and proper window management.
System monitor — real-time memory and process info (autoplays inline):
Desktop walkthrough — multiple windows, browser, and apps (autoplays inline):
UniqOS is a from-scratch x86_64 operating system with approximately 8,000 lines of source code across C, assembly, and headers.
| Component | Description |
|---|---|
| Boot | GRUB/Multiboot2 -> 64-bit long mode, boots via boot.S/boot64.S |
| Memory | Physical Memory Manager (PMM) + Virtual Memory Manager (VMM) with paging |
| Heap | Custom kmalloc/kfree allocator for kernel objects |
| Interrupts | IDT, PIC, PIT (100Hz timer), syscall gate |
| Scheduler | Cooperative multitasking with thread_create/scheduler_yield |
| Component | Description |
|---|---|
| Display | 1024x768 32-bit framebuffer via VESA/VBE (GRUB provides mode) |
| Keyboard | PS/2 scancode handling with keyboard mouse mode (Ctrl+M) |
| Mouse | Absolute positioning via VirtualBox extension-less mouse mode |
| NIC | virtio_net — paravirtualized network adapter, interrupt-driven |
| PCI | PCI bus enumeration for device discovery |
| Component | Description |
|---|---|
| Ethernet | Raw frame TX/RX via virtio |
| ARP | Address Resolution Protocol — resolves IP->MAC, caches entries |
| IP | Internet Protocol — packet routing, checksums |
| ICMP | Ping support (echo request/reply) |
| TCP | Full state machine — SYN/SYN-ACK/ACK, tcp_send/tcp_close, sequence tracking |
| DNS | UDP-based DNS resolution with callback |
| HTTP | HTTP 1.0 GET requests, chunked header parsing, fetch callback |
| Component | Description |
|---|---|
| Window Manager | z-ordered windows with titlebars, close/minimize buttons |
| Font Renderer | PSF font with styled output (display_put_char_styled) — bold synthesis, italic slant, underline |
| Desktop | Bottom panel with app launch buttons, task switching |
| App | Description |
|---|---|
| Browser | HTML parser -> CSS style mapping -> Flow layout engine -> Styled renderer -> Clickable link map. Fetches via HTTP/1.0. |
| Terminal | Framebuffer terminal emulator with command shell |
| Editor | Multi-line text editor with line numbers |
| File Manager | Directory listing with VFS backend |
| SysMon | Live system monitor (memory, uptime) |
- Browser: No HTTPS/TLS, no JavaScript, no external CSS, limited HTML5 support
- Network: NAT only (no bridge), DHCP not implemented (static IP 10.0.2.15)
- Storage: No persistent filesystem (VFS is in-memory only)
- Graphics: No hardware acceleration, software rendering only
- Scheduler: Cooperative only — no preemption, no SMP
- Testing: No automated test suite; manual QA via
qa.py
clang-21(LLVM/Clang cross-compiler targeting x86_64-none-elf)ld.bfd(GNU ld)xorriso(for ISO creation)VirtualBoxorQEMU(for running)
cd x86_64
make iso # Build optimized release ISO
make debug # Build with debug symbols (Og -g)make run-vbox # Builds ISO and starts "UniqOS" VMOr manually:
- Create a VM named "UniqOS" with:
- Type: Other, Version: Other/Unknown (64-bit)
- Memory: 512MB+
- Network: NAT
- Storage: Attach
uniqos.iso
make run-qemu # Builds and runs with serial output| Key | Action |
|---|---|
Ctrl+Shift |
Toggle keyboard mouse mode |
h/j/k/l |
Move mouse left/down/up/right (in mouse mode) |
Space/Enter |
Left click (in mouse mode) |
Ctrl+T |
New terminal |
Ctrl+E |
Open editor |
Ctrl+B |
Open browser |
Ctrl+F |
Open file manager |
Ctrl+M |
Open system monitor |
This project was built with assistance from frontier LLMs. The following multi-agent frameworks represent the trajectory of AI capability that makes projects like this possible:
| Framework | Stars | Type | Best For |
|---|---|---|---|
| AutoGPT | 185K | Autonomous agent loop | Single agent with tools |
| AutoGen (Microsoft) | 60K | Multi-agent conversation | Agent teams, code generation |
| crewAI | ~20K | Role-based crews | Structured workflows |
| CAMEL | 17K | Multi-agent framework | Research, scaling laws |
| ChatDev | 34K | Virtual software company | Simulated dev teams |
| AgentVerse | 5K | Multi-agent deployment | Applications |
| Langroid | 4K | Multi-agent programming | Dev-focused |
| Generative Agents | 22K | Simulated society | Social simulation |
Note: These frameworks inspired the development approach. UniqOS was built primarily with direct LLM assistance (single-agent + human steering), not autonomous multi-agent swarms.
The trajectory is clear: each generation of these frameworks reduces the gap between human intent and working software. UniqOS is a data point on that curve.
UniqOS/
├── assets/ # Screenshots and logo for README
├── qa_shots/ # Full-resolution screenshots
├── x86_64/
│ ├── boot.S / boot64.S # Bootloader entry (GRUB -> long mode)
│ ├── kernel.c # Main kernel entry point
│ ├── kernel.h # Kernel API and platform defines
│ ├── Makefile # Build system (clang-21 cross-compiler)
│ ├── link.ld # Linker script
│ ├── grub.cfg # GRUB boot config (1024x768 framebuffer)
│ ├── multiboot2.h # Multiboot2 structures
│ ├── gdt.c / idt.c # GDT/IDT setup for protected/long mode
│ ├── pic.c / pit.c # Interrupt controller and timer
│ ├── pmm.c / vmm.c # Physical & virtual memory managers
│ ├── heap.c # Kernel heap allocator
│ ├── scheduler.c # Cooperative thread scheduler
│ ├── display.c # Framebuffer drawing primitives
│ ├── font.c # PSF font renderer (8x16 bitmap)
│ ├── keyboard.c # PS/2 keyboard driver
│ ├── mouse.c # PS/2 mouse driver (absolute positioning)
│ ├── pci.c # PCI bus enumeration
│ ├── virtio_net.c # VirtIO network adapter driver
│ ├── net.c / arp.c # Ethernet + ARP layer
│ ├── ip.c / icmp.c # IP + ICMP (ping) layer
│ ├── tcp.c # TCP state machine (SYN/SYN-ACK/ACK/DATA/FIN)
│ ├── dns.c # DNS resolver (UDP, callback-based)
│ ├── http.c # HTTP 1.0 GET client
│ ├── html_parse.c # Recursive-descent HTML DOM parser
│ ├── css_minimal.c # Tag->CSS style mapping (bold, italic, block, etc.)
│ ├── layout.c # Flow layout engine (word-wrap, margin, block)
│ ├── render.c # Box renderer (styled text, images, links)
│ ├── link_map.c # Clickable link rectangle builder
│ ├── browser.c # Web browser app (history, links, navigation)
│ ├── desktop.c # GUI desktop (window manager, taskbar)
│ ├── window.c # Window abstraction (z-order, draw, click)
│ ├── fbterm.c # Framebuffer terminal emulator
│ ├── shell.c # Command-line shell
│ ├── editor.c # Text editor app
│ ├── fileman.c # File manager app
│ ├── sysmon.c # System monitor app
│ ├── vfs.c # Virtual filesystem
│ └── support.c # String/memory utilities
└── README.md
MIT License — see LICENSE for details.
This project is under active construction — it is a research tool for testing the limits of current AI agent swarms and frameworks. Nothing here is stable or final. Everything is an experiment.
Getting a working browser was one of the toughest parts — a full TCP/IP stack from scratch, DNS resolution, HTTP parsing, then a DOM engine, layout, and styled renderer all had to align before a single webpage appeared on screen. If you want another project that pushes the same boundaries, try a physics engine from scratch: constraint solvers, collision detection, continuous integration tests in a simulated environment — it exercises the same kind of cross-layer reasoning that separates toy demos from real working systems.
Built in the open. For the curious. For the future.
"The best way to predict the future is to build it."