ExecuTorch is PyTorch's unified solution for deploying AI models on-device (mobile, embedded, edge). It enables direct export from PyTorch without intermediate format conversions (.onnx, .tflite) and powers Meta's production on-device AI across Instagram, WhatsApp, Quest 3, and Ray-Ban Meta Smart Glasses. The framework provides an ahead-of-time (AOT) compilation workflow: Export → Compile → Execute, supporting LLMs (Llama 3.2/3.1/3, Qwen 3, Phi-4-mini), vision (MobileNetV2, DeepLabV3, YOLO26), speech (Whisper), and multimodal models (Llava, Voxtral) across 12+ hardware backends including XNNPACK, CoreML, Qualcomm QNN, MediaTek Neuropilot, ARM Ethos-U, NXP, Cadence DSP, Vulkan, CUDA (experimental), Metal (experimental), and MLX (experimental). The architecture is modular with core runtime (C++/C), export pipeline (Python), backend-specific delegates, and examples/tools for model conversion and benchmarking. Key entry points include the Python API (torch.export.export() → to_edge_transform_and_lower() → .to_executorch()), C++ API (executorch::runtime::Module), backend partitioners (XnnpackPartitioner, CoreMLPartitioner), and command-line tools for model export and benchmarking. Data flows involve model export to Edge IR (EXIR), partitioning/lowering for backend, serialization to .pte, and runtime execution via delegate interfaces. External dependencies include PyTorch, FlatBuffers, backend-specific SDKs (QNN, Ethos-U, CoreML/Metal, Vulkan, WebGPU), CMake, Buck2, and testing frameworks. The codebase demonstrates strong engineering practices with reusable components like the visitor pattern for operator lowering, quantization pipelines for LLMs, memory planning utilities, and a flexible delegate framework. While actively maintained with frequent commits and CI/CD, technical drift is medium due to experimental backends, generated code synchronization challenges, and conditional build complexity across numerous hardware targets.
Arduino CLI is a command-line tool and gRPC daemon for Arduino embedded development. It manages board platforms (cores), libraries, sketches, compilation, upload, monitoring, and debugging. The architecture is dual: a CLI frontend using the Cobra framework and a gRPC server (daemon mode) that exposes the same operations via protobuf-defined services. The core domain logic is organized under `internal/arduino/` with subsystems for building (preprocessor, compiler, linker, diagnostics), package management (index loading, install/uninstall, dependency resolution), sketch handling (profiles, YAML config), and hardware discovery/monitoring. External dependencies include gRPC, protobuf, Cobra/Viper for CLI, and Arduino-specific libraries for path handling, properties, serial communication, and pluggable discovery protocols. The system supports cross-platform operation (Linux, macOS, Windows) and includes extensive integration tests that exercise real CLI commands against isolated environments.
Trice is an embedded logging and tracing toolchain consisting of a lightweight C instrumentation library for microcontrollers and a Go-based host CLI tool. The C library provides variadic macros that emit compact binary records (ID + values) instead of format strings, drastically reducing flash and bandwidth usage. The Go tool manages Trice IDs (insert, clean, bind), decodes incoming binary streams from targets over UART, RTT, TCP/UDP, or file, and displays formatted logs with timestamps, colors, and filtering. It supports multiple buffer strategies (stack, static, double, ring), framing protocols (COBS, TCOBS), optional XTEA encryption, and local logging on the target itself. The architecture is a classic host-target split: the target runs the C library, the host runs the Go CLI. The codebase is well-tested with a large matrix of CGO test configurations and CI pipelines for multiple STM32 example projects. It is actively maintained with frequent releases and a responsive issue tracker.
SwiftIO is a Swift framework for microcontrollers that provides an easy-to-use interface for hardware peripherals. It abstracts low-level hardware details into Swift classes, allowing developers to interact with GPIO, ADC, PWM, timers, communication protocols (I2C, SPI, UART), and more without dealing with complex register manipulation. The library is structured into a C layer (CSwiftIO) for direct hardware access and a Swift layer that wraps this functionality in a safe, idiomatic API. It emphasizes error handling through Swift's Result type and provides consistent patterns for resource management and peripheral interaction.
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 contains CANopenNode, a full-featured, portable ANSI C implementation of the CANopen protocol stack compliant with EN 50325-4 (CiA 301) and related standards (CiA 302, 303, 304, 305, 309). It is designed for embedded microcontrollers and real-time industrial automation systems. The stack implements Network Management (NMT) with heartbeat and node guarding, SDO server/client with expedited/segmented/block transfer, PDO with dynamic mapping, Emergency messages, SYNC, Time-stamp, LSS, Safety-Related Data Objects (SRDO), and an ASCII gateway for remote management (CiA 309-3). The architecture is modular, with each protocol in its own directory (301/, 303/, 304/, 305/, 309/). Central orchestration is provided by `CANopen.c` with a main processing loop `CO_process()` that should be called cyclically. The stack is configuration-driven via compile-time macros in `CO_config.h`, allowing feature enable/disable to reduce footprint. A hardware abstraction layer (`CO_driver.h`) separates CAN bus specifics, and example blank drivers (`CO_driver_blank.c`, `CO_storageBlank.c`) facilitate porting to new platforms. Key design patterns include a generic Object Dictionary interface with extension callbacks, a reusable circular FIFO buffer with protocol parsing, storage abstraction with CRC integrity, and non-blocking state machines. The codebase adheres to MISRA C:2012 (with documented exceptions) and includes Doxygen documentation. While primarily a library, the repository contains an example application skeleton and a generated device profile XML. Technical debt includes the FIFO and gateway modules being excluded from static analysis, certain static variables limiting reentrancy, and the trace feature being non-functional. The project is actively maintained with a large user base and multiple derivative repositories for specific platforms (Linux, STM32, PIC, etc.).
ArcadeDB is a high-performance, multi-model database system supporting graph, document, key-value, time-series, vector, and full-text data models. It exposes multiple query languages (SQL, Cypher, Gremlin, GraphQL) and wire protocols (HTTP, Bolt, PostgreSQL, MongoDB, gRPC). The architecture is modular: a core engine (storage, indexing, query execution) with pluggable server plugins for protocols, replication (Raft-based HA), and observability. It features advanced indexing (LSM-tree, hash, vector quantization, sparse vectors, full-text BM25), time-series with PromQL and downsampling, and graph analytical views with CSR compression. Python bindings allow embedded use. The codebase demonstrates strong engineering with extensive use of interfaces, design patterns, comprehensive test coverage (including issue-specific regression tests), and automated CI/CD with performance benchmarks. It is actively maintained with low technical debt and a clean architecture.
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.
lockfree is a header-only C++11 library providing lock-free data structures for concurrent programming. It offers both single-producer single-consumer (SPSC) and multi-producer multi-consumer (MPMC) variants of queues, ring buffers, bipartite buffers, and priority queues. The library is designed for use across a wide spectrum of systems from deeply embedded to HPC, featuring no dynamic allocation and optimized for high performance. Architecture-wise, it's organized into spsc/ and mpmc/ namespaces with each data structure having separate header and implementation files, aggregated through lockfree.hpp. The implementation uses atomic operations and clever algorithms to achieve lock-free behavior without mutexes.
Trussed is a no_std Rust library and framework for building cryptographic firmware on microcontrollers. It implements a client-service syscall architecture: applications use strongly-typed client traits such as CryptoClient, FilesystemClient, and CertificateClient to send Request enums through an interchange channel; Service::process dispatches requests to pluggable mechanism implementations or custom backends, persists keys and files across three littlefs2 filesystems (internal, external, volatile), and returns Reply enums. It is not a standalone application or CLI but an embedded component used by firmware runners such as Solo 2 and Nitrokey 3.
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.
IronOS is embedded firmware for a family of portable soldering irons (TS100, TS80/P, TS101, Pinecil, Pinecil V2, MHP30, Sequre S60/S60P/T55/S99). The firmware runs on three distinct SoC architectures — STM32F103 (Cortex-M3), GD32VF103 (RISC-V), and Bouffalo BL702 (RISC-V) — behind a single board-support abstraction. It implements PID temperature control of the soldering tip via PWM, thermocouple uV-to-temperature conversion with cold-junction compensation, USB-PD (FUSB302/FUSB302B/HUB238/FS2711) and Quick Charge 3.0 power negotiation, accelerometer/hall-effect-based motion detection for sleep, an OLED menu UI, and a full BLE GATT stack on Pinecil V2. The core control loop is: ADC samples tip thermocouple voltage (with PWM holdoff timing) -> gain/op-amp compensation and lookup-table interpolation to Celsius -> PID controller -> PWM duty to the heating element, with input voltage/current monitoring for wattage budgeting and thermal runaway protection.
minimp3 is a minimal, high-performance, ISO-conformant MP3 decoder implemented as a single-header C library (minimp3.h). It provides a low-level frame decoding API and a higher-level streaming/seek API (minimp3_ex.h) with callback-based I/O abstraction. The decoder supports SSE and NEON SIMD acceleration, and compiles to a ~30kB binary with zero external dependencies. The repository includes a comprehensive test suite with over 50 test vectors covering standard and edge-case MPEG audio streams, a fuzzing harness, and a full-featured GUI player (using SDL2 and Nuklear) that demonstrates real-world usage. An additional tool (huffopt) generates optimized Huffman tables for Layer III. The library is designed for embedded systems, game engines, and any environment requiring a lightweight MP3 decoder.
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.
Cubeboot is a GameCube bootloader/firmware project that enhances the boot process by restoring customizable boot animations, enabling SD card-based software loading, and providing fallback mechanisms. It patches the system's Initial Program Loader (IPL) to inject custom functionality while maintaining compatibility with official hardware. The project supports multiple GameCube hardware revisions (NTSC/PAL variants), various storage adapters (SDGecko, SD2SP2, RP2040-based PicoBoot), and runtime configuration via INI files. Key features include boot animation customization (colors, logo replacement), button-triggered DOL loading, progressive scan support, and fallback to secondary bootloaders like Swiss. The architecture combines bare-metal C/assembly with modular components for filesystem access, ELF/DOL parsing, and hardware abstraction, built using the devkitPPC toolchain.
This repository is a comprehensive personal R&D platform implementing a polyglot microservices architecture. It hosts a personal website/web application (React/Vite), multiple API servers in different languages (Rust/Axum, Go/Gin/gRPC, Python/FastAPI, Node.js/Express), mobile applications (iOS/Android/React Native), and desktop applications (Qt). The platform includes extensive data processing infrastructure (Kafka, Pulsar, NATS, Spark, Flink), machine learning capabilities (model training/serving/fine-tuning), monitoring and observability tools, and infrastructure as code (Terraform/OpenTofu, Kubernetes). Services communicate via messaging systems and APIs, with a clear separation of concerns and standardized patterns for configuration, health checks, logging, and error handling across language implementations.
CherryUSB is a portable, high-performance USB device and host stack for embedded systems (MCUs, RTOS). It provides a full-featured USB 2.0/3.0 stack with support for many USB class drivers (CDC ACM/ECM/NCM, HID, MSC, Audio, Video, DFU, MIDI, RNDIS, MTP, ADB, Bluetooth, vendor serial, gamepad, etc.) on both device and host sides. The architecture separates OS abstraction (OSAL), hardware controller drivers (DWC2, EHCI, XHCI, OHCI, MUSB, ChipIdea, FSdev, and many vendor-specific ports), and class implementations. It includes extensive demo templates, platform integrations (FatFS, lwIP, LVGL, UF2 bootloader), and tooling (Python test scripts, UF2 conv). The stack is used in commercial products and is registered in several embedded package ecosystems (RT-Thread, ESP-IDF, Bouffalolab). Key entry points are usbd_initialize() and usbh_initialize() with class-specific initialization routines in the demo folder. The codebase is large and well-organized but contains legacy ports and some vendor-specific glue code that may require adaptation.
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.
MCUboot is a secure bootloader for 32-bit microcontrollers, providing signed and encrypted firmware upgrade capabilities. The repository contains the core bootloader library (C) with support for multiple RTOS platforms (Zephyr, Mynewt, NuttX, Mbed OS, Espressif, Cypress), a Python image signing and management tool (imgtool), a Rust-based simulator for testing boot scenarios, and vendored cryptographic libraries (TinyCrypt, Mbed TLS subset, fiat-crypto). The system architecture is a library with platform-specific ports: the common boot logic (bootutil) handles image validation, swap algorithms (scratch, move, offset, direct-XIP, RAM-load), encryption, and fault-injection hardening. Each platform provides flash map, logging, watchdog, and boot entry point implementations. The codebase is highly configurable via compile-time flags, supporting multiple signature schemes (RSA, ECDSA, Ed25519), encryption backends, and upgrade modes. It is not a standalone application but a bootloader intended to be integrated into embedded firmware projects.