Operating Systems Labs and Projects

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.

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 curriculum designed to teach the fundamentals of operating system development and low-level systems programming. It provides a structured sequence of lessons and code samples that guide users through building a functional kernel and bootloader from scratch, enabling a practical understanding of how software interacts directly with computer hardware. The repository distinguishes itself by focusing on the core mechanics of bare-metal execution. It covers the implementation of essential system components, including assembly-based bootloaders that transition processors from real to protected mode, and the manual configuration of global descriptor tables for memory segmentation. Users learn to manage hardware events and software exceptions through interrupt descriptor table handling, as well as how to communicate with peripherals and render text via direct memory-mapped input and output. The materials emphasize the internal design of processors and memory management, offering a technical reference for those studying computer architecture. The content is organized as a step-by-step learning resource, utilizing a combination of C and assembly language to demonstrate how to maintain system control without the abstraction layer of a host operating system.

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 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 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.

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.

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.

你管这破玩意叫操作系统源码 — 像小说一样品读 Linux 0.11 核心代码

Redox is a POSIX-compliant, microkernel-based operating system written entirely in Rust. By utilizing a memory-safe language for the kernel and all system components, the project eliminates common vulnerabilities such as buffer overflows and use-after-free errors. Its architecture relies on a minimal kernel that manages only essential hardware and process isolation, delegating all other system services to unprivileged user-space processes. The system distinguishes itself through a modular design where hardware drivers and system services run as independent user-space daemons, allowing them to be updated or restarted without a full system reboot. Communication between these components is handled through structured message-passing rather than shared memory, ensuring strict isolation. Furthermore, Redox employs a unique scheme-based resource access model, where hardware, services, and system resources are exposed as file-like objects accessed through a unified URI-based naming convention. The operating system provides a comprehensive environment for general-purpose computing and development, including a standard library that enables the execution of existing Unix-like software with minimal modification. It supports multiple CPU architectures and includes a robust suite of tools for build automation, package management, and system image generation. These utilities allow developers to cross-compile software, manage dependencies, and test system variants within virtualized environments. The project is maintained as an open-source repository with extensive documentation and tooling to support custom kernel builds and system-level development.

CppGuide is a curated collection of educational resources and practical guides focused on C++ server development, Linux kernel internals, concurrent programming, network protocols, and security exploitation. It provides structured learning paths for backend developers, covering everything from interview preparation to building high-performance network servers and understanding operating system fundamentals. The guide distinguishes itself by offering in-depth, hands-on tutorials that walk through real-world implementations, including building a Redis-like server from scratch, designing custom network protocols, and constructing remote control tools. It also delves into advanced topics such as shellcode injection, kernel module development, and the architecture of the Linux kernel, providing a mental model for how the kernel operates as a responsive, object-based system. Beyond core C++ and kernel topics, the repository covers a broad range of supporting areas including memory management strategies, concurrency and synchronization patterns, network communication diagnostics, and performance optimization techniques. It also includes material on modern C++ language features, standard library usage, and software architecture patterns like the reactor model and event-driven design. The documentation is organized as a series of guides and tutorials, with practical code examples and step-by-step explanations that trace execution paths through both user-space and kernel-space code.

This project is a collection of operating systems courseware and educational programming exercises designed for studying operating system design and implementation. It provides a set of concept simulators for modeling CPU scheduling, memory virtualization, and concurrency mechanisms. The project includes specialized tools such as a concurrency simulation lab for experimenting with synchronization, a file system modeling suite for studying disk persistence and RAID configurations, and a process tree visualizer for displaying parent-child relationship hierarchies. The software covers broader capability areas including process management through code generation and visualization, resource management for simulating memory and CPU abstractions, and persistence system simulation for data storage and recovery.

This project is a collection of educational simulations and code examples designed to illustrate core operating system concepts. It provides practical implementations of virtualization, concurrency, and persistence to demonstrate how an operating system manages hardware and software resources. The repository includes simulators for CPU scheduling, memory virtualization via paging and segmentation, and file system architectures. It provides specific models for virtual-to-physical address translation and the distribution of processor time across competing tasks. The simulations cover concurrency control through the use of locks, semaphores, and condition variables to manage shared data. Additional coverage includes the modeling of non-volatile data persistence through simulated block-level disk input and output operations.