Roadmap

Phase 1: Bootloader

Main Page

1. Learn the Basics of Real Mode:
   • Understand BIOS Interrupts (e.g., int 13h for disk I/O, int 10h for display).
   • Study x86 assembly for 16-bit real mode.
2. Write a Simple Bootloader:
   • Write a program in assembly to display a message (e.g., “Hello, OS!”).
   • Ensure it fits in a 512-byte boot sector.
   • Compile using AS and link with GCC.
3. Load a Kernel:
   • Extend the bootloader to load a kernel from disk into memory.
   • Use BIOS calls for disk reads.
4. Transition to Protected Mode:
   • Switch from real mode (16-bit) to protected mode (32-bit).
   • Setup the Global Descriptor Table (GDT).

Phase 2: Kernel Basics

1. Set Up the Kernel Environment:
   • Write the kernel entry point in assembly.
   • Switch to C for higher-level kernel development.
   • Test printing messages from the kernel.
2. Implement Basic Memory Management:
   • Create a basic memory manager to allocate/deallocate memory.
   • Implement a simple heap or stack
3. Handle CPU Interrupts:
   • Set up the Interrupt Vector Table (IVT).
   • Write interrupt handlers for keyboard input and timer.

Phase 3: Device Drivers

1. Keyboard Input:
   • Write a driver to capture keyboard input.
   • Display typed characters on the screen.
2. Display Output:
   • Start with VGA text mode for output.
   • Optional: Explore graphical modes later.
3. Mouse Support (Optional)
   • Write a basic driver to read mouse input.
   • Display mouse movements on the screen.

Phase 4: Userland and File System

1. Develop a Simple CLI:
   • Allow basic user commands (e.g., “help”, “reboot”).
   • Handle I/O efficiently.
2. File System:
   • Implement a simple file system (e.g., FAT12/FAT16 or custom).
   • Add support for reading files from disk.

Phase 5: Advanced Features

1. Multi-tasking:
   • Learn about process management and context switching.
   • Implement a basic scheduler.
2. Enhance the Kernel:
   • Add support for modules (dynamically loadable components).
   • Consider moving to a hybrid or microkernel architecture.
3. Networking (Optional)
   • Implement basic networking capabilities.

Phase 6: Refine and Expand

1. Polish the OS:
   • Optimize performance and memory usage.
   • Refactor code for modularity.
2. Experiment with 64-bit Mode:
   • Transition into x86_64 for more features and modern architecture.
3. Build Userland Applications:
   • Develop small programs or utilities to showcase OS capabilities.