Newspipe is a self-hosted web news aggregator (RSS/Atom feed reader) built with Flask. It provides a full-featured reading experience with multi-user support, two-factor authentication, role-based access control, and a RESTful API. The system fetches feeds asynchronously using asyncio, sanitizes content against XSS, and guards against SSRF via IP pinning. It supports categories, bookmarks, tags, notes, search, infinite scroll, and a resizable reading pane. Data can be imported/exported in OPML and JSON formats, and it integrates with Pinboard for bookmark import. The frontend uses Bootstrap 5, Chart.js, and Luxon for relative dates, with i18n support for English, French, and German. The architecture follows a layered pattern: Flask blueprints for views, controllers for data access (with a generic AbstractController), SQLAlchemy models, and utility libraries for security and data handling. The crawler is a separate async module that can be invoked via CLI or cron. The codebase demonstrates strong security practices (CSP, CSRF, safe redirects, input sanitization) and includes unit tests for security-critical components. While the project is well-structured and actively maintained, there is a known bug where non-admin users with API access cause a 500 error on article updates due to a tag association proxy issue.
ClickClack is a production-grade, self-hostable team chat platform built for people, bots, and agents. The backend is a single Go binary serving a REST API with WebSocket real-time events, supporting both SQLite and PostgreSQL as interchangeable storage backends. The frontend is a Svelte 5 single-page application embedded into the Go binary, with an optional Electron desktop client and a TypeScript SDK for bot development. The system provides workspaces, channels, threads, direct messages, file uploads, full-text search, reactions, pinned messages, slash commands, event subscriptions, and push notifications (Web Push and Pushover). Authentication supports magic links, passwords (Argon2id), GitHub OAuth, and Cloudflare Access JWT. The architecture emphasizes security with SSRF-safe callback dialers, strict cookie namespacing, rate limiting, and bot scope enforcement. The codebase is notable for its dual-database store pattern with shared contract tests, a real-time event hub with cursor-based recovery, and a comprehensive test suite including unit, integration, and Playwright end-to-end tests. It is not a data research project; it is a fully featured application designed for self-hosting or cloud deployment.
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.
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.
Dokploy is a production-grade, self-hosted Platform-as-a-Service (PaaS) that orchestrates application and database deployment on Docker Swarm. The code confirms the README claims: it clones repos from Git providers (GitHub, GitLab, Bitbucket, Gitea), builds via multiple strategies (Dockerfile, Nixpacks, Railpack, Paketo, Heroku), provisions six database types (Postgres, MySQL, MariaDB, Mongo, Redis, LibSQL) as Swarm services, generates Traefik reverse-proxy configs with ACME/TLS and forward-auth middleware, runs rclone-based backups to S3-compatible storage, and streams logs/terminal/stats over WebSockets. It is not a research or data project; the only data assets are operational metrics collected by a Go agent into SQLite for monitoring dashboards.
changedetection.io is a self-hosted web application for monitoring web pages for content changes. It periodically fetches URLs, computes diffs (text, JSON, image, or stock/price), and sends notifications via 100+ channels (Apprise). The system is built on Flask with Socket.IO for real-time UI updates, a pluggable processor architecture (text_json_diff, restock_diff, image_ssim_diff), and an LLM integration layer (via litellm) for intelligent change summarization and intent-based filtering. It supports multiple fetcher backends (requests, Playwright, Selenium, Puppeteer), browser automation steps, RSS feeds, and a REST API with OpenAPI spec. Architecturally, it is a monolith with background workers: a priority queue (RecheckPriorityQueue) dispatches watch rechecks to async workers, which fetch content, run processors, and trigger notifications. The datastore is file-based JSON with atomic writes and schema migrations. The frontend uses jQuery, SCSS, and custom JavaScript for diff visualization, visual selectors, and real-time queue monitoring. The plugin system (pluggy) allows extending fetchers, processors, conditions, and UI elements. Key entry points include the CLI (changedetection.py), the Flask app factory (flask_app.py), the worker pool (worker_pool.py), and the notification service (notification_service.py). External dependencies include Playwright, Apprise, litellm, lxml, and various image processing libraries (OpenCV, libvips). The codebase is well-tested with over 120 test files covering security, integration, and unit tests.
Karakeep is a self-hostable bookmarking and read-it-later application. It supports saving links, notes, images, PDFs, and videos, with AI-powered auto-tagging, summarization, and semantic search. The system consists of a Next.js web app, an Expo React Native mobile app, a browser extension (Chrome/Firefox/Safari), a CLI, a Model Context Protocol (MCP) server, and a set of background workers (crawler, embeddings, feeds, webhooks, rule engine, backups). The backend uses tRPC for API, Drizzle ORM with SQLite, and a plugin system for swapping infrastructure (asset stores, queues, search, rate limiting). The architecture is monorepo with shared packages for types, server utilities, and React hooks. It is actively maintained with frequent releases and a large community.
Budibase is an open-source low-code platform for building AI agents, internal applications, and automations. It provides a visual builder (Svelte frontend) for designing screens, data models, and workflows, backed by a Koa.js server and worker services. The platform supports multi-tenancy, self-hosting via Docker/Kubernetes, and a cloud offering. Core capabilities include a drag-and-drop app builder, an automation engine with triggers and steps, AI agent creation with LLM integration and knowledge bases, external datasource connectivity (REST, SQL, NoSQL, S3, etc.), role-based access control, SCIM provisioning, and audit logging. The architecture follows a monorepo pattern with distinct packages for server, worker, builder, client, pro features, CLI, and shared libraries, using CouchDB as the primary document store, Redis for caching/queues, and S3/MinIO for object storage.
Feishin is a feature-complete self-hosted music player client, delivered as an Electron desktop application and a standalone web build. In production it connects to Subsonic/OpenSubsonic, Navidrome, or Jellyfin servers and presents their libraries (albums, artists, playlists, folders, genres, radio) through a React 19 + Mantine 9 UI. Playback is performed client-side through multiple engines: MPV via an IPC bridge, an HTML5/web-audio engine with gapless transition and crossfade curve math, and DLNA speaker casting via SSDP discovery and SOAP control. It also ships a companion mobile remote web app (src/remote) that controls the desktop player over a WebSocket-based protocol, including queue, playlists, and radio. The repository is purely an application; its only data-related surfaces are integrations with external music-server APIs and client-side caching/validation logic. Architecturally, the app is split into an Electron main process (src/main) housing platform features — lyrics providers (Genius, NetEase, Lrclib, SimpMusic), DLNA, Discord RPC, MPRIS, custom-theme file watching, and a taglib-wasm tag editor — a typed preload IPC bridge (src/preload), and a feature-foldered React renderer (src/renderer). Data flows through TanStack React Query with structured per-server query keys and optimistic mutations; Zustand stores (with persistence and migration logic) manage player/settings/auth/app state; a typed event emitter decouples list, queue, and player components. Additional subsystems include a smart-playlist query builder, word-level synchronized karaoke lyrics with furigana/romaji conversion, scrobbling, Auto-DJ, internet radio, audio visualizers (Butterchurn, AudioMotion), and an extensive theming/i18n surface (30+ themes, 40+ locales). The codebase is very actively maintained with CI covering build/release on all desktop platforms, Docker, and updates. The strongest, most reusable craftsmanship sits in self-contained subsystems: the dual-player web audio engine, the lyrics animation engine, hand-rolled ThumbHash/BlurHash placeholder decoders, a Zod-based response-validation layer, and generic polymorphic component utilities. The tradeoff is breadth over polish: near-identical list/filter/grid/table variants are copy-pasted per entity, virtual-table hooks are tightly coupled to DOM structure, isElectron() guards are scattered throughout, and visible unit tests are minimal. It is a solid reference for Electron + React music-player architecture, but extracting individual features requires care due to internal coupling.
Papra is a self-hostable, open-source document management platform that provides a full-stack solution for archiving, organizing, and searching documents. The system consists of a Hono-based API server with SQLite (via Drizzle ORM and libsql/Turso), a SolidJS web client, a React Native mobile app (Expo), a CLI tool, and several standalone packages. It supports multi-tenant organizations, role-based access, document upload with content extraction (OCR via Tesseract, Mistral OCR, Azure Document Intelligence, Docling, and a custom HTTP strategy), full-text search via SQLite FTS5 with a custom query parser, tagging with automatic tagging rules, document sharing with password-protected links, intake emails, webhooks, and subscriptions with Stripe integration. The architecture is modular, using repository and usecase patterns, an in-process event system, and a driver-based approach for storage (filesystem, S3, Azure Blob), email delivery, and KV stores. The codebase is heavily tested with unit, integration, and e2e tests, and includes a comprehensive demo mode.
Nexterm is a comprehensive remote server management platform enabling connections via SSH, VNC, RDP, web, SFTP, and FTP protocols. It features a multi-layer architecture with web (React), mobile (Flutter), desktop (Tauri), and CLI (Rust) clients communicating with a Node.js/Express server and C-based connection engine. The platform provides session management, organization-based access control, audit logging, script execution, file management, monitoring, and AI-assisted command generation. Real-time updates are facilitated through WebSocket connections, with data persistence handled via Sequelize ORM supporting PostgreSQL, MySQL, and SQLite databases.
This repository implements a self-hosted deployment platform alternative to services like Vercel or Netlify. It enables users to deploy GitHub repositories with zero-downtime updates, instant rollback, and preview deployments for branches. The platform provides team-based access control, custom domain support with automatic Let's Encrypt SSL, storage provisioning (databases/volumes), and real-time log aggregation via Loki. Built with FastAPI, SQLAlchemy, and ARQ for background jobs, the architecture separates concerns into routers, services, models, utilities, and workers. Infrastructure is orchestrated via Docker Compose, including Traefik for routing, PostgreSQL for primary data, Redis for caching/job queue, and Loki/Alloy for logs. Key entry points include the main FastAPI app, API routers for auth/project/team/admin, and worker entrypoints for ARQ jobs and deployment monitoring.
OpenBudgeteer is a personal budgeting application built with .NET 9.0 featuring a Blazor WebAssembly frontend and ASP.NET Core Web API backend. It implements the bucket budgeting methodology, allowing users to manage financial accounts, transactions, budget categories (buckets), automated transaction rules, recurring transactions, and financial reporting. The application supports multiple database providers (MySQL, PostgreSQL) and uses Redis for session storage and application settings. The architecture follows a layered approach with distinct data, service, presentation, and API layers. The data layer uses Entity Framework Core with a repository pattern for data access. The service layer provides business logic through generic and EF Core-specific services. The presentation layer employs the MVVM pattern with Blazor components and ViewModels handling UI state and logic. The API layer exposes RESTful endpoints for the frontend to interact with the backend. Key reusable components include a generic repository pattern, a generic service pattern, a ViewModel base class for Blazor, a fluent CSV bank transaction mapper, and a MudBlazor theme persistence service. These components demonstrate craftsmanship in abstraction and separation of concerns, making them suitable for extraction and reuse in other projects. The application is actively maintained with recent updates to .NET 9.0, MudBlazor, and ApexCharts, indicating low technical drift.
TelegramRSS is a PHP web service that acts as a proxy between clients and a Telegram API server, providing RSS and JSON feeds of Telegram channel content. Built with AMPHP for asynchronous handling, it features rate limiting, IP-based access control, and middleware-based request processing. The service fetches messages from Telegram via a backend API server and formats them as RSS or JSON responses with media support.
Goeland is a self-hosted RSS/Atom feed to email digest tool written in Go. It fetches feeds from RSS/Atom/JSON sources, Imgur tags, and Miniflux instances, applies a composable chain of filters (e.g., unseen, today, digest, language, retrieve, replace), and sends beautiful responsive HTML emails via SMTP or writes to HTML files. It runs as a one-shot CLI command or as a persistent daemon with per-pipe cron scheduling. The architecture is modular: commands are defined with Cobra, configuration is read via Viper (TOML files with env overrides), logging uses Logrus with structured output support, and unseen entry tracking uses BoltDB. External dependencies include an SMTP server, Miniflux REST API, Imgur API, and optional CSS themes. The codebase demonstrates strong engineering practices: clean package boundaries, thorough unit tests (filter_test.go covers all filters including edge cases), security-conscious HTTP fetching with SSRF protection, internationalization support, and automated CI/CD with Docker multi-arch builds. It is production-stable and actively maintained.
n8n is a production-grade workflow automation and AI agent platform. In production, it runs as a Node.js Express server with a Vue 3 frontend, executing user-defined workflows composed of nodes (triggers, actions, LLM calls). Workflows can be triggered manually, via webhooks, schedules, or events, and the execution engine handles concurrency, retries, errors, and data passing between nodes. The platform supports AI agents through an SDK that manages LLM calls, tool execution, memory, conversation loops, and MCP (Model Context Protocol) integration, enabling autonomous multi-step agents. Architecturally, the monorepo is organized into backend (packages/cli, packages/core, @n8n/engine), frontend (packages/frontend/editor-ui), database layer (@n8n/db with TypeORM), AI/agent packages (@n8n/agents, @n8n/ai-utilities, @n8n/instance-ai), and a vast node/credential library (packages/nodes-base, @n8n/nodes-langchain). Dependency injection is handled by @n8n/di, controllers are decorated with @RestController, and database models use a forked TypeORM. The system supports multiple database backends (PostgreSQL, SQLite) and can scale with Redis and worker processes. Key data flows: Workflow definitions are persisted in the database with version history. Execution data (inputs, outputs, binary data) is stored for monitoring and replay. The AI agent runtime uses a persistent message store for conversation memory, supports checkpoint/restore for long-running agents, and integrates with external LLMs (OpenAI, Anthropic, etc.) via a unified model factory. The platform exposes REST APIs for CRUD operations on workflows, credentials, users, and executions, as well as WebSocket push for real-time UI updates. External dependencies include a database, optional Redis for scaling, and numerous third-party services via nodes and credentials.
Open WebUI is a full-stack, self-hosted AI chat platform that provides a feature-rich interface for interacting with local and cloud-based large language models (Ollama, OpenAI-compatible APIs, Anthropic). The system is built as a monolith with a Python FastAPI backend and a Svelte (SvelteKit) frontend, deployed via Docker. It supports retrieval-augmented generation (RAG) with multiple vector database backends (Chroma, Qdrant, Milvus, pgvector, Elasticsearch, etc.), web search integration (20+ providers), document loading (PDF, DOCX, YouTube, web pages), and a plugin system for custom filters, actions, tools, and pipelines. Additional features include user/group management with granular access control, real-time collaboration via WebSockets, automations with RRULE scheduling, calendar, notes, channels, code execution (Pyodide/Jupyter), image generation (ComfyUI), voice/video calls, and comprehensive analytics. The architecture emphasizes extensibility through abstract base classes (vector DB, reranker, storage provider) and a valve-based configuration system for plugins.
AList is a self-hosted file listing and sharing gateway written in Go. In production it aggregates over 100 distinct storage backends — local disk, Aliyun Drive, OneDrive, Google Drive, S3, Baidu, PikPak, Thunder, WebDAV mounts, FTP/SFTP servers, and more — behind a unified virtual file tree, then exposes that tree simultaneously through a web UI + REST API, WebDAV, an S3-compatible object storage endpoint, FTP, SFTP, and an MCP (Model Context Protocol) tool server. It is a monolithic Go application (Gin + GORM) deployed as a single binary or Docker container, with a rich feature surface: role/permission-based multi-user access with path-scoped grants, password-protected time-limited shares with burn-after-read and download tracking, pluggable search backends (Meilisearch, Bleve, database full-text, no-index), offline downloads via aria2/qBittorrent/Transmission plus cloud-native tools, archive extraction (zip/7z/rar/iso9660), device session limits, rate limiting, SSO/LDAP/WebAuthn auth, and an FRP reverse-proxy client for NAT traversal.
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.
Dawarich is a production Ruby on Rails 8 monolith for personal location history tracking, positioning itself as a self-hostable Google Timeline replacement. It ingests timestamped geospatial points from a broad range of trackers (OwnTracks, Overland, Traccar) and file formats (GPX, GeoJSON, KML/KMZ, TCX, FIT, CSV, Google Takeout), then drives them through heavy background processing: reverse geocoding, anomaly filtering, visit detection, track generation, transportation-mode classification, trip building, and monthly/yearly statistics with digest emails. The web frontend is a MapLibre GL JavaScript application using vector-tile rendering, WebSocket real-time updates, and novel in-browser encoding studios for route videos (WebCodecs MP4) and printable posters (hand-rolled PNG encoder). The system also integrates photo libraries (Immich, PhotoPrism), flight logs (AirTrail), TeslaMate, and TREK trip planning, plus family location sharing, achievements, and an MCP API endpoint. Architecturally it is a conventional but well-executed Rails service-object monolith: controllers are thin, domain logic lives in app/services (command pattern with call methods), heavy processing is delegated to a large Sidekiq job surface with named queues, and cross-process coordination uses Redis-based debouncers, per-user advisory locks, and tile epochs for cache invalidation. PostGIS powers spatial queries (ST_DWithin, lonlat geography, H3 hexagons, vector tiles). The codebase ships dual-mode: self-hosted Docker deployments and a cloud SaaS with subscription/entitlement gating, with many env-conditional branches. Test coverage is extensive (RSpec with regression specs for timezone/race/geospatial edge cases, Playwright e2e, locale-parity and schedule-consistency specs), CI includes RuboCop, Trivy, and Dependabot. The strongest engineering is in the data-ingestion and processing layer: streaming SAX-style JSON parsers for huge Google Takeout files, batched upsert with deduplication and Null Island filtering, deterministic nearest-centroid transportation-mode classification with explicit explainability, and Redis coordination patterns for geocoding claims and per-user job locks. Weaknesses include a sprawling surface area (35+ service subdomains in one repo), significant schema churn via migration-enqueued backfill jobs, and dual self-hosted/cloud branches that add cognitive load. Overall this is a well-maintained, feature-complete application with genuinely reusable geospatial and streaming-data patterns.