Cilium is a Kubernetes-native networking, observability, and security solution built on eBPF. It provides CNI plugin functionality with overlay/native routing modes, distributed load balancing (replacing kube-proxy), cluster mesh for multi-cluster connectivity, identity-based network policies (L3-L7), service mesh with mutual authentication, and observability via Hubble (flow metrics, DNS insights). The architecture features a modular design using the Hive dependency injection framework, with components including the cilium-agent daemon, operator for CRD management, CLI tools for management/debugging, and API servers for inter-component communication. The data plane leverages eBPF/XDP for high-performance packet processing, while the control plane integrates deeply with Kubernetes through client-go, controller-runtime, and custom resource definitions.
WinFsp is a Windows File System Proxy that provides a FUSE (Filesystem in Userspace) compatible API for Windows. It allows developers to create custom file systems in user space using C, C++, .NET, or any language that can call a C library. The repository contains a kernel-mode Windows driver (`src/sys/`) that handles IRP dispatch and communicates with a user-mode DLL (`src/dll/`) via a transaction protocol. It includes a comprehensive FUSE v2 and v3 compatibility layer, a native WinFsp API, a service launcher for running file systems as Windows services, a network provider for automatic mounting, and an extensive test suite. The architecture is a hybrid kernel/user-mode system, deeply integrated with Windows NTFS semantics. While primarily an application framework, it also contains performance benchmarking data and analysis notebooks in its documentation. The codebase is actively maintained, demonstrates high craftsmanship in a difficult domain, and contains several reusable components such as a fault injection framework, POSIX-to-Windows security mapping, and a directory buffer abstraction.
The Linux Kernel Module Programming Guide (LKMPG) is a comprehensive, community-maintained guide to writing Linux kernel modules. It consists of a LaTeX book and a large collection of example kernel modules that demonstrate a wide range of kernel APIs and programming patterns, including character devices, the /proc filesystem, sysfs, debugfs, system call interception, synchronization primitives (mutex, spinlock, rwlock, RCU), interrupt handling, timers, workqueues, block devices, network drivers, DMA, device tree, GPIO, and more. The repository also includes a QEMU-based development environment (devtools) that automates building a minimal kernel and initramfs, allowing developers to compile and test modules inside a virtual machine without affecting their host system. The code is well-structured, follows kernel coding conventions, and includes proper error handling and cleanup. Many examples include version guards for compatibility across different kernel versions (5.10 through 6.17+). The devtools scripts are robust, with caching, idempotency, and prebuilt binary support to speed up setup. The CI pipeline builds the book, compiles all examples, runs static analysis (cppcheck, sparse, gcc, smatch), and tests module loading/unloading in both bare-metal and QEMU environments. While primarily educational, the example modules are self-contained and can serve as templates for real kernel module development. The devtools provide a reproducible environment for kernel module testing, which is valuable for developers working on out-of-tree modules. The repository is actively maintained and targets recent Linux 5.x and 6.x kernels.
Asterinas is a production-grade, memory-safe operating system kernel written in Rust that aims to be Linux-compatible. It implements a framekernel architecture combining monolithic performance with microkernel-inspired separation, providing system call interfaces, device drivers, filesystems, networking, and process management. The project includes the OSDK (OS Development Kit) for building, running, and testing Rust kernels, and supports multiple architectures (x86-64, RISC-V, LoongArch) with varying tier levels. While it has strong research roots (evidenced by recent academic papers), its primary focus is on creating a usable OS that can run real-world applications via NixOS distribution.
This repository implements 'moss', a monolithic, Unix-like operating system kernel written in Rust, targeting AArch64 (with stubs for x86_64). It boots on QEMU and aims to run unmodified Linux userspace binaries (e.g., bash, coreutils, strace) by providing a Linux-compatible syscall interface. The kernel features an asynchronous core: all non-trivial syscalls are async functions, and the scheduler (EEVDF) and synchronization primitives are designed for async operation. The architecture includes a Hardware Abstraction Layer (HAL) via the `Arch` trait, but the majority of the code is ARM64-specific, covering boot, exception handling, MMU, interrupt controllers (GICv2/v3), UART drivers, timers, RTC, virtio, and a virtio-GPU display driver. The kernel provides a full process model with clone, execve, signals, futex, epoll, inotify, ptrace, and POSIX credentials. Memory management includes demand paging, copy-on-write, mmap, brk, a slab allocator with per-CPU caches, and a buddy allocator for physical frames. The VFS supports multiple filesystems: tmpfs, ext4 (via the ext4plus crate), FAT32, procfs, devfs, sysfs, and a cgroupfs stub. Networking uses the smoltcp stack for TCP/UDP and provides Unix domain sockets. The codebase is experimental and contains many stubs and unimplemented syscalls, but it is actively developed with a working init process, shell, and basic tools. Key strengths include the clean separation of architecture-independent kernel building blocks in the `libkernel` crate, the async-friendly synchronization primitives (`WakerSet`, `CondVar`, `Mutex`), the generic page table framework, and the driver registration macro. The code is well-structured for a kernel of this complexity, with extensive use of Rust's type system for safety (e.g., typed addresses, user-copy abstractions). However, the project is not production-hardened, relies on nightly Rust, and has significant architecture-specific code that limits portability.
simplefs is a Linux kernel module that implements a simple extent-based filesystem for educational use, accompanied by a userspace mkfs.simplefs formatter. The kernel component registers a VFS filesystem type and implements superblock, inode, file, and directory operations. The on-disk layout is a fixed 4 KiB block format: superblock, inode store, inode free bitmap, block free bitmap, and data blocks. Inodes are 72 bytes and point to an extent-index block; regular files use extents of up to 8 contiguous blocks (maximum file size around 10.65 MiB), while directories use a hashed ring of extents to support up to 40,920 entries. Functionally, the filesystem supports create, lookup, unlink, rename, hard links, symbolic links, mkdir, rmdir, and read/write. File I/O is implemented through both traditional VFS page-cache helpers and simpler direct buffer-head read/write paths, making the code a useful teaching reference for how Linux VFS callbacks and buffer management interact. External journaling is supported via the kernel's jbd2 subsystem, mounted with a journal_path or journal_dev option, though only extent metadata is journaled and the journal size is currently hardcoded. Entry points are module_init/module_exit in fs.c, the mount path through simplefs_fill_super in super.c, and main() in mkfs.c. Dependencies are Linux kernel headers, jbd2, block-device APIs, and a Linux or macOS host for mkfs. The repository includes shell-based integration tests that exercise maximum directory fill, large-file behavior, remount persistence, random create/delete, and free-block reclamation, plus CI jobs for formatting and macOS mkfs verification. The code maintains compatibility macros spanning Linux 5.10 through 7.3, reflecting active upkeep.
Tilus is a tile-level GPU kernel programming language and compiler framework, primarily targeting NVIDIA architectures (SM80, SM90, SM100). It provides a Python DSL (`tilus.Script`) for writing high-performance CUDA kernels with explicit management of shared/register memory, tensor cores (WGMMA, tcgen05), and advanced synchronization primitives (mbarrier, cluster sync, TMA). The compiler stack includes a custom IR with layout inference (register/shared/tensor-memory), a pass pipeline (dead code elimination, bound-aware simplification, sub-byte type lowering), and backend emitters that generate PTX/CUDA code. Autotuning over tile sizes, warp counts, and pipeline stages is built into the framework. The architecture separates concerns into three layers: the user-facing `lang` package (Script, autotune, instructions), the `ir` package (tensors, layouts, instructions, inference rules), and the `backends` package (emitters, contexts, code generation). The `hidet` subpackage integrates a vendored copy of the Hidet IR and transforms, which provides the low-level expression/statement IR and a comprehensive set of optimization passes. Examples cover progressive matmul implementations (V0–V6) for Ampere, Hopper, and Blackwell, as well as flash attention, layer norm, and quantization kernels. This is a research project (ASPLOS '26 paper) with a strong emphasis on correctness and performance, evidenced by CUDA-level validation against PyTorch and cuBLAS. While the codebase is well-structured and demonstrates advanced compiler design patterns, it remains in beta (version 0.2.0) and carries some duplication between vendored Hidet code and native Tilus code, as well as hardware-specific constraints (NVGPU only). The layout inference system and autotuning infrastructure are particularly notable as reusable components.
xv6 is a monolithic, teaching-oriented Unix-like operating system kernel for RISC-V, reimplemented from Version 6 Unix. The kernel provides process management (fork, exec, wait, exit), multiprocessor scheduling via a round-robin scheduler, virtual memory with SV39 page tables, a block-oriented file system with crash recovery via a write-ahead log, and essential device drivers (UART console, virtio disk). It boots in QEMU and includes a minimal init process, shell, and a suite of simple user commands (cat, grep, ls, etc.). The codebase is intentionally compact and clear, demonstrating core OS concepts with a focus on simplicity and directness rather than performance or production robustness. It is not a hybrid repo; it is purely a systems software application (an operating system).
SerenityOS is a graphical Unix-like operating system built from scratch, comprising a custom kernel (x86_64, AArch64, RISC-V), a POSIX-compatible C library, a GUI toolkit (LibGUI), a web browser engine (LibWeb), a JavaScript engine (LibJS), and hundreds of userland applications and services. The codebase demonstrates high engineering effort with consistent patterns (ErrorOr, reference counting, IPC frameworks, object macros) and extensive test coverage across kernel, libraries, and web standards. However, it bears some technical drift: many POSIX functions are stubs, kernel features are incomplete on newer architectures, and the ports system for third-party software requires ongoing maintenance. The repository is actively developed with frequent commits and issue triage.
KernelScript is a domain-specific language and compiler (OCaml) for developing eBPF-centric programs. The compiler translates a single `.ks` source file into multiple C outputs: idiomatic eBPF C code (for kernel execution via XDP, TC, kprobe, tracepoint, perf_event, struct_ops), userspace loader C code (managing maps, ring buffers, tail calls, and program lifetime), and optionally kernel module C code (for `@kfunc` functions). The compiler pipeline includes lexing, parsing, symbol table construction, type checking (including context-specific rules for eBPF program types), IR generation with control-flow and data-flow analysis, loop analysis (bound detection, bpf_loop optimization), tail-call detection and automatic progarry management, map assignment optimization, safety checking (null pointer, bounds, overflow), and multi-program optimization (map type changes, batching). It also supports BTF introspection for kernel type and kfunc extraction, a Python bridge, and a compile-time evaluator. The architecture is modular with pluggable context code generators per program type. The project includes an extensive test suite covering the full pipeline from parse to C output and specific features like perf_event attach, ring buffer dispatch, struct_ops, and multi-program scenario.
Falkon is a Python library for large-scale kernel ridge regression and logistic regression, leveraging Nyström approximation and preconditioned conjugate gradient to scale to billions of points. It provides a scikit-learn-like API (fit/predict) with GPU acceleration via custom CUDA/cuBLAS/cuSOLVER kernels and optional KeOps integration for on-the-fly kernel-vector products. The library includes hyperparameter optimization through differentiable objectives (LOOCV, GCV, Nyström compression) with gradient-based solvers, out-of-core operations for GPU memory overflow, and sparse tensor support. Benchmark infrastructure compares Falkon against GPyTorch, GPflow, and EigenPro on datasets like Higgs, TIMIT, MillionSongs. The codebase is well-tested with CI/CD for CPU/GPU builds and pre-built wheels for multiple PyTorch/CUDA combinations. While the core library is production-grade, some benchmark scripts are one-off and a few modules have TODO comments or limited platform support (Linux-only, Windows untested).
This is a bare-metal x86-64 operating system kernel written in Swift (using Embedded Swift). It boots on real hardware and emulators (QEMU, Bochs, VMWare) via both BIOS and UEFI. The kernel implements core OS primitives: memory management (page tables, slab allocator), interrupt handling (APIC, IOAPIC, PIC), ACPI table parsing and a full AML bytecode interpreter, PCI/PCIe bus enumeration, USB host controllers (UHCI, XHCI, EHCI), PS/2 keyboard/mouse, Intel i915 GPU driver, and a simple cooperative task scheduler. It uses a custom Swift toolchain (swift-kstdlib) and custom Swift macros for printf-style output. The project is a research/learning effort by a single developer, exploring Swift as a systems programming language for kernels. Architecture is modular with device driver tree, ACPI namespace, and separate memory management layer. Many drivers are functional but some remain incomplete or experimental (e.g., VMX virtualization, i915 only supports two GPU IDs).
This repository contains a Linux kernel driver for managing battery health features on Acer laptops via the WMI (Windows Management Interface) interface. The driver enables control of two key battery functions: a health mode that limits charge to 80% to prolong battery lifespan, and a calibration mode that performs a full charge-discharge cycle for accurate capacity reporting. It also provides battery temperature readings. Implemented as a single kernel module (acer-wmi-battery.c), it interacts with the laptop's firmware through WMI methods to query and set battery parameters, exposing these controls via sysfs attributes under /sys/bus/wmi/drivers/acer-wmi-battery/. The driver follows standard Linux kernel module practices, including proper error handling, version-dependent includes for compatibility, and sysfs attribute creation for user-space interaction. It includes reusable WMI helper functions that encapsulate the boilerplate for WMI method calls, buffer handling, and response validation. The project is actively maintained with recent commits, supports multiple Acer laptop models as documented in MODELS.md, and is licensed under GPL-2.0.
This repository serves as packaging infrastructure for building and distributing CachyOS software (primarily kernel variants and related system tools) for Fedora Linux via COPR. It contains RPM SPEC files, source code patches, and configuration files that define how to construct installable packages. The repository does not contain an application itself but provides the necessary build specifications to produce kernel packages (kernel-cachyos, kernel-cachyos-lts, etc.) and associated tools like CachyOS-Settings, scx-scheds, scx-manager, and ananicy-cpp. Users enable the associated COPR repository to install these packages directly on Fedora systems. The packaging follows standard RPM conventions with some customizations for kernel building and system integration.
This repository is a step-by-step tutorial for building an operating system from scratch, progressing from a simple boot sector to a kernel with interrupts, memory management, and a basic shell. The code is organized into sequential lessons, each building upon the previous. The system boots via a custom boot sector, loads a kernel into memory, transitions to 32-bit protected mode, sets up interrupt handling (including timer and keyboard), and provides a shell that can echo user input and handle basic commands like 'END' to halt and 'PAGE' to test memory allocation. While educational and well-commented, the codebase shows signs of abandonment per the README, though the last commit date indicates recent activity. The architecture is monolithic with modular components for bootloader, kernel, drivers (screen, keyboard, timer), and a lightweight libc.
This repository is a custom operating system kernel project (UtopiaKernel) targeting x86-64 with the Limine boot protocol. The kernel entry point is written in Rust (using edition 2024, which is unstable) and is compiled as a bare-metal binary. The boot process uses the Limine bootloader, whose precompiled binaries for multiple architectures (x86_64, aarch64, riscv64, loongarch64, IA-32) are included in the repository. The only substantial source code beyond the kernel entry is a C utility (`limine.c`) for installing the Limine bootloader onto disk images and the Limine protocol header. The project demonstrates a modular adapter pattern for boot protocol abstraction, but the codebase is dominated by opaque binary blobs, limiting inspectability and reusability. It appears to be in active development but carries technical drift risk from using an unstable Rust edition and vendored third-party binaries.