Make it boot.
Write the early code that takes control of the machine and brings your kernel to life.
BOOTLOADER → KERNEL THE COMPLETE PEACHOS COURSE SERIES
Build your own
operating
system.
From your first boot sector to a
64-bit graphical desktop.
Go beneath the frameworks. Follow Daniel McCarthy through C, x86 assembly, memory, filesystems and user applications. Understand the machine by building what runs it.
3 connected courses
70+ hours of video Lifetime access
$199.00One payment.
All included courses.
All included courses.
PEACHOS / PROJECT EXPLORER
PeachOS v2.0.0 — 64 bit mode
Browser preview · type help for commands
> calc
Calculator opened. Try 6 * 7.
YOUR FIRST GUI APPLICATION
Integer maths · evaluated left to right
FOLLOW ONE FILE READ
One call. Several layers.
- 01 User program
- 02 C library
- 03 System call
- 04 Filesystem
- 05 Your bytes
your-program.cC · example
// fd is an already-open file.char buffer[64];int result = fread( buffer, 1, sizeof(buffer), fd);stdlib/src/file.cC · excerpt
int fread(void* buffer, size_t size, size_t count, long fd){ return peachos_fread( buffer, size, count, fd);}stdlib/src/peachos.asmNASM · excerpt
peachos_fread: mov rax, 12 ; fread command ; ...four arguments pushed... int 0x80 ; enter the kernel add rsp, 32 ; restore the stack retsrc/fs/file.cC · excerpt
// ...validate fd and look up desc...res = desc->filesystem->read( desc->disk, desc->private, size, nmemb, (char*) ptr);out:return res;src/fs/fat/fat16.cC · excerpt
res = diskstreamer_read( stream, out, total_to_read);// ...check errors, advance...bytes_read += total_to_read;// ...finish loop; check errors...return bytes_read;Your program asks to read from an open file. The highlighted call starts the journey.
MAKE MEMORY VISIBLE
Virtual addresses. Real pages.
A simplified model: consecutive virtual pages can map to separate physical frames.
VIRTUAL PAGES
V0V1V2V3
PHYSICAL FRAMES
01234567
No pages mapped. Allocate a page to reveal its physical frame.
01 /
Clicks become events. Events become actions. You build both the window system and the application.
View sourceInteractive browser recreation · the course builds the real C / assembly kernel.
This is where you’re heading. Try the calculator. Drag a window. Explore what happens underneath.
Built with C & x86 assemblyLearn by writing a real kernelSource code you can exploreAlready own Part 1? Get Part 2
THE PROJECT IS THE POINT
From “how does that work?”
to “I built that.”
You use an operating system every day. Now build the layers that make one work, with a visible result at every stage.
Give it a foundation.
Manage memory, load executable files and switch between tasks in your own kernel.
MEMORY → PROCESSESMake it respond.
Draw windows, handle mouse events and connect user applications to kernel services.
SYSTEM CALLS → GUIONE PROJECT. A CONNECTED LEARNING PATH.
Start at the first instruction.
Keep going to the desktop.
Work through the series in order. Each course gives you the foundations for the next, with explanations alongside the code.
Part 1 INCLUDED
Make the machine yours.
Start at the boot sector. Build a kernel that manages memory, reads files and runs programs.
- Real mode, assembly and your bootloader
- Protected mode, interrupts and paging
- FAT16, ELF loading and multitasking
YOUR RESULTYour own 32-bit multitasking kernel
29h 30m of video
View full curriculumPart 2 · Module 1 INCLUDED
Step into 64-bit.
Take PeachOS into long mode. Turn a framebuffer into graphics and rebuild the foundations underneath.
- UEFI boot and 64-bit foundations
- Pixels, fonts and a graphical terminal
- Multi-heap allocation and GPT partitions
YOUR RESULTA 64-bit kernel with graphics foundations
21h 12m of video
View full curriculumPart 2 · Module 2 INCLUDED
Bring your OS to life.
Connect the kernel to a usable interface. Build windows, handle clicks and run graphical applications.
- Draggable windows and GUI events
- User-space C library and system calls
- PCI/PCIe enumeration and NVMe storage
YOUR RESULTAn interactive graphical operating system
19h 47m of video
View full curriculumPart 1 starts with legacy BIOS and 32-bit foundations. Part 2 moves into UEFI and 64-bit development. Video duration is viewing time; allow additional time to code, debug and experiment.
CHALLENGING. BUILDABLE. YOURS.
You don’t need to know
how to build a kernel.
That’s what we’ll learn.
This series is for programmers who want to understand computers at a deeper level. Bring a working knowledge of C, some assembly familiarity, and the patience to debug.
Try the free NASM bootloader tutorialA QUICK PREREQUISITE CHECK
Does this sound like you?
Tick the skills you’re comfortable with.
A little preparation makes the first lessons much easier.
YOUR INSTRUCTOR · DANIEL MCCARTHY
Build it with the person
who wrote it.
The PeachOS source is public. The course gives you the guided progression: how the pieces fit together, why the code is there, and how to build it up yourself.
Follow Daniel through the project in recorded lessons. Pause, implement, revisit an explanation, and move on when you’re ready.
Explore the course project on GitHubBEFORE YOUR FIRST BOOT
A few practical
questions.
Still unsure whether this is your next project?
Ask DragonZapWhat exactly do I get?
One purchase gives you lifetime access to the 3 courses listed above in your DragonZap account, including their lessons and course resources. Work through them at your own pace. This bundle is a one-time purchase.
Is this suitable for a complete programming beginner?
Learn the basics of C first, especially pointers, functions and structs. Some assembly familiarity helps. Part 1 introduces kernel development from the boot process, but it is not a first course in programming.
What computer and tools will I need?
The project targets x86 and x86-64. Development uses a compiler/toolchain, a terminal and an emulator. The Part 2 repository runs QEMU with OVMF for UEFI. Check the setup lessons in each curriculum before buying; Windows and macOS may need a suitable Linux environment. An ARM Mac does not run this x86-64 kernel natively.
You can study using an emulator. Physical hardware compatibility depends on the drivers implemented; this is an educational OS project.
Is the interactive preview running the real kernel?
The preview is a browser recreation of selected PeachOS behaviours, plus simplified file-read and memory visualisations. It lets you explore the ideas without a download. In the courses you write and run the actual C and assembly project. The source links beside the preview show the relevant implementation.
Can I finish it in the video running time?
Allow extra time for setup, writing code, debugging and trying your own changes. The running time describes the recorded lessons. You have lifetime access, so you can revisit difficult topics and set your own pace.
I already own Part 1. What should I buy?
Check your existing courses first. If you already own Part 1 and want the 64-bit continuation, view the Part 2 series, which contains Module 1 and Module 2.
Why take the course if the source code is public?
The source shows the implementation. The lessons guide you through building it, explaining the structures, decisions and connections as you go. You are buying a structured way to learn the project, with the code available to inspect alongside it.
YOUR NEXT BIG PROJECT STARTS HERE
Don’t just use
an operating system.
Build one.
First boot. First process. First window.
Learn what happens underneath every one of them.
THE COMPLETE PEACHOS SERIES
One project. All the stages.
- 3 connected courses
- 70+ hours of recorded lessons
- Course source code and resources
- Lifetime access. Learn at your own pace.
$199.00One-time payment
Offer available until 14 Sep 2026.
Continue through your DragonZap account to purchase.
Already have Part 1? Explore Part 2 →