$171.09

~~$294.99~~

Developing a Multithreaded Kernel From Scratch: Part Two - Module Two course preview image

Description

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.

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

1 Lessons

0H 4M

1. Introduction

4m 20s

Filesystem And Memory Management

11 Lessons

2H 38M

2. Implementing FOPEN in userland

29m 5s

3. Implementing FCLOSE in userland

9m 45s

4. Implementing FREAD in userland

9m 41s

5. Improving our memory managment system for processes - part 1

25m 23s

6. Improving our memory managment system for processes - part 2

22m 27s

7. Compiling and testing FREAD

6m 9s

8. Implementing FSEEK in userland

9m 43s

9. Implementing FSTAT in userland

12m 33s

10. Moving the task paging descriptor into the process

6m 54s

11. Making the process list use vectors

10m 50s

12. Making the process_realloc function

15m 46s

Windowing System

8 Lessons

2H 14M

13. Creating some essential graphics functions

36m 58s

14. The Window System In Detail

15m 31s

15. Building the Window header files

13m 44s

16. Building the Window source files part 1

16m

17. Building the Window source files part 2

19m 36s

18. Building the Window source files part 3

13m 11s

19. Building the Window source files part 4

8m 39s

20. Building the Window source files part 5

11m 16s

CPU

6 Lessons

0H 42M

21. Understanding CPUID

3m 30s

22. Implementing CPUID in our kernel

5m 53s

23. Understanding the TSC Frequency And Delay Functionality

4m 2s

24. Using the TSC Frequency And Implementing Delay Functionality

17m 8s

25. Using the TSC Frequency And Implementing Delay Functionality Part 2

10m

26. Using the TSC Frequency And Implementing Delay Functionality Part 3

1m 30s

Mouse and Graphics

18 Lessons

2H 49M

27. Understanding the mouse

10m 19s

28. Building mouse abstraction

21m 54s

29. Building mouse abstraction - Part 2

10m 44s

30. Implementing window_position_set function

12m 47s

31. Implementing graphics_info_recalculate

4m 7s

32. Implementing window_redraw and testing our windows

3m 2s

33. Implementing the PS2 mouse

19m 34s

34. Implementing the PS2 mouse - Part 2

17m 22s

35. Implementing the PS2 mouse - Part 3

3m 34s

36. Implementing the PS2 mouse - Part 4 , Testing the mouse

2m 24s

37. Implementing click handlers for graphics

20m 45s

38. Implementing move handlers for graphics

4m 48s

39. Registering mouse event listeners in windows and implementing the click handler

7m 29s

40. Implementing the window_click function

2m 33s

41. Implementing the window helper functions

11m 42s

42. Pushing events for focus and unfocus

2m 18s

43. Dealing with title bar clicks

6m 50s

44. Moving windows with the mouse

7m 14s

Windowing System - Stage two

27 Lessons

3H 59M

45. Fixing compile errors with the graphics and windows

3m 40s

46. Fixing common runtime errors identified in graphical and window system

5m 40s

47. Testing our windows

1m 46s

48. The translation layer for graphics and windows in user space

11m 16s

49. Creating userland pointers

12m 28s

50. Creating windows from userspace - part one

15m 39s

51. Creating windows from userspace - part two

8m 33s

52. Creating windows from userspace - part three

6m 31s

53. Creating windows from userspace - part four

3m 36s

54. Diverting stdout to a window

11m 13s

55. The link between kernel window events and userspace

7m 13s

56. Creating the window event functionality for processes - part one

12m 13s

57. Creating the window event functionality for processes - part two

6m 57s

58. Creating the window event functionality for processes - part three

17m 33s

59. Creating the isr80h function to get events in user space

5m 21s

60. Calling the isr80h get event function from userspace

7m 36s

61. Accessing the graphics info of a window from userspace

14m 5s

62. Getting the pixels buffer of a graphics info entity to use in userspace

18m 25s

63. Creating ability for user space to redraw windows

3m 39s

64. Compiling our changes

3m 38s

65. Testing the drawing of pixels in our userspace application

8m 37s

66. Binding the window redraw to ISR80H

1m 41s

67. Creating relative graphics from userspace

12m 43s

68. Redrawing window regions in userspace

5m 37s

69. Updating window properties from userspace

10m 31s

70. Implementing keyboard events and handlers

15m 32s

71. Implementing the window keyboard listener

7m 19s

PCI And Implementation

6 Lessons

2H 6M

72. Understanding PCI

30m 56s

73. Implementing the PCI header files

15m 52s

74. Implementing the PCI source files part one

26m 20s

75. Implementing the PCI source files part two

23m 53s

76. Implementing the PCI source files part three

25m 46s

77. Implementing the PCI source files part four

3m 37s

Disk Driver Improvements

8 Lessons

1H 14M

78. Upgraded disk abstraction and disk drivers

4m 49s

79. Attaching hardware disk to the disk structure and basic driver metadata

6m 42s

80. Creating the disk driver header file

8m 39s

81. Creating the disk driver source file

12m 35s

82. Rewriting our disk code to work with the disk driver abstraction

7m 50s

83. Implementing the pata disk driver header file

3m 58s

84. Implementing the pata disk driver source file

25m 48s

85. Finalizing and testing our pata driver

3m 52s

NVMe SSD Disk Driver

6 Lessons

1H 58M

86. All About NVMe

23m 26s

87. Implementing the NVME header file

11m 33s

88. Implementing the NVME source file - part one

30m 36s

89. Implementing the NVME source file - part two

27m 18s

90. Implementing the NVME source file - part three

18m 13s

91. Implementing the NVME source file - part four compile and testing

7m 42s

Task sleeping and keyboard events

4 Lessons

0H 23M

92. Fixing the keyboard events on userspace

1m 22s

93. Implementing ability for tasks to sleep

7m 53s

94. Implementing ability for tasks to sleep in userspace

12m 15s

95. Implementing ability for tasks to sleep in userspace part two

1m 36s

Small optimizations

3 Lessons

0H 7M

96. Rewriting the makefiles

4m 56s

97. Fixing process realloc bug

1m 56s

98. Calling int 0x80 in fclose

32s

Disk Streamer Cache

5 Lessons

0H 52M

99. Implementing the disk stream cache header files

15m 27s

100. Implementing the disk stream cache source files - part one

12m 13s

101. Implementing the disk stream cache source files - part two

19m 41s

102. Implementing the disk stream cache source files - part three

3m 57s

103. Implementing the disk stream cache source files - part four

1m 25s

Finishing up

3 Lessons

0H 36M

104. Installing dependency libraries for our userspace and running the calculator

8m 22s

105. Explaining how to use the GUI SDK

22m 25s

106. Rules for contributing

5m 32s

Daniel McCarthy

Dragon Zap Instructor

4.91 Star Rating

17 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:

$171.09

~~$294.99~~

42% off

9 days and 14 hours at this price

This course includes:

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

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

Daniel McCarthy

$171.09

Description

Requirements

Who This Course is For

What You Will be Learn

Daniel McCarthy

0.0

Students Feedback (0)

Sort by:

$171.09

This course includes:

Share This Course

Related Courses

Genarative Ai for Dynamic Java Web Application with ChatGPT AI

Create RESTful APIs using PHP, POSTMAN and MySQL: Secure API

Mastering Home Automation with Google Home, Arduino, and API Integration

Learn Ethical Hacking From A-Z: Beginner To Expert Course

Arduino Multithreading: Do More with Less!

C++ Programming Beginner To Expert