Open-source alternatives to Abi Aa

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

HelloSilicon is a programming guide and tutorial for writing and debugging low-level 64-bit assembly code specifically for Apple Silicon processors. It serves as an architecture reference for interacting with macOS and iOS kernel services using system calls and hardware registers. The project provides specialized instruction on foreign function interfacing to bridge assembly with high-level languages like C or Python. It also includes a toolkit for configuring Mach-O binaries and compiling universal binaries and dynamic libraries for cross-hardware compatibility. The material covers low-leve

ReactOS is an open-source operating system designed to be binary compatible with Windows applications and drivers. It consists of a low-level system kernel that manages hardware resources and a binary compatibility layer that enables the execution of software designed for the Windows binary interface. The project implements a cross-platform build system and toolchain for compiling and deploying bootable operating system images across different hardware architectures. This includes the use of cross-compilation toolchains and a hardware-abstraction layer to support various processor and motherb

This project is a technical reference and study of the Go language internals, providing a deep dive into the runtime architecture, compiler internals, and memory management mechanisms. It serves as a guide for analyzing how the Go compiler and runtime implement low-level features. The materials specifically detail the implementation of polymorphism through virtual tables and dynamic dispatch. It covers the translation of high-level source code into portable pseudo-assembly and machine-specific instructions, alongside the structural mechanics of the interface system, including scalar type boxi

This project is an ARMv8 assembly programming guide and tutorial designed to teach the translation of high-level logic into low-level machine instructions. It serves as a low-level systems programming reference for writing and executing code specifically for the ARMv8 architecture. The resource provides instructions for cross-platform assembly implementation, focusing on unifying symbol naming and memory addressing to ensure source code builds across different operating systems. It also covers the integration of assembly routines with higher-level languages using standardized calling conventi

This project provides an open-source firmware platform and complete build environment for portable multi-tool hardware. It functions as an embedded operating system designed to manage radio, infrared, and physical interface components, enabling users to develop custom applications and system logic for specialized hardware devices. The firmware distinguishes itself through a modular architecture that organizes system functionality into isolated units, allowing for the development of custom user interfaces and logic. It includes a comprehensive collection of low-level drivers and applications s

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

Zephyr is a real-time operating system and cross-platform embedded framework designed for resource-constrained hardware architectures. It provides an embedded kernel that manages memory, power consumption, and hardware peripherals across multiple microcontroller architectures. The project utilizes a hardware abstraction layer to decouple high-level kernel services from physical hardware through standardized driver interfaces. It employs a device tree hardware description format and a hierarchical configuration system to optimize binaries and feature sets for specific hardware constraints. Th

Tock is a secure embedded operating system and microcontroller kernel designed to isolate untrusted applications and drivers. It functions as a memory-safe process isolator that uses a combination of hardware memory protection and language-level type safety to execute mutually distrustful applications on bare metal. The system distinguishes itself through a hardware abstraction layer that decouples high-level components from specific microcontroller implementations using standardized traits. It further employs a virtualization layer to allow multiple independent software components to share a

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

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

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

OpenWrt is a modular Linux distribution designed for resource-constrained networking hardware. It functions as a comprehensive network routing platform, providing a complete build environment that allows users to generate custom firmware images for a wide variety of embedded processor architectures. By utilizing a standardized cross-compilation toolchain and a package-based ecosystem, it enables the creation of tailored operating systems for specific hardware deployments. The project distinguishes itself through a hardware abstraction layer that normalizes interactions across diverse chipsets

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 process

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 project provides the technical standards and API specifications for asynchronous JavaScript module loaders. It defines the protocols for defining, referencing, and loading modular code to ensure consistent execution and interoperability across different browser environments. The system establishes a standard interface for fetching and initializing JavaScript dependencies and non-code assets without blocking the main browser thread. It includes a resource loader interface for mapping module identifiers to physical file paths and resolving relative dependencies into absolute URLs. The cap

Raspberry Pi Imager is a graphical utility designed to download and write operating system images directly to SD cards and USB drives. It serves as a deployment tool for preparing bootable storage media for single-board computers, facilitating the automated installation and initial configuration of embedded systems. The application distinguishes itself by enabling on-the-fly image customization, which allows users to inject network settings and user credentials directly into the image during the writing process. It supports custom image sources and remote repository manifests, providing flexi

Odin is a compiled, statically typed systems programming language designed for high-performance software development. It focuses on pragmatic low-level memory control, providing a toolset for manual memory management and precise control over hardware utilization. The language is distinguished by its flexible memory model, which includes custom allocators and precise data layout capabilities to optimize resource usage. It features a comprehensive foreign function interface for importing assembly files and linking with external libraries using configurable calling conventions. The type system

This project is a Chinese translation and educational resource focused on the internal workings of the Linux kernel. It provides a curated collection of technical content designed for studying low-level operating system mechanisms and kernel development. The project utilizes a specialized localization workflow where translations are maintained in a forked repository. It employs a patch-based model and Git-driven synchronization to align Chinese translations with the original English source files through differential merge processes. The technical scope covers core operating system internals,

AsmJit is a runtime machine code generator and JIT compiler backend that translates high-level definitions into executable processor instructions. It provides a unified instruction emission API and an executable memory manager to allocate and protect virtual memory pages across multiple CPU architectures. The library functions as an assembly engine for x86 and ARM, supporting cross-platform assembly generation through a unified backend. It enables the creation of optimized machine code for different CPUs while maintaining a single codebase. The project covers low-level system abstractions in

xHook is a low-level instrumenter and hooking library for Android ELF binaries. It functions as a framework for intercepting native symbols and redirecting function calls by modifying the procedure linkage table. The tool utilizes regular expressions to filter specific binary files and symbols for interception. It enables the redirection of native calls toward custom function implementations without altering the original binary files. The framework covers dynamic symbol resolution, ELF table modification, and security analysis of native libraries. It also includes stability mechanisms that u

This repository contains the complete source code for a Unix-like operating system, including the monolithic kernel and base system utilities. It provides a BSD-derived system core and a full build toolchain required to compile a functional operating system for servers, desktops, or embedded devices. The system features a Linux binary compatibility layer that enables the execution and emulation of Linux binaries on a non-Linux platform. It also includes a modular kernel configuration process to tailor hardware support and system features during compilation. The project covers broad system ca

Geode is a game modification SDK and mod loader for Geometry Dash. It functions as a hooking engine and UI framework that allows for the injection of dynamic libraries to alter game behavior and add new features. The toolkit distinguishes itself through a centralized mod compatibility manager and hook registry that tracks active modifications to prevent logic conflicts and application crashes. It utilizes a trampoline-based hooking engine to redirect game function calls while preserving native call stacks, alongside a dedicated UI framework for rendering custom popups and interface components

Open-smartwatch-os is an operating system designed for resource-constrained wearable devices. It provides a development and testing environment that allows developers to build, validate, and debug firmware for smartwatches within a simulated desktop environment before deploying to physical hardware. The project distinguishes itself through a comprehensive suite of tools for hardware emulation and remote diagnostics. By utilizing a hardware abstraction layer and modular driver architecture, it decouples core system logic from specific physical components. This enables developers to run the ope

Lede is an embedded Linux build tool and firmware build system designed to generate bootable operating system images for routers and embedded network devices. It functions as a network device OS compiler that manages toolchains and target architectures to produce customizable firmware. The system enables the creation of custom router operating systems by integrating external package feeds from remote Git repositories. This allows for the expansion of available software packages and the tailoring of network appliance features during the build process. The build environment covers toolchain-ba

Contiki is an operating system designed for resource-constrained embedded devices and the Internet of Things. It provides a lightweight, event-driven kernel that enables multitasking and low-power wireless network connectivity on hardware with extremely limited memory and processing power. The system distinguishes itself through a stackless threading model that allows for a blocking-style programming interface while maintaining a minimal memory footprint. It supports dynamic module and firmware management, enabling the loading and linking of relocatable binary code at runtime to update applic

This project is an educational framework and toolkit designed for developing and testing operating system kernels. It provides a structured environment for implementing fundamental system primitives, including virtual memory management, preemptive process scheduling, and filesystem organization, using Rust and C. The framework is specifically oriented toward RISC-V and x86 architectures, serving as a laboratory for learning how to build core system software from the ground up. The project distinguishes itself by supporting both bare-metal deployment and hardware emulation, allowing developers