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.
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 Godot 4 editor plugin designed for creating puzzle dependency charts (graphs) used in adventure game design. It provides a user-friendly interface within the Godot editor to create and manage boards (graphs) containing nodes (things) that can be customized with text, types (which determine color), and connections to represent dependencies. The plugin features include node creation, editing, resizing, dragging, connecting, and deletion, all integrated with Godot's undo/redo system. Users can switch between multiple boards, edit board labels, and export the current board to Graphviz format. The plugin follows a modular scene-based architecture, with separate scenes for the main view, board, individual nodes, and various dialogs (settings, export, etc.). It leverages Godot's built-in tools and APIs, such as the GraphEdit node for the graph interface and the EditorPlugin system for integration into the editor. The code demonstrates good engineering practices through proper use of the undo/redo system for user actions, encapsulation of settings and utility functions, and a clear separation of concerns between UI logic and data management. Notable reusable components include a utility for generating color textures (`utilities/icons.gd`) and a settings management wrapper (`utilities/settings.gd`) that simplifies the handling of plugin-specific data in Godot's ProjectSettings. The plugin is actively maintained, with recent commits indicating ongoing support, and shows minimal technical debt by adhering to current Godot 4.x conventions and APIs.
This repository is the JetBrains Godot Support plugin, a multi-language IDE extension for IntelliJ IDEA and Rider that provides comprehensive GDScript language intelligence, scene editing, debugging, and project integration for the Godot game engine. It consists of several modules: a Kotlin-based GDScript language plugin with custom lexer/parser, PSI, annotations, inspections, refactoring, formatting, code completion, and LSP client; a C# debugger worker that allows inspecting Godot scenes during debugging with optimized bulk-fetch strategies; a C++ native addon (GDExtension) for bidirectional communication between the IDE and Godot editor; a PHP toolchain to generate SDK metadata from Godot's official XML documentation; and .NET ReSharper components for C# Godot project support. The plugin uses JetBrains' PolySymbols framework for unified symbol resolution and has an extensive test suite covering parsing, type inference, inspections, and debugger integration. While deeply integrated with JetBrains platform APIs and generated code, the debugger worker's child-chunking algorithm and SDK fingerprinting utility are well-crafted, self-contained components that could be reused in other contexts. The codebase is actively maintained with regular commits, but relies on several internal/experimental APIs and snapshot dependencies, posing moderate technical drift risk.
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 is a Home Assistant add-on distribution point for Music Assistant, not a standalone application. It packages the Music Assistant server and a companion local audio output add-on as installable Home Assistant add-ons. The repository contains multiple variants—stable, beta, dev, and nightly—each with its own Dockerfile, run script, configuration schema, translations, and changelog. The local_audio add-on provides low-latency playback to local sound cards and is hardened with a custom AppArmor profile. In production, the add-ons run inside Home Assistant OS or a supervised installation. The main entry points are the add-on config.yaml files and the shell scripts that start the Music Assistant server or local audio player. The server exposes a web UI and integrates with Home Assistant; audio flows from music providers to players, with local_audio acting as an output sink. External dependencies include Home Assistant, Docker, the Music Assistant Python server, and system audio libraries. The codebase is primarily operational glue: shell scripts, Dockerfiles, YAML configuration, and security profiles. The most reusable artifacts are the AppArmor profile for sandboxing a network-exposed audio player and the git-ref-based source installer used by the development add-on. The repository is actively maintained, with frequent releases and detailed changelogs, and shows low technical drift relative to current Home Assistant add-on practices.
A browser extension (ImprovedTube) that provides 80+ configuration options to customize YouTube's appearance and behavior. It injects CSS and JavaScript into YouTube pages to modify the player, sidebar, comments, thumbnails, themes, and more. Features include ad blocking, forced playback parameters, keyboard shortcuts, a blocklist for channels/videos, smart speed based on heatmap data, and integration with Return YouTube Dislike. The extension uses a message-passing architecture between content scripts and page-world scripts via custom DOM events, and a custom Satus UI framework for the settings panel. It is localized into 40+ languages but has a high number of open issues and dependencies on fragile YouTube DOM structures. The codebase is functionally comprehensive but shows signs of maintenance drift with hardcoded API keys, heavy use of !important CSS, and incomplete locale coverage.
This repository is a Godot 4 addon that integrates the libsm64 library (a reimplementation of Super Mario 64's game engine) into Godot via GDExtension. It provides both a low-level C++ API exposed as a Godot singleton (`LibSM64`) and high-level GDScript nodes (`LibSM64Mario`, `LibSM64StaticSurfaceHandler`, `LibSM64SurfaceObjectsHandler`, `LibSM64AudioStreamPlayer`) for easily adding Mario characters and surface geometry to Godot scenes. The addon handles coordinate system conversion (SM64 to Godot), fixed-rate physics ticking at 30 FPS with interpolation for smooth rendering, and dynamic material switching based on Mario's power-up state. A demo project with multiple playable scenarios (Bob-omb Battlefield, many Marios, flying range) is included, along with a ROM picker dialog for loading the required Super Mario 64 US ROM. The architecture is a classic Godot plugin: a GDExtension shared library (built from C++ source in `extension/`) registers new engine classes and a singleton, while GDScript files in `addons/libsm64_godot/` provide editor integration and higher-level abstractions. The core C++ code wraps all libsm64 functions (global init, Mario creation/tick, surface loading, audio) and exposes them as Godot methods. The GDScript layer adds node lifecycle management, input mapping, interpolation, and surface handling utilities. The demo project in `libsm64_godot_demo/` showcases the addon with custom scenes, a camera rig, HUD, and input configuration. Key external dependencies are the libsm64 C library (included as a Git submodule) and the godot-cpp bindings (also a submodule). The addon requires a specific Super Mario 64 US ROM (SHA-256 verified) to function, as libsm64 uses original game assets. The build system uses SCons and GitHub Actions to compile the GDExtension for Windows, macOS, Linux, and Web platforms. The code is well-structured with clear separation between C++ engine bindings and GDScript gameplay logic, making it a solid reference for integrating complex C libraries into Godot.
This is a Home Assistant add-on repository for the Cloudflared add-on, which enables remote access to Home Assistant via a Cloudflare Tunnel without opening ports. The repository itself does not contain the add-on's runtime code (which resides in a separate repository); instead, it serves as a meta-repository that defines the add-on's configuration schema, provides multi-language translations, and hosts documentation and CI/CD infrastructure. The primary functional artifact is the `cloudflared/config.yaml` file, which defines input validation rules (including regex-based parameter validation), port mappings, and optional configuration fields. The repository is not a library or framework but a configuration and distribution hub for the add-on. It is well-maintained with automated dependency updates, linting, and release management.