MediaCrawler is a multi-platform social media data collection tool targeting Chinese platforms: Xiaohongshu, Douyin, Kuaishou, Bilibili, Weibo, Baidu Tieba, and Zhihu. It uses Playwright browser automation to log in (QR code, phone, cookie) and then scrapes posts, comments, and media files based on search keywords, specific post IDs, or creator IDs. The architecture is a monolith with modular platform-specific crawlers, a shared abstract base layer, and a FastAPI backend that provides a WebUI for visual control. Data can be stored in multiple formats (CSV, JSON, JSONL, SQLite, MySQL, PostgreSQL, MongoDB, Excel). Additional features include a robust media downloader with DASH support, proxy rotation, word cloud generation, and privacy-focused anonymization. The codebase demonstrates solid engineering with design patterns (factory, abstract base, mixin), good test coverage, and a clean separation of concerns, though there is some duplication across platform implementations.
DWARF Explorer (dwex) is a cross-platform GUI application for visualizing DWARF debugging information in executable files. It supports ELF, Mach-O, PE, WASM, and static archive formats, providing a tree view of Debugging Information Entries (DIEs), attribute inspection, reference following, search/highlight, and analysis dialogs (function map, data section, frames, unwind info). The architecture is a monolithic Qt6 desktop app built on pyelftools for DWARF parsing and vendored filebytes for PE/Mach-O parsing. It includes a custom DWARF v1 parser and a Mach-O compact unwind info parser. The codebase is well-structured with clear separation between format detection, data models, and UI, though some modules are tightly coupled to internal pyelftools structures. It is actively maintained with support for Python 3.6-3.14 and recent PyQt6.
ASPECT (Advanced Solver for Problems in Earth's ConvecTion) is a massively parallel, finite-element geodynamics simulation code built on the deal.II library. It solves the Stokes and advection-diffusion equations for mantle convection, lithosphere dynamics, melt migration, and related tectonic processes. The code features a highly modular plugin architecture with registration macros for material models, heating models, boundary conditions, postprocessors, mesh refinement, particle tracking, and more. It includes an extensive benchmark suite for code verification and numerous cookbooks demonstrating real geodynamic applications. The repository also bundles the Geodynamic World Builder (contrib/world_builder), a standalone library for constructing initial temperature, composition, and velocity fields from structured input files. ASPECT is actively developed with continuous integration, Docker support, and coupling to external tools like Landlab and FastScape for surface processes.
OneConfig is a modular, Compose-based configuration library for Minecraft mods, providing a unified API for config definitions, UI rendering, HUD management, keybind handling, event system, and notifications. It supports multiple Minecraft versions and mod loaders (Fabric, NeoForge) via a stonecutter-based build system and extensive mixin compatibility layers for third-party mod configs (e.g., YACL, ClothConfig, MoulConfig). The library features a custom Compose runtime (poly-compose) for Skia-accelerated UI, a tree-based config model with annotation-driven properties, and a service-loader-based platform abstraction. It is actively maintained with a large test suite covering config persistence, event validation, keybind codecs, and HUD migration.
This repository contains a desktop application for managing Nintendo Switch emulators, built with Tauri (Rust backend) and Vue 3 (frontend). It supports installing, updating, and configuring multiple emulators including Yuzu, Ryujinx, Eden, and Citron. The application provides features for firmware management, key installation, cheat code management, save backup/restore, and a self-update mechanism. The backend uses a layered architecture with commands, services, repositories, and models, while the frontend uses Vuetify 3 components and Pinia state management. The download subsystem is particularly notable, featuring a unified DownloadManager trait with two implementations: one using the native Rust bytehaul library and one using the aria2 external tool as fallback on Windows. The code also includes sophisticated network utilities with DNS-over-HTTPS resolver, GitHub API circuit breaker, mirror fallback chain, and adaptive parallelism. Configuration is persisted atomically with debounced saves, and progress is broadcast to the frontend via a typed event system. The codebase demonstrates good engineering practices with clear separation of concerns, error handling via typed AppError/AppResult, extensive test infrastructure (though many tests are marked ignored as they require network access), and platform-specific handling for Windows, macOS, and Linux. However, the UI is entirely in Chinese, and some external dependencies (CDN URLs, emulator project APIs) may require ongoing maintenance.
This repository is a curated library of over 230 specialized AI agent definitions, each with a detailed persona, mission, rules, deliverables, and workflow. It serves as a multi-agent orchestration framework (NEXUS) that coordinates agents through phases with quality gates and handoffs. The agents are designed to be installed into various AI coding tools (Claude Code, Cursor, Copilot, etc.) via a modular installer and conversion pipeline. The repository also includes strategy documents, runbooks, and coordination templates for managing multi-agent projects. While primarily a collection of prompt definitions, it is supported by a robust set of scripts for validation, installation, and consistency checking, making it a practical tool for deploying AI agents in real-world workflows.
This repository is the Spring Cloud integration layer for Netflix Eureka, providing both client-side service registration/discovery and an embedded Eureka server. It is a library, not a standalone application, designed to be consumed by Spring Boot microservices. The architecture is a multi-module Maven project with clear separation between client (`spring-cloud-netflix-eureka-client`), server (`spring-cloud-netflix-eureka-server`), and starter modules. In production, it enables Spring Boot applications to automatically register with a Eureka server, discover other services via `EurekaDiscoveryClient` or `EurekaReactiveDiscoveryClient`, and integrate with Spring Cloud LoadBalancer for zone-aware routing. The server module provides a full Eureka registry with a web dashboard, peer replication, and Micrometer-based metrics. The codebase demonstrates strong Spring Boot auto-configuration patterns, including conditional HTTP client selection (Jersey, RestClient, WebClient), health check aggregation, and config server bootstrapping. While actively maintained with a sophisticated release train CI system, the project carries significant technical debt from its long history. It still defaults to the deprecated Jersey HTTP client, relies on an older version of Netflix Eureka (2.0.6), and has several disabled flaky tests. The tight coupling to Netflix's proprietary libraries limits its reusability outside the Spring Cloud ecosystem, but the patterns it demonstrates for service discovery integration are well-crafted and instructive.
This is a comprehensive server monitoring and management platform called ServerBox (Flutter Server Box). It consists of a cross-platform Flutter mobile/desktop app, a Rust-based agent (monitor) that collects system metrics and exposes a REST/WebSocket API, and a Svelte web panel. The system supports SSH terminal sessions, SFTP file management, container management, virtual machine management (Proxmox VE and libvirt), BMC/Redfish power and sensor monitoring, firewall management (ufw/firewalld), cron, systemd/OpenRC services, process management, benchmark execution, custom commands, and push notifications. The architecture is heavily dependent on shared Rust crates (`sbm_parser`, `sbm_virt`, `sbm_redfish`, `sbm_ffi`) that are used both by the agent and via FFI by the Flutter app. This is a production-grade, actively maintained project with extensive test coverage across all layers.
This repository provides a Python library (`espargos`) and a suite of Qt6/QML demo applications for controlling ESPARGOS digital phased array hardware (ESP32-based). The system captures WiFi channel state information (CSI) from 802.11g/n/ax packets, raw I/Q samples, and performs radar-like FTM timestamp measurements. It supports calibration of phase and timing offsets across multiple boards, enabling phase-coherent combined arrays. Demos include real-time spatial spectrum (MUSIC/MVDR), azimuth-delay, polarization analysis, IQ signal analysis, transmit beamforming, and more. The architecture is modular with capability registration, sensor clustering, ring buffers, and a calibration object model. The library is well-structured but tightly coupled to the specific hardware, and demos depend on the common framework. It is actively maintained with no significant technical drift.
BepInEx is a plugin/modding framework for Unity (Mono and IL2CPP) and .NET games (XNA, FNA, MonoGame). It injects itself into a game process via Doorstop, runs a preloader that patches game assemblies, and then loads user-authored plugins through a chainloader. The framework provides a comprehensive infrastructure: thread-safe configuration (TOML-based), structured logging (console, disk, Unity log), assembly patching API, native detour abstraction (Dobby/Funchook), and interop generation for IL2CPP games (via Cpp2IL and Il2CppInterop). It supports Windows, Linux, and macOS (with limitations), and handles multiple Unity runtime variants and .NET Framework/Core. The architecture is modular: core libraries (`BepInEx.Core`, `BepInEx.Preloader.Core`) provide the base plugin contract, configuration, logging, and assembly scanning; runtime-specific projects (`BepInEx.Unity.Mono`, `BepInEx.Unity.IL2CPP`, `BepInEx.NET.*`) implement the platform-specific startup, patching, and integration. External dependencies include HarmonyX for runtime method patching, MonoMod for assembly manipulation, and SemanticVersioning for dependency resolution. While many components are tightly coupled to the game-modding domain, several subsystems—logging, configuration, topological sorting, native detours—are well-abstracted and potentially reusable in other C# host applications. The codebase shows signs of long-term evolution (deprecated methods, duplicated `KeyboardShortcut` classes, static singletons) but remains actively maintained with recent commits and responsive issue triage.
This is the type-challenges repository, a collection of TypeScript type-level programming challenges. It is not a traditional application but rather an educational resource and community project focused on advancing TypeScript type system mastery. The repository contains 189+ challenges ranging from 'warm-up' to 'extreme' difficulty, each consisting of a template file (the challenge to solve), test cases, and documentation in multiple languages. The architecture is straightforward: challenges are organized in the `questions/` directory with standardized file structures (template.ts, test-cases.ts, info.yml, README.md). The `utils/` package provides shared type utilities (Equal, Expect, NotAny) used across challenges. The `scripts/` directory contains build tooling for generating playgrounds, translating content, and managing GitHub Actions for community contributions. The project serves as both a learning platform and a community hub. Users solve challenges by implementing types that satisfy the test cases, which use a custom Expect/Equal assertion pattern. The challenges progressively teach advanced TypeScript concepts including conditional types, infer, template literal types, recursive type manipulation, and type-level algorithms. The repository has strong community engagement with 48K+ stars and active issue management. Key differentiators include the difficulty progression system, multi-language documentation, integration with TypeScript Playground, and the practical nature of challenges that often mirror real-world type manipulation scenarios. The project maintains quality through standardized test patterns and active community moderation.
mqttwarn is a production‑stable MQTT notification broker that subscribes to MQTT topics and forwards messages to over 70 pluggable notification services. It runs as a long‑lived Python daemon, using an INI‑based configuration to define MQTT connections, service endpoints, and topic‑to‑target mappings. The architecture is plugin‑oriented: each notification service is a self‑contained Python module exporting a `plugin(srv, item)` function, and user‑defined transformation functions (filter, datamap, alldata) can manipulate message payloads before dispatch. The project includes a comprehensive test suite, Docker images, CI/CD pipelines, and supports a wide range of integrations including messaging (Slack, Telegram, Pushover), databases (MySQL, PostgreSQL, InfluxDB), monitoring (Zabbix, Icinga), and home automation (Chromecast, Freeswitch). While the codebase is mature and well‑tested, it carries some technical debt such as global mutable state in the core module, a few deprecated service plugins, and a stale tox configuration. Overall, it is a solid, actively maintained integration hub for MQTT‑driven alerting and automation.
Go application for extracting Google Maps business data (leads, emails, reviews, phone numbers, websites, ratings, coordinates, opening hours) delivered through multiple interfaces: a CLI scraper, a local web UI, a REST API, and a self-hosted SaaS edition with admin panel, TOTP 2FA, API keys, Postgres-backed River job queue, and automated worker provisioning on DigitalOcean and Hetzner. The core scraping logic in the gmaps package parses undocumented Google Maps internal protobuf JSON payloads using positional array indices, with regression fixtures and tests that document hard-won fixes. It supports search queries, place details, reviews (RPC fetch plus DOM fallback), email extraction, grid-based bounding-box splitting to bypass the ~120-result search cap, proxy support, deduplication, resume mode, and multiple output targets: CSV, JSONL, PostgreSQL, S3, LeadsDB, and custom Go writer plugins. The codebase is modular, well-tested, and CI-published as Docker images for amd64/arm64. It shows solid Go engineering: clean package boundaries, embedded assets, concurrency-aware components, strict linting, and pre-commit hooks. Weaknesses include brittle positional parsing of Google Maps payloads that will break without warning, duplicated migration sets, two overlapping API spec generations (OpenAPI 3 and Swagger 2), a committed test-only SSH key, and promotional sponsor files mixed into the source tree. Primarily an application, though hybrid in character: it is a data-extraction product whose raw Google Maps fixtures are a valuable reference dataset for anyone maintaining Google Maps protobuf decoders. The repo also ships an AI-agent skill (SKILL.md) that translates natural-language lead requests into containerized scrape runs.
FlexGet is a rule-based media download automation tool written in Python. It manages the acquisition of TV series, movies, and other content from RSS feeds, torrent sites, Usenet indexers, and custom sources. The system uses a plugin architecture where each feature (input, filter, output, notifier, metadata lookup) is a plugin registered via an event system. Tasks are defined in YAML configuration files and executed through a pipeline of phases (input, metainfo, filter, modify, output). It runs as a daemon with a built-in scheduler (APScheduler), provides a REST API (Flask-RESTx) for remote management, and includes both a legacy AngularJS web UI and a modern React-based UI. The codebase is extensive with over 100 plugins, SQLAlchemy-based persistence, and a comprehensive test suite. While primarily an application, it incorporates data engineering patterns such as caching, rate limiting, and metadata enrichment from external APIs (TMDB, Trakt, IMDB, TVDB).
This is a .NET client library for Google Maps Platform web services. It provides a strongly-typed, async-first wrapper around 15+ Google Maps APIs, including Geocoding, Directions, Distance Matrix, Places (New), Routes, Address Validation, Elevation, Time Zone, Roads, Solar, Aerial View, Air Quality, Pollen, and Static Maps. The library is published as a NuGet package (over 2M downloads) and targets multiple .NET frameworks (netstandard2.0, net8.0, net10.0). It follows a consistent request/response pattern with generic constraints for compile-time safety, and includes a built-in engine that handles HTTP serialization, API key injection, error handling, and OpenTelemetry diagnostics (tracing and metrics). An optional dependency injection extension package registers `IGoogleMapsClient` with `IHttpClientFactory`. The repository also contains a comprehensive test suite with a VCR (record/replay) system, benchmarks, mutation testing, and sample applications (Blazor, Console, Minimal API, Generic Host) demonstrating usage.
This repository provides the Docker image build infrastructure for Composer, the PHP dependency manager. It contains Dockerfiles for multiple Composer versions (1.10 LTS, 2.2 LTS, latest), a common entrypoint script, and GitHub Actions workflows that build multi-architecture images and push them to Docker Hub, Amazon ECR, and GitHub Container Registry. The Dockerfiles use multi-stage builds to produce both a full runtime image and a standalone binary image, with security best practices such as SHA checksum verification for downloaded artifacts. The entrypoint script wraps the Composer CLI with tini for proper signal handling and supports transparent command forwarding. The repository also includes a script for generating the official Docker library metadata and automated dependency updates via Dependabot and Renovate. It is a well-maintained, production-grade CI/CD pipeline for containerizing Composer.
Outpost is a production-grade, multi-tenant event delivery platform by Hookdeck. It ingests events via an HTTP API or message queue adapters (RabbitMQ, AWS SQS, GCP PubSub, Azure Service Bus), routes them to configurable destinations (webhooks, AWS S3/SQS/Kinesis, Azure Service Bus, GCP PubSub, Kafka, RabbitMQ, Hookdeck), and provides end-to-end observability including delivery logs, metrics, alerting, and a self-service user portal. The system is implemented as a modular Go monolith with pluggable storage drivers (PostgreSQL, ClickHouse, Redis) and a clean provider pattern for destination types. It includes generated SDKs for Go, Python, and TypeScript (via Speakeasy), plus a React-based embedded portal. The codebase demonstrates strong engineering practices: abstract backends with conformance test suites, cursor-based pagination, configurable backoff strategies, distributed locking, and comprehensive integration tests covering all destination types. Notable reusable components include a generic LRU cache with TTL, a JSON filter matcher, a cursor pagination library, and an ID generation utility.
CCteam-creator is a Claude Code skill that enables multi-agent team orchestration through file-based planning and role-based collaboration. It sets up persistent agent teams with specialized roles (backend-dev, frontend-dev, researcher, e2e-tester, reviewer, custodian) that communicate via SendMessage while maintaining state in .plans/ directories. The system includes mechanisms for context recovery, team snapshots, doc-code synchronization, invariant-driven review, and automated code quality checks via golden_rules.py. Team-lead (the main conversation) acts as the control plane managing task delegation, phase gates, and operational protocols.
ClawScan is a Go-based CLI tool for composable security scanning of AI agent skills and plugins. It orchestrates multiple external scanners (e.g., Snyk, VirusTotal, Socket, AIG, Cisco, SkillSpector) against skill directories, collects raw evidence, and optionally feeds results to an LLM judge for evaluation. The tool supports profile-based configuration (built-in profiles like `clawhub` and `openclaw-install-policy`), Docker sandboxing, declarative gate rules for automated policy enforcement, and benchmark execution against datasets like SkillTrustBench and clawhub-security-signals. It is distributed via npm (`@openclaw/clawscan`) and GitHub Releases, with a rich CI/CD pipeline including automated runtime image builds, dependency updates, and a Hugging Face leaderboard for security signals research. While primarily an application, it has strong data/research elements through its benchmark infrastructure and leaderboard submission validation.
This repository implements a static site that reconstructs and visualizes GitHub's historical status incidents and downtime. It ingests the official GitHub Status history Atom feed (committed into git via Flat Data), parses entries into structured incident timelines with status transitions, downtime windows, and impacted components. The frontend displays a 90-day and all-time uptime overview, per-service uptime bars, an incident timeline with filters, and a rolling uptime chart. The system is designed as a data pipeline: a GitHub Action fetches the Atom feed daily, another Action runs the extractor script to produce parsed artifacts (CSV, JSONL), and a third Action deploys the static site to GitHub Pages. The repository also includes an experimental GLiNER-based component extraction fallback to infer affected services from incident postmortems when the structured data is missing. The codebase demonstrates strong craftsmanship with well-isolated pure functions, testable frontend modules, and defensive caching patterns, though it remains tightly coupled to GitHub's specific status page format and prose patterns.