Developing a Multithreaded Kernel From Scratch: Part Two - Module One

$315.99

Description

This course is the continuation of Part 1, where we built PeachOS, a fully functioning 32-bit multitasking operating system. In Part 2, we take the project to the next level: building a 64-bit multi-threaded kernel that runs in long mode with a graphical user interface (GUI) capable of rendering interactive, clickable, and draggable windows.

This isn’t just theory—you’ll be building a complete, modern OS step by step, starting from the bootloader all the way up to a graphical desktop environment.
Module 1 Overview

In the first module of Part 2, we focus on the foundations of a modern 64-bit kernel. We migrate from 32-bit protected mode into 64-bit long mode, create a UEFI bootloader, and lay down the critical systems that will later allow us to support GUIs, multitasking, and advanced storage.

Here’s what we cover in detail:
🔹 Graphics & Display

— Capture and take control of the UEFI framebuffer, giving us the ability to write pixels directly to the screen.
— Implement full support for loading images and fonts.
— Build a terminal system that uses pixel-based fonts to render text directly onto the display.
— Design a graphical subsystem on which the terminal itself is built. This includes:
— Relative drawing anywhere on the screen.
— Hierarchical graphics (parents and children, with relative offsets).
— A system that allows complex UI elements to be composed cleanly and drawn efficiently.

🔹 Memory Management

— Rebuild the heap allocator so that it dynamically uses the E820 memory map provided by UEFI/BIOS, instead of relying on a fixed memory region.
— Develop a multi-heap system, capable of merging multiple heaps into a unified allocator that intelligently chooses blocks for allocation.
— Implement a paging-based memory defragmenter that can remap scattered free regions into a single continuous block of memory—solving fragmentation issues and maximizing usable RAM.

🔹 Disk & Partitions

— Extend our FAT16 filesystem to support multiple GPT partitions.
— Mount each partition as a virtual drive, allowing the OS to work with multiple logical disks simultaneously.
— Redesign and abstract the disk system to support this multi-partition model, preparing the kernel for future support of modern storage hardware like SSDs.

✅ By the end of Module 1, you’ll have:

— A 64-bit kernel bootable on modern UEFI systems.
— A fully functional terminal with a graphical foundation underneath.
— An advanced heap allocator with defragmentation support.
— A multi-partition disk subsystem capable of treating different GPT partitions as separate drives.
— The core building blocks required for a GUI-based operating system.

Coming in Module 2 (Estimated Release: December 2025)

Module 2 builds directly on this foundation 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.
— 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 Part 2, 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.

Special Discount for Early Students

🎉 SUPER DISCOUNT OFFER: If you purchase Module 1 before Module 2 is released, you will be able to obtain Module 2 for just 34.99 EUR (or equivalent in your currency). Just email me at daniel@dragonzap.com

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

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

What You Will be 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

Introduction

4 Lessons

0H 35M

1. Introduction

2m 10s

2. Course Detail

8m 1s

3. 64 Bit Long Mode Explained

11m 44s

4. Downloading and building a 64 bit cross compiler

13m 27s

Preparing Our Project And Getting to long mode

4 Lessons

1H 3M

5. Cloning PeachOS and preparing our project

6m 51s

6. How do you get to long mode

11m 59s

7. Rewriting our bootloader to get to 64 bit long mode

33m 29s

8. Getting from kernel.asm back to kernel.c in long mode

11m 4s

Restoring our kernel functionality to work in long mode

60 Lessons

10H 7M

9. Restoring simple terminal functionality

3m 58s

10. Restoring heap functionality

7m 36s

11. Changing pages from 2MB to 4KB

11m 43s

12. Restoring and Improving Page Mapping Systems In Our C Code - Part One

19m 23s

13. Restoring and Improving Page Mapping Systems In Our C Code - Part two

49m 24s

14. Restructuring build files

4m 14s

15. Abstracting out kernel paging functionality

3m 11s

16. Allowing kernel heap to have a dynamic size

14m 9s

17. E820 Memory Maps

6m 55s

18. Building the E820 Memory Map functionality

22m 11s

19. Multi-heap explained

11m 3s

20. Building our multi-heap - Part 1

47m 44s

21. Page Mapping Present only available E820 memory

6m 23s

22. Building our multi-heap - Part 2

6m 43s

23. Building our multi-heap - Part 3

16m 37s

24. Building our multi-heap - Part 4

11m

25. Building our multi-heap - Part 5

14m 29s

26. Creating callback handlers for our individual heaps

7m 30s

27. Building our multi-heap - Part 6

18m 1s

28. Building our multi-heap - Part 7

15m 35s

29. Building our multi-heap - Part 8

12m 23s

30. Building our multi-heap - Part 9

25m 28s

31. Implementing the paging_get and missing paging functions

10m 15s

32. Calling multiheap_ready

2m 43s

33. Reimplementing the IO to work for 64 bit

8m 16s

34. Loading more sectors of our kernel in boot.asm

42s

35. 64 Bit pushad and popad and making IDT 64 bit

3m 35s

36. Remaking idt.asm to work with 64-bit code

4m 39s

37. Remaking idt.c to work with 64-bit code

13m 58s

38. Testing our upgraded 64 bit idt

7m 59s

39. Adding user segment descriptors to the GDT

2m 51s

40. Rebuilding the task system to be 64-bit

20m 47s

41. Rebuilding the task system to be 64-bit - Part two

5m 42s

42. Rebuilding the process system to be 64 bit

5m 7s

43. Implementing paging_desc_free in paging.c

6m 49s

44. Implementing kernel_desc and moving paging prototype function

1m 27s

45. Testing our changes

5m 48s

46. Bringing FAT16 into 64 bit mode

2m 38s

47. Bringing the disk functionality into 64 bit mode

48. Bringing process functionality into 64 bit mode

1m 51s

49. Building GDT and TSS C Code

14m 31s

50. Finalizing TSS code and Initializing it in the kernel

18m 53s

51. Creating GDT Descriptors for TSS

2m 10s

52. Restoring the disabled IDT functionality

4m 7s

53. Restoring the keyboard

2m 18s

54. Registering the isr80h commands

4m 8s

55. Loading the TSS

2m 9s

56. Refactoring the isr80h commands to work in 64 bit long mode

5m 17s

57. Calling initializers of many subsystems we have refactored

3m 6s

58. Creating a simple user program ready for 64-bit loading

6m 46s

59. Loading our simple user program part 1

4m 52s

60. Loading our simple user program part 2

4m 53s

61. Remapping the PIC

11m 48s

62. Rebuilding STDLIB to work with 64 bit long mode

12m 54s

63. Re-enabling ELF files and making the loader work on long mode

5m 36s

64. Filesystem and Disk bug fixes

19m 26s

65. Refactoring our ELF32 loader to load ELF64 files

25m 39s

66. Fixing a bug in the IDT and running our first ELF program in 64 bit mode

1m 56s

67. Implementing the IRQ C code to allow us to enable or disable PIC interrupts

11m 5s

68. Updating our keyboard driver to re-enable the keyboard IRQ + Testing shell.elf

3m 13s

Building UEFI bootloader to modern boot our kernel

8 Lessons

2H 17M

69. Understanding UEFI and EFI SDK

15m 20s

70. Downloading and setting up EDK2 SDK

13m 43s

71. Compiling and executing our EDK2 module

19m 37s

72. The changes we will make to our filesystem and disk drivers

4m 58s

73. Loading kernel.asm bootloader from UEFI

48m 11s

74. Fixing kernel.asm to survive the UEFI boot process

9m 30s

75. Being able to detect free memory regions again

21m 41s

76. Solving unmapped kernel problem

4m 41s

Optimizations And Upgrades

8 Lessons

1H 45M

77. Writing code to read and decode the partition tables

23m 14s

78. Creating the ability to have virtual disks that point to partitions

28m 40s

79. Creating the ability to be able to read the volume name from a filesystem

10m 35s

80. Building the krealloc function

22m 11s

81. Path parsing symbolic link to system filesystem

5m 36s

82. Compiling our GPT and calling gpt_init

3m 8s

83. Improving our disk streamer

6m 33s

84. FAT16 changes and running our user program again

5m 15s

Graphical System

19 Lessons

5H 23M

85. Graphics, Windows And Framebuffers

14m 29s

86. Injecting the framebuffer pointers into our kernel from UEFI

21m 11s

87. Graphic Foundations and Creating simple graphics in our kernel

1h 36s

88. Opening image files in our kernel part 1 image abstraction

27m 5s

89. Opening image files in our kernel part 2 BMP image loader

34m 13s

90. Drawing images to the screen

10m 27s

91. The Font system explained

7m 1s

92. Implementing the font system - part 1

26m 14s

93. Implementing ability to redraw graphics to the framebuffer at a rectangle region

15m 14s

94. Implementing the font system - part 2

10m 3s

95. Drawing text to the screen

6m 5s

96. Creating the terminal functionality - part 1

15m 47s

97. Creating the terminal functionality - part 2

27m 34s

98. Creating the terminal functionality - part 3

19m 24s

99. Implementing graphics transparency and ignore keys and drawing of rectangles

6m 21s

100. Creating the terminal functionality - part 4

13m 46s

101. Redrawing the enitre background as black and testing our terminal

1m 10s

102. Running programs in the shell and making fonts

4m 16s

103. Module 1 summary

2m 17s

Daniel McCarthy

Dragon Zap Instructor

4.90 Star Rating

15 Courses

Dragon Zap Instructor

Daniel McCarthy is a seasoned software engineer, boasting an impressive career spanning over 14 years in the industry. Holding a Master's Degree in Advanced Computer Science from Cardiff Metropolitan University, his broad spectrum of experience encompasses everything from web development to complex compiler and interpreter development. Daniel has honed his skills in bootloader and kernel development. In testament to his proficiency in the field, he has designed two proprietary programming languages: Craft, a general-purpose language, and Marble, a web-focused language akin to PHP. Moreover, he has successfully developed compilers for the C programming language. A testament to his versatility, Daniel demonstrates proficiency in an extensive list of programming languages that includes C, C++, Java, x86 Assembly language, PIC assembly, SQL, PHP, HTML5, JavaScript, CSS, and of course, his own creations, Craft and Marble. His professional portfolio also includes the development of Linux kernel modules, a task he has executed with proficiency in a professional context. Currently, Daniel is channeling his wealth of experience and expertise into the education sector, with the aim of nurturing the next generation of professional software engineers.

0.0

Course Rating

Students Feedback (0)

Sort by:

$315.99

This course includes:

Full Lifetime Access
30 Days Money Back Guarantee
Free Exercises File
Watch online or offline
Certificate of Completion