Projects sharing features with Tock

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 m

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

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

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

NuttX is a POSIX-compliant real-time operating system designed for resource-constrained embedded environments. It functions as a scalable microcontroller OS that provides a Unix-like environment for managing hardware and running applications across architectures ranging from 8-bit to 64-bit. The system ensures high software portability by implementing a kernel that follows POSIX and ANSI standards. This allows developers to create portable embedded applications using standardized API calls across diverse hardware architectures. The project includes a modular kernel architecture and a hardwar

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

F Prime is a component-based framework designed for the development and deployment of embedded and spaceflight software. It provides a modular architecture that decouples software logic from communication interfaces, allowing developers to define system structures through a domain-specific modeling language. This model-based approach enables automated code generation, ensuring consistency across complex system topologies while maintaining strict interface contracts between software modules. The framework distinguishes itself through its integrated build system and ground data operations suite

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

Embedded-hal is a hardware abstraction layer for embedded microcontrollers that defines common traits allowing peripheral drivers to remain entirely independent of specific hardware platforms. The library provides platform-agnostic interfaces that decouple driver logic from microcontroller architectures, utilizing zero-cost trait abstractions that compile down to direct hardware register manipulations without runtime overhead or memory allocation. The project features asynchronous execution support and synchronous-to-asynchronous adaptation, enabling non-blocking peripheral operations and coo

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

FreeRTOS-Kernel is a real-time operating system kernel for microcontrollers. It provides a multitasking environment through a priority-based task scheduler, an embedded memory manager, and an inter-process communication framework to ensure time-critical tasks meet their deadlines. The kernel includes a software timer engine for executing functions at predefined intervals or after set delays. It supports a minimal model of concurrent tasks and lightweight co-routine execution for systems with limited memory resources. The project covers a broad surface of embedded resource management, includi

TencentOS-tiny is a real-time operating system for microcontrollers designed to manage task scheduling and resource allocation across various hardware modules. It functions as an embedded platform and modular kernel for deploying real-time software on different chip architectures. The system includes built-in protocol stacks to enable secure data transmission and connectivity between terminal IoT devices and cloud platforms. The project covers real-time task management, embedded software deployment, and microcontroller administration. It utilizes a modular microkernel architecture and a har

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

OM1 is a multimodal AI agent runtime and orchestration framework designed to connect large language models to physical robot hardware and sensors. It provides an execution environment that processes audio, video, and sensor data to drive autonomous decisions and actions in real-world settings. The system integrates a robotics SLAM and navigation stack with a hardware abstraction layer, allowing high-level AI commands to be translated into low-level motor and actuator instructions. It distinguishes itself by incorporating blockchain-based governance to enforce immutable operational rules and p

Lunatic is a WebAssembly runtime and concurrent process manager that implements an Erlang-inspired model of lightweight concurrency and fault tolerance. It functions as a distributed actor system where isolated processes communicate via message passing across a network of linked nodes. The system utilizes a WebAssembly sandbox environment to isolate memory and restrict system call permissions for each individual process. This capability-based security model ensures that processes are sandboxed to safely execute untrusted code. The platform provides a fault-tolerant supervision tree for hiera

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

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

The Espressif SoC Development Framework is a comprehensive toolset for developing, compiling, and flashing applications targeting Espressif system-on-chips. It serves as an embedded toolchain orchestrator and a hardware abstraction layer that simplifies the control of low-level peripherals, memory mapping, and chip-specific registers. The framework provides a dedicated IoT connectivity stack for implementing Wi-Fi, Bluetooth, Zigbee, and Ethernet communication on microcontrollers. It also includes an embedded real-time operating system integration layer to manage multitasking and scheduling o

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

WinFSP is a framework for implementing custom file systems on Windows. It enables the creation of user-mode file systems that appear as standard disk drives or network shares to the operating system, allowing developers to implement file system logic in user space via a proxy architecture that avoids the need for custom kernel code. A primary differentiator is its FUSE compatibility layer, which maps POSIX-based file system calls to native Windows requests. This allows existing file systems written for the FUSE API to be ported to Windows and Cygwin environments. The project covers a wide ra

Mbed OS is a real-time operating system designed for connected internet-of-things devices and microcontroller hardware. It provides a fundamental framework that combines a real-time operating system with an embedded security framework, a hardware abstraction layer for controlling sensors and peripherals, and a device management platform for cloud-based orchestration. The system establishes security foundations to protect connected products from unauthorized access and vulnerabilities. It further enables remote monitoring and hardware orchestration by connecting embedded devices to cloud servi

Firefox is a cross-platform web browser engine designed to render web content, execute JavaScript, and manage secure browsing sessions. It utilizes a multi-process isolation architecture that distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from impacting the entire application. The engine incorporates a sandboxed execution environment to restrict web content and untrusted scripts to isolated memory compartments, enforcing security policies that prevent unauthorized access to system resources. The project distinguis

systemd is a comprehensive system and service manager for Linux that orchestrates the entire operating system lifecycle. It functions as the primary init system, managing the transition from firmware to a fully initialized user space while providing a unified framework for service orchestration, hardware management, and resource control. The project distinguishes itself through its declarative, unit-based configuration model and dynamic dependency resolution, which allow for efficient, on-demand service activation and socket-based process management. It integrates deep system observability th

FreeRTOS is a real-time operating system for embedded devices that provides a kernel for predictable task execution. It utilizes priority-based preemptive scheduling and deterministic timing to manage simultaneous hardware tasks. The project includes a symmetric multiprocessing kernel that distributes processing workloads across multiple CPU cores using a shared memory architecture. It also provides a thread-safe TCP/IP networking stack for managing internet protocol traffic and IPv6 connectivity on embedded processors. The system incorporates an embedded memory manager with fixed-size alloc

This project is a comprehensive technical interview preparation resource and computer science interview guide. It serves as an educational reference for developers to study core software engineering fundamentals and common coding patterns required for employment screenings. The repository provides detailed guides and references covering data structures and algorithms, networking and security, operating systems, and web development. It specifically focuses on the implementation and complexity analysis of sorting, searching, and graph algorithms. The material encompasses a wide breadth of comp

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

TinyGo is a specialized compiler and development toolkit designed to bring the Go programming language to resource-constrained microcontrollers and WebAssembly environments. It provides a bare-metal runtime environment that enables high-level code execution without the need for a traditional operating system, utilizing an LLVM-based backend to generate efficient machine instructions. The project distinguishes itself through aggressive optimization techniques tailored for small hardware, including a static memory allocation strategy and whole-program dead code elimination that significantly re