Home Assistant Core is the open-source home automation platform that powers millions of smart homes. It provides a unified event-driven architecture for integrating, controlling, and automating IoT devices, services, and voice assistants. The system runs as a Python async application with a modular component system: each integration (e.g., lights, sensors, climate, locks) is a self-contained Python package under `homeassistant/components/`, following a consistent pattern of config entries, data update coordinators, and entity platforms. Key entry points include the CLI (`hass`), the web-based frontend (served via aiohttp), WebSocket API, and REST API. Data flows are event-driven: state changes, service calls, and automation triggers propagate through a central bus. External dependencies include hundreds of third-party libraries for device communication (BLE, Zigbee, Z-Wave, MQTT, HTTP), cloud services (Nabu Casa, Google Assistant, Alexa), and media playback (Cast, DLNA). The architecture is a monolith with a plugin system, not microservices, but supports horizontal scaling via separate instances and the 'recorder' component for persistent state history.
uStreamer is a lightweight, high-performance MJPEG-HTTP video streaming server designed primarily for PiKVM (IP-KVM over HDMI). It captures video from V4L2 devices (USB cameras, HDMI capture cards) and streams it as MJPEG over HTTP with sub-second latency, while also supporting H.264 streaming via WebRTC through a Janus plugin. The system is a single, multithreaded C daemon with pluggable JPEG encoders (CPU via libjpeg-turbo, hardware passthrough, and V4L2 M2M acceleration) and includes a worker pool for parallel encoding. It integrates tightly with Linux multimedia subsystems (V4L2, ALSA, DRM) and provides additional features like audio capture/playback with Opus encoding, GPIO control, systemd socket activation, and shared memory IPC for zero-copy frame access by other processes (e.g., Janus, Python bindings, dump tool). The codebase is production-grade, extensively tested in the PiKVM ecosystem, and packaged for multiple Linux distributions and container environments. The architecture separates concerns into clean modules: capture (V4L2 buffer management with DMA export), encoding (abstraction over CPU/HW/M2M), HTTP server (libevent-based, serving MJPEG streams, snapshots, and static assets), and a generic worker thread pool for parallel JPEG compression. Shared memory sinks (memsink) enable efficient frame transfer to external consumers like the Janus WebRTC plugin or the standalone dump utility. The project also includes a full-featured Janus plugin for H.264/Opus streaming with NTP timestamping and PLI handling, a Python C extension for shared memory client access, and a separate V4 passthrough tool for the PiKVM V4 Plus hardware. Build configuration uses Makefiles with numerous feature flags (WITH_GPIO, WITH_JANUS, WITH_SYSTEMD, etc.), permitting a modular build. Overall, uStreamer exemplifies careful engineering of real-time video pipelines on embedded Linux, with a focus on minimal latency, hardware offload, and robust IPC.
PiPedal is a real-time audio effects processing system designed for guitarists, featuring a hybrid architecture with a C++ backend and React/TypeScript frontend. It hosts LV2/VST3 plugins to create customizable pedalboard chains, provides web-based remote control, manages Wi-Fi connectivity (including hotspot and P2P modes), handles MIDI input, and manages presets/snapshots of effect configurations. The system emphasizes low-latency audio processing for live performance and integrates with online services like Tone3000 for neural amp model downloads.
OctoPrint is a full-stack web application for controlling and monitoring 3D printers. In production it runs as a Python server that exposes a Flask-based REST API and a SockJS/WebSocket real-time channel, while serving a Knockout.js single-page frontend. The core system talks to printers over serial connections through a stateful connector, parses G-code for print-time and filament analysis, manages file storage across local/SD/printer backends, coordinates slicing jobs, captures and renders timelapses, and enforces granular permissions with user/group management. It is a monolith with a deeply embedded plugin architecture: mixins (StartupPlugin, SettingsPlugin, BlueprintPlugin, EventHandlerPlugin, etc.) and hook dictionaries let third-party code extend nearly every layer, from API routes to G-code processing to the UI. The primary entry points are the `octoprint` CLI (serve, config, user, plugins, timelapse, analysis), the package's `__main__.py`, and the server initializer that wires together settings, logging, plugins, event management, and printer connectivity. Data flows center on the frontend interacting with REST/WebSocket endpoints, which delegate to core managers: `FileManager`, `SlicingManager`, `PrinterStateConnection`, `EventManager`, `Timelapse`, and the serial connector. External dependencies include sarge/pyserial for serial and process execution, ffmpeg for timelapse rendering, requests for update checks and plugin repository access, and optional network services (announcements, tracking, discovery). The codebase contains an extensive test suite spanning unit tests, HTTP API tests, serial parser tests, and Playwright end-to-end tests, plus thorough Sphinx documentation. OctoPrint is actively maintained, with recent commits, a large issue tracker, and a mature contributor ecosystem. The backend uses modern Python packaging, Pydantic schemas, and pinned dependency ranges, but the frontend carries significant legacy weight: Knockout.js, jQuery, Bootstrap 2/3-era assets, and deprecated API methods marked for removal in 3.0.0. This mixed state makes the project solidly engineered but with noticeable technical debt. It is not a data-research repository; the data it handles is operational telemetry, G-code metadata, user settings, and printer state, all serving real-time control rather than analytical workloads.
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.
The OpenCAL firmware is a Python application designed to control a Computed Axial Lithography (CAL) 3D printer running on a Raspberry Pi 5. It orchestrates hardware components including a stepper motor (via Pololu Tic T249 or similar), LED array, projector (using mpv), camera (using picamera2), LCD display, and rotary encoder. Users interact via a menu-driven LCD interface to select video files from a USB drive and initiate print jobs, during which the system coordinates motor rotation, LED illumination, video projection, and image capture. The application follows a modular architecture with clear separation of concerns: GUI logic in `gui/`, hardware abstraction in `hardware/`, and configuration management in `utils/`. The LCD GUI implements a state machine for menu navigation, while the hardware layer uses a strategy pattern to support multiple stepper motor drivers (Tic USB, step/dir, UART, and a mock for testing). Configuration is managed through typed dataclasses loaded from a JSON file, allowing easy adaptation to different hardware setups. Key strengths include the reusable stepper motor abstraction layer, which cleanly separates the control interface from driver-specific implementations, and the configuration system that provides a robust, typed interface to hardware parameters. The USB media handler offers a simple, self-contained utility for managing media files on removable storage. The system is actively maintained and targets the Raspberry Pi 5 platform with specific hardware dependencies.
MMM-GooglePhotos is a MagicMirror² module that displays photos from Google Albums on a smart mirror dashboard. It features a clean architecture separating UI logic (MMM-GooglePhotos.js) from backend processing (node_helper.js), with a well-abstracted Google Photos API client (GPhotos.js). The module handles OAuth2 authentication, automatic token refresh, paginated API requests, photo filtering (by date, dimensions, aspect ratio), sorting, and caching to minimize API calls. It supports user interactions via notifications for navigating photos and uploading new images to designated albums.
Pi-hole is a network-wide ad blocking application that operates as a DNS sinkhole. The repository contains the core shell scripts for installation, configuration, and management of the Pi-hole system. The primary entry points are the `pihole` CLI command and `gravity.sh`, which downloads and compiles blocklists into a SQLite database. The architecture is a collection of bash scripts that orchestrate the FTLDNS daemon (a separate binary) and provide a command-line interface for allow/deny lists, querying, debugging, and updates. The code is well-structured with modular functions, error handling, and extensive test coverage across multiple Linux distributions. It is a mature, actively maintained project with a large community.
This repository provides a collection of shell scripts to automate the setup and management of an IPsec VPN server on Linux. It supports multiple VPN protocols (IPsec/L2TP, IPsec/XAuth, IKEv2) and a wide range of Linux distributions including Ubuntu, Debian, CentOS, Rocky Linux, AlmaLinux, Oracle Linux, and Alpine Linux. The main entry point is `vpnsetup.sh`, which detects the OS and runs the appropriate installer. The project also includes helper scripts for user management, IKEv2 certificate handling, upgrades, and uninstallation. Additionally, it offers an Azure ARM template for cloud deployment. The code is well-structured with OS-specific installers, common bash utility functions, and extensive documentation in multiple languages. It is a mature, widely-used DevOps tool for system administrators.
TeslaMate is a self-hosted data logger for Tesla vehicles that collects telemetry via the Tesla API (both polling and streaming), stores data in PostgreSQL, and provides visualization through a Phoenix LiveView web interface and Grafana dashboards. It integrates with home automation systems via MQTT and supports importing historical vehicle data from CSV files (TeslaFi format). The application uses a supervision tree to manage background processes for data collection, MQTT publishing, import tasks, and update checking. Key features include geofencing for location-based cost tracking, encrypted storage for API tokens using Cloak, internationalization via Gettext, and custom Ecto expressions for geographic calculations. The architecture is monolithic with clear separation of concerns through Phoenix contexts (Log, Vehicles, Settings, Locations).
LedFx is a networked LED light effect controller that synchronizes multiple addressable LED devices (e.g., WLED, LIFX, Nanoleaf, Art-Net, DDP) to real-time audio analysis. It runs as a Python asyncio application with a built-in aiohttp REST API and a prebuilt React frontend served on port 8888. The system captures audio from system loopback, microphone, or network streams (Sendspin), processes it through FFT/melbank/beat detection, and drives audio-reactive effects on virtual LED strips and matrices. It also integrates with now-playing services (MPRIS, SMTC, Sendspin) to extract album art gradients and apply them to effects. The architecture is plugin-based: effects, devices, integrations, and API endpoints are registered via a `BaseRegistry` pattern with voluptuous schema validation. The core runtime (`LedFxCore`) orchestrates device discovery, virtual management, scene/playlist systems, and configuration persistence. The codebase is well-structured with clear separation of concerns, but some modules (e.g., `core.py`, `virtuals.py`) are large and handle multiple responsibilities. The project is actively maintained with comprehensive CI/CD, extensive test coverage (including API integration tests), and detailed documentation for users and developers.
Xonsh is a cross-platform, Python-powered interactive shell that combines Python syntax with shell subprocess commands. The codebase implements a full shell environment with a custom parser (PLY-based with version-specific extensions), an execution engine that compiles xonsh code to Python AST, a rich tab-completion system with multiple backends (bash, git, pip, python, custom completers), a pluggable history backend (JSON, SQLite), a prompt system with git status and virtualenv information, and a subprocess management layer with job control. It also includes CLI tools for formatting, linting, and interactive configuration (xonfig wizard and web UI). The architecture is monolithic with a clear module structure: parsers, executers, completers, prompts, history, procs, and shells. External dependencies include prompt_toolkit, pygments, and PLY (vendored). The repository is actively maintained with frequent releases, supports Python 3.10+, and has an extensive test suite. Some technical drift exists due to deprecated API shims, multiple parser versions, and LLM-generated tests, but the core is well-engineered.
The iOS Backup Machine is a self-contained backup appliance for iOS devices, designed to run on a single-board computer (Radxa Zero 3W) with a Waveshare e-Paper display and PiSugar UPS. The software provides a Flask-based web UI for configuration and monitoring, a background daemon that manages iPhone backups via libimobiledevice (idevicebackup2), remote sync via rsync over SSH with host key pinning, WireGuard VPN integration for secure remote access, and notification delivery via MQTT or webhooks. It features encrypted credential storage (AES-256-GCM), automatic backup scheduling, staleness detection, battery-aware operation, and a setup wizard. The architecture is primarily monolithic with the main daemon (iosbackupmachine.py) handling display, backup orchestration, network monitoring, and hardware integration, while separate modules handle sync management, crypto, config, and the web interface. The codebase is well-tested with unit tests covering fail-safes, resource bounds, and configuration migration, and it demonstrates strong engineering practices in areas like atomic file writes, log capping, and rate-limited progress reporting.
Gogs is a self-hosted Git service written in Go, providing a full-featured platform for hosting Git repositories with issue tracking, pull requests, wiki, webhooks, and Git LFS support. The backend is a monolithic Go application using a dual web framework (Macaron and Flamego) and dual ORM (XORM and GORM) during an ongoing migration. The frontend is a hybrid of legacy server-rendered templates and a modern React SPA built with TanStack Router, Radix UI, and Tailwind CSS. The system supports multiple authentication backends (LDAP, SMTP, PAM, GitHub OAuth), SSH and HTTP Git protocols, and extensive REST API. It is deployed via Docker with s6 supervisor and backup rotation scripts. The codebase demonstrates strong engineering practices with well-structured utility packages, security-conscious input validation, and comprehensive test coverage using golden files and mock stores. However, it carries technical debt from the framework migration, vendored outdated frontend plugins (CodeMirror 5.17.0), and a monolithic legacy JavaScript file.
This repository contains a native WebRTC streaming application designed for Raspberry Pi and NVIDIA Jetson platforms. It captures video from various camera sources (libcamera, libargus, V4L2) and audio from PulseAudio/ALSA, encodes the streams using hardware acceleration when available or software fallbacks, and transmits them via WebRTC with multiple signaling options (MQTT, WebSocket, HTTP/WHEP). The application includes recording capabilities, snapshot functionality, and IPC for local control. The architecture is modular with clearly separated concerns for capture, encoding, signaling, and real-time communication.
DSMR-reader is a production-grade Django web application for reading, storing, and visualizing Dutch Smart Meter (DSMR) data from the P1 port. It parses electricity, gas, and water consumption telegrams via serial or network socket, computes hourly/daily statistics with cost calculations, and provides a comprehensive web dashboard with interactive ECharts graphs, a REST API (v1/v2), and integrations with MQTT, InfluxDB, Dropbox, PVOutput, MinderGas, and notification services (Pushover, Telegram, Prowl). The application is container-first (Docker/Podman) and requires PostgreSQL 14+. It exhibits a modular Django app architecture with a signal-driven service layer, singleton settings via django-solo, and extensive test coverage. The frontend is built with Bootstrap 3, jQuery, and Font Awesome 7.2.0 but carries significant technical debt (legacy libraries, unused CSS, jQuery UI), and the project maintains a detailed tech-debt document tracking planned upgrades.
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.
KIAUH (Klipper Installation And Update Helper) is a text-based user interface (TUI) and CLI tool for managing the Klipper 3D printer firmware ecosystem. It automates installation, update, removal, and backup of core components (Klipper, Moonraker, Mainsail, Fluidd, KlipperScreen, Crowsnest) and a wide range of community extensions (OctoPrint, Telegram Bot, Obico, Spoolman, etc.). The tool runs on Linux systems (primarily Raspberry Pi and similar SBCs) and handles systemd services, Python virtual environments, git repositories, nginx configuration, and system package management. Architecturally, KIAUH is a Python package with a modular design: a core framework provides menu navigation, logging, spinner animations, and a backend abstraction layer for command execution and filesystem operations. Components and extensions are implemented as classes inheriting from BaseExtension, each with install/update/remove methods. The tool supports multiple printer instances via an InstanceManager and uses a custom SimpleConfigParser for round-trip safe manipulation of Klipper-style configuration files. A headless CLI mode enables scripted, non-interactive operation. The codebase demonstrates solid engineering practices: dependency injection for testability, a plugin architecture for extensions, extensive test coverage (pytest with fake backends), and a well-organized package structure. Key reusable assets include the SimpleConfigParser (a standalone, comment-preserving config parser), the backend abstraction (enabling deterministic testing), and the BaseExtension plugin interface. While the tool is actively maintained and widely used, some areas show technical debt such as singleton proliferation, direct subprocess calls in places, and a Python 3.8 baseline that may limit future compatibility.
Dire Wolf is a software Terminal Node Controller (TNC) for amateur radio packet radio, specifically AX.25 and APRS. It replaces hardware TNCs by demodulating audio from sound cards or SDR receivers, decoding AX.25 frames, and providing network interfaces (KISS, AGW) for client applications like Xastir, APRSIS32, and UI-View. The codebase is a monolithic C application with threaded audio capture, multiple modem demodulators (AFSK, PSK, G3RUH, 9600bps), forward error correction (FX.25, IL2P), digipeating, IGate (internet gateway), GPS integration, DTMF/APRStt gateway, and telemetry decoding. It runs on Linux, Windows, and macOS. The architecture is single-process with multiple threads, using a global event queue for inter-module communication. Key entry points include the main `direwolf` daemon and several standalone utilities (`decode_aprs`, `kissutil`, `gen_packets`, `atest`, etc.). The implementation is production-grade, with extensive protocol handling and real-world tuning, but exhibits some monolithic design patterns and legacy code (vendored regex, geotranz).
JARVIS2 is a real-time dashboard framework designed for Raspberry Pi, built with Flask (Python) and Mithril (JavaScript). It features live-updating widgets via server-sent events (SSE) and a plugin-based job system for data fetching. The backend schedules periodic jobs (e.g., weather, public transport, email, RSS) that push data to connected browsers. The frontend renders widgets using Mithril components and updates them reactively as events arrive. The architecture is a monolith: a single Flask application with background scheduling via APScheduler. Key entry points are the Flask routes for dashboards, individual widgets, and the SSE event stream. External dependencies include various APIs (Yr, Entur, Avinor, Google APIs, Sonos, etc.) and libraries (Flask, APScheduler, requests, BeautifulSoup, soco). The codebase is well-structured, with clear separation between job implementations, static assets, and templates. It includes a comprehensive test suite and CI pipeline. The project is actively maintained, targeting Python 3.14 and using modern tooling (uv, ruff). However, it retains some deprecated dependencies (oauth2client) and Python 2 compatibility shims, indicating moderate technical drift.