Make it boot.
Write the early code that takes control of the machine and brings your kernel to life.
BOOTLOADER → KERNEL PART 1 + PART 2, MODULES 1 & 2
Build your own
operating system.
One guided path from your first boot sector to a 64-bit graphical desktop.
3 courses: Part 1 + both Part 2 modules
70+ hours of video Lifetime access
$257.00One payment
for all 3 courses
for all 3 courses
Buying separately: $878.97 Save $621.97
New here? Create your free account first, then continue to checkout. Already registered? Sign in from that page.
Secure checkout · One-time purchase · Lifetime course access
Build the real PeachOS project in C and x86 assembly with Daniel McCarthy. Write the bootloader, multitasking kernel, 64-bit foundations and graphical applications.
EXPLORE WHAT YOU’LL BUILD
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.
Try the ideas in your browser. This interactive recreation shows the destination. The lessons guide you through the real C and assembly project.
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 → GUIEXACTLY WHAT’S IN THE BUNDLE
Part 1. Module 1. Module 2.
One operating system.
Start at the bootloader and work through the series in order. Each course builds the foundations for the next, with explanations alongside the code.
Part 1 INCLUDED
Build a 32-bit multitasking kernel
Developing a Multithreaded Kernel From Scratch
29h 30m of recorded lessons
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
Watch course preview
Part 2 · Module 1 INCLUDED
Move to 64-bit and add graphics
Developing a Multithreaded Kernel From Scratch: Part Two - Module One
21h 12m of recorded lessons
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
Watch course preview
Part 2 · Module 2 INCLUDED
Build windows and user applications
Developing a Multithreaded Kernel From Scratch: Part Two - Module Two
19h 47m of recorded lessons
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
Watch course preview
Part 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.
Ready to start at the bootloader? All 3 courses for $257.00.
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. These courses make up the complete Developing a multi-threaded kernel from scratch series. Work through them at your own pace. This bundle is a one-time purchase.
What happens when I click the purchase button?
If you’re new to DragonZap, you’ll create a free account first. Existing students can sign in. Your selected bundle then takes you straight to checkout. You can review the order before paying.
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.
PART 1 + PART 2 MODULES 1 & 2
The whole PeachOS learning path.
- 3 connected courses
- 70+ hours of recorded lessons
- Course source code and resources
- Lifetime access. Learn at your own pace.
$257.00One-time payment
Buying separately: $878.97 Save $621.97
Secure checkout · No subscription
Offer available until 18 Oct 2026.
Create a free account or sign in, then review your order at checkout.
Already have Part 1? Explore Part 2 →