Open-source alternatives to Lua RTOS ESP32

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

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

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

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

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 project is a Lua-based firmware environment for the ESP8266 WiFi chip, providing an embedded Lua interpreter and a development framework for WiFi SoC hardware. It functions as a C-based wrapper around the Espressif non-OS SDK, enabling the execution of asynchronous scripts to manage wireless communication and hardware peripherals. The environment integrates a SPIFFS flash filesystem for storing persistent scripts and data directly on non-volatile memory. To optimize limited hardware resources, the system utilizes execute-in-place flash execution, running read-only constants and instructi

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

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

The Linux kernel source tree is core system software tailored specifically for Rockchip processor architectures and embedded hardware boards. It manages hardware resources, processor execution contexts, memory allocation, and process scheduling for custom computing platforms. The project provides low-level hardware abstraction, initialization routines, and a collection of kernel modules designed to control integrated silicon components, storage, and networking hardware. The codebase incorporates hierarchical data structures to describe physical board layouts, memory maps, and peripheral conne

U-Boot is an embedded bootloader that initializes hardware components and loads operating system kernels into memory. It functions as a hardware abstraction layer providing standardized access to networking, storage, and peripheral buses, while also serving as a secure boot loader and a firmware update interface. The project distinguishes itself through the implementation of secure boot sequences that verify cryptographic signatures and interface with TPM modules to establish hardware-rooted trust. It further provides specialized capabilities for updating device firmware via standardized prot

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 WebAssembl

The pico-sdk is a software development kit for creating C and C++ applications on RP2040 and RP2350 hardware platforms. It functions as an embedded development kit that provides hardware abstraction layers and drivers to interface with microcontroller peripherals and registers. The project utilizes a CMake build system to manage the compilation of source code into multiple binary formats, including UF2, ELF, and HEX images. This environment coordinates the build and link processes to ensure the resulting firmware is correctly tailored for the target hardware. The toolkit covers embedded hard

AliOS-Things is a scalable operating system for internet-connected devices. It provides an embedded firmware framework and runtime for managing hardware peripherals, network connectivity, and secure data execution across diverse CPU architectures. The system includes an edge AI inference engine for processing audio and image patterns locally without cloud dependencies. It also features a cloud connectivity SDK for automated onboarding, remote diagnostics, and log reporting, alongside a scripting engine for executing high-level code on resource-constrained hardware. Connectivity is handled th

OpenRazer is an open source driver and daemon for controlling Razer peripheral lighting and hardware settings on GNU/Linux. It functions as a Linux input device manager and RGB peripheral controller, providing a background service that handles raw USB communication and state monitoring for compatible gaming mice and keyboards. The project provides a D-Bus hardware interface that exposes device control functions to third party applications via a system message bus. This communication layer allows scripts and external software to manage physical hardware components through a programmatic interf

This library provides a collection of low-level abstractions for interacting with hardware peripherals on Raspberry Pi devices using the Rust programming language. It serves as a type-safe interface for controlling physical pins and managing communication with external electronic components and sensors. The project distinguishes itself through its use of compile-time abstractions that map high-level function calls directly to hardware instructions, ensuring minimal runtime overhead. It provides consistent access to hardware by wrapping kernel-level device interfaces and memory-mapped register

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

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 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

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

ZSWatch is a real-time operating system for wearable devices featuring a touch display and Bluetooth Low Energy connectivity. It provides a comprehensive software suite that includes a Bluetooth LE communication stack, an embedded UI framework for round displays, and a complete firmware toolchain for compiling, flashing, and simulating wearable hardware. The project is distinguished by its specialized wearable capabilities, such as a graphical framework for designing reactive screens and watchfaces via a visual editor. It implements a publish-subscribe messaging system to decouple hardware se

Vis is a terminal-based modal text editor that utilizes vi keybindings and a system of structural regular expressions. It functions as a scriptable environment where Lua is used for configuration, custom key mappings, and plugin development. The editor distinguishes itself through a syntax highlighting system based on Parsing Expression Grammars and a pattern matching engine that treats text as a structure for complex search and replace operations. It also integrates directly with the system shell, allowing users to pipe text ranges to external commands and capture the resulting output. The

OpenCat-Quadruped-Robot is a development framework and motion control API for building four-legged robots. It provides a comprehensive environment for quadruped robot development, featuring tools for locomotion gait design, inverse kinematics, and a layered control architecture that separates high-level intelligence from low-level motion. The project distinguishes itself as an embedded AI deployment tool, allowing users to train, quantize, and deploy machine learning models to vision modules for tasks such as object detection and visual target tracking. It further supports complex human-robot

ZMK is a modular firmware framework built on the Zephyr RTOS for wireless keyboards. It functions as a programmable system for defining custom keymaps, layers, and input behaviors, acting as an HID device emulator for keyboard and mouse input on computers and mobile devices. It specifically provides a controller solution for synchronizing two separate keyboard halves over wireless or wired links. The project is distinguished by its focus on Bluetooth Low Energy connectivity, featuring multi-device pairing and the ability to switch between several saved host profiles. It includes advanced powe

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

Sol2 is a C++ Lua binding library that serves as a language interoperability layer for integrating Lua scripts into C++ applications. It acts as a scripting wrapper and API toolkit, enabling the execution of Lua code and the management of shared state within a native C++ environment. The library focuses on automated function and type mapping to bridge native C++ classes and complex data types with the Lua scripting engine. It provides mechanisms for bidirectional data exchange, allowing compiled logic and variables to be synchronized between the host application and the script runtime. The s

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

mruby is a lightweight Ruby interpreter designed to be embedded into C applications. It compiles Ruby source code into a compact, platform-independent bytecode that executes on a register-based virtual machine, and exposes a stable C API for host programs to initialize the interpreter, load bytecode, and invoke Ruby methods at runtime. The interpreter distinguishes itself through a tightly coupled parser and compiler that performs lexical analysis, syntax parsing, and bytecode generation in a single pass without constructing an intermediate AST, minimizing memory overhead. It also includes a