MQTTX is a cross-platform MQTT 5.0 client tool developed by EMQ, available as a desktop application (Electron + Vue), a web application (Vue), and a command-line interface (Node.js). It allows users to connect to MQTT brokers, publish and subscribe to topics, inspect messages, and manage connections with support for MQTT 5.0 features, TLS, WebSocket, and various payload formats (JSON, Base64, Hex, CBOR, MsgPack, Protobuf, Avro). It also includes an AI Copilot for MQTT assistance, a dashboard with real-time widgets, and scripting capabilities for payload transformation. The desktop app uses Electron with Vue 2, Element UI, TypeORM with SQLite for persistence, and MQTT.js for MQTT protocol. The web app shares many Vue components but uses lowdb/LocalStorage. The CLI is a separate Node.js package with its own test suite. The codebase is organized into shared utilities, database services, Vue components, and AI integration modules. Key entry points include src/background.ts (Electron main process), src/main.ts (render process), cli/bin/index.js (CLI), and web/src/main.ts (web app). Data flows involve MQTT connection lifecycle, message buffering via RxJS, payload conversion pipelines, and database persistence for messages, subscriptions, and settings. External dependencies include MQTT.js for MQTT protocol, TypeORM for database ORM, Electron for desktop, Vue 2 and Element UI for UI, Monaco Editor for code editing, ECharts for charts, and various AI SDKs (OpenAI, Anthropic, etc.) for the Copilot feature. The project also includes custom patches for third-party libraries (Monaco clipboard, MCP SDK, Azure SDK). The CLI depends on commander, chalk, and @faker-js/faker for simulation. While primarily an application, MQTTX includes data-oriented features such as message history querying with SQL recursive CTEs, topic tree persistence, data export/import in multiple formats, and IoT data simulation scenarios. These elements serve the application's debugging and testing purpose but demonstrate data engineering patterns.
HomePlate is embedded firmware for Soldered Inkplate e-paper displays, turning them into wall-mountable smart dashboards. It connects via WiFi to Home Assistant (through MQTT and screenshots) or TRMNL to display content such as Home Assistant dashboards, TRMNL screens, custom images, QR codes, and text messages. The firmware is built on PlatformIO with FreeRTOS, supporting deep sleep for battery life, OTA updates, and a captive portal web configurator. It uses MQTT for Home Assistant discovery, exposing sensors (WiFi RSSI, battery, temperature) and config entities. The architecture is activity-driven: an activity queue dispatches display modes (HomeAssistant, Trmnl, Info, etc.) triggered by MQTT, timers, or physical buttons. Power management is a core focus, with configurable sleep schedules, a wakelock system for critical operations, and always-on mode. The codebase is well-organized, includes unit tests, and has reusable components like a buffer stream wrapper and sleep scheduling logic. It is actively maintained with CI/CD, releases, and a web installer.
Gobot is a Go framework for robotics, physical computing, and the Internet of Things. It provides a consistent hardware abstraction layer (HAL) over dozens of single-board computers (Raspberry Pi, BeagleBone, Intel Edison, Jetson, etc.), microcontrollers (Arduino via Firmata, Digispark), and communication protocols (GPIO, I2C, SPI, BLE, serial, MQTT, NATS, MAVLink). The architecture is modular: platform-specific adaptors implement core interfaces (DigitalPinner, PWMPinner, I2cBusAdaptor, etc.) and are composed from reusable building blocks in the `platforms/adaptors` package. Drivers for sensors, actuators, displays, and robots (Sphero, Parrot drones, DJI Tello, GoPiGo3) are organized by bus type (gpio, i2c, spi, ble, aio, onewire, serial) and share a common lifecycle pattern with event publishing and command registration. A built-in HTTP API server (with optional basic auth and CORS) exposes robot state and commands over REST and Server-Sent Events, and includes an embedded web UI (Robeaux). The framework supports both high-level orchestration via `Robot` and `Manager` and low-level 'metal' usage for direct hardware control. External dependencies include `periph.io` for GPIO, `tinygo.org/x/bluetooth` for BLE, `gocv.io/x/gocv` for computer vision, and `go.bug.st/serial` for serial communication. The codebase is extensively tested with mock filesystem and syscall infrastructure, and uses functional options for configuration throughout.
FUXA is a full-stack web-based SCADA/HMI builder and runtime for industrial automation and IoT. It provides a visual editor (Angular + SVG) to create real-time dashboards, connect to field devices via 13+ protocols (Modbus, OPC UA, BACnet, Siemens S7, MQTT, etc.), and manage alarms, data acquisition (DAQ), scripting, scheduling, and user permissions. The backend (Node.js/Express) communicates with the frontend via Socket.IO for real-time device value updates. The system supports multiple time-series databases (SQLite, InfluxDB, QuestDB, TDengine) and can be deployed as a web server, Docker container, or Electron desktop app. It also integrates with Node-RED for low-code automation flows. The architecture is modular with a device driver factory pattern, JWT-based authentication, and a plugin system for extensibility. While the codebase is large and contains some monolithic components, it demonstrates solid engineering practices and has a rich set of reusable UI components and utility patterns.
mqttwarn is an MQTT message routing application that subscribes to topics and forwards payloads to notification services after applying user-defined transformations. It features a plugin-based architecture with over 70 built-in services (e.g., Slack, Twilio, HTTP, databases) and supports dynamic routing via INI configuration. The system runs as a long-lived daemon with worker threads for asynchronous processing, periodic task scheduling, and automatic reconnection. Core components include MQTT client handling, job queuing, transformation pipelines (filter, datamap, format), and a context manager for accessing configuration and custom functions. While the core is well-structured, the extensive service list creates maintenance overhead and potential dependency drift.
BatMON is a Home Assistant add-on and standalone Docker application for monitoring battery management systems (BMS) over Bluetooth Low Energy (BLE) and serial connections. It decodes telemetry from ~25 BMS families (Daly, JK, ANT, Renogy, Seplos, etc.) and publishes normalized data to MQTT for Home Assistant, or directly to InfluxDB. The architecture is a Python asyncio application with a BMS abstraction layer (`bmslib`) that defines a common interface (`fetch()`, `fetch_voltages()`) and model-specific decoders. The main entry point is `main.py`, which dispatches to HA add-on or standalone mode via `entrypoint.sh`/`addon_main.sh`. Data flows from BMS hardware through BLE/serial adapters into decoder classes, then to MQTT/InfluxDB via a GUI wire format (`bmslib/wire/model.py`). External dependencies include bleak (BLE), paho-mqtt, influxdb, and Home Assistant add-on infrastructure (bashio, supervisor). The project includes a Helm chart, Docker multi-arch builds, and a test suite with known-answer vectors for CRC/AES and protocol decoders.
This repository provides embedded firmware for the ESP8266 that bridges Chinese solar inverters (Voltronic/Axpert, PIP, EASUN, Deye, Anenji, Must PV/PH18) to MQTT and a local web interface. It communicates with inverters via RS232 serial (using proprietary ASCII protocols like PI30, PI18) or RS485 Modbus RTU, parses real-time status (grid, battery, PV, loads, faults), and publishes structured JSON to configurable MQTT topics including Home Assistant auto-discovery. The firmware also hosts a full web-based configuration portal with captive portal for WiFi setup, OTA updates, a live JSON endpoint, and LED status indication. Architecturally, it is a monolithic embedded application written in C++ for the PlatformIO build system. Key entry points are `src/main.cpp` (setup/loop), the web server endpoints, MQTT callbacks, and the serial/Modbus polling loop. The code is organized into a serial protocol handler (`PI_Serial`), an abstract Modbus device layer (`modbus_device`) with concrete implementations, a settings manager using EEPROM with versioning and fallback, and a chunked HTML serving mechanism to avoid heap fragmentation on memory-constrained ESP8266 devices. Notable strengths include the modular Modbus device interface that allows adding new inverter models by subclassing and providing register tables, and the auto-detection logic that probes protocols in sequence. The web UI is built with Bootstrap and jQuery loaded from CDN, and the project actively supports Home Assistant integration and multiple hardware configurations (Wemos D1 Mini, ESP-01, WiFi dongle). While the code is well-structured for an embedded project, it relies on dynamic `String` objects and large JSON documents on a limited memory platform, which could cause heap fragmentation over long periods. The license (CC BY-NC-ND 4.0) restricts commercial use and derivative works, limiting community contributions.
FarmBot Web App is the cloud-based control panel for FarmBot, an open-source CNC farming robot. It provides a full-stack web application (Rails API + React/TypeScript SPA) for managing devices, creating automated sequences via a visual CeleryScript AST editor, scheduling farm events, monitoring telemetry and logs, managing plants/weeds/tools, and viewing real-time 2D/3D garden maps. The backend is a monolithic Rails app with PostgreSQL, RabbitMQ/MQTT for device communication, and DelayedJob for background processing. The frontend is a complex Redux SPA with extensive 3D visualization using Three.js. The system supports multiple hardware variants and includes firmware update management, camera calibration, and AI-assisted feedback. The codebase is actively developed with a large test suite, but exhibits some technical debt like legacy AST storage paths, future-dated migrations, and heavy mocking in tests.
ESPAtherma is an embedded firmware application (PlatformIO/Arduino) for monitoring and basic control of Daikin Altherma heat pump systems via an ESP32 or ESP8266 microcontroller. In production, it connects to the heat pump's X10A serial port, queries specific register addresses (reverse-engineered Daikin I and S protocols), converts raw bytes into human-readable values using configurable label definitions, and publishes the data over MQTT to a Home Assistant instance. It also provides Home Assistant MQTT auto-discovery for seamless integration. The architecture is a single-threaded loop: setup reads model-specific definition files and MQTT/WiFi config, then repeatedly queries registers, converts data, and publishes to MQTT. Key entry points are `src/main.cpp`, `include/comm.h` (serial query), and `include/homeassistant.cpp` (discovery payload generation). External dependencies include PubSubClient, ArduinoJSON, and board-specific libraries (M5Unified for M5Stick). The project also includes reverse-engineering scripts, serial log dumps, and a heat pump emulator, making it a hybrid of embedded application and protocol research. However, the primary usage and codebase character are that of an IoT monitoring/control application.
MQTT-SN Tools is a suite of four command-line applications for working with the MQTT-SN (MQTT for Sensor Networks) protocol. The system provides mqtt-sn-pub for publishing messages, mqtt-sn-sub for subscribing to topics, mqtt-sn-dump for monitoring packets, and mqtt-sn-serial-bridge for serial-to-UDP bridging. All tools share a common C library (mqtt-sn.c/h) that implements the MQTT-SN protocol handling, including socket management, packet encoding/decoding, keep-alive mechanics, and topic mapping. The architecture is modular with clear separation between the protocol library and application-specific logic. Each tool follows a standard pattern: parse command-line arguments, establish UDP connection to an MQTT-SN broker, perform protocol operations (connect, publish/subscribe, etc.), handle incoming/outgoing packets, and clean up resources. The project has active maintenance with recent commits and a test suite.
This repository provides the Home Assistant add-on packaging for Zigbee2MQTT, a Zigbee to MQTT bridge. It contains Docker build configurations, entrypoint scripts, and add-on metadata to run Zigbee2MQTT as a managed add-on within Home Assistant OS or Supervised installations. The actual Zigbee2MQTT application is fetched from its upstream repository during Docker build (either a stable release or the dev branch for the edge variant). The add-on supports serial device passthrough, socat for remote serial forwarding, MQTT auto-discovery via Home Assistant services, and an ingress-enabled web frontend. The codebase is primarily configuration and build orchestration; there is no application logic beyond the entrypoint script that translates add-on configuration into environment variables for Zigbee2MQTT. It is a well-structured, actively maintained add-on following Home Assistant best practices, but offers no reusable software components outside the Home Assistant ecosystem.
Automation Gateway is a reactive, configuration-driven bridge for industrial protocols (OPC UA, MQTT, PLC4X) that routes real-time process data to multiple time-series databases (InfluxDB, IoTDB, OpenSearch, Cassandra, PostgreSQL, etc.) and exposes it via GraphQL, MQTT, and OPC UA servers. The system runs as a single JVM or GraalVM native binary, orchestrated through YAML configuration files that define driver instances, logger sinks, and server endpoints. Its core architecture is built on Vert.x event bus for internal pub/sub messaging, with abstract base classes (DriverBase, LoggerBase) enabling consistent extension for new protocols or data stores. The gateway does not persist data itself; it acts as a real-time router with configurable buffering and queue reliability (memory-mapped disk queue). Key entry points include `App.kt` for the main application and `GraphQLServer.kt` for the administrative API, which supports JWT authentication, health checks, and dynamic component management. External dependencies include Eclipse Milo (OPC UA), HiveMQ MQTT client, PLC4X, Apache IoTDB Thrift, InfluxDB HTTP client, and various database drivers. The codebase is mature (v1.38) with active development, but carries some technical drift in the form of deprecated features still present in source code and a large set of reflection configurations for GraalVM native-image that require careful maintenance.
Edzelf/ESP32Radio-V2 is an internet radio receiver firmware for the ESP32 microcontroller. It streams audio from Shoutcast/Icecast servers and plays local MP3 files from an SD card. The system supports both hardware (VS1053) and software (Helix MP3/AAC) audio decoding, with output via I2S DAC, internal DAC, or Toslink optical. It offers a web-based interface for station selection, volume control, and configuration, as well as MQTT, IR remote, and rotary encoder inputs. The firmware is built with PlatformIO and the Arduino framework, and it is designed to be highly configurable through compile-time defines in a central `config.h` file. Architecturally, the application is monolithic, with all main logic concentrated in a single `main.cpp` file. It uses multiple FreeRTOS tasks for networking (HTTP streaming), audio decoding/output, and SD card operations, communicating via FreeRTOS queues. A custom state machine handles HTTP streaming and metadata extraction. The system abstracts display hardware (various TFT, OLED, and LCD types) through a set of driver libraries with consistent interface macros, allowing the same firmware to be compiled for different display modules with minimal code changes. Audio decoders are also abstracted via macros, enabling compile-time selection between VS1053 and Helix software decoding. The codebase is actively maintained (last commit Feb 2026), but shows some signs of technical drift: it uses the deprecated SPIFFS filesystem, has version-guarded but older I2S API calls, and relies heavily on conditional compilation which complicates testing and maintenance. The library includes several well-crafted standalone components, such as the display drivers and hardware codec driver (VS1053), which can be reused in other ESP32 audio projects. The Helix MP3 and AAC decoders are large monolithic files with global state, limiting their reusability outside this specific project context.
This repository is a personal Home Assistant configuration for a multi-occupant smart home, managing lights, sensors, cameras, locks, media players, and presence detection across numerous devices. It integrates over 30 services including ZHA, Frigate, Ecobee, Sonos, Alexa, and Google Assistant through a modular YAML structure with blueprints, Python scripts, and shell scripts. The codebase demonstrates patterns for MQTT discovery, presence fusion, and external API wrappers, but is heavily tied to a specific hardware setup and runs on an outdated Home Assistant version (0.92). Many integrations referenced are deprecated, and several shell scripts contain hardcoded credentials or paths, limiting reusability. The repository is stale with no recent maintenance, and some Python scripts contain syntax errors indicating untested code.
The ZeroClaw-Android repository is an archived Android application project that was intended as an experiment to create a home for AI agents on Android. The README explicitly states the project is archived due to scope concerns and safety issues with the largely AI-generated codebase. No actual source code is visible in the provided file tree beyond the README and a ZIP archive (ZeroClaw-Android-main.zip) whose contents cannot be inspected. The repository consists almost entirely of Git metadata, indicating the source code is not directly accessible for analysis. Without access to the application code, it is impossible to assess architecture, functionality, or code quality. The project is marked as abandoned with no maintenance activity.