Kernel Development Tutorials

About this repository

An archive of James Molloy's Kernel Development tutorials. As of the time of archiving, the original website seems to be offline or inaccessible.

I used Wayback Machine snapshots from 2021-2023 in order to backup the tutorial pages and, some of, the original tutorial resources/files. Each chapter has been converted into formatted markdown pages to be easily viewed.

If you happen to notice something that doesn't make sense, or if you have found an error, please let me know by making a new issue.

Note

Known bugs & issues

This tutorial is known for some bugs and issues, you can read more about in on the OSDev wiki page dedicated to the tutorial.

Roll your own toy UNIX-clone OS

This set of tutorials aims to take you through programming a simple UNIX-clone operating system for the x86 architecture. The tutorial uses C as the language of choice, with liberally mixed in bits of assembler. The aim is to talk you through the design and implementation decisions in making an operating system. The OS we make is monolithic in design (drivers are loaded through kernel-mode modules as opposed to user-mode programs), as this is simpler.

This set of tutorials is very practical in nature. The theory is given in every section, but the majority of the tutorial deals with getting dirty and implementing the abstract ideas and mechanisms discussed everywhere. It is important to note that the kernel implemented is a teaching kernel. I know that the algorithms used are not the most space efficient or optimal. They normally are chosen for their simplicity and ease of understanding. The aim of this is to get you into the correct mindset, and to give you a grounding upon which you can work. The kernel given is extensible, and good algorithms can easily be plugged in.

If you have problems with the theory, there are plenty of sites that would be delighted to help you (most questions on OSDev forums are concerned with implementation - "My gets function doesn't work! help!" - A theory question is a breath of fresh air to many ;) ). Links can be found at the bottom of the page.

Prerequisites

Tools needed to compile and build the code within the tutorials:

• Netwide Assembler (NASM)
• GNU Compiler (GCC)
• GNU Binutils (ld)
• GNU Make

There is no point, however, in just compiling and running without comprehension. You must understand what is being coded, and as such you should have a very strong knowledge of C, especially regarding pointers. You should also know a little bit of assembly (Intel syntax is used in these tutorials), including what the EBP register is used for.

Table of contents

1. Environment setup

   • 1.1. Directory Structure
   • 1.2. Compiling
   • 1.3. Running
   • 1.4. Bochs
   • 1.5. Useful Scripts

2. Genesis

   • 2.1. The boot code
   • 2.2. Understanding the boot code
   • 2.3. Adding some C code
   • 2.4. Compiling, linking and running!

3. The Screen

   • 3.1. The theory
   • 3.2. The practice
   • 3.3. Summary
   • 3.4. Extensions

4. The GDT and IDT

   • 4.1. The Global Descriptor Table (theory)
   • 4.2. The Global Descriptor Table (practical)
   • 4.3. The Interrupt Descriptor Table (theory)
   • 4.4. The Interrupt Descriptor Table (practical)

5. IRQs and the PIT

   • 5.1. Interrupt requests (theory)
   • 5.2. Interrupt requests (practical)
   • 5.3. The PIT (theory)
   • 5.4. The PIT (practical)

6. Paging

   • 6.1. Virtual memory (theory)
   • 6.2. Paging as a concretion of virtual memory
   • 6.3. Page faults
   • 6.4. Putting it into practice

7. The Heap

   • 7.1. Data structure description
   • 7.2. Algorithm description
   • 7.3. Implementing an ordered list
   • 7.4. The heap itself
   • 7.5. Testing
   • 7.6. Summary

8. The VFS and the initrd

   • 8.1. The virtual filesystem
   • 8.2. The initial ramdisk
   • 8.3. My own solution
   • 8.4. Loading the initrd as a multiboot module
   • 8.5. Testing it out

9. Multitasking

   • 9.1. Tasking theory
   • 9.2. Cloning an address space
   • 9.3. Creating a new stack
   • 9.4. Actual multitasking code
   • 9.5. Testing
   • 9.6. Summary

10. User Mode

    • 10.1. Switching to user mode
    • 10.2. System calls
    • 10.3. Testing

Resources

• OSdev.org Wiki & Forums
• OSdever Tutorials & Forums
• Operating Systems: From 0 to 1
• BrokenThorn OS Development Series
• The Little OS Book
• Intel Software Development Manuals
• MikeOS Project
• FusionOS Project

About This Repository

This repository exists solely to preserve and archive the original set of tutorials authored by James Molloy, which were previously available on his personal website. As of the time of archiving, the original source appears to be offline or inaccessible. These tutorials have historically been a valuable resource for developers, especially those interested in low-level programming and operating system development.

I would like to express full credit and authorship to James Molloy for the creation of this work. I make no claim of ownership over the material contained within this repository. This archive has been made available under the Creative Commons CC0 license, in the spirit of open access and educational preservation.

If James Molloy, as the original author, wishes for this repository to be modified, removed, or taken down for any reason, I will comply fully and immediately with any such request.

For questions, feedback, or takedown requests, I can be reached via:

• GitHub: Issue
• E-mail: git@exclavia.network

---

© 2008 James Molloy - james@jamesmolloy.co.uk

Archived: July 2025 by Tristan Wehler

---