Learn Kernel Development with Daniel McCarthy's Courses

If you've ever wanted to understand how operating systems really work, not just use them, Daniel McCarthy's kernel development courses are designed to take you deep into low-level systems programming by building a real kernel from scratch.

Start by Building a Multitasking Kernel from Scratch

👉 https://dragonzap.com/course/developing-a-multithreaded-kernel-from-scratch

Instead of only teaching operating-system theory, this course takes a build-first approach. You progressively create your own 32-bit multitasking operating system and learn why each major kernel subsystem exists as you implement it.

What You'll Learn

You'll work through topics including:

• The x86 boot process and how a computer starts executing your code
• Real mode and protected mode
• Writing your own bootloader in Assembly
• Switching the processor into 32-bit protected mode
• Interrupts, the IDT, and the Programmable Interrupt Controller
• Building your own kernel heap with malloc and free
• Paging and virtual memory
• Mapping virtual addresses to physical memory
• Reading from disks using the ATA controller
• Understanding how filesystems work
• Building a Virtual File System (VFS) layer
• Implementing a FAT16 filesystem driver
• Understanding kernel space, user space, and CPU protection rings
• Creating processes and tasks
• Implementing system calls so user programs can communicate with the kernel
• Writing a PS/2 keyboard driver
• Loading and executing ELF binaries
• Writing user-space programs in C
• Creating a small standard library
• Building your own command shell
• Handling program crashes and termination
• Running multiple tasks at the same time
• Debugging your kernel with GDB and an emulator

By the end, you aren't simply reading about operating-system concepts — you've implemented many of them yourself.

Why Take This Course?

Kernel development can be difficult to learn because there is a huge gap between understanding C or Assembly and knowing how all the pieces of an operating system fit together.

This course gives you a structured path through that gap.

Instead of jumping between documentation, forum posts, specifications, and disconnected tutorials, you follow the development of one kernel from the boot process all the way to processes, filesystems, user programs, multitasking, and a working shell.

That makes it especially useful if you want to:

• Become stronger at C and Assembly
• Understand what happens underneath Linux, Windows, and other operating systems
• Learn systems programming beyond normal application development
• Understand memory management, processes, filesystems, interrupts, and CPU architecture at a practical level
• Prepare yourself for more advanced kernel, driver, embedded, or low-level programming
• Build an operating-system project that you can continue experimenting with yourself

Who Is It For?

The course is aimed at programmers who want to learn kernel development from the ground up.

You should already have an understanding of C and ideally some Assembly language experience. There is also an Assembly catch-up section to help reinforce the low-level concepts used throughout the course.

The course currently contains 139 lessons and more than 29 hours of material, with lifetime access.

If you've been reading OSDev resources but want a guided project that shows how the pieces connect in a complete system, this is a great place to start.

Start Learning

👉 Developing a Multitasking Kernel From Scratch
https://dragonzap.com/course/developing-a-multithreaded-kernel-from-scratch

Build the bootloader. Build the memory manager. Build the filesystem. Build the process model.

Then watch it all come together as your own operating system.