Embedded, IoT and hardware

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 hardware abstraction. It includes a unified device driver framework for peripheral access across different CPU architectures and supports hardware execution simulation for testing firmware logic without physical hardware.

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. The system covers a broad range of capabilities, including embedded network stack implementation for wired and wireless connectivity, power management for energy efficiency, and secure storage for protecting sensitive data. It also includes tools for file system management, inter-process message routing, and system event logging. Development is supported by a manifest-driven dependency management system and a structured environment configuration process to automate the organization of the workspace.

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 on embedded hardware. The project covers broad capability areas including build and deployment automation, low-level hardware access, and system memory management. It also provides core system services for device initialization and security operations to protect firmware and communication channels. Development environment bootstrapping is handled via Python-driven automation to install required compilers and toolchains.

QEMU is a cross-platform system emulator and hardware virtualization platform that enables the execution of multiple isolated operating systems on a single host machine. It functions as a processor architecture emulator, translating machine instructions between different hardware platforms to allow software designed for one architecture to run on another. The project distinguishes itself through a modular target architecture that separates core emulation logic from specific hardware definitions, supporting a wide range of processor and peripheral configurations. It utilizes dynamic binary translation to convert guest instructions into host-native code and leverages hardware-assisted virtualization to execute guest operating system code directly on the host processor for near-native performance. Beyond general system virtualization, the software provides a device emulation layer that simulates virtualized hardware components, such as disk controllers and network cards, to interact with guest systems. It manages system resources through a micro-kernel-style control layer and handles concurrent input and output operations using asynchronous multiplexing. These capabilities support diverse technical requirements, including embedded systems development, legacy software preservation, and cross-platform compatibility testing.

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. It automates the entire lifecycle of embedded software, from cross-compilation and dependency management to the generation of telemetry and command interfaces. By providing a unified environment for both onboard flight software and ground-based monitoring, it facilitates seamless integration, testing, and command-and-control of distributed embedded systems across diverse hardware platforms. Beyond its core architecture, the project includes comprehensive tools for system observability, including real-time telemetry visualization, event logging, and diagnostic tracing. It supports a wide range of deployment scenarios, from bare-metal environments to real-time operating systems, and provides mechanisms for memory management, state-driven behavior modeling, and asynchronous task execution. The project is maintained as a C++ repository with extensive documentation and build-system support for cross-platform development.

Tiny-gpu is an educational hardware emulator designed to model the fundamental operations of a graphics processing unit. It provides a software environment that simulates hardware data flow and parallel computing logic, allowing users to visualize the internal execution cycles and memory structures characteristic of graphics hardware. The project distinguishes itself by implementing a cycle-accurate execution model that tracks the progression of operations through discrete processing steps. It utilizes a fixed-function pipeline to process geometric data through sequential transformation and rasterization stages, while employing instruction-level parallelism to execute graphics instructions across multiple data elements simultaneously. This framework supports the study of graphics pipeline development and parallel computing by mapping scalar inputs into vector data streams. It maintains internal register-based state management to track data evolution during shader program execution, providing a platform for exploring high-performance computing concepts through the simulation of hardware pipelines.

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 and bootloader environments. It employs a declarative configuration framework where system and network settings are managed via structured text files, which are then coordinated through a unified system message bus. This architecture allows for precise control over kernel-level packet filtering, high-performance routing, and complex firewall policies, all of which can be managed through both command-line utilities and a dynamic web-based dashboard. Beyond core routing and firewall management, the platform supports a broad range of infrastructure capabilities including virtual private network connectivity, wireless access point engineering, and virtual local area network segmentation. It also provides tools for storage management, secure remote access, and the integration of external services such as home automation controllers or web application hosting. The system is designed to be extensible, allowing users to install independent software packages to expand functionality beyond the minimal base system.

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 boot kernel images onto physical hardware via UART. The framework covers core system capabilities including virtual memory mapping and configuration for resource isolation, hardware exception handling for system stability, and the implementation of serial drivers for console output. It also supports hardware simulation through emulators and on-chip debugging to verify kernel logic before physical deployment.

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 motherboard types. The system covers the generation of bootable ISO images and media for installation on physical or virtual hardware. It includes capabilities for formatting system partitions and deploying the operating system to supported file system types.

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 comprehensive kernel tracing and instrumentation suite that enables non-intrusive monitoring of system events, function execution, and latency metrics. Furthermore, the kernel enforces strict interface stability guarantees and lifecycle tracking to ensure backward compatibility for dependent applications. Beyond its core identity, the system includes extensive capabilities for hardware abstraction, network protocol implementation, and security policy enforcement. It supports specialized engineering requirements through power state management, embedded system optimizations, and firmware-based booting processes. The architecture also features robust diagnostic frameworks for memory analysis, system execution verification, and the validation of concurrent programming models. The source repository provides a complete build system for transforming code into executable binary images, including tools for kernel feature selection and configuration optimization to tailor the output for specific hardware requirements.

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 reduce binary footprints. It employs a register-based calling convention to minimize memory overhead and provides a consistent hardware abstraction layer, allowing developers to write portable driver logic that remains decoupled from specific chip implementations. Beyond core compilation, the toolkit offers a comprehensive suite of utilities for the entire embedded lifecycle. This includes support for concurrent task management, hardware interrupt handling, and direct interaction with peripherals such as I2C, SPI, and GPIO pins. It also features robust deployment tools for flashing firmware directly to hardware via USB or external debug probes, alongside observability features like heap allocation tracing and binary size reporting. The project provides extensive documentation and command-line utilities to prepare development environments, including integration with editor language servers to ensure accurate code completion for hardware-specific targets.

MicroPython is a lean implementation of Python 3 optimized to run on microcontrollers and other resource-constrained systems. It serves as a cross-platform embedded runtime and hardware abstraction layer, providing a firmware framework that maps high-level software commands to specific microcontroller registers across diverse processor architectures. The project functions as an embedded language interpreter that enables rapid prototyping on hardware through an interactive read-eval-print loop. It supports a wide range of target environments, including ARM, ESP32, STM32, RISC-V, and WebAssembly. The runtime covers comprehensive hardware integration for GPIO pin management, analog signal processing, and serial protocol communication. It includes capabilities for networking via WiFi, Ethernet, and Bluetooth Low Energy, as well as data persistence through a virtual filesystem. The system also provides tools for asynchronous logic, bytecode compilation, and the integration of native C modules for low-level hardware access. The environment can be deployed via firmware flashing or remote over-the-air updates, with support for embedding application code directly into the binary.

SerenityOS is a complete, self-hosted desktop operating system built from the kernel up. It features a monolithic kernel architecture that manages system services, hardware drivers, and networking within a single address space. The system provides a full computing environment, including a proprietary windowing system and a suite of native desktop applications, all while maintaining a POSIX-compliant interface for standard system programming. The project is distinguished by its integrated development workflow, which relies on a cross-compilation build pipeline to generate system images from host machines. Developers iterate on low-level changes within a virtualization-based environment that simulates physical hardware, allowing for isolated testing and debugging of the kernel and user-space components. To support a broader software ecosystem, the system includes an integrated porting layer that adapts and compiles third-party open source applications to run natively. This infrastructure maps external dependencies to local libraries, enabling the execution of standard software within the custom environment. The build process is managed through a collection of scripts that orchestrate the compilation of the entire operating system and its associated software ports.

OpenClash is a network traffic controller designed for embedded router hardware. It functions as a kernel-level traffic management solution that intercepts network packets to enforce user-defined routing policies and connectivity rules across home or office network environments. The project distinguishes itself through a comprehensive build and deployment pipeline tailored for diverse firmware architectures. It provides a cross-compilation environment that transforms source code into hardware-specific installation files, while also offering a package management system to handle the retrieval and installation of pre-compiled binaries. This approach ensures compatibility across a wide range of resource-constrained gateway devices. Beyond its core routing capabilities, the software includes a configuration-driven state management layer that synchronizes local settings with remote rule sets. It also features a modular architecture for extending protocol support and an automated provisioning system that prepares host environments by resolving necessary system dependencies and libraries.

Johnny-Five is a JavaScript robotics framework and microcontroller hardware interface designed for programming robots and IoT devices. It provides a standardized library for managing pins, motors, and displays across various microcontroller platforms, allowing developers to control sensors and actuators using a consistent JavaScript API. The framework is distinguished by its use of a plugin-based hardware abstraction system, which enables communication with diverse hardware platforms and protocols. It supports real-time hardware manipulation and debugging through a read-eval-print loop that allows for live object injection and function execution. The project covers a broad range of physical computing capabilities, including motor and actuator control for servos, steppers, and DC motors, as well as comprehensive sensing for environmental data, motion, proximity, and user input. It also includes tools for managing visual displays such as LCDs, LED matrices, and seven-segment displays, along with audio tone generation for piezo buzzers. The library handles hardware board initialization via automatic port detection or specified communication ports and supports the management of multiple boards within a single program.