Most OS tutorials stop at a text kernel booting in an emulator. This one doesn't. You start with an empty file and finish with your own operating system — windows, files, settings, a network stack — booting off a USB stick on your actual laptop. Then you run DOOM on it, because of course you do.
Every free OS-dev resource teaches the same thing: legacy BIOS, QEMU, a kernel that prints text and stops. That path skips the two questions that actually stump people — how do I get off the emulator, and how do I do any of this under UEFI instead of BIOS. This course is built entirely around those.
No 16-bit real mode, no GRUB, no bootloader you didn't write. Your code is what the firmware loads. This is how machines actually boot today — and almost nobody teaches it.
Every phase ends on physical hardware. You'll hit the bugs emulators hide — uncached framebuffers, DMA alignment, firmware quirks — and learn to read the machine, not the emulator's polite fiction.
Compositor, windows, a file manager, settings, a hand-written TCP/IP stack, USB. You build a system a person can actually use — then you boot DOOM on it to prove it's real.
Four phases. Each one ends with something running on real hardware. Module 01 is free — read the whole thing, write the code, boot it, before you pay for anything.
Empty file → a UEFI app the firmware runs → a USB stick that boots → the Graphics Output Protocol → your own logo drawn on your real screen. The whole toolchain and the whole first win.
Take the firmware's memory map and build your own physical memory manager. Install an IDT, wire up the timer and keyboard, and make the machine respond to you.
Double buffering, dirty rectangles, and a write-combined framebuffer so big displays don't crawl. Draw rectangles, text, and rounded windows — the primitives everything else is built on.
A window manager, draggable and resizable chrome, a dock, and a desktop. Build a small UI toolkit so every app shares one consistent, themeable look.
Bring up the xHCI controller, claim it from the firmware, talk to a USB drive over Bulk-Only Transport, and read & write real FAT32 files. Then a working file manager on top.
Drive the Ethernet NIC directly, then hand-write ARP, IP, ICMP, and TCP. Watch your OS answer a ping and open a socket using nothing but code you wrote. Settings, Wi-Fi status, NetMon.
Port doomgeneric onto your OS: WAD loading off your filesystem, your framebuffer as its display, your keyboard as its input. The universal proof that you built something real.
I detached UEFI's own USB driver mid-boot and the firmware started spamming write errors. I hit a 64 KB DMA boundary that silently corrupted transfers. I shipped a UI that ran flawlessly in QEMU and black-screened on real silicon. You'll learn this from someone who has already walked into every one of these walls.
// PixelsPerScanLine != HorizontalResolution // works in QEMU, shears diagonally on real panels buf[y * pitch + x] = color; // RIGHT buf[y * width + x] = color; // WRONG — the trap // firmware left the framebuffer UNCACHED: // 3.7M single bus writes per fill on a 1440p panel. // instant in QEMU, a slideshow on metal. enable_write_combining(fb_base, fb_size);
The full source of a working OS comes with every option. Buy it outright and it's yours forever, or subscribe while the course is still growing.
Drag sliders for window radius, titlebar height, icon size, and taskbar position.
Pick an accent. Watch a live ForgeOS desktop update as you go — then export the
real forge_chrome.h
and theme files that produce your design. Nobody else has built this.
Module 01 is completely free — the toolchain, the bootloader, and your first pixels on real hardware. No account, no card. Just build it.
Open module 01 →