Building an Operating System from Scratch

Building an operating system from scratch is one of the most challenging yet rewarding experiences in software engineering. It forces you to understand how computers really work at the lowest level.

Why Build an OS?

When I started working on prometheus-os, my goal wasn’t to create the next Linux. It was to understand the fundamental concepts that every developer takes for granted:

• How does the CPU execute instructions?
• What happens when you allocate memory?
• How do interrupts work?
• What makes multitasking possible?

These questions led me down a rabbit hole of assembly language, hardware specifications, and systems programming that fundamentally changed how I think about software.

The Boot Process

Everything starts with the bootloader. When you power on a computer, the BIOS/UEFI loads the first sector of your disk into memory and jumps to it. This 512-byte bootloader is your entry point:

; bootloader.asm - First stage bootloader
[BITS 16]
[ORG 0x7C00]

start:
    ; Set up segment registers
    xor ax, ax
    mov ds, ax
    mov es, ax
    mov ss, ax
    mov sp, 0x7C00

    ; Load kernel from disk
    mov ah, 0x02        ; BIOS read sector function
    mov al, 10          ; Number of sectors to read
    mov ch, 0           ; Cylinder 0
    mov cl, 2           ; Start from sector 2
    mov dh, 0           ; Head 0
    mov bx, 0x1000      ; Load address
    int 0x13            ; BIOS interrupt

    ; Jump to kernel
    jmp 0x1000

times 510-($-$$) db 0
dw 0xAA55               ; Boot signature

This tiny piece of code is responsible for loading your entire kernel into memory.

Memory Management

One of the most critical components of any OS is memory management. You need to track which memory pages are in use and provide allocation/deallocation services to processes.

class PhysicalMemoryManager {
private:
    uint32_t* bitmap;
    uint32_t totalPages;
    uint32_t usedPages;

public:
    void* allocatePage() {
        for (uint32_t i = 0; i < totalPages; i++) {
            if (!testBit(i)) {
                setBit(i);
                usedPages++;
                return (void*)(i * PAGE_SIZE);
            }
        }
        return nullptr; // Out of memory
    }

    void freePage(void* address) {
        uint32_t page = (uint32_t)address / PAGE_SIZE;
        clearBit(page);
        usedPages--;
    }
};

The bitmap approach is simple but effective for educational purposes. Production systems use more sophisticated algorithms like buddy allocation.

Interrupt Handling

Interrupts are how the CPU responds to external events (keyboard input, timer ticks) and internal exceptions (division by zero, page faults). Setting up the Interrupt Descriptor Table (IDT) is crucial:

struct IDTEntry {
    uint16_t offsetLow;
    uint16_t selector;
    uint8_t  zero;
    uint8_t  typeAttr;
    uint16_t offsetHigh;
} __attribute__((packed));

void setupIDT() {
    // Set up exception handlers (0-31)
    setIDTEntry(0, (uint32_t)divisionByZeroHandler, 0x08, 0x8E);
    setIDTEntry(14, (uint32_t)pageFaultHandler, 0x08, 0x8E);

    // Set up IRQ handlers (32-47)
    setIDTEntry(32, (uint32_t)timerHandler, 0x08, 0x8E);
    setIDTEntry(33, (uint32_t)keyboardHandler, 0x08, 0x8E);

    // Load IDT
    loadIDT(&idtDescriptor);
}

Lessons Learned

Building prometheus-os taught me invaluable lessons:

1. Every abstraction has a cost: High-level languages hide complexity, but that complexity still exists. Understanding it makes you a better programmer.

2. Hardware is unforgiving: Unlike application development, OS development has no safety net. A single bug can freeze the entire system.

3. Documentation is essential: The Intel manuals, OSDev wiki, and other resources are your lifeline. Read them thoroughly.

4. Start simple: Begin with printing text to the screen. Then add keyboard input. Then memory management. Build incrementally.

Resources for Getting Started

If you want to embark on this journey:

• OSDev Wiki: The definitive resource for OS development
• Intel Software Developer Manuals: Essential for x86 architecture
• “Operating Systems: Three Easy Pieces”: Excellent theoretical foundation
• QEMU: For testing without constantly rebooting real hardware

Conclusion

Building an operating system won’t make you faster at writing web applications. But it will give you a profound appreciation for the layers of abstraction we build upon. When you understand what happens between your code and the CPU, you become a more thoughtful, more effective engineer.

The next time you allocate memory or handle an interrupt in your application, you’ll know exactly what’s happening beneath the surface.