Projects sharing features with Nuttx

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

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 provides a server-side language runtime and a standardized Docker image for deploying applications across different operating systems. It functions as an execution environment for generating dynamic HTML, JSON, and XML content, while also serving as a command line interface for automation scripts and background jobs. The runtime is designed for extensibility through a C-based extension architecture, allowing the loading of custom modules for specialized functionality. It supports multiple server application interfaces, including a FastCGI web interface for high-performance commun

This project is a learning guide and collection of study notes designed to teach Node.js backend development. It provides a comprehensive core API reference and practical demonstrations for implementing server-side logic, network programming, and system APIs. The guide specifically covers advanced technical domains including process management for scaling applications via clusters and child processes, as well as network programming for building TCP, UDP, and HTTP services. It also includes detailed instructional material on security implementation, focusing on cryptographic hashing and encryp

nix is a Unix system API library and Rust system programming interface that provides type-safe bindings for invoking low-level system calls. It serves as a low-level operating system wrapper and POSIX compatibility layer, allowing for kernel interactions and administrative tasks through safe wrappers around platform-specific APIs. The project provides a kernel device interface for controlling hardware devices, managing kernel modules, and configuring terminal interfaces. It differentiates itself by offering type-safe wrappers for memory mapping and zero-copy input-output operations to reduce

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

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 flight control autopilot software designed as a real-time operating system for managing the flight dynamics and navigation of autonomous multicopters, fixed-wing aircraft, and rovers. It serves as a multi-vehicle autopilot framework that supports various aircraft configurations, including vertical takeoff and landing platforms across industrial environments. The system includes a MAVLink communication stack for exchanging telemetry and command data between unmanned vehicles and ground control stations. It also provides a software-in-the-loop flight simulator to test autopilot

This is an open-source, crowd-sourced wiki textbook that teaches Linux system programming in C. It covers the core operating system concepts of process management through the fork-exec-wait model, dynamic memory allocation using implicit free list heap allocators, inode-based file systems, inter-process communication via pipes and shared memory, POSIX threads with synchronization primitives, signal-based asynchronous notification, virtual memory with page table translation, and runtime diagnostics using Valgrind and GDB. The textbook distinguishes itself by providing practical, implementation

Skill-Tree is an educational framework designed to map theoretical technical concepts to practical implementation pipelines and structured interview preparation. It organizes technical knowledge into a tree-based index to enable structured navigation and uses a theory-to-implementation pipeline to verify conceptual understanding through concrete software tasks. The project provides curated study paths and cross-referenced indexing that links common interview questions and simulated exam sets to specific technical modules. It employs module-based subject isolation to separate diverse backend d

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

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

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

RT-Thread is an IoT real-time operating system and embedded device kernel. It provides a lightweight execution environment for microcontrollers, combining a real-time kernel with a hardware abstraction layer to manage multi-threaded task scheduling and hardware resource allocation. The project is built as a modular framework that utilizes a package-based ecosystem. This allows for the integration of reusable software libraries and high-level services through a loosely coupled architecture. The system covers real-time task scheduling, resource-constrained memory management, and embedded hardw

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

IREE is an MLIR-based compiler toolchain and runtime designed to translate machine learning models from various frameworks into optimized binaries for execution across diverse hardware targets. It provides a unified pipeline to ingest models from PyTorch, TensorFlow, JAX, and ONNX, lowering them into a common intermediate representation for deployment on CPUs, GPUs, and bare-metal embedded systems. The project distinguishes itself through a bytecode virtual machine and a hardware abstraction layer that decouple high-level model logic from specific hardware instruction sets. It supports sophis

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

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

Asterinas is a memory-safe operating system kernel designed to prevent data races and memory corruption. It functions as a Linux-ABI compatible kernel, enabling the execution of existing Linux binaries and container workloads while providing a declarative operating system distribution model. The project distinguishes itself by acting as a virtual machine container host and a confidential computing guest OS, allowing it to run within hardware-isolated Trusted Execution Environments such as Intel TDX. It implements a minimal trusted computing base by isolating unsafe low-level operations and se

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

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

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

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

LXD is a unified platform for managing both system containers and virtual machines through a single REST API and command-line interface. It provides a programmatic HTTP interface for controlling the full lifecycle of instances, enabling automation and integration with external tools. The system runs unprivileged containers with per-instance UID/GID mappings, seccomp filters, and AppArmor profiles for kernel-level isolation, while supporting multiple storage backends including directory, Btrfs, LVM, ZFS, Ceph, LINSTOR, and TrueNAS through a unified driver interface. The platform distinguishes

Lancet is a comprehensive extension of the Go standard library, providing a collection of reusable functions and data structures designed to reduce boilerplate code in applications. It serves as a general-purpose toolkit across multiple domains, including concurrency, security, networking, and functional logic. The project distinguishes itself through specialized toolkits for Go concurrency, such as keyed locking and channel-based stream processing, and a dedicated functional programming kit that supports currying and function composition. It also includes a dedicated cryptography library imp

OpenThread is an open-source implementation of the Thread networking protocol stack. It provides a standard-compliant IPv6 mesh networking stack, integrating 6LoWPAN and IEEE 802.15.4 to enable secure, internet-connected communication for low-power wireless devices in smart home and industrial automation environments. The project includes a Thread Border Router, which acts as a networking gateway bridging low-power mesh networks to external IP networks such as Wi-Fi or Ethernet. It is designed for energy efficiency, featuring a low-power wireless mesh implementation that allows battery-operat