Writing an x86 OS: Kernel, Assembly & C

Learning Goal: Write a basic x86 operating system kernel from scratch using C and Assembly to understand low-level system execution. This curriculum guides you from bare-metal execution to managing hardware interrupts and drafting custom screen drivers.

  • Estimated Total Study Time: 40 Hours
  • Prerequisites:
    • Basic familiarity with programming logic (variables, loops, and pointers in any language).
    • Access to a modern operating system (Linux, macOS, or Windows via WSL) capable of running terminal utilities, an emulator (QEMU), and compiler tools.

Module 1: Computer Architecture & Assembly Foundations

Module Overview

To program directly on hardware, you must first strip away the high-level abstractions of modern runtime environments. This module establishes a strong understanding of how the Central Processing Unit (CPU) executes instruction sequences, interacts with main memory (RAM), and coordinates data processing via registers. You will learn the fundamentals of x86 assembly language from absolute scratch, setting up your mental model of the Von Neumann architecture.

Recommended Videos

How a CPU Works
How a CPU Works
@InOneLesson20:008,470,759
How a CPU Works

A CPU (Central Processing Unit) functions as the brain of a computer by following a fetch-decode-execute cycle: it retrieves instructions from RAM, decodes them using the control unit, executes operations through the ALU (Arithmetic Logic Unit) which performs calculations and comparisons, stores intermediate results in registers, and uses flags to make conditional decisions; this process repeats billions of times per second in modern CPUs, enabling complex computations through simple sequential

@InOneLesson · 20:00

Why this video

This classic visualization provides a perfect introduction to computer systems. It details the fetch-decode-execute cycle of a CPU, showing how control units, registers, and memory buses work together. Observing the physical movement of instructions from RAM to the processor makes the low-level execution pipeline easy to understand.

The Central Processing Unit (CPU): Crash Course Computer Science #7
The Central Processing Unit (CPU): Crash Course Computer Science #7
@crashcourse11:371,746,181
The Central Processing Unit (CPU): Crash Course Computer Science #7

The Central Processing Unit (CPU) is the heart of a computer that executes programs by repeatedly performing a fetch-decode-execute cycle: it fetches instructions from RAM using an Instruction Address Register, decodes the instruction's opcode (operation code) and address fields via a Control Unit made of logic gates, and executes the instruction using components like the Arithmetic Logic Unit (ALU) and registers; the entire process is synchronized by a clock that triggers operations at regular

@crashcourse · 11:37

Why this video

This video explains the microarchitectural blocks of the CPU, including the Arithmetic Logic Unit (ALU) and system registers. It explains how high-level programmatic logic is compiled down to raw binary states, providing the context needed for hardware-level programming.

Start coding in ASSEMBLY (tutorial for beginners)
Start coding in ASSEMBLY (tutorial for beginners)
@screeck46:2510,502
Start coding in ASSEMBLY (tutorial for beginners)

This tutorial introduces x86 assembly language fundamentals for beginners, covering key concepts including CPU registers (EAX for return values, ECX for loop counters, ESP for stack pointer), basic arithmetic instructions (ADD, SUB, MUL, DIV), stack operations (PUSH, POP), labels for memory addressing, conditional jumps using CMP and flags, and loop implementation. The instructor demonstrates practical examples using Visual Studio with MASM assembler, showing how to set up the development enviro

@screeck · 46:25

Why this video

This tutorial transitions you from hardware theory to actual assembly programming. It explains x86 registers (EAX, ECX, ESP), arithmetic instructions, and how parameters move on the memory stack.

Intro to x86 Assembly Language (Part 3)
Intro to x86 Assembly Language (Part 3)
@DavyBot10:21130,136
Intro to x86 Assembly Language (Part 3)

This video tutorial explains how to access and manipulate memory in x86 assembly language, covering direct memory addressing using labels with square brackets, data types (DB for bytes, DW for 16-bit words, DD for 32-bit double words), and stack operations where the stack pointer (ESP) manages a LIFO structure that grows downward in memory; the instructor demonstrates writing to specific memory locations using move operations with byte offsets and shows how to allocate and write strings directly

@DavyBot · 10:21

Why this video

Operating systems manage data storage directly in memory. This video explains how to read and write memory locations in assembly, configure pointers, and use size directives (DB, DW, DD) to define global data in your raw binaries.

Knowledge Checkpoint

  • Detail the exact components of a CPU's fetch-decode-execute cycle.
  • Explain the difference between registers, RAM, and storage buses.
  • Write x86 assembly instructions to move values between registers and memory.
  • Use size suffixes (such as byte, word, dword) to define and load variables of different sizes.

Module 2: The Boot Sector & Real Mode

Module Overview

When an x86 computer powers on, it starts in 16-bit Real Mode, mimicking the original Intel 8086 processor. It executes firmware known as the BIOS (Basic Input/Output System). The BIOS runs basic diagnostic checks (POST) and loads exactly 512 bytes from the first sector of the bootable media—the Master Boot Record (MBR)—into memory address 0x7C00.

In this module, you will write a functional 16-bit bootloader in x86 Assembly. This bootloader will call BIOS interrupts to write text to the display and read keyboard inputs.

Recommended Videos

Making Simple Bootloader using x86 Assembly
Making Simple Bootloader using x86 Assembly
@nirlichtman6:4750,281
Making Simple Bootloader using x86 Assembly

A simple x86 bootloader written in NASM assembly must be 16-bit code starting at memory address 0x7c00, use BIOS interrupt 10h with AH=0Eh to print characters by loading each character from a null-terminated string into AL register and incrementing a counter (SI register) until reaching the null terminator, while ensuring the entire code fits within a 512-byte sector by padding with zeros and ending with the magic bytes 0x55AA.

@nirlichtman · 6:47

Why this video

This video walks you through writing your first 16-bit bootloader. It explains the significance of the 0x7C00 loading address, how to invoke basic BIOS interrupts to render text, and why you must terminate your 512-byte sector with the magic boot signature 0xAA55.

Making an OS (x86) Chapter 2 - BIOS, Printing the Alphabet, Conditional Jumps
Making an OS (x86) Chapter 2 - BIOS, Printing the Alphabet, Conditional Jumps
@DaedalusCommunity7:14181,526
Making an OS (x86) Chapter 2 - BIOS, Printing the Alphabet, Conditional Jumps

This video teaches how to use BIOS interrupts for character output and implement conditional jumps in x86 assembly language. To print a character, set AH to 0x0E, move the ASCII value to AL, then call interrupt 0x10. The CMP instruction compares values, and conditional jumps like JE allow programs to make decisions—demonstrated by printing the alphabet by incrementing from 'A' (65) to 'Z' (90) and using JE to exit the loop when reaching 'Z' + 1.

@DaedalusCommunity · 7:14

Why this video

This practical guide shows how to write loop structures, handle memory offsets, and use conditional jumps in a bootloader. These techniques allow you to process data sequentially and build interactive prompts.

x86 Operating Systems - Printing A Message in BIOS
x86 Operating Systems - Printing A Message in BIOS
@olivestemlearning8:017,323
x86 Operating Systems - Printing A Message in BIOS

This video demonstrates how to modify a simple x86 bootloader to print a message on screen using BIOS interrupt 0x10 with AH=0x0e, which prints a character from AL register; the process involves initializing segment registers (DS, ES, SS) to zero, setting up the stack pointer at 0x7c00, defining a null-terminated string with DB, preserving registers (SI, AX, BX) on the stack, using LODSB to load characters, checking for the null terminator with OR AL, AL and JZ, and finally calling int 0x10 to p

@olivestemlearning · 8:01

Why this video

This video explains the mechanics of BIOS interrupts (specifically INT 0x10, service 0x0E for teletype output). It shows you how to write custom print functions in x86 assembly to output entire strings to the display.

Knowledge Checkpoint

  • Explain why the bootloader must be exactly 512 bytes long and end with the bytes 0x55 and 0xAA.
  • Explain why the bootloader program is loaded at memory location 0x7C00.
  • Call the BIOS interrupt INT 0x10 (service 0x0E) to write characters and strings.
  • Write assembly code that performs conditional jumps based on comparisons (cmp and je/jne).

Module 3: Transitioning to 32-bit Protected Mode

Module Overview

16-bit Real Mode limits memory access to a maximum of 1MB and lacks memory protection, allowing any process to read or write any address. To build a modern kernel, you must switch the CPU to 32-bit Protected Mode.

This transition requires configuring the Global Descriptor Table (GDT), which defines memory segment limits and access rights. You will also disable BIOS interrupts and set the control register cr0 to activate Protected Mode.

Real Mode (16-bit) -> Limit: 1MB RAM, No Security │ ▼ Define GDT (Segment Bases, Limits, Privileges) ▼ Disable BIOS Interrupts (cli) ▼ Set CR0 Register PE Bit (Protection Enable) ▼ Perform Far Jump (Flush Pipeline) │ Protected Mode (32-bit) -> Limit: 4GB RAM, Kernel vs User Privileges

Recommended Videos

Making an OS (x86) Chapter 6 - Entering Protected mode, GDT
Making an OS (x86) Chapter 6 - Entering Protected mode, GDT
@DaedalusCommunity11:2871,911
Making an OS (x86) Chapter 6 - Entering Protected mode, GDT

To switch from real mode to protected mode in x86 architecture, you must first define a Global Descriptor Table (GDT) containing segment descriptors for code and data segments, then disable interrupts with CLI, load the GDT with LGDT, set the PE bit in CR0 using a 32-bit register, and perform a far jump to establish the new segment; this enables 32-bit operation with 4GB memory addressing and memory protection features.

@DaedalusCommunity · 11:28

Why this video

This step-by-step tutorial demonstrates how to define a 3-entry GDT (Null segment, Code segment, and Data segment), load it using the lgdt instruction, and execute the far jump needed to switch to Protected Mode.

OSDev Lecture Series 4: Global Descriptor Table
OSDev Lecture Series 4: Global Descriptor Table
@aptrock32750:361,144
OSDev Lecture Series 4: Global Descriptor Table

The Global Descriptor Table (GDT) forms the foundation of x86 protected mode memory management, containing descriptors that define all memory segments accessible by the CPU. The GDT comprises the null descriptor (8 bytes of zeros for CPU reference), code descriptors, data descriptors, optional Task State Segment (TSS) descriptors for multitasking, and the GDTR register. Each segment descriptor occupies exactly 8 bytes (64 bits) with a specific format: 16 bits for the limit address, 24 bits for t

@aptrock327 · 50:36

Why this video

The x86 GDT structure is notoriously complex. This lecture explains its layout, including segment base addresses, limits, privilege levels (DPL), and type flags, helping you configure it correctly.

Knowledge Checkpoint

  • Describe the binary layout of an 8-byte GDT segment descriptor.
  • Explain why BIOS interrupts can no longer be called once you transition to Protected Mode.
  • Explain why a "far jump" is required immediately after modifying the cr0 control register.
  • Implement a minimal, valid GDT configuration in assembly containing Null, Kernel Code, and Kernel Data descriptors.

Module 4: Setting Up the C Environment & VGA Driver

Module Overview

Operating system kernels are rarely written entirely in assembly. Instead, assembly is used for the minimal startup routine, which then transfers control to a main function written in C.

This transition requires a cross-compiler to generate target x86-ELF binaries independently of your host OS's native architecture. It also requires a linker script to organize your code and data sections in memory.

Once your C runtime environment is ready, you will write a VGA text-mode driver to print characters directly to screen memory.

Gap Acknowledgment & Guidance: Since modern YouTube libraries lack comprehensive tutorials on building an i686-elf-gcc cross-compiler from scratch, the videos below focus on build automation theory, linker scripts, and VGA memory mapping. To set up your toolchain, you should compile the source code for GCC and Binutils with --target=i686-elf on your host system, or use a prepackaged cross-compiler toolchain inside a Docker image or package manager (such as gcc-multilib or i686-elf-gcc via Homebrew).

Assembly Code (boot.asm) C Code (kernel.c) ┌─────────────────────────┐ ┌────────────────────────┐ │ - Set up stack pointer │ │ - void kernel_main() │ │ - Call kernel_main ────┼────►│ - Print messages │ └─────────────────────────┘ │ - Run main loop │ └────────────────────────┘ ▲ ▲ └──────────────┬───────────────┘ │ Linker Script (link.ld) ┌──────────────────────────────┐ │ - Merge .text, .data, .bss │ │ - Align to 4KB boundaries │ │ - Output ELF file │ └──────────────────────────────┘

Recommended Videos

Anatomy of Cross-Compilation Toolchains
Anatomy of Cross-Compilation Toolchains
@LinuxfoundationOrg11:4333,802
Anatomy of Cross-Compilation Toolchains

Building a cross-compilation toolchain follows a specific sequence: build binutils for the target architecture; build MPFR, GMP, and MPC for the host; install kernel headers for the target; build first-stage GCC (limited C support); use first-stage GCC to build the target C library; finally build the complete GCC. The C library is integral to the toolchain—changing it requires rebuilding everything. The sysroot is the logical root directory where GCC searches for headers and libraries, containin

@LinuxfoundationOrg · 11:43

Why this video

This video explains how cross-compilers work. It shows why host-system libraries must be bypassed when building bare-metal programs, helping you understand why standard headers like <stdio.h> cannot be used in a kernel.

Bare metal embedded lecture-4: Writing linker scripts and section placement
Bare metal embedded lecture-4: Writing linker scripts and section placement
@FastbitEmbeddedBrainAcademy37:40110,702
Bare metal embedded lecture-4: Writing linker scripts and section placement

A linker script is a text file written in GNU linker command language (.ld extension) that defines how object file sections are merged into the final executable, specifying memory regions with their start addresses and sizes using the memory command, creating output sections with the sections command to control placement in specific memory regions, and utilizing the location counter (.) symbol to track section boundaries for use in C startup code to relocate data sections from flash to RAM.

@FastbitEmbeddedBrainAcademy · 37:40

Why this video

Linker scripts define how compiled code and data are organized in memory. This tutorial explains sections like .text, .data, and .bss, alignment constraints, and how to write a custom linker script to organize your binary.

Making an OS (x86) Chapter 7 - Cross Compiler, Bootloader, Kernel
Making an OS (x86) Chapter 7 - Cross Compiler, Bootloader, Kernel
@DaedalusCommunity3:2378,525
Making an OS (x86) Chapter 7 - Cross Compiler, Bootloader, Kernel

This section details the complete kernel development workflow. The kernel handles interrupts, peripherals, memory management, and system-level operations. The development process involves writing C code with extern C declarations for proper linking, creating assembly entry points that bridge the bootloader and kernel, and using cross-compilation tools (gcc, nasm, ld) to generate executable binaries. The compilation pipeline produces object files that are linked into a single binary. Critical con

@DaedalusCommunity · 3:23

Why this video

This guide shows how to bridge your bootloader, compiler toolchain, and C code. It demonstrates how to compile C files, assemble assembly components, and link them together into a final bootable operating system image.

OS15: Writing a Simple VGA Driver (Graphics)
OS15: Writing a Simple VGA Driver (Graphics)
@PageKey12:268,991
OS15: Writing a Simple VGA Driver (Graphics)

This video demonstrates VGA graphics programming for operating system development, covering both emulated (QEMU) and real hardware (HP Pavilion dm4) environments. VGA (Video Graphics Array) is an old analog display standard now replaced by digital interfaces like DVI and HDMI. Programming VGA requires two approaches: IO ports for mode setting and memory-mapped IO for pixel plotting. Key concepts include calculating pixel offsets with (x + y × pixels_per_row), implementing functions for clearing

@PageKey · 12:26

Why this video

In Protected Mode, writing text to the screen is done by writing characters and color attributes directly to the VGA video memory buffer starting at address 0xB8000. This video shows how to build a VGA driver in C to print characters, update cursor positions, and clear the screen.

Knowledge Checkpoint

  • Explain why you cannot use your host operating system's native compiler (like standard gcc or clang) to compile your kernel's C code.
  • Write a basic linker script that maps the boot sector entry point to its load address and groups .text and .data sections.
  • Describe the layout of the VGA text-mode memory buffer starting at address 0xB8000.
  • Implement a C function, print_string(char* text, char color_attribute), that writes character bytes directly into VGA memory.

Module 5: Interrupts, Inputs, and Kernel Mechanics

Module Overview

To respond to hardware events like keyboard presses or system timers, your kernel must support hardware interrupts. In x86 architectures, this requires configuring the Interrupt Descriptor Table (IDT), which maps interrupt vectors to Interrupt Service Routines (ISRs) written in assembly.

You must also reprogram the dual 8259 Programmable Interrupt Controllers (PICs). By default, the PIC maps hardware interrupts to CPU vectors that conflict with internal exception vectors. You will reprogram the PIC to remap hardware interrupts to a safe, non-conflicting offset (such as vector 0x20 onwards).

Hardware Event (e.g., Key Press) │ ▼ [ 8259 PIC (Remapped to 0x20) ] ────► Signals CPU Interrupt │ ▼ [ IDT (Interrupt Table) ] │ ▼ Interrupt Service Routine ┌─────────────────────────┐ │ 1. Push All Registers │ │ 2. Call C Handler │ │ 3. Send PIC EOI Signal │ │ 4. Pop All & iret │ └─────────────────────────┘

Recommended Videos

x86 Operating Systems - Interrupts
x86 Operating Systems - Interrupts
@olivestemlearning45:087,588
x86 Operating Systems - Interrupts

This video explains how to implement the Interrupt Descriptor Table (IDT) in an x86 operating system, covering the creation of IDT entries with specific structures including offset, present bit, DPL, gate type, and segment selector; initializing the Programmable Interrupt Controllers (PICs) at ports 0x20 and 0xA0; setting up Interrupt Service Routines (ISRs) for exception handling (like divide-by-zero errors) using assembly macros; and implementing Interrupt Request (IRQ) handlers for hardware i

@olivestemlearning · 45:08

Why this video

This video explains the IDT structure, explaining IDT gate descriptors, task gates, and trap gates. It shows how to register an interrupt handler and explains the difference between regular function returns and the IRET (Interrupt Return) instruction.

Introduction to 8259 Programmable Interrupt Controller - Study and Interfacing of Peripherals
Introduction to 8259 Programmable Interrupt Controller - Study and Interfacing of Peripherals
@Ekeeda30:4329,404
Introduction to 8259 Programmable Interrupt Controller - Study and Interfacing of Peripherals

The 8259 Programmable Interrupt Controller (PIC) is an external device that manages interrupt operations for microprocessors like the 8085, handling 8 interrupt requests simultaneously, resolving priority levels, providing interrupt vector addresses, and supporting both level and edge triggering modes; it can be cascaded to handle up to 64 interrupt requests through master-slave configuration, and allows individual masking of interrupts with status reading capabilities.

@Ekeeda · 30:43

Why this video

This video details the internal architecture and pinout configurations of the 8259 Programmable Interrupt Controller (PIC). Understanding its cascading master/slave configuration is essential for remapping interrupts.

Write your own Operating System 6: Keyboard
Write your own Operating System 6: Keyboard
@writeyourownoperatingsystem12:3221,077
Write your own Operating System 6: Keyboard

When handling hardware interrupts, the CPU must send acknowledgment signals back to the PIC through command and data ports. For the master PIC, an acknowledgment is always sent. For the slave PIC, an acknowledgment is only sent if the interrupt number falls between 0x28 and 0x30. An abstract base class called 'interrupt handler' is created to define the interface for different hardware drivers. The class stores the interrupt number and a pointer to the interrupt manager. The constructor and dest

@writeyourownoperatingsystem · 12:32

Why this video

Once the IDT and PIC are configured, you can process input events. This tutorial shows how to send End of Interrupt (EOI) commands back to the PIC controllers, read input scan codes, and translate key releases.

OS12: Basic Keyboard Driver (x86 Interrupts)
OS12: Basic Keyboard Driver (x86 Interrupts)
@PageKey31:169,182
OS12: Basic Keyboard Driver (x86 Interrupts)

This video teaches how to create a basic keyboard driver for x86 architecture by implementing interrupts, including setting up the Interrupt Descriptor Table (IDT) with 256 entries, programming the Programmable Interrupt Controller (PIC) with initialization control words (ICWs), accessing I/O memory using IN/OUT assembly instructions, and handling keyboard interrupts to map scancodes to characters.

@PageKey · 31:16

Why this video

This comprehensive video integrates the concepts of this module, walking you through configuring your IDT entries, reprogramming the PIC, reading scan codes from port 0x60, and implementing a keyboard driver.

Knowledge Checkpoint

  • Describe the structural format of an IDT entry, detailing segment selectors and gate execution privileges.
  • Explain why the 8259 PIC must be remapped in protected mode, and write the sequence of initialization commands (ICWs) to complete this remapping.
  • Implement an assembly wrapper ISR that preserves register states, calls a C handler, sends the End-of-Interrupt (EOI) byte 0x20 to the PIC, and exits via iret.
  • Write a keyboard driver in C that reads scan codes from I/O port 0x60 and prints characters to the screen.

Course Map

Key People Index

  • Linus Torvalds The creator of the Linux kernel. His early work on writing a terminal emulator that booted on his Intel 386 machine is a classic example of modern, custom OS development.
  • Daedalus Community An educational content creator who produces highly detailed tutorials on 32-bit x86 OS development, providing clear guidance on the transition from Assembly bootloaders to C kernels.
  • Kelsey Steele & Nischala Yelchuri Linux kernel contributors and educators who advocate for understanding bare-metal development, helping students bridge the gap between educational hobbyist kernels and modern, enterprise-scale operating systems.

Final Self-Assessment

To verify your kernel's functionality, ensure you can check off every item in this list:

  • Write a 16-bit bootloader that boots on bare metal (or an emulator like QEMU) and prints a welcome message.
  • Define a valid Global Descriptor Table (GDT) and successfully switch the CPU to 32-bit Protected Mode.
  • Configure a target cross-compiler (such as i686-elf-gcc) and write a linker script to build an un-poisoned, flat binary executable.
  • Initialize a stack pointer in assembly, call your C main entry point, and write code that compiles assembly files and C modules into a unified kernel image.
  • Implement a custom VGA text-mode driver in C that outputs text to memory address 0xB8000 and handles newlines, scrolling, and basic formatting.
  • Build and register an Interrupt Descriptor Table (IDT) containing standard ISR exception handlers.
  • Reprogram the dual 8259 PICs, mapping hardware interrupts away from exception vector addresses to a safe range (vectors 0x20 to 0x28).
  • Implement a keyboard driver that handles keystroke interrupts, reads keyboard scan codes from I/O port 0x60, and prints characters to the screen.
Explore Further

Related Computer Science Roadmaps

View All→
computer-science

Building BitTorrent: Go, P2P & Concurrency

01Go Fundamentals & Concurrency
02Networking Foundations & P2P Architecture
03Bencode Parsing & Torrent Metadata
+ 3 more learning modules
26h6 modules
Explore Roadmap
computer-science

Actor Models (C++ Concurrency & Lock-Free)

01C++ Multi-Threading Foundations
02Thread Pools and Task Scheduling
03Atomics and Lock-Free Queue Design
+ 3 more learning modules
45h6 modules
Explore Roadmap
computer-science

Coding HM Type Inference: Algorithm W & OCaml

01Introduction to Functional Programming & OCaml
02Abstract Syntax Trees & Language Interpreters
03Type Systems & Lambda Calculus
+ 2 more learning modules
28h5 modules
Explore Roadmap
computer-science

Building OAuth 2.0: Node.js OIDC Server

01Web & Security Foundations
02Authentication vs. Authorization & JWTs
03The OAuth 2.0 Protocol & Grant Types
+ 3 more learning modules
25h6 modules
Explore Roadmap