This is a bare-metal (no_std) hardware abstraction layer (HAL) for Espressif ESP32 microcontrollers, supporting RISC-V and Xtensa cores. It provides low-level drivers for GPIO, SPI, I2C, UART, ADC, DAC, PWM, timer, USB, Ethernet, Wi-Fi, BLE, IEEE 802.15.4, and many other peripherals across a dozen+ chip families (ESP32, ESP32-C2/C3/C5/C6/C61, ESP32-H2/H4, ESP32-P4, ESP32-S2/S3/S31). The repository is a monorepo containing multiple independently versioned crates: esp-hal (core HAL), esp-radio (wireless radio stacks), esp-alloc (heap allocator), esp-storage (flash storage), esp-backtrace, esp-println, esp-sync (synchronization primitives), esp-rom-sys (ROM function bindings), esp-rtos (lightweight RTOS with async/embassy integration), esp-lp-hal (low-power core HAL), esp-config (build-time configuration), esp-metadata (chip property code generation), xtask (build/release tooling), and bootloader/OTA support. The architecture is built on extensive use of compile-time chip selection via macros (cfg_select!, for_each_*), versioned low-level driver modules per peripheral, and type-erased patterns for unified APIs across chip variants. Async support is first-class via embassy executor integration. The codebase demonstrates high engineering quality with clear abstractions, comprehensive hardware-in-the-loop testing (hil-test, hil-test-radio), and mature CI/CD workflows.
Tasmota is a monolithic firmware application for ESP8266/ESP32 microcontrollers that enables local control of IoT devices via MQTT, HTTP, Serial, or KNX protocols. It provides a web-based configuration interface, OTA update capabilities, automation features (timers/rules), and runtime extensibility through the Berry scripting language. The architecture integrates numerous hardware drivers, networking stacks, GUI components (LVGL), audio processing, and cryptographic implementations into a single firmware image built with PlatformIO. Key entry points include the web server for configuration, MQTT client for telemetry/control, serial command interface, OTA update mechanism, and hardware abstraction layer for peripherals. Data flows involve configuration persistence, sensor telemetry transmission, command reception for actuator control, and firmware update streams.
ESPectre is a production-grade Wi-Fi motion sensing system that runs on ESP32 microcontrollers. It captures Channel State Information (CSI) from Wi-Fi packets and runs on-device detection algorithms (Lightweight turbulence-based and High Accuracy neural network) to detect human motion without cameras or microphones. The system is designed for local-first operation with no cloud dependency, integrating with Home Assistant via ESPHome, MQTT, or Matter. The architecture is layered: a core sensing layer handles CSI capture, filtering, and feature extraction; a runtime layer manages lifecycle, configuration, and diagnostics; and multiple frontend adapters (native MQTT/HTTP, ESPHome, Matter, MicroPython) expose motion events to home automation systems. A Python CLI provides device discovery, flashing, monitoring, and dataset analysis tools. A web interface at espectre.dev offers browser-based device management. The repository also includes a significant data/research component: a published dataset of CSI recordings, ML training infrastructure, dataset quality validation pipelines, and performance benchmarking tools. These support the development and validation of the detection algorithms and ensure cross-language parity between C++ firmware and Python reference implementations. The codebase demonstrates strong engineering practices: interface-based design for testability, extensive unit and integration tests with coverage gates, cross-language parity enforcement, and a comprehensive CI/CD pipeline. Multiple frontends share a common core SDK, reducing duplication while allowing platform-specific optimizations.
This is a large polyglot monorepo for WiFi-based human sensing (WiFi-DensePose) that turns commodity WiFi routers into spatial intelligence systems. It captures Channel State Information (CSI) from ESP32 nodes to detect presence, estimate 17-keypoint body pose, measure breathing and heart rate, and track movement through walls without cameras or wearables. The system integrates deeply with Home Assistant via MQTT and Matter, provides a HomeKit bridge, and exposes multiple surfaces: a Rust backend workspace (v2/crates) with 50+ crates for signal processing, privacy shielding (VEIL/BFLD), pose physics, and home automation; Python bindings (PyO3) for ML training and inference; TypeScript CLI and MCP tools for AI agent integration; ESP32-C6/S3 firmware with adaptive sensing; React Native mobile app; Lit-based dashboard; and Tauri desktop app. The architecture is event-driven with a streaming engine, coherence-gated privacy layers, and deterministic verification via SHA-256 golden files. The codebase is heavily ADR-driven with extensive test coverage including cross-language parity gates. While primarily an application, it also contains substantial research code (benchmarks, physics simulations, SOTA surveys) and is best described as a research-informed production platform.
The pyespargos repository provides a Python library for interacting with ESPARGOS WiFi channel sounder hardware to capture, process, and deliver Channel State Information (CSI) data. The library handles low-level communication with single or multiple ESPARGOS boards, clusters CSI data from distributed antennas, applies calibration to compensate for hardware imperfections, and offers signal processing utilities for beamforming, polarization analysis, and direction-of-arrival estimation. The architecture is modular, with core components separated into board communication (board.py), multi-board pooling and clustering (pool.py), calibration management (calibration.py), and signal processing (util.py). A demo framework (demos/common/) provides reusable Qt/QML-based applications for various WiFi sensing tasks, including MUSIC spectrum analysis, polarization visualization, radar CSI processing, and camera-based beamforming overlays. The demos inherit from a base application class and combine mixins for backlog handling, combined array configuration, and CSI format selection. While the library is tightly coupled to the ESPARGOS hardware firmware (particularly the CSI packet formats and controller API), it encapsulates this complexity behind a clean interface. The signal processing utilities in util.py are hardware-agnostic and represent the most reusable component, offering implementations of advanced algorithms like MUSIC and MVDR beamforming. The clustering logic in cluster.py provides a general pattern for fusing sensor data from multiple distributed nodes. The repository shows active maintenance with recent commits and a linting CI workflow, though it carries some technical debt in the form of incomplete features and hardware-specific calibration complexity.
raylib is a cross-platform game development library written in C99, designed to provide a simple and easy-to-use API for creating games, prototypes, and multimedia applications. It abstracts away platform-specific details like window creation, input handling, and graphics rendering, offering a consistent interface across Windows, macOS, Linux, Android, and Web (via Emscripten). The library is modular, with core modules for shapes, textures, text, 3D models, audio, and shaders, all built on top of a low-level OpenGL abstraction layer (rlgl). It bundles its own windowing backend (a fork of GLFW) and includes numerous single-file external libraries for image loading (stb_image), audio decoding (dr_flac, dr_mp3, dr_wav, jar_mod, jar_xm), compression (sdefl, qoa, pep), and model loading (tinyobj_loader, cgltf, vox_loader). The repository contains over 200 example programs that serve as both documentation and test cases, covering everything from basic window creation to advanced shader effects and 3D rendering pipelines. The architecture follows a monolithic library pattern with a single public header (raylib.h) and several optional headers (raymath.h, rlgl.h, raygui.h). The core library is compiled from source files (rcore.c, rshapes.c, rtextures.c, rtext.c, rmodels.c, raudio.c) and platform-specific backends (rcore_desktop_glfw.c, rcore_android.c, rcore_web_emscripten.c, etc.). The library is designed to be self-contained, with no external runtime dependencies beyond the operating system's graphics drivers. Build system support includes CMake, Make, Zig, Meson, and IDE project files for Visual Studio, VSCode, CodeBlocks, and others. Key data flows involve initializing a window and graphics context, then entering a game loop where user input is polled, game state is updated, and rendering commands are issued. The library handles resource management (textures, fonts, models, audio streams) internally, with automatic cleanup on window close. The audio subsystem supports streaming, effects, and multi-channel playback. The shader system allows custom GLSL vertex and fragment shaders to be applied to 2D and 3D rendering. The library also includes utility modules for math (vectors, matrices, quaternions), easing functions, gesture recognition, and camera systems. External dependencies are minimal due to extensive bundling; the only required system libraries are OpenGL (or OpenGL ES on mobile/web) and the platform's native windowing/input APIs. The bundled GLFW fork provides a consistent windowing layer across platforms. The library is actively maintained with regular commits, CI builds for multiple platforms, and a large community of users and contributors.
LVGL (Light and Versatile Graphics Library) is an embedded GUI library written in C, providing a comprehensive widget toolkit (30+ widgets), style system, layout managers (flex, grid, split), animation framework, and multiple rendering backends (software, GPU-accelerated via VG-Lite, NanoVG, OpenGL ES, and hardware-specific backends for various MCU/MPU platforms). It is designed for resource-constrained devices with a small memory footprint (~100kB RAM for typical UIs) and supports a wide range of display drivers (SDL, Wayland, DRM, UEFI, Windows, and many embedded display controllers) and input devices (touch, keypad, mouse, gestures). The library features a public/private header pattern for encapsulation, a configurable build system via Kconfig, extensive Unity-based test suites with screenshot comparison, and a GDB plugin for runtime introspection. It is actively maintained with frequent commits, comprehensive CI/CD, and a large ecosystem of examples and demos.
ElegantOTA is an Arduino library that provides a polished web-based portal for over-the-air (OTA) firmware and filesystem updates on wireless microcontrollers (ESP8266, ESP32, RP2040+WiFi, RP2350+WiFi). The library exposes a minimal C++ API (begin, loop, callbacks) and serves a gzipped HTML/CSS/JS portal at /update. It handles the entire OTA workflow: capacity check before upload, MD5 integrity verification, chunked writing, progress reporting, and automatic reboot. The code is well-structured with platform-specific abstractions via preprocessor macros, supporting both synchronous (WebServer) and asynchronous (ESPAsyncWebServer) modes. The repository includes comprehensive CI testing across multiple boards and toolchains (Arduino CLI, PlatformIO), a CLA assistant, and stale issue management. The library is actively maintained with recent bug fixes (MD5 verification, RP2040 space calculation) and a clear upgrade path to a commercial Pro version.
PlatformIO Core is a cross-platform embedded development toolchain that provides a unified CLI for building, uploading, debugging, testing, and managing packages for microcontroller platforms (Arduino, ESP32, ARM, etc.). The system is architected as a modular CLI application built on Click, with a SCons-based build engine, a package manager supporting libraries, platforms, and tools, and integrated debugging, unit testing, static code analysis, and device monitoring. Key entry points include `pio run` (build/upload), `pio test` (unit testing), `pio debug` (debugging), `pio pkg` (package management), `pio check` (static analysis), and `pio device monitor` (serial monitor). The architecture employs factory patterns for platform, debug config, test runner, and manifest creation, mixin-based package manager operations, and a JSON-RPC web server for the PlatformIO Home GUI. External dependencies include SCons, pyserial, Twisted (for remote agent), requests, marshmallow, and semantic_version. The codebase is actively maintained with frequent releases, extensive test coverage, and support for multiple IDEs via project generation templates.
openHASP is an embedded firmware framework for home automation touch panels, built around LVGL for GUI rendering. It provides a configurable dashboard for controlling IoT devices via MQTT, with support for ESP32, STM32, and other microcontrollers. The system features hardware abstraction layers for displays and touch controllers, modular services (MQTT, HTTP, FTP, Telnet, WireGuard VPN), OTA updates, and a JSON-based configuration system. It integrates with home automation platforms like Home Assistant through auto-discovery and state topics, while offering local UI interaction via touchscreen. The architecture separates concerns into HAL, GUI, networking, storage, and services, enabling cross-platform deployment.
FastAccelStepper is a high-performance stepper motor control library for Arduino/ESP-IDF, supporting AVR, ESP32, SAM, SAMD51, and RP2040 platforms. It provides precise trapezoidal (optionally cubic) acceleration ramps with tick-exact step generation through a queue-based command execution model. The library abstracts hardware pulse generation behind a platform driver pattern (AVR timers, ESP32 RMT/MCPWM/PCNT/I2S, RP2040 PIO, SAM/SAMD51 timers) and avoids floating-point arithmetic by using a custom fixed-point log2 representation for speed calculations. It includes extensive automated testing (simulated AVR with VCD traces, PC-based unit tests, ESP32 hardware-in-the-loop) and CI matrices covering 50+ environment combinations. The library is production-ready, published on Arduino Library Manager and PlatformIO, with a detailed changelog from v0.8.0 to v1.3.3. It is used in real robotic and motion control systems, evidenced by issue reproductions for direction-change miscounts. Though the codebase is actively maintained, it suffers from conditional compilation proliferation across multiple ESP-IDF versions (4/5/6) and chip variants, and some platforms (SAM) have known bugs with no CI coverage. A major refactoring of direction-change handling is proposed but not yet merged. A companion web-based demo application (Esp32StepperDemo) is under design but incomplete. Highlights include the log2 fixed-point math component, a lock-free ring buffer queue, a portable platform abstraction layer, and an I2S mux driver capable of driving 32 steppers from one I2S transmitter. The extensive test harnesses and build-matrix generation scripts provide a solid foundation for regression testing across diverse hardware.
Arduino-IRremote is a comprehensive Arduino library for sending and receiving infrared remote control signals. It supports over 20 standard IR protocols (NEC, Sony, RC5, Samsung, LG, etc.) as well as exotic protocols like Bose Wave and Bang & Olufsen. The library is designed for embedded systems, handling the low-level timing generation and decoding required for IR communication. It provides both a full-featured receiver with a 50µs timer interrupt and a lightweight interrupt-based receiver (TinyIRReceiver) for resource-constrained boards. The sender uses software or hardware PWM to generate the 38kHz carrier, with bit-bang fallback for boards without PWM timers. Key entry points are the main include header (IRremote.hpp), static objects IrReceiver and IrSender, and a command dispatcher for mapping IR codes to callback functions.
This repository implements a DIY smart lock controller for ESP32 hardware, enabling Apple HomeKey NFC authentication, HomeKit integration, and MQTT connectivity for Home Assistant. The architecture is a hybrid embedded system: a C++ backend built on ESP-IDF (FreeRTOS) handles hardware interaction (NFC, GPIO, Ethernet) and protocol stacks (HomeSpan, mbedTLS), while a Svelte 5 frontend hosted on the device's LittleFS provides a web-based configuration and monitoring interface. The system manages configuration persistence in NVS using MessagePack/JSON serialization and streams real-time logs via WebSocket. Engineering quality is high, featuring RAII wrappers for memory safety in C++, template-based configuration management, and a decoupled event-loop architecture. However, the codebase carries significant security debt, explicitly acknowledging the lack of flash encryption and plain-text password storage in configuration. Hardware support is fragmented across ESP32 variants and NFC modules, requiring hardcoded pin presets that limit portability. Despite 52 open issues, the recent commit activity and modern tech stack (ESP-IDF 5.x, Svelte 5) indicate active development.
FreakWAN is a LoRa-based wide-area network (WAN) messaging system designed for ESP32 and T-ECHO devices. It implements a fully distributed, open chat network independent of internet or cellular infrastructure. The system supports plaintext and encrypted messaging, group chats, media sharing (small images), sensor data collection, and includes features like duty cycle tracking, automatic retransmission with ACK suppression, and neighborhood discovery via HELLO messages. The codebase is written in MicroPython (with a C port for T-ECHO) and is entirely self-contained, relying only on standard libraries. Architecturally, the application runs as a single asyncio event loop with multiple tasks for periodic message sending, HELLO advertising, serial input handling, and optional IRC/Telegram bot integration. The radio layer is abstracted behind SX1276 and SX1262 drivers, and the display uses a terminal-like Scroller view with splash screen and status icons. The protocol layer defines message types (Data, Ack, Hello, Ping, Pong) and supports encryption via AES-CBC with HMAC integrity. The repository is well-structured, with clear separation of concerns and reusable components that can be extracted for other projects.
This repository provides an Arduino library that implements the Bluetooth Low Energy MIDI (BLE-MIDI) transport layer, enabling Arduino boards to send and receive MIDI data over BLE connections. The library works with the FortySevenEffects Arduino MIDI Library and supports multiple hardware platforms including ESP32 (with both standard BLE and NimBLE), ArduinoBLE (NANO 33 BLE), and nRF52. The architecture features a clean separation between the core BLE-MIDI protocol implementation and hardware-specific adaptations. The transport layer correctly handles timestamp generation per the BLE-MIDI specification, running status optimization, and buffer management. Hardware abstractions use C++ templates to provide a consistent interface across different BLE stacks while exposing platform-specific configuration options.
This repository is an ESPHome custom component and configuration pack that turns an ESP32 into a BLE bridge for controlling Tesla vehicles. It implements a `tesla_ble_listener` component that connects to the car's BLE advertisement/command channel, encrypts/decrypts Tesla's proprietary BLE messages using a forked `tesla-ble` library, and exposes ESPHome services, buttons, sensors, and selectors for actions like lock/unlock, frunk/trunk, climate, and cabin overheat protection. The repo is primarily YAML package definitions and C++ component code, with a Makefile and CI workflow for building board-specific firmware.
MicroLink v2 is a production-ready Tailscale VPN client for ESP32-S3 devices that establishes secure WireGuard tunnels through Tailscale's control plane. It implements the full Tailscale protocol stack including Noise protocol for control plane encryption, HTTP/2 framing, DISCO peer discovery, STUN for NAT traversal, DERP relay fallback, and WireGuard encryption via wireguard-lwip integration. The architecture uses a multi-task FreeRTOS design with separate tasks for coordination, WireGuard management, DERP transmission, network I/O, and application logic, communicating via message queues and event groups. Key features include WiFi/cellular network failover with health monitoring, zero-copy WireGuard receive option for high-throughput scenarios, NVS-based peer caching with LRU eviction, and an HTTP configuration server for runtime management. The code demonstrates strong protocol fidelity through direct reference to Tailscale's Go source files while adapting to embedded constraints.
This repository implements a complete embedded IoT system for automated meter reading (water, gas, electricity) using an ESP32-CAM with on-device TensorFlow Lite inference. The firmware captures images, performs alignment and ROI extraction, runs digit and analog pointer recognition via quantized TFLite models, applies post-processing (consistency checks, rate limiting, decimal shift), and publishes readings via MQTT, InfluxDB (v1/v2), Webhook, or a built-in REST API. The architecture follows a modular flow-control pattern with separate components for camera control, image processing, neural network inference, configuration, logging, and output protocols. A full-featured web interface provides setup wizards, live data graphs, OTA updates, and file management. The system is designed for low-power edge deployment on ESP32 with PSRAM and SD card storage.
ESPHome Designer is a Home Assistant custom component that provides a visual drag-and-drop editor for designing display layouts on ESP32/ESP8266 devices running ESPHome. It supports multiple rendering protocols including native ESPHome C++ lambdas, LVGL, OpenEPaperLink (OEPL), and OpenDisplay (ODP). The editor features a canvas with zoom/pan, snap-to-grid, drag-and-drop, lasso selection, and a property panel for configuring widget attributes. Widgets are organized as plugins, each providing render, export, and lifecycle hooks for all supported output formats. The system can generate complete ESPHome YAML configurations including hardware definitions, sensor registrations, font loading, and display lambdas. The architecture is split between a Python backend (Home Assistant integration) and a JavaScript frontend (Vite-built SPA). The backend provides REST APIs for layout CRUD, entity history proxying, image/RSS proxying, hardware profile management, and PNG rendering. The frontend manages state via an AppState singleton with undo/redo, communicates with the backend through a bridge, and supports offline YAML parsing. An AI integration allows generating layouts from natural language prompts using multiple providers (Gemini, OpenAI, OpenRouter). The codebase demonstrates strong engineering practices with a plugin-based architecture, adapter pattern for multi-format export, schema-driven property panels, and extensive test coverage (200+ Vitest tests plus Python tests). It is actively maintained with CI/CD pipelines, quality gates, and regular releases. While the widget plugin surface is large and some legacy modules coexist with newer code, the overall design is modular and extensible.
SensESP is an embedded firmware framework for ESP32 microcontrollers that enables building custom marine sensors that communicate via the Signal K protocol. It provides a complete pipeline from physical sensor reading (via Arduino libraries or built-in ADC/digital inputs) through data transformation (30+ composable transforms like linear scaling, moving average, hysteresis, curve interpolation) to publishing over WebSocket to a Signal K server. The framework includes a full web-based configuration UI (Preact/Bootstrap) served directly from the device, WiFi/Ethernet provisioning with captive portal, OTA updates, and a REST API for device management. Architecture follows a reactive dataflow pattern: sensors produce typed values that flow through transform chains to consumers (Signal K output, UI, logging). The core is built on ReactESP event loop, with observable/value producer/consumer abstractions enabling type-safe connections. Notable components include a TOFU certificate pinning system for secure Signal K connections, a circular log buffer with snapshot cursor for the web UI, and a smart switch controller supporting local and remote actuation with double-click sync. The codebase is well-structured with unit tests for transforms, metadata, and networking components, though some deprecated APIs and a large god object (SensESPApp) indicate areas for refactoring.