Frigate is a production-grade, full-stack Network Video Recorder (NVR) with real-time AI object detection. It ingests IP camera streams, performs motion detection, object detection (via TFLite/ONNX/OpenVINO/TensorRT on CPU/GPU/NPU), tracking, and recording. The backend is Python with FastAPI, Peewee ORM, and ZMQ-based inter-process communication. The frontend is a React/TypeScript single-page application with live views, timeline review, config editing, and GenAI enrichments (face recognition, license plates, semantic search, chat). It supports hardware acceleration across a wide range of devices (Coral, Intel iGPU, NVIDIA Jetson, Hailo, Rockchip NPU, etc.) and integrates deeply with Home Assistant. While primarily an application, it contains substantial data/research components including ML model runners, embedding pipelines, and post-processing logic for classification and transcription.
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.
Valetudo is a production-grade, self-contained control web interface for robot vacuums. It replaces vendor cloud services by running directly on the vacuum's embedded Linux hardware and communicating with the robot over reverse-engineered local protocols (MiIO/MIoT for Dreame and Roborock, MSmart for Midea, and 3irobotix for Viomi). The backend is a Node.js/Express application that exposes a REST API with OpenAPI schemas, server-sent events for live state/map/log updates, MQTT integration for Home Assistant and Homie discovery, an updater for over-the-air firmware-style binary updates, timers, consumables, and map management. The frontend is a React/TypeScript SPA with a canvas-based interactive map renderer, manual control, provisioning, timers, updater UI, and configuration pages.
This is a Home Assistant addon that runs Tailscale inside a supervised container, providing a zero-config VPN for building secure networks. The addon orchestrates multiple processes via s6-overlay: tailscaled, a web UI, nginx for ingress, and dnsmasq for MagicDNS proxying. It handles complex networking including iptables DNAT for forwarding tailnet connections to the host, MSS clamping, subnet route protection to avoid collisions with tailnet routes, and Tailscale Serve/Funnel for exposing Home Assistant with TLS. It also supports Taildrop file sharing and Taildrive directory sharing. The architecture is a single container with tightly integrated services, all configured through Home Assistant's addon options. The codebase is well-structured with robust error handling and health checks, but is tightly coupled to the Home Assistant Supervisor environment via bashio and the hassio-addons base image.
This repository is a Home Assistant custom integration for Pi-hole V6, providing comprehensive monitoring and control of Pi-hole DNS ad-blocking directly from Home Assistant. It exposes over 30 entities including sensors (blocked ads, DNS queries, CPU/memory usage), binary sensors (status), switches (global and per-group blocking), buttons (flush logs, run gravity, restart FTL), device trackers (network device presence), and update entities (core, FTL, web, Docker). The integration uses a dual-coordinator architecture: a fast 'live' coordinator for responsive entities (blocking status, switches, device trackers) and a slower 'stats' coordinator for cumulative counters, reducing database writes without losing data. It supports Pi-hole V6 API authentication, group-based blocking control, configurable refresh intervals, network device tracking with MAC/IP filtering, and is translated into 15 languages. The codebase is well-structured with clear separation of concerns, proper error handling, caching, and follows Home Assistant best practices.
This repository is a Home Assistant custom component that adds OpenAI-compatible text-to-speech to a HA instance. It is distributed as an integration for HACS and registered as a config-flow service integration. In production it exposes TTS entities, an `openai_tts.say` service that announces text to media players with automatic volume save/restore and optional chimes, and an `openai_tts.set_api_key` service for credential rotation. The architecture is a HA integration split into focused modules: config flow and profile subentries, a streaming TTS engine, a sentence-level audio pipelining layer, an ffmpeg-based loudness pipeline, push-driven API health tracking, cache and validation logic, repairs, diagnostics, and a large announcement orchestration module. Provider support is driven by declarative presets for OpenAI, Mistral, Groq, Lemonfox, Kokoro, Chatterbox, and custom OpenAI-compatible endpoints, and the code intentionally modern-targets HA's streaming TTS contract rather than retaining legacy fallback paths.
This repository provides an ESPHome external component and a Home Assistant custom component for controlling Mitsubishi heat pumps via the CN105 serial interface. The core component implements a full climate controller with dual setpoint support, multiple operating modes (heat, cool, heat_cool, dry, fan_only), fan speeds, swing modes, remote temperature integration, and a wide array of sensors (compressor frequency, power, kWh, outside temperature, error codes, etc.). It communicates with the heat pump over UART at 2400 baud using a reverse-engineered protocol with checksum validation and cyclic request scheduling. The Home Assistant proxy component dynamically adjusts the UI to show single or dual setpoint sliders based on the active mode, fixes Auto mode behavior, and supports advanced features like coordinator single-target mode for multi-zone systems. The codebase is well-structured with standalone reusable modules for frame parsing, protocol encoding/decoding, request scheduling, and temperature conversion, supported by a comprehensive unit test suite and CI pipeline. The repository includes example configurations for various microcontrollers (ESP32, Xiao, M5Stack) and deployment scenarios, making it a mature and practical solution for integrating Mitsubishi heat pumps into smart home systems.
rtlamr2mqtt is a Home Assistant add-on and standalone Docker container that reads utility meters (electric, gas, water) using an RTL-SDR USB receiver and publishes readings to MQTT. The application runs rtl_tcp to interface with the SDR hardware and rtlamr to decode meter transmissions, parsing the JSON output and publishing formatted readings, HA auto-discovery payloads, and status to an MQTT broker. It supports sleep/wake cycles to conserve resources on Raspberry Pi, automatic process restart with backoff, USB device reset on timeout, and listen mode for discovering unknown meter IDs. The architecture is fully async (asyncio TaskGroup) with three independent tasks: MeterReader (rtlamr output parsing), MQTTPublisher (aiomqtt-based MQTT communication), and ManagedProcess (generic async subprocess lifecycle manager). It can run as a Home Assistant add-on (auto-discovers MQTT via Supervisor API) or standalone with a YAML config file.
This repository is a firmware build system for Silicon Labs wireless chips (EFR32, MGM210) used in Home Assistant hardware (SkyConnect, Yellow, ZBT-2, ZWA-2). It provides a Python-based CLI tool (`tools/build_project.py`) that reads YAML manifests, generates projects using the Silicon Labs Configurator (slc), applies SDK patches, compiles with GCC or LLVM, and produces signed/encrypted GBL firmware images. The repo also includes a multi-stage Dockerfile for reproducible builds, CI/CD pipelines, and a set of custom firmware extensions (LED effects, accelerometer driver, watchdog, Zigbee XNCP commands, Z-Wave Serial API commands) that demonstrate high-quality embedded engineering patterns such as priority-based LED management, temporal dithering for WS2812 LEDs, linker-wrapping for stack fixes, and Jinja-templated command dispatchers. The build system is well-architected with attention to reproducibility, LTO handling, and validation of linker wraps. While the firmware extensions are specific to NabuCasa hardware, many patterns are reusable in other Silicon Labs projects.
This is the official documentation website for Home Assistant, a popular open-source home automation platform. Built with Jekyll (a static site generator), the repository contains extensive documentation including integration guides, automation tutorials, configuration references, and a blog. It includes custom Ruby plugins for enhanced content presentation (alerts, tabbed blocks, terminology tooltips, template function documentation) and dedicated product pages for Home Assistant hardware (Green, Yellow, Connect ZBT-2, ZWA-2, Voice Preview Edition). The site is not a software application or data pipeline but a content-driven knowledge base. The repository is actively maintained with frequent updates and a well-organized structure for community contributions.
This repository provides the complete design and firmware for the Smart Plant, an ESP32-S2 based IoT device for monitoring soil moisture, ambient temperature, humidity, and illuminance. The firmware, built on the ESPHome framework, publishes sensor data to Home Assistant via MQTT and displays it on a 2.9-inch ePaper screen. It employs a sophisticated deep-sleep architecture to achieve 40-50 days of battery life, with careful power management of sensors and MQTT connections. The architecture is centered around a highly modular ESPHome YAML configuration. The `examples/multi-device/packages/smart_plant_base.yaml` file serves as a reusable base package, enabling fleet management through YAML substitutions and overrides. This pattern allows users to deploy multiple devices with a shared core configuration, customizing only device-specific parameters like MQTT topics and sensor calibrations. The data flow is strictly sensor-to-cloud, with retained MQTT messages ensuring Home Assistant entities remain available during the device's deep sleep cycles. Beyond firmware, the repository encompasses the full hardware design. The PCB is designed in Autodesk Eagle, and the 3D-printable enclosure is provided in both FDM (STL) and SLA (STEP) formats, originating from CATIA. The project is accompanied by professional Sphinx documentation hosted on ReadTheDocs, including assembly guides, safety information, and programming instructions. Overall, this is a high-quality, production-ready IoT project. The ESPHome base package is a standout reusable component for anyone building battery-powered ESPHome sensors. The hardware designs are complete and manufacturable. While the documentation contains minor copy-paste errors (e.g., referencing 'Smart Powermeter') and mixed-language comments in the YAML configs, the core firmware architecture and hardware design are exceptionally well-executed.
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.
This repository is a Home Assistant custom component that implements a full OpenID Connect (OIDC) Client/Relying Party for authentication. It allows Home Assistant users to log in via an external OIDC Identity Provider (IdP) such as Authentik, Authelia, Keycloak, or any standard OIDC-compliant server. The integration registers a custom auth provider within Home Assistant's auth system, intercepts the default login flow to redirect users to the OIDC provider, and handles the full authorization code flow including PKCE (RFC 7636), ID token validation with configurable signing algorithms, and userinfo retrieval. It supports both public and confidential clients, device code flow for mobile app login, automatic user linking, role-based access mapping from IdP groups, and a multi-step UI configuration wizard for easy setup.
This repository provides a custom firmware and backend system for the Sonoff NSPanel smart touchscreen switch, replacing its stock interface with a Home Assistant Lovelace-like UI. The system consists of three core components: a Nextion display firmware (HMI files) rendered on the panel, a Tasmota Berry driver that handles serial communication and flashing, and a backend application running as an AppDaemon app in Home Assistant or as a standalone MQTT manager. The backend processes YAML configuration, manages localization across 38 languages, maps icons to Unicode glyphs, and synchronizes entity states between Home Assistant and the panel via MQTT. The repository also includes extensive documentation, CI/CD workflows for building Docker images and validating HMI changes, and integration examples for ioBroker and IP-Symcon. While primarily an application, it contains substantial data artifacts such as translation JSON files and icon mapping tables that support the UI.
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.
Universal Notifier is a Home Assistant custom integration that acts as a centralized notification router. It exposes a single `universal_notifier.send` service that fans out messages to multiple channels—text (Telegram, mobile app) and voice (Alexa, Google Home via TTS)—with context-aware features: time-of-day greetings, per-slot volume control, weekday/weekend Do Not Disturb schedules, priority bypass, and a FIFO async queue for serialized voice announcements. The integration also provides monitoring entities (volume sensor, family presence sensor, DND binary sensor) and runtime controls (priority volume select, text format select, voice buffer number, DND override switch, last-message text). Configuration is fully UI-driven via a multi-step config flow and an options menu for post-setup edits. Architecturally, the component is a typical Home Assistant custom component with modular entity platforms (sensor, binary_sensor, select, number, switch, text) and a core `__init__.py` that registers the service, manages the voice queue worker, and handles snapshot/resume of media players. The code is well-organized, uses standard HA patterns (config entries, entity registry, service registrations), and includes a solid test suite with high coverage. The main service handler is long and somewhat monolithic, but it is subdivided into labeled sections and handles many edge cases (e.g., `notify.send_message` target kwargs, Telegram chat IDs, MarkdownV2 escaping, SSML preservation for TTS). The utils module contains genuinely reusable text-processing and time-slot helper functions. Dependencies are minimal (only HA core), and the project uses `uv` for Python management and CI with GitHub Actions (tests, HACS validation, hassfest). It targets Python 3.13+ and requires HA 2025.12.1 or newer, indicating an up-to-date stack. External integrations like Telegram, Alexa Media Player, or TTS must be installed separately; this component merely routes to them. The repository is actively maintained with frequent releases and a changelog, and it supports multiple languages (READMEs and translations).
This is a Home Assistant custom integration for controlling TP-Link Tapo cameras, doorbells, and chimes entirely locally. It provides a comprehensive set of entities (camera, binary sensor, sensor, switch, select, number, button, siren, light, update) and a media source for browsing and playing recordings. The integration communicates with devices via the pytapo library over local IP, using RTSP, proprietary streaming, ONVIF for motion events, and UDP for doorbell presses. It features a multi-step config flow with reauthentication, options flow for fine-tuning, and a background media synchronization system with hot/cold storage and thumbnail generation. The codebase is well-structured with clear patterns (base entity classes, mixins, capability detection) but suffers from a monolithic utils.py (~1500 lines) and a high config flow version number (25) indicating frequent breaking changes. It is actively maintained with recent commits and responsive issue triage, though it relies on undocumented Tapo APIs that may break with firmware updates.
Tunet is a modern, responsive React dashboard for Home Assistant that provides a customizable interface for monitoring and controlling smart home entities. The application features a React/Vite frontend with an Express/Node.js backend, using SQLite for persistent storage of user configurations. It implements a modular card-based UI system with 20+ specialized card types (lights, climate, media, etc.), real-time WebSocket synchronization with Home Assistant, and extensive customization options including theming, layout configuration, and plugin-like extensibility. The application follows React best practices with custom hooks, context API for state management, and a well-organized component architecture.
This is a personal Home Assistant configuration repository for automating a smart home. It uses Home Assistant's core automation system supplemented with AppDaemon for complex Python-based automations, HACS for managing community integrations, and Lovelace for custom UI. The configuration controls lighting, climate, security, media players, vacuum robots, and plant monitoring, with integrations for devices like Philips Hue, Xiaomi Aqara, KEF speakers, LG OLED TV, and Roborock. The repository demonstrates good organization through modular includes for reusable configuration snippets, functional separation of automations by domain, and clear separation between YAML-based and Python-based automation approaches.