HyperDX / ClickStack is a full-stack observability platform for ingesting, storing, querying, and visualizing logs, traces, metrics, and session replays. The system is architected as a monorepo with a Next.js frontend (React, Mantine, CodeMirror, Recharts), an Express.js API backend (MongoDB metadata, ClickHouse primary data store), a CLI tool (ink-based TUI), and an OpenTelemetry collector for ingestion. Key capabilities include real-time dashboards with drag-and-drop tile layout, multi-channel alerting (webhook, Slack, incident.io), advanced search with Lucene and SQL, log pattern mining (Drain algorithm), session replay, service maps, Kubernetes monitoring, and a Model Context Protocol (MCP) server that exposes observability tools to AI assistants. The platform supports authentication via local accounts or OIDC, OpAMP agent configuration, and includes an evaluation framework (hdx-eval) for benchmarking agent performance on SRE scenarios. Although the repo is primarily an application, it contains data-intensive components like the log miner and analytics query engines that cross over into data engineering territory.
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).
Sidequest.js is a Redis-free background job processing system for Node.js/TypeScript that provides distributed, durable job processing using existing databases (PostgreSQL, MySQL, SQLite, MongoDB). The system features a modular monorepo architecture with separate packages for core logic, engine, database backends, web dashboard, and CLI tools. It implements job lifecycle management, scheduling via cron expressions, uniqueness constraints, retry mechanisms with backoff strategies, and provides a web interface for monitoring and management. The architecture follows clean separation of concerns with dependency injection, worker thread isolation via Piscina, and process isolation through forked child processes. Key entry points include the main Sidequest facade, engine configuration, dashboard interface, and CLI administration tools.
ADAMANT Forging Pool is a blockchain service that calculates and distributes delegate voter rewards on the ADAMANT network. It consists of a Node.js/Express backend that processes forged blocks, computes voter rewards, handles scheduled payouts, and maintains MongoDB storage for blocks, voters, and transactions. The system features a Svelte/Vite web dashboard for monitoring pool status and voter rewards, plus a control CLI (`adm-pool`) for managing encrypted passphrases. Key security features include operator-encrypted passphrases, input validation to prevent NoSQL injection, and secret-free health monitoring. The architecture follows a modular design with clear separation between API handling, business logic, data storage, and external integrations.
Plex Rewind is a Next.js web application that provides a personalized year-in-review (Rewind), a real-time activity monitor, and a configurable dashboard for Plex media servers. It ingests data from Tautulli (play history, library stats), Overseerr (content requests), and TMDB (posters, ratings), and authenticates users via Plex OAuth through NextAuth. The architecture is a monolith with server-side rendering, API routes, and a middleware layer that enforces setup requirements and access control. Settings are persisted to a local JSON file. The application supports PWA installation, multi-language i18n (English, Estonian, French, German), and is fully containerized with Docker. The codebase demonstrates strong engineering practices: strict TypeScript, server actions for form handling, React Server Components, motion animations, and a well-organized component hierarchy. It is actively maintained with semantic release automation and CI/CD pipelines.
AstrBot is a production-grade, multi-platform LLM chatbot framework and development platform. It connects to 10+ instant messaging platforms (QQ, Telegram, Discord, Slack, WeChat, Lark, etc.) via adapter pattern, integrates with 20+ LLM providers (OpenAI, Anthropic, Gemini, DashScope, etc.), and provides a plugin system (Stars) with command/regex/filter decorators. The architecture is a modular monolith: a FastAPI backend serves a Vue 3 dashboard for management, while a pipeline of stages processes incoming messages through waking checks, rate limiting, content safety, LLM interaction, and response delivery. It includes a knowledge base with RAG (FAISS vector store, chunking, hybrid retrieval), agent runners (Dify, Coze, DeerFlow), sandboxed code execution (computer use), TTS/STT, cron jobs, and a CLI. The codebase is well-structured with extensive test coverage, but its broad scope introduces some duplication and deprecated modules.
Your_Spotify is a self-hosted web application that tracks your Spotify listening history and provides a rich dashboard for exploring statistics. It consists of a React frontend (with Redux, MUI, Recharts) and an Express backend (with MongoDB, Mongoose, JWT auth). The system polls Spotify's recently played endpoint every two minutes and also supports importing historical data from Spotify's privacy exports. Users can view top songs, artists, albums, listening time breakdowns, collaborative affinity between users, and create Spotify playlists from their stats. The architecture is a monorepo with two main apps (client and server) deployed via Docker. The codebase is well-structured with clear separation of concerns, reusable UI components, and custom server-side patterns like a queued HTTP client and a write lock mechanism. However, there are no visible tests, and some aggregation pipelines are complex.
Merlion is a mature Python library for time series intelligence, specializing in anomaly detection and forecasting. It provides a comprehensive, modular ecosystem including model zoo (classical, tree-based, deep learning, ensemble, AutoML), composable transforms, post-processing chains, evaluation frameworks, and a Dash-based interactive dashboard. The architecture follows a clean layered design: data loading via `ts_datasets`, core `TimeSeries` abstraction, `ModelBase` hierarchy with config-driven instantiation, invertible transforms, and pluggable post-rules. It integrates with Spark for distributed inference and provides benchmarks against standard datasets (NAB, M4, UCR). Though primarily a library (application), it includes research-oriented components such as state-of-the-art transformer architectures (Autoformer, Informer) and Bayesian change point detection, making it a hybrid tool suitable for both production and research.
f1-dash is a real-time Formula 1 telemetry and timing dashboard. It consists of a Rust backend that connects to the official F1 live timing SignalR endpoint, ingests data (timing, car metrics, positions, weather, race control messages, team radios), and streams it via Server-Sent Events (SSE) to a Next.js frontend. The frontend displays a leaderboard, track map with driver positions, weather complications, race control messages, team radios, and a schedule page. It supports a delay feature to sync with TV broadcasts. The architecture is multi-service: a realtime service handles the SignalR connection and SSE, an API service provides schedule data from an iCal feed, and the dashboard is a standalone Next.js app. The codebase is well-organized with reusable Rust libraries (SignalR client, state service) and frontend utilities (deep merge, inflate, buffer for delayed playback, map rendering). It demonstrates strong engineering practices, though the project is currently in maintenance mode with the author focusing on other projects.
Orchid is a comprehensive Laravel admin panel framework providing a declarative screen-based architecture for building complex admin interfaces. It offers a rich set of reusable UI components including layouts (tables, tabs, modals, charts, cards), form fields (50+ types), actions (buttons, links, dropdowns), and a full permissions/role system. The frontend is powered by Bootstrap 5, Hotwire Turbo for SPA-like navigation, Stimulus controllers for interactivity, and integrates major libraries like Leaflet, Quill, CodeMirror, Cropper.js, Tom Select, and Frappe Charts. The backend provides artisan generators for scaffolding, an attachment engine with duplicate detection, a filter/sort pipeline, metric/chart helpers, and an HMAC-signed state serialization mechanism. The codebase is production-quality, actively maintained (14.x series, Laravel 11 support), with extensive unit, feature, and browser tests. It is not a data research project; it is a pure application framework for building administrative web applications.
The antd-admin repository is a monorepo providing two production-ready admin application templates (basic and with-lingui) and a CLI tool for scaffolding new projects from these templates. Built with React 19, Ant Design 6, TanStack Router & Query, Zustand, Zod, Vite+, MSW, and Playwright, it includes features like JWT authentication, role-based access control, CRUD operations with optimistic updates, URL-synchronized table state, dark theming, and optional i18n via Lingui. The architecture emphasizes modularity, with reusable hooks, components, and mocking utilities that encapsulate complex patterns such as data fetching mutations, schema-aware API mocking, and persistent state management.
OpenClaw-bot-review is a Next.js 16 + React 19 monitoring dashboard for the OpenClaw multi-platform AI agent system. It reads local filesystem data (config, session logs) to display real-time agent status, model/session statistics, gateway health, and alerts. The dashboard includes a pixel-art office visualization where agents are represented as wandering characters with a full game loop, sprite system, and bug simulation. It also houses a self-improvement R&D council with an evidence-driven decision pipeline (ingest usage → build council items → deliberate → approve/reject/snooze). The architecture is a client-heavy Next.js app with API routes that wrap OpenClaw CLI commands and direct file reads; no database is used. Key entry points are the main dashboard (`app/page.tsx`), API routes under `app/api/`, and the pixel-office engine in `lib/pixel-office/`. The codebase demonstrates solid engineering with several reusable modules (CLI wrapper, path resolution, model probe, game loop), but contains some large monolithic client components and limited test coverage.
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.
ESPHome Designer is a Home Assistant custom component that provides a visual drag-and-drop editor for designing display layouts on ESP32/ESP8266 devices running ESPHome. It supports multiple rendering protocols including native ESPHome C++ lambdas, LVGL, OpenEPaperLink (OEPL), and OpenDisplay (ODP). The editor features a canvas with zoom/pan, snap-to-grid, drag-and-drop, lasso selection, and a property panel for configuring widget attributes. Widgets are organized as plugins, each providing render, export, and lifecycle hooks for all supported output formats. The system can generate complete ESPHome YAML configurations including hardware definitions, sensor registrations, font loading, and display lambdas. The architecture is split between a Python backend (Home Assistant integration) and a JavaScript frontend (Vite-built SPA). The backend provides REST APIs for layout CRUD, entity history proxying, image/RSS proxying, hardware profile management, and PNG rendering. The frontend manages state via an AppState singleton with undo/redo, communicates with the backend through a bridge, and supports offline YAML parsing. An AI integration allows generating layouts from natural language prompts using multiple providers (Gemini, OpenAI, OpenRouter). The codebase demonstrates strong engineering practices with a plugin-based architecture, adapter pattern for multi-format export, schema-driven property panels, and extensive test coverage (200+ Vitest tests plus Python tests). It is actively maintained with CI/CD pipelines, quality gates, and regular releases. While the widget plugin surface is large and some legacy modules coexist with newer code, the overall design is modular and extensible.
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.
NyaProxy is a lightweight API gateway/proxy service built with FastAPI and Uvicorn that manages authentication, credential rotation, load balancing, rate limiting, and observability for HTTP APIs. It acts as an intermediary between clients and upstream services, injecting credentials, enforcing quotas, and providing features like retry logic, key quarantine, and request/response transformation. The system includes a web dashboard for monitoring traffic, metrics, and queue status, and exposes Prometheus metrics for external monitoring. The architecture follows a modular design with separate concerns: core proxy logic (queue-first request handling), traffic management (load balancing and rate limiting), configuration management (using Nacho for layered config and schema validation), services (metrics, state persistence), and a dashboard interface. Requests are processed via a priority queue with worker pools, enabling prioritization of retries and high-priority requests. State persistence saves rate limit windows and key cooldowns to disk using SHA256-hashed keys to avoid storing secrets, allowing survival across restarts. Key entry points include the CLI (`python -m nya` or `nyaproxy` script) and the main application factory in `nya/server/app.py`. The system relies on dependencies like FastAPI, Uvicorn, Pydantic, Nacho, and the Prometheus client, with explicit version pins in `pyproject.toml` and regular updates shown in the changelog. The codebase demonstrates strong engineering practices including comprehensive test coverage (unit and end-to-end), secure secret handling, and clean separation of concerns.
Nellavio is a production-grade, open-source Next.js dashboard starter designed for building modern SaaS products, internal tools, and admin panels. It provides 90+ reusable UI components, 60+ chart variations, authentication (Better Auth) with RBAC, i18n (next-intl), theme switching, and extensive data visualization pages (analytics, orders, customers, products, calendar, charts showcase). The architecture follows App Router with clear separation: server components for data fetching (Apollo Client GraphQL with mock fallback), client components for interactive views, Zustand for global state, and TanStack Table for data tables. The codebase is well-tested with Vitest, Storybook, and CI/CD (GitHub Actions). Despite some hardcoded demo data and recent migrations (Clerk→Better-Auth, Tremor→Recharts), the engineering practices are strong, making it a solid foundation for bootstrapping dashboard-centric applications.
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.
Redash is a full-stack business intelligence platform that enables users to connect to multiple data sources, write and schedule queries, build interactive visualizations, and create dashboards with alerting and sharing capabilities. The backend is a Python Flask application with SQLAlchemy for database access, Redis for caching and task queuing, and RQ for background job execution. The frontend is a React single-page application using Ant Design, Plotly, D3, and Leaflet, organized into pages for queries, dashboards, alerts, data sources, and administration. The system exposes a RESTful API for all operations and supports authentication via password, Google OAuth, SAML, LDAP, JWT, and API keys. The architecture follows a modular plugin pattern for query runners and visualizations. Over 35 query runners (e.g., PostgreSQL, BigQuery, Snowflake, MongoDB, Prometheus) are registered via a common base class, each implementing run_query, get_schema, and configuration_schema. The visualization library (viz-lib) is a separate package that registers chart types (line, bar, pie, map, table, cohort, sankey, etc.) with editors and renderers. Dashboards use a grid layout with widgets that can display visualizations, text, or embedded content. Alerts evaluate query results against conditions and send notifications to destinations like Slack, email, PagerDuty, and webhooks. Key data flows: users write SQL or use query runners to fetch data from connected sources; results are cached and can be visualized; dashboards aggregate multiple visualizations with parameter bindings; scheduled queries refresh results and trigger alerts. The system also supports embedding visualizations in external sites and public sharing of dashboards. While primarily an application, the extensive query runner and visualization plugin systems make it a flexible platform for data exploration and operational reporting.
DataEase is a self-hosted, open-source business intelligence (BI) platform that enables users to connect to diverse data sources, build datasets, create interactive charts and dashboards, and share insights via links or embedded widgets. The codebase is a full-stack monolith with a Java Spring Boot backend (JPA, Calcite SQL parser, Quartz scheduling) and a Vue 3 frontend (AntV G2/G2Plot/L7 for charts, UniverJS for spreadsheets). It supports a wide range of database connectors (MySQL, PostgreSQL, Oracle, ClickHouse, StarRocks, Elasticsearch, MongoDB, etc.), dataset types (SQL, union, custom fields), chart types (bar, line, pie, map, table, indicator, etc.), and enterprise features like row/column-level permissions, scheduled sync, report delivery, and multi-factor authentication. The architecture includes an SDK layer for extensions (datasource providers, sync providers, chart plugins) and a separate Xpack module for commercial features. The platform is deployed via Docker Compose with APISIX gateway. The codebase is actively maintained (24k+ stars, recent commits) but exhibits some technical drift due to deep inheritance hierarchies in chart handlers, code duplication across engine providers, and tight coupling to specific library versions (AntV G2, UniverJS). Overall, it is a solid, production-grade BI tool with good separation of concerns but with room for refactoring in certain areas.