Open-source alternatives to Openbsd Src

This project is a Linux kernel designed for Windows Linux integration, providing the underlying operating system kernel required to execute binary files and applications within the Windows Subsystem for Linux. It utilizes hypervisor-based virtualization to run a full kernel within a lightweight utility virtual machine managed by a Windows host. The repository enables the customization and compilation of the kernel from source. This allows for the modification of system behavior, the addition of specific drivers, and the tailoring of hardware compatibility for virtualized environments. The sy

This project is a version-controlled Git archive and software archaeology dataset containing the continuous evolution of Unix source code from 1970 to the present. It serves as a chronological record of system history, synthesizing a versioned code timeline from disparate historical snapshots. The archive enables longitudinal software analysis by reconstructing a sequence of commits and merges from fragmented releases. This allows for the tracking of system evolution and the attribution of specific lines of code to original authors through synthesized version control metadata. The dataset co

Hello-World is a Git repository hosting service and source code management platform. It functions as a version control system for storing and managing source code. The platform facilitates remote code hosting and version control management to track changes over time. It supports public code distribution and collaborative software development, allowing multiple contributors to work on the same project from different locations. The system includes a web-based interface, an HTTP-based API, and SSH-based authentication for secure access. It utilizes a distributed repository model and content-add

This project is a community-curated directory of open-source tools and resources designed to assist system administrators with infrastructure management. It functions as a centralized knowledge base, providing a structured index of software and documentation that helps professionals discover solutions for automating, monitoring, and maintaining distributed computing environments. The repository distinguishes itself through a collaborative, community-driven structure that organizes a vast array of technical resources into a hierarchical taxonomy. By utilizing hyperlink-centric navigation, it d

This project is a tutorial for developing a custom bare metal operating system specifically for the Raspberry Pi 4. It provides the guidance and resources necessary to write software that interacts directly with hardware without the use of a pre-existing kernel. The project centers on an ARM64 cross-compilation toolchain and a build pipeline that transforms source code into raw binary images. It utilizes linker scripts to define physical memory addresses and section placements, ensuring the resulting binary loads at the correct hardware entry point. The codebase covers direct hardware interf

Universal Ctags is a multi-language symbol indexer and regex-based parsing engine used to extract and catalog functions, classes, and variables from source code. It functions as a source code indexer that scans files across diverse programming languages to create searchable catalogs of definitions and declarations. The project is distinguished by its extensible parser framework, which allows users to define new language rules using regular expressions and configuration files. It supports complex parsing scenarios through state-based parsing, stack-oriented scope tracking, and guest-parser del

This project is a tutorial and framework for building a low-level, bare-metal operating system from scratch using the Rust language. It focuses on ARMv8 kernel development specifically for the Raspberry Pi 3, providing the resources necessary to implement a monolithic kernel that runs directly on hardware without an underlying operating system. The project distinguishes itself by providing a complete embedded cross-compilation suite within a containerized environment to ensure consistent builds. It includes a dedicated kernel deployer that uses a serial interface and chainloader to load and b

This repository is a collection of reference source code and implementation examples for developing drivers using the Windows Driver Kit. It provides hardware device driver samples and development templates for building kernel-mode software that enables communication between the Windows operating system and hardware devices. The library includes examples for creating universal Windows drivers, which utilize a shared set of interfaces to operate across multiple versions of the operating system. It also contains specialized implementation samples for various hardware categories, including netwo

The Linux kernel is a monolithic operating system core that manages hardware resources, memory, and process scheduling across diverse computing architectures. It provides a standardized, POSIX-compliant environment for application execution while maintaining a modular driver framework that allows for the dynamic loading and removal of hardware interfaces. The project is distinguished by its high-performance concurrency toolkit, which utilizes lockless synchronization primitives and read-copy-update mechanisms to manage shared data access in multi-core environments. It incorporates a comprehen

rCore is a Rust-based operating system kernel and microkernel designed for Linux compatibility. It functions as a self-hosted development kit that implements a system call interface to support the execution of standard Linux userspace applications. The system is designed for modularity, featuring a mechanism for loading and integrating kernel modules into the active environment without requiring a system reboot. The kernel provides core operating system capabilities, including virtual memory mapping for process isolation, a disk-based file system for data persistence, and a layered network p

XNU is an operating system kernel designed to manage system hardware and process execution across different processor architectures. It utilizes a hybrid microkernel design that combines microkernel message passing with monolithic kernel performance by embedding critical subsystems into a single address space. The project implements a port-based asynchronous messaging system for communication between kernel tasks and userspace processes. It manages hardware interactions through a layered driver architecture and enforces system-wide security policies via a mandatory access control interface.

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 imple

This repository provides the Android device kernel and the corresponding Linux kernel source tree. It serves as the foundational codebase for managing the hardware architecture and power management of mobile devices. The project includes a comprehensive mobile hardware driver set designed to manage device-specific components, such as CPUs, GPUs, and cellular modems. The source code supports activities including Android kernel customization, custom ROM development, Linux kernel auditing, and mobile driver development.

This project is a monolithic operating system kernel designed to serve as the foundational software layer for diverse computing architectures and embedded platforms. It manages core system services, including processor scheduling, memory allocation, and hardware resource distribution, to facilitate communication between user applications and physical hardware. The kernel utilizes a hardware abstraction layer and platform-specific device trees to ensure consistent operation across a wide variety of processors and specialized computing devices. It supports dynamic functionality through loadable

This repository provides the original source code and binaries for legacy disk operating systems. It serves as a historical software archive and a reference implementation for early personal computer operating systems. The project is designed for software archaeology, legacy operating system research, and the study of foundational kernel design. It allows for the technical analysis of historical software architecture and implementation. The codebase covers several core system areas, including monolithic kernel design, segmented memory addressing, and file allocation table indexing. It also i

embedded-notes is a collection of technical study guides and development notes focused on embedded Linux, Linux kernel internals, and C programming. It serves as a reference for embedded systems development and a preparation resource for technical interviews in the field. The project provides detailed documentation on writing device drivers, managing virtual memory, and understanding kernel internals. It also includes guides on IoT network protocols, such as MQTT and TCP/IP, and outlines the architectural details of chip architectures and hardware peripherals. The material covers a broad sur

30dayMakeOS is an educational hobby operating system project designed for the x86 architecture. It implements a monolithic kernel and a custom bootloader that transitions the CPU from real mode to 32-bit protected mode to enable flat memory addressing. The project focuses on low-level system development, featuring a custom graphics driver for direct pixel-buffer rendering and window management without an existing operating system. It includes an x86 bootloader that loads the kernel from disk into memory. The system covers core kernel capabilities including round-robin task scheduling for pro

XNU is a hybrid operating system kernel that combines a microkernel architecture with a monolithic layer for system services. It provides a foundation for operating system development, incorporating standardized system-call interfaces, a modular device driver framework, and mandatory access control security. The architecture features a Mach-based microkernel and a BSD-based monolithic layer. It utilizes a message-passing inter-process communication bus for secure data exchange between isolated kernel components and user-space processes, alongside an object-oriented driver framework that decou

This project is a macOS system camera driver and software plugin that exposes software video streams as hardware-recognized camera inputs. It functions as an OBS virtual camera plugin, allowing the live output of OBS to be utilized as a webcam device within other applications. The tool enables the routing of composited video from a production suite into video conferencing applications such as Zoom or Google Meet. This allows for the streaming of processed scenes instead of a raw webcam feed. The system integrates with macOS using a kernel-level device driver and shared-memory buffer transfer

This project is a Windows Precision Touchpad driver and Apple Trackpad HID driver. It functions as an input device gesture driver that converts raw touch data from Apple trackpads and MacBooks into native multi-touch gestures and precise pointer movement. The driver implements the precision touchpad protocol to enable native Windows gesture and pointer controls for Apple hardware. This allows the operating system to recognize Apple trackpads as precision touchpads, replacing basic mouse functionality with native multi-finger swipes and precise scrolling. The implementation covers kernel-mode

This project provides a customized Linux kernel and driver suite designed to enable hardware compatibility for Surface devices. It focuses on building and patching the Linux kernel to provide driver support for proprietary hardware components that are missing from the upstream source. The system includes a secure boot kernel signing mechanism and a process for enrolling custom keys into the system firmware. This allows the execution of patched kernels while maintaining system security protections. The project covers peripheral driver support for touchscreens, styluses, and keyboards, as well

NuttX is a POSIX-compliant real-time operating system designed for microcontrollers ranging from 8-bit to 64-bit architectures. It provides a deterministic execution environment with a real-time task scheduler and a POSIX embedded kernel to ensure portable code execution across diverse hardware targets. The project distinguishes itself through a comprehensive hardware abstraction layer that provides standardized drivers for I2C, SPI, CAN, and USB across various semiconductor chipsets. It also features an embedded networking stack supporting TCP, UDP, IPv4, and IPv6, alongside industrial proto

Build Linux is a toolset for assembling a custom Linux distribution entirely from source code, automating the process described by Linux From Scratch. It compiles every system component from upstream source, giving the builder full control over included packages and configuration. The build process relies on a Makefile-driven orchestration that coordinates the entire sequence, using script-defined package recipes for each component. It employs chroot isolation to keep build artifacts separate from the host, and follows a stage-wise bootstrapping approach that first builds a minimal set of tem

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

The Linux Kernel Module Programming Guide is an educational resource that teaches how to write, compile, and manage loadable kernel modules for modern Linux kernels. It covers the complete lifecycle of kernel modules, from building and loading to unloading and debugging, with a focus on extending kernel functionality without recompiling the entire kernel. The guide provides comprehensive coverage of core kernel programming concepts including dynamic module loading, file-operation registration, interrupt handling, kernel-user data copying, concurrency control, and deferred task scheduling. It

This project provides a development framework for writing loadable Linux kernel modules using the Rust programming language. It establishes a methodology for safe systems programming by enforcing memory and thread safety within the restricted execution environment of the kernel, allowing developers to extend operating system functionality while preventing common memory corruption errors. The framework distinguishes itself through automated generation of type-safe foreign function interfaces, which bridge high-level code with low-level kernel headers and system structures. It maps high-level s

PHPUnit is a unit testing framework and automated testing tool for the PHP ecosystem. It provides a comprehensive suite for writing and running automated tests to verify the functional correctness of PHP code and identify software bugs. The framework supports both unit and end-to-end testing to validate individual code units and complete application workflows. It includes capabilities for automated regression testing and test suite management, allowing for the execution of targeted subsets of tests. The tool provides mechanisms for identifying flaky tests through automatic retries and test r