Build a real UEFI-native operating system from scratch. The complete path to a polished desktop is free. Paid members continue through storage, networking, applications and DOOM.
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.
The supplied R32 baseline is verified to reach its clean desktop in QEMU. The course then shows you how to test compatible UEFI hardware, record the exact machine and EFI hash, and treat uncached framebuffers, DMA alignment and firmware quirks as measured results—not universal promises.
Compositor, windows, a file manager, settings, a hand-written TCP/IP stack and USB. You can inspect each real subsystem, interact with the booting desktop, then integrate and verify the archive's DOOM port.
Modules 01–04 are free and end with a decent bootable desktop. Every paid plan unlocks all written sections. Downloads depend on your plan.
Install the toolchain, build a UEFI application, boot it in QEMU or from USB, and draw correctly into the firmware framebuffer.
Own the memory map, install interrupt handling, bring up timer and keyboard input, and establish the kernel foundations.
Build double buffering, dirty-region rendering, text and the drawing primitives required by the desktop.
Finish the free path with draggable windows, a desktop, consistent controls and a bootable visual system.
Read and write real files, load assets and make the OS useful beyond the initial desktop.
Bring up Ethernet and build the network layers required for connected ForgeOS applications.
Integrate doomgeneric, provide display/input/time/file callbacks, use a legally obtained WAD and verify the port in QEMU before real hardware.
Protected processes, user memory, ELF loading, file descriptors, threads, shared objects and native applications.
AHCI, NVMe, USB storage, display modes, CPU capabilities, memory pressure and performance profiling.
HTTP/TLS, certificates, package detection, downloads, updates and the path from network stack to a usable web client.
VMX capability, guest memory, executable/runtime requirements and the staged route toward hosted emulation.
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. if (wc_policy_validated(fb_base, fb_size)) enable_write_combining(fb_base, fb_size);
All paid plans unlock every written section. A$9/month is reading only. A$39/month adds every Section 1 download through DOOM. Lifetime includes all current and future important-module and section downloads.
Secure card checkout is handled by Stripe. Apple Pay and Google Pay appear when supported by the customer’s device and your Stripe settings.
Module 01 is completely free — the toolchain, the UEFI entry point, and your first pixels in QEMU, followed by a bounded physical test. No account, no card. Just build it.
Open module 01 →