Build Your Own Operating System Kernel

This project is an educational resource and technical reference for building operating systems from scratch. It provides a comprehensive guide to mastering x86 architecture and implementing core kernel components by writing code that executes directly on hardware without the support of standard libraries or operating system abstractions. The materials focus on low-level systems engineering, teaching users how to interpret technical datasheets to manage hardware resources. It covers the fundamental mechanics of bare-metal programming, including the use of assembly language to define execution flows, the configuration of memory layouts through linker scripting, and the direct manipulation of processor registers. The curriculum encompasses the architectural requirements for system-level development, such as transitioning processors into protected memory modes and establishing hardware-assisted multitasking. It also details the implementation of interrupt-driven communication, enabling the kernel to respond to asynchronous peripheral signals and manage inter-processor events. The repository includes instructional guides on debugging techniques for low-level environments and provides a structured approach to constructing functional operating system components. All documentation is provided as a set of technical references designed to facilitate the study of hardware-software interaction.

This project is an educational operating system kernel designed to demonstrate the fundamental architectural principles of memory paging and process management. It is implemented as a minimal kernel that serves as a practical reference for building a functioning system from the ground up. The implementation features a preemptive multitasking kernel that switches execution contexts between threads to share a single CPU. It includes an x86 virtual memory manager that uses paging to map virtual addresses to physical memory and isolate processes. The system covers low-level hardware interfacing through disk drivers for raw read and write operations, as well as privilege-level mode separation to restrict user-mode execution. Interaction is handled via a text-based command line shell, and the project includes specialized techniques for low-level kernel debugging.

xv6 is a Unix-like educational operating system designed for teaching kernel concepts. It is implemented as an instructional kernel for x86 and RISC-V architectures, featuring a virtual memory manager and support for symmetric multiprocessing. The system is designed to demonstrate core OS principles through a simplified re-implementation of Unix Version 6. It provides a controlled environment for studying system calls, trap handling, and process lifecycles. Its capability surface covers process management, including scheduling and context switching, and memory management via page tables for process isolation. It includes a Unix-style file system with inode metadata and crash recovery logging, as well as concurrency control using spinlocks and mutexes to synchronize resources across multiple CPUs. The project is built using a cross-compiler toolchain and is intended to be executed within a virtual machine emulator.

This project is a technical reference and educational guide focused on the internal architecture of the Linux kernel. It serves as a low-level systems programming resource and documentation for operating system internals, detailing the implementation of core mechanisms within the kernel source code. The materials provide a detailed study of the Linux kernel, tracing behavior through actual C source and assembly. It specifically covers the progression from the bootloader and decompression to the final kernel entry point, alongside the management of hardware interrupts and symmetric multiprocessing. The content covers fundamental system architecture areas, including memory paging and resource control groups, process synchronization using primitives like spinlocks and read-copy-update, and the organization of kernel data structures such as radix trees and doubly linked lists. It also analyzes system call execution and the frameworks used for system time management. The guide includes information on the kernel development workflow, covering the processes for compiling source code, linking binaries, and submitting patches.

This project is a bare-metal operating system developed for ARM64 architecture. It serves as a low-level implementation of kernel engineering, focusing on the fundamental construction of an OS from the hardware level up. The system is distinguished by its comprehensive approach to ARM64 processor control, featuring a red-black tree task scheduler and a hierarchical page table system for virtual memory management. It implements a sophisticated privilege model that handles transitions between kernel and user modes, ensuring process isolation through address space splitting and exception level management. The kernel covers a broad range of low-level capabilities, including hardware driver development for UART serial communication, interrupt routing across multiple processor cores, and the management of floating point units. It provides a complete process lifecycle, from executable program loading and task creation to context switching and workload balancing. The project includes a recursive build system and supports execution within the QEMU emulator for testing and development without physical hardware.

This project is a freestanding kernel written in Rust that boots on x86 hardware without a standard library. It serves as a low-level system implementation focusing on the creation of a bare metal operating system. The system implements a bootable disk image toolchain that transforms source code into binaries compatible with a bootloader. It features a custom memory allocator for dynamic memory management and an x86 kernel implementation that includes paging, interrupt handling, and VGA text mode. The project covers several core capability areas, including low-level memory management through paging and frame allocation, CPU interrupt handling for exception management, and the development of a multitasking system using asynchronous execution patterns. It also provides a workflow for building freestanding binaries, managing build environments via containers, and verifying kernel logic through integration tests. The compiled disk images can be executed on physical hardware via USB drives or run within virtual machines and emulators for testing.

This project is a comprehensive educational framework designed to guide learners through the complexities of systems engineering and low-level software development. It provides structured learning paths that integrate hardware simulation, source code analysis, and project-based exercises to help developers master the foundational concepts of computer architecture, operating systems, and firmware design. The curriculum distinguishes itself by emphasizing direct interaction with system internals, requiring learners to examine and modify existing open-source kernel and driver implementations. By utilizing emulator-based hardware abstraction, the project allows for safe experimentation with kernel development, memory management, and context switching without the need for dedicated physical hardware. It also bridges traditional and modern development practices by exploring both high-performance C programming and memory-safe systems integration using Rust. The scope of the material covers a broad technical surface, including assembly language programming, microcontroller firmware design, and the construction of custom operating system kernels. Learners are guided through the entire lifecycle of system software, from reading hardware schematics and managing device registers to debugging complex kernel-level operations and contributing to established open-source projects.

This project is an educational resource for developing bare-metal operating systems and kernels from scratch on Raspberry Pi hardware. It provides a structured guide to systems programming using the Rust language, focusing on the implementation of core kernel components that execute directly on ARM-based hardware without the support of an underlying operating system or standard library. The tutorials emphasize a modular architecture that separates hardware-independent kernel logic from processor-specific and board-specific configurations. By utilizing a hardware abstraction layer and distinct namespaces for device drivers and memory maps, the project demonstrates how to maintain clean code separation while interfacing directly with system registers and peripherals. The material covers the fundamental requirements for bare-metal development, including the creation of entry points for system initialization, static linking of kernel binaries, and the direct mapping of physical memory. These guides are designed to assist in the construction of custom firmware and operating system subsystems through low-level programming techniques.

SerenityOS is a complete, self-hosted desktop operating system built from the kernel up. It features a monolithic kernel architecture that manages system services, hardware drivers, and networking within a single address space. The system provides a full computing environment, including a proprietary windowing system and a suite of native desktop applications, all while maintaining a POSIX-compliant interface for standard system programming. The project is distinguished by its integrated development workflow, which relies on a cross-compilation build pipeline to generate system images from host machines. Developers iterate on low-level changes within a virtualization-based environment that simulates physical hardware, allowing for isolated testing and debugging of the kernel and user-space components. To support a broader software ecosystem, the system includes an integrated porting layer that adapts and compiles third-party open source applications to run natively. This infrastructure maps external dependencies to local libraries, enabling the execution of standard software within the custom environment. The build process is managed through a collection of scripts that orchestrate the compilation of the entire operating system and its associated software ports.

xv6-riscv is a simplified Unix-like teaching operating system designed for the study of kernel design and hardware interaction. It provides a low-level RISC-V kernel implementation that serves as a bootable system image for execution and debugging within a virtual machine or emulator. The project focuses on educational instruction regarding the RISC-V architecture. It enables the study of operating system concepts through a minimal kernel that implements process management and memory handling. The system covers core kernel operations including multiprocessor resource management and the implementation of a file system. It includes a shell for command execution and a suite of utilities for file, directory, and text data processing. The project includes a build system for generating kernel images and user-space binaries using a RISC-V cross-compiler toolchain.

Bitwise is a computer architecture education kit and a comprehensive set of guides for building a custom CPU, operating system, and compiler from scratch. It serves as a CPU design tutorial and a practical framework for implementing a unique instruction set architecture. The project provides a custom instruction set architecture toolchain, including resources for creating a matching assembler and compiler. It further includes a hardware development guide for synthesizing computer components and peripheral controllers for deployment on programmable logic devices and FPGAs. The kit covers full-stack systems engineering, spanning hardware emulation development, operating system implementation with task switching, and the creation of custom compiler toolchains. It includes instructions for building a complete computer system, from the initial hardware logic to the final software stack.