Introduction
1 Lessons
4M
- 1. Introduction 4m 20s
Developing a Multithreaded Kernel From Scratch: Part Two - Module Two
Created by
Daniel McCarthy
Best Seller!
Lifetime Access
Certificate Included
About this course
This course is the continuation of Part 2 Module 1, where we continued building the 32-bit PeachOS kernel, into a fully functioning 64-bit multitasking operating system. In Part 2 Module 2, we take the project to the next level by continuing the development from Module 1. By the end of this course you will have a fully functioning 64-bit operating system capable of GUI windows, task scheduling and more. Keep reading for the full details.
Part 2 - Module 2 (This Module)
Module 2 builds directly on the work from Module 1 and focuses on turning the kernel into a full graphical operating system with multitasking, drivers, and a rich user experience.
You will:
— Expose standard C library functions (fopen, fread, etc.) to userspace through isr80h.
— Build the complete windowing system, with support for fully interactive GUI elements.
— Implement an NVMe SSD driver, enabling high-speed reads from modern solid-state storage.
— Add full PCI/PCIe support, including bridges, making the kernel capable of scanning and interacting with a wide variety of devices.
— Building a disk streamer cache to speed up program loading by 10x to 20x.
— Access a GitHub repository of user programs that you can run directly on your OS. You’ll even be able to submit pull requests to share your own user-space programs with other students in the course.
By the end of this module, you’ll have created a multi-threaded, 64-bit, GUI operating system from scratch bootable on modern hardware and extensible enough to run real user applications.
Skill Level
Intermediate
Total Length
19H 46M
Lessons
106
Your Progress
Start anytime
What you'll learn
- Build a 64-bit multitasking kernel from scratch
- Write a UEFI bootloader to boot on modern hardware
- Switch the CPU into long mode (x86-64) and run your kernel there
- Capture and use the UEFI framebuffer to draw pixels directly to the screen
- Load and render images and fonts in your OS
- Build a graphical terminal system capable of text rendering via pixels and fonts
- Design a hierarchical graphics system supporting relative drawing and child graphics
- Implement a dynamic multi-heap memory allocator using E820 memory regions
- Create a memory defragmenter using paging to provide continuous virtual memory blocks
- Extend the FAT16 filesystem to support multiple GPT partitions and virtual drives
- Abstract and rewrite the disk system to support multi-partition mounting
- Lay the groundwork for a full GUI windowing system with draggable, clickable elements
- Prepare to add userspace stdio functions, PCI, and NVMe drivers in later modules
Who this course is for
- Programmers who want to understand operating systems at a low level
- Developers interested in kernel and OS design from scratch
- Students of computer science, systems programming, or embedded systems
- Hobbyists who enjoy building their own OS or experimenting with bare-metal programming
- Engineers who want to learn modern 64-bit, UEFI-based booting and kernel development
- Anyone curious about memory management, paging, and heap design in kernels
- Developers who want hands-on experience with graphics, terminals, and GUI systems
- Programmers looking to implement file systems, disk drivers, and PCI/NVMe support
- Learners who enjoyed Part 1 (PeachOS) and want to continue into 64-bit multi-threaded kernels
- Advanced C programmers seeking a real-world project that pushes their skills
Requirements
- A computer (Windows, macOS, or Linux) capable of running QEMU/VirtualBox/VMware
- Basic knowledge of C programming (pointers, structs, functions)
- Familiarity with x86 assembly language at a beginner level (recommended)
- Understanding of basic computer architecture concepts (CPU, RAM, stack, registers)
- A code editor or IDE of your choice (VS Code, CLion, Vim, etc.)
- Willingness to use the terminal/command line for building and testing the OS
- GCC or Clang toolchain installed (I’ll show you how to set it up)
- (Optional but recommended) Completion of Part 1: Developing a Multitasking Kernel From Scratch a.k.a Kernel Development For Beginners Tutorial
Curriculum
106 Lessons • 19H 46M
Filesystem And Memory Management
11 Lessons
2H 38M
- 1. Implementing FOPEN in userland 29m 5s
- 2. Implementing FCLOSE in userland 9m 45s
- 3. Implementing FREAD in userland 9m 41s
- 4. Improving our memory managment system for processes - part 1 25m 23s
- 5. Improving our memory managment system for processes - part 2 22m 27s
- 6. Compiling and testing FREAD 6m 9s
- 7. Implementing FSEEK in userland 9m 43s
- 8. Implementing FSTAT in userland 12m 33s
- 9. Moving the task paging descriptor into the process 6m 54s
- 10. Making the process list use vectors 10m 50s
- 11. Making the process_realloc function 15m 46s
Windowing System
8 Lessons
2H 14M
- 1. Creating some essential graphics functions 36m 58s
- 2. The Window System In Detail 15m 31s
- 3. Building the Window header files 13m 44s
- 4. Building the Window source files part 1 16m
- 5. Building the Window source files part 2 19m 36s
- 6. Building the Window source files part 3 13m 11s
- 7. Building the Window source files part 4 8m 39s
- 8. Building the Window source files part 5 11m 16s
CPU
6 Lessons
42M
- 1. Understanding CPUID 3m 30s
- 2. Implementing CPUID in our kernel 5m 53s
- 3. Understanding the TSC Frequency And Delay Functionality 4m 2s
- 4. Using the TSC Frequency And Implementing Delay Functionality 17m 8s
- 5. Using the TSC Frequency And Implementing Delay Functionality Part 2 10m
- 6. Using the TSC Frequency And Implementing Delay Functionality Part 3 1m 30s
Mouse and Graphics
18 Lessons
2H 49M
- 1. Understanding the mouse 10m 19s
- 2. Building mouse abstraction 21m 54s
- 3. Building mouse abstraction - Part 2 10m 44s
- 4. Implementing window_position_set function 12m 47s
- 5. Implementing graphics_info_recalculate 4m 7s
- 6. Implementing window_redraw and testing our windows 3m 2s
- 7. Implementing the PS2 mouse 19m 34s
- 8. Implementing the PS2 mouse - Part 2 17m 22s
- 9. Implementing the PS2 mouse - Part 3 3m 34s
- 10. Implementing the PS2 mouse - Part 4 , Testing the mouse 2m 24s
- 11. Implementing click handlers for graphics 20m 45s
- 12. Implementing move handlers for graphics 4m 48s
- 13. Registering mouse event listeners in windows and implementing the click handler 7m 29s
- 14. Implementing the window_click function 2m 33s
- 15. Implementing the window helper functions 11m 42s
- 16. Pushing events for focus and unfocus 2m 18s
- 17. Dealing with title bar clicks 6m 50s
- 18. Moving windows with the mouse 7m 14s
Windowing System - Stage two
27 Lessons
3H 59M
- 1. Fixing compile errors with the graphics and windows 3m 40s
- 2. Fixing common runtime errors identified in graphical and window system 5m 40s
- 3. Testing our windows 1m 46s
- 4. The translation layer for graphics and windows in user space 11m 16s
- 5. Creating userland pointers 12m 28s
- 6. Creating windows from userspace - part one 15m 39s
- 7. Creating windows from userspace - part two 8m 33s
- 8. Creating windows from userspace - part three 6m 31s
- 9. Creating windows from userspace - part four 3m 36s
- 10. Diverting stdout to a window 11m 13s
- 11. The link between kernel window events and userspace 7m 13s
- 12. Creating the window event functionality for processes - part one 12m 13s
- 13. Creating the window event functionality for processes - part two 6m 57s
- 14. Creating the window event functionality for processes - part three 17m 33s
- 15. Creating the isr80h function to get events in user space 5m 21s
- 16. Calling the isr80h get event function from userspace 7m 36s
- 17. Accessing the graphics info of a window from userspace 14m 5s
- 18. Getting the pixels buffer of a graphics info entity to use in userspace 18m 25s
- 19. Creating ability for user space to redraw windows 3m 39s
- 20. Compiling our changes 3m 38s
- 21. Testing the drawing of pixels in our userspace application 8m 37s
- 22. Binding the window redraw to ISR80H 1m 41s
- 23. Creating relative graphics from userspace 12m 43s
- 24. Redrawing window regions in userspace 5m 37s
- 25. Updating window properties from userspace 10m 31s
- 26. Implementing keyboard events and handlers 15m 32s
- 27. Implementing the window keyboard listener 7m 19s
PCI And Implementation
6 Lessons
2H 6M
- 1. Understanding PCI 30m 56s
- 2. Implementing the PCI header files 15m 52s
- 3. Implementing the PCI source files part one 26m 20s
- 4. Implementing the PCI source files part two 23m 53s
- 5. Implementing the PCI source files part three 25m 46s
- 6. Implementing the PCI source files part four 3m 37s
Disk Driver Improvements
8 Lessons
1H 14M
- 1. Upgraded disk abstraction and disk drivers 4m 49s
- 2. Attaching hardware disk to the disk structure and basic driver metadata 6m 42s
- 3. Creating the disk driver header file 8m 39s
- 4. Creating the disk driver source file 12m 35s
- 5. Rewriting our disk code to work with the disk driver abstraction 7m 50s
- 6. Implementing the pata disk driver header file 3m 58s
- 7. Implementing the pata disk driver source file 25m 48s
- 8. Finalizing and testing our pata driver 3m 52s
NVMe SSD Disk Driver
6 Lessons
1H 58M
- 1. All About NVMe 23m 26s
- 2. Implementing the NVME header file 11m 33s
- 3. Implementing the NVME source file - part one 30m 36s
- 4. Implementing the NVME source file - part two 27m 18s
- 5. Implementing the NVME source file - part three 18m 13s
- 6. Implementing the NVME source file - part four compile and testing 7m 42s
Task sleeping and keyboard events
4 Lessons
23M
- 1. Fixing the keyboard events on userspace 1m 22s
- 2. Implementing ability for tasks to sleep 7m 53s
- 3. Implementing ability for tasks to sleep in userspace 12m 15s
- 4. Implementing ability for tasks to sleep in userspace part two 1m 36s
Small optimizations
3 Lessons
7M
- 1. Rewriting the makefiles 4m 56s
- 2. Fixing process realloc bug 1m 56s
- 3. Calling int 0x80 in fclose 32s
Disk Streamer Cache
5 Lessons
52M
- 1. Implementing the disk stream cache header files 15m 27s
- 2. Implementing the disk stream cache source files - part one 12m 13s
- 3. Implementing the disk stream cache source files - part two 19m 41s
- 4. Implementing the disk stream cache source files - part three 3m 57s
- 5. Implementing the disk stream cache source files - part four 1m 25s
Finishing up
3 Lessons
36M
- 1. Installing dependency libraries for our userspace and running the calculator 8m 22s
- 2. Explaining how to use the GUI SDK 22m 25s
- 3. Rules for contributing 5m 32s
- 0.00 instructor rating
- 1 courses
- Systems students worldwide
Daniel McCarthy
Learn from DragonZap instructors with practical, build-first lessons focused on systems, low-level programming, compilers, kernels, and real-world engineering fundamentals.
Systems programming
Low-level concepts
Practical projects
Student reviews
chulyean jang
===== 26/04/05/sun 14:00 ===== Wow! Your lecture is the Fantastic. I learned about OS, Kernel, bootloader, Asm, Compiler, etc ... . I think that Now I am a Software Engineer! Very Very thank you!
