Awesome Privacy is a curated directory of privacy-respecting software and services, accessible via a public website and API. The repository centers around a single source of truth YAML file (`awesome-privacy.yml`) that catalogs tools across categories like Essentials, Communication, and Security Tools. This data is processed by a Python-based toolchain (`lib/`) for validation, changelog generation, and README updates, while a modern web frontend (`web/` built with Astro and Svelte) provides interactive browsing and search, and a TypeScript API backend (`api/` using Hono) serves JSON endpoints and enriches service data with metadata from external sources like GitHub, Docker Hub, and app stores. The architecture cleanly separates data, processing, and presentation layers, with robust caching, rate limiting, and authentication in the API, and client-side search via MiniSearch in the web app. The project emphasizes maintainability through automated PR checks, dependency management, and clear contribution guidelines, though it relies on numerous third-party APIs for enrichment, introducing potential external dependency risks.
The ai-boost/awesome-prompts repository is a curated collection of prompt templates designed to configure AI agents for specific roles and tasks. It contains hundreds of specialized prompts for agent architectures (e.g., personal agent brains, multi-agent orchestrators), agent skills (e.g., coding agents, security auditors), and domain-specific agents (e.g., healthcare operations, legal analysts). Each prompt encapsulates non-obvious design patterns for agent systems, such as three-layer retrieval for memory, plan-execute loops, declarative UIs, and skill-based architectures. The repository serves as a reference for prompt engineering and agent design, enabling users to build reliable, safe, and effective LLM-based agents without starting from scratch.
Dashy is a self-hosted dashboard application that serves as a customizable startpage and service monitor for homelabs and server infrastructure. In production, it aggregates links to internal and external services, displays live widgets (weather, system metrics, crypto prices, news, etc.), and performs HTTP/ICMP status checks to indicate service health. The application is configured entirely via a YAML file (conf.yml) that defines pages, sections, items, widgets, authentication providers, themes, and layout options. Users can interact through multiple views: a default grid, a workspace with sidebar and iframe content, and a minimal tabbed view. The system also includes an interactive configuration editor, cloud backup/restore with AES encryption, and full REST API for programmatic management. Architecturally, Dashy is a full-stack web application with a Vue 3 frontend (built with Vite) and a Node.js Express backend. The frontend handles rendering, theming, localization (30+ languages), and client-side authentication flows (OIDC, Keycloak, header auth, built-in users). The backend provides endpoints for config saving, CORS proxying (with SSRF protection), status/ping checks, and optional REST API. Deployment is Docker-first, but bare-metal, cloud (Netlify, Render), and static hosting are also supported. The codebase is organized into reusable mixins (WidgetMixin, ThemingMixin, HomeMixin), custom Vue directives (DragSort, Tooltip, LongPress), and a schema-driven configuration system that powers both validation and the CodeMirror-based YAML editor. Key data flows include: (1) configuration loading from file and localStorage, merged by the ConfigAccumulator; (2) widget data fetching via the CORS proxy or direct API calls, with standardized error handling and update intervals; (3) authentication token exchange and session management across client and server; (4) status checks that update item indicators in real-time. External dependencies are limited to Node.js, Vue 3, Express, and a handful of widget-specific APIs (OpenWeatherMap, CoinGecko, etc.), all of which are optional and configurable. The project is purely an application with no data research or analytics components.
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.
This repository is a comprehensive, practitioner-focused educational hub for generative AI. It is not a deployable software application or a traditional data pipeline, but a curated knowledge base that bridges theory and practice. The content is organized into free courses (Applied LLMs Mastery, Agentic AI, AI Evals), interview preparation guides for multiple AI roles (AI Engineer, AI PM, FDE, AI Strategist), system design case studies with runnable LangGraph code, and curated research updates (monthly paper lists, State of AI reports). The architecture is a hybrid of educational content and reusable code patterns, with the core value lying in its structured learning paths and conceptual frameworks. The repository's dominant character is educational content curation and research tracking. The code examples are explicitly demonstration-grade, designed to teach production-adjacent patterns like provider-agnostic LLM layers, hash-chained audit trails, and deterministic guardrails. These patterns are genuinely reusable and demonstrate strong engineering craftsmanship. The information architecture of the repo itself is excellent, making it easy for learners to navigate from foundational concepts to advanced system design. The repository is actively maintained with a massive community following. Its primary risk is the inherent rapid obsolescence of the AI field, which the maintainers mitigate by explicitly archiving outdated content and providing clear versioning. The code examples are not production-ready out of the box, but the patterns they teach are directly applicable to real-world systems. The research paper lists and interview questions require ongoing curation to stay current.
This is the central 'Awesome' curated list repository, maintained by Sindre Sorhus. It is not a software application or data pipeline, but a community-driven meta-list of awesome lists on GitHub, organized by categories such as platforms, programming languages, front-end development, and more. The repository consists primarily of a single markdown file (readme.md) that is continuously updated via pull requests, with a GitHub Actions workflow that lints new entries using awesome-lint. The repo serves as a discovery index for developers seeking high-quality resources, tools, and learning materials across many domains. It has no runtime code, no API, and no data processing logic; its value lies in curation and community governance.
This repository is a meticulously curated knowledge base and toolkit for AI video prompt engineering. Its core is a structured data pipeline: raw knowledge from official vendor documentation and YouTube masterclasses is reverse-engineered into standardized methodologies (21+ SOPs) and a centralized prompt database (`prompts/data/all-prompts.json`). This data is then exposed through a cross-model benchmark (`prompts/data/cross-model-matrix.json`), zero-dependency web tools (Prompt Browser, Cross-Model Matrix), and executable Claude Code Skills (`skills/`). The architecture is data-centric. The primary value lies in the curated, structured data assets and the rigorous methodology used to create them. The application layer (web tools, skills) is a thin, well-crafted consumer of this data. The repository actively manages its primary risk—model version drift—through an automated monitoring system (`scripts/monitor_models.py`) that hashes external endpoints and files issues on change. While primarily a data_research project, it exhibits strong application characteristics through its interactive tools and AI skill integrations. It is a living knowledge base, actively maintained with a clear contribution workflow and a strong emphasis on data provenance and reproducibility. The `cross-model-matrix.json` is a standout asset, providing a controlled benchmark for comparing prompt styles across 11 major AI video models.
This repository is a comprehensive, curated bibliography and knowledge base for the field of active learning. It organizes hundreds of research papers by conference (ICML, NeurIPS, CVPR, etc.), journal (JMLR, TPAMI, etc.), thesis, and content topic (problem settings, deep active learning, applications, etc.). The repository also provides taxonomies, summaries, and links to papers. It is not a software application or data pipeline; it is a structured reference list intended for researchers and practitioners. The content is entirely in Markdown files, making it trivially reproducible and easy to navigate. The repository is actively maintained with recent commits and a growing star count.
This repository is an IPTV live-source automation tool that collects, tests, and aggregates TV channel streams from various sources (local files, subscriptions, EPG). It provides multiple interfaces: a CLI for updating channel lists, a REST API for serving M3U/TXT playlists, an RTMP/HLS streaming service for relaying channels, and desktop GUIs (Qt and Tkinter) for configuration and monitoring. The application is modular, with separate components for data fetching, channel testing, result aggregation, streaming, and GUI. It uses Docker for easy deployment and includes features like automatic speed testing, resolution filtering, whitelist/blacklist management, and EPG integration. The code demonstrates strong engineering practices with reusable components such as a structured reporting system, adaptive performance tuning, smart URL freezing with backoff, and cross-platform process handling.
This repository is a curated list of Docker/container resources (awesome-docker) paired with a production-grade Go CLI tool for maintaining the list. The CLI provides commands for parsing the README, linting entries (alphabetical order, description capitalization, period, duplicates), checking external and GitHub links concurrently, scoring repository health via the GitHub API, generating markdown/JSON health reports, building a static website from the README, an interactive TUI browser, and pruning stale/archived entries from both the README and the health cache. The architecture is modular with clear separation of concerns: parser, linter, checker, scorer, cache, builder, pruner, and TUI packages. The code is well-tested, uses modern Go idioms (Cobra CLI, Bubbletea TUI, GitHub GraphQL API), and is backed by comprehensive CI/CD workflows. The project is actively maintained with frequent commits, dependabot updates, and automated health reports. While the primary value is the curated list, the tooling itself is a high-quality, reusable framework for managing any curated awesome list.
Piral is a production-grade micro-frontend framework that enables building modular single-page applications (SPAs) with independently developed, runtime-integrated modules called pilets. The repository is a monorepo containing the core framework (piral-core, piral-base, piral), a CLI toolchain (piral-cli, piral-cli-webpack5), over 20 feature plugins (authentication, UI components, state management, search, notifications, etc.), and 15+ framework converters (React, Vue, Angular, Svelte, Blazor, etc.). The core architecture provides a shell application with pilet loading, extension slots, event system, shared dependency management via import maps, and state management using Zustand. The CLI supports scaffolding, building, debugging, validation, and publishing of both pilets and Piral instances. The codebase demonstrates strong engineering practices with extensive TypeScript, unit tests (Vitest), and a consistent plugin/converter pattern. Some technical drift exists in legacy pilet specifications and multiple router version adapters, but the project remains actively maintained.
This repository is a comprehensive educational resource for data engineering, structured as a handbook and bootcamp. It contains curated learning paths (beginner, intermediate, Databricks AI bootcamp) with lecture materials, homework, and sample datasets. The codebase includes teaching examples of core data engineering patterns: dimensional data modeling (cumulative tables, SCD type 2), fact data modeling (array metrics, datelist int), Apache Spark jobs with unit tests, Apache Flink streaming jobs, and analytical SQL patterns (retention, funnel, grouping sets, growth accounting). It also includes a small Flask server for A/B experimentation and Docker Compose setups for local development. While primarily educational, the SQL scripts and job templates are production-quality and reusable across projects. The repository is actively maintained with pinned dependencies and clear documentation, making it highly reproducible for learners.
This repository is a curated directory of self-hosted, open-source alternatives to popular SaaS products (VPN, photo hosting, cloud storage, email, chat, notes, password managers, kanban, etc.). The primary deliverable, README.md, is not hand-maintained: it is generated by readme-gen.py from a structured JSON dataset (dyos-db.json) containing roughly 180 projects grouped into ~37 service categories. Each project record stores name, description, GitHub URL, site URL, star count, last-push timestamp, and an ETag cache key. The repo answers: 'What self-hosted services exist for any given SaaS category, and how actively maintained is each option?' A GitHub Actions cron (maintenance.yml) runs daily. keep-alive.py iterates every GitHub-hosted project, queries the GitHub REST API for current star counts and pushed_at dates, and uses If-None-Match/ETag conditional requests so unchanged repos return cheap HTTP 304 responses - a genuinely thoughtful pattern that avoids rate-limit exhaustion across ~150 repos. Results are written back to dyos-db.json, then readme-gen.py regenerates the README with relative recency labels (🟢 under a month, 🟠under a year, 🔴 older) and per-category star sorting. Both scripts use only the Python standard library, so the dependency surface is zero. Hybrid note: although it contains application-style CLI automation scripts, the dominant character is data curation - the JSON dataset and its rendered markdown output are the product, not the scripts. Data lineage is GitHub API plus manual community submissions (via the issue template) into dyos-db.json, transformed into README.md. Reproducibility is high: cloning and running readme-gen.py regenerates the README offline with no dependencies; keep-alive.py needs only a GitHub token loaded from environment or .env. The codebase is small, has no tests, and its value lies in the curated data and the clean maintainability tooling rather than in complex engineering.
This repository is a bilingual curated awesome-list for Agent Skills focused on "persona distillation" — distilling expressive style, decision frameworks, and interaction patterns from people, relationships, conversations, works, or digital traces. The primary content is two static README files (Chinese and English) listing ~70 projects across five categories, sorted by repository name for maintainability. The codebase itself is not an end-user application; it is the curation infrastructure behind the list: a set of Bun/Node.js scripts, GitHub Actions workflows, and tests that automate the submission, validation, and merging of new entries.
This repository provides a LaTeX document class (`awesome-cv.cls`) for creating professionally formatted CVs, résumés, and cover letters. The class offers a clean, semantic markup system with configurable sections for personal information, work experience, education, skills, honors, publications, and more. It includes a rich set of styling commands, color themes, and support for Font Awesome icons and modern fonts (Source Sans 3, Roboto). The repository also ships example documents (cv.tex, resume.tex, coverletter.tex) with sample content demonstrating all features. The project is maintained with CI/CD via GitHub Actions to compile PDF examples on each push, and it provides both a Makefile-based build and a Docker workflow for reproducible compilation. Its primary value is as a reusable LaTeX template that can be customized for job applications.
Matcha is a full-featured terminal email client (TUI) written in Go, using the Bubble Tea framework. It supports multiple email protocols (IMAP, JMAP, POP3, Maildir) and provides a rich set of features including PGP/SMIME encryption, OAuth2 authentication, a Lua plugin system with 35+ community plugins, background daemon for push notifications and sync, spellcheck, i18n with 11 languages, and a configurable theme system. The architecture is modular: a backend provider interface abstracts protocol implementations, a daemon runs as a background process communicating via JSON-RPC over Unix sockets, and the TUI is built with composable Bubble Tea models. The codebase demonstrates strong engineering practices with extensive test coverage, CI/CD pipelines, cross-platform packaging (Homebrew, Snap, Flatpak, Nix, WinGet), and a well-designed plugin API. It is not a data research project; it is a production-grade application.
This repository is a curated list (awesome-list) of open-source quantitative finance libraries, packages, and resources. It provides a structured README.md organized by category, with inline language tags, and a pipeline that parses the list, enriches it with GitHub metadata (stars, last commit dates), and generates a static website deployed to GitHub Pages. The repo also includes automated tooling for pull-request review: a validation script that checks entry format, section placement, URL security, duplicate detection, and a full CI-driven PR review workflow. The core logic resides in parse.py (multi-threaded GitHub API enrichment), site/generate.py (static site generator), scripts/validate_readme.py (entry validation), and scripts/review_pr.py (automated PR review with offline URL reachability checks and cross-PR duplicate detection). The project is primarily a reference list, not an application or data pipeline, but it includes high-quality supporting tooling for maintainers and contributors.
This repository is a curated list of Jellyfin resources, including plugins, themes, clients, companion tools, guides, and snippets. It is maintained by the community and follows a structured format with automated checks. The repository includes a YAML-based client list that is automatically generated into a Markdown file, a script to check for stale projects, and a snippet for adding language overlays to movie posters. It is not a software application itself but a directory of applications and tools for the Jellyfin media server ecosystem. The repository demonstrates good practices for maintaining an awesome list with contribution guidelines, issue templates, and CI/CD workflows for linting and monthly releases.
This repository is a curated 'awesome list' of password cracking tools, research, and resources — not a software application. The primary artifact is a single, comprehensive README.md that catalogs ~150 tools and resources across 15+ categories: hashcat automation/distributed cracking/rules, John the Ripper tooling, cloud-based cracking (AWS/Colab), wordlist generators and analyzers, hash conversion utilities, ML/AI password guessing models, academic papers (2009-2026), and notable researchers in the field. The list is alphabetically sorted, CC0-licensed, and maintained by a human curator who explicitly rejects AI-generated contributions. The repo's engineering value lies in its community governance infrastructure. A GitHub Actions workflow (pr-quality.yaml) uses peakoss/anti-slop to automatically detect and close AI-generated or spam PRs, enforcing account age, profile completeness, PR size limits, and maintainer-can-modify permissions. A second workflow runs awesome-lint to enforce list formatting standards. The PR template requires AI self-disclosure via a magic string. This governance stack is a genuinely reusable pattern for any community-curated repository facing AI slop. The content is current (papers through 2026) and the repo is actively maintained with zero open issues. While it contains no application code, it serves as a high-value reference index for security researchers, penetration testers, and anyone working on password recovery or authentication security. The hybrid nature: it's a curated data resource (the list itself) wrapped in application-grade CI/CD governance.
This repository is a curated list (awesome list) of resources about post-quantum cryptography. It is not a software application or a data research project. It aggregates links to standards, initiatives, libraries, research papers, and other resources related to PQC. The content is maintained by the community and appears to be regularly updated.