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.
This repository is the source of the awesome-go curated list, a community-maintained index of Go frameworks, libraries, and tools. The primary artifact is README.md, which contains thousands of categorized entries. Around this data, the repo includes a Go-based static site generator (main.go) that parses the README, fetches repository metadata from GitHub/GitLab APIs, and renders HTML pages using templates in tmpl/. It also contains a suite of Go tests and GitHub Actions workflows that enforce list integrity: alphabetical ordering, no duplicates, entry formatting, maturity checks, and stale repository detection. The codebase is a hybrid: it is fundamentally a curated data resource (the list itself) wrapped in application-style tooling for validation and site generation. There are no API endpoints or user-facing services; the Go code runs as CLI/CI tooling. The architecture is simple: markdown parsing via goldmark, HTML manipulation via goquery, metadata caching with a 7-day TTL, and template rendering. External dependencies include GitHub/GitLab APIs, Netlify for deployment, and several Go modules. The most reusable pieces are the small, self-contained packages pkg/slug and pkg/markdown, plus the standalone CI scripts under .github/scripts/ that validate repository quality and PR diffs. These can be extracted for other awesome-list projects or documentation pipelines. The code is generally clean and tested, though it contains some FIXME comments and hardcoded limits, and relies on external API availability. Overall, it is an actively maintained, well-organized project that successfully automates the curation of a massive list.
This repository is a mature, well-structured JavaScript library that dynamically generates HTML forms from JSON Schema definitions. It is a client-side library that can be used as a standalone script or npm package. The core architecture is built on an abstract base class (`AbstractEditor`) with a rich plugin system for editors (string, number, array, object, etc.), themes (Bootstrap 3/4/5, Tailwind, Spectre, etc.), icon libraries, and template engines. It includes a full JSON Schema validator with support for draft-04, 07, and 2020-12 keywords, plus custom validators. The codebase demonstrates strong engineering practices: event-driven communication, extensible resolver patterns, and a modular design that separates concerns. However, the project is explicitly in maintenance mode, with active development moved to a fork (Jedison). This means new features are not expected, but critical bug fixes and security patches are still accepted. The codebase shows some technical drift: several third-party integrations (e.g., SimpleMDE, SignaturePad v1) are outdated, some themes (Foundation 3, Bootstrap 2) are legacy, and the code uses ES5 patterns. The test suite is extensive, with both unit tests (Jasmine) and end-to-end tests (CodeceptJS) covering many edge cases and real-world issues. Overall, it is a high-quality library for its domain, but its maintenance mode status limits its future viability for new projects.
The `pre-commit` npm package automatically installs and manages git pre-commit hooks for Node.js projects. When installed as a devDependency, its `install.js` script locates the project's `.git` directory (including submodules and linked worktrees) and writes a shell wrapper into `.git/hooks/pre-commit`. Upon commit, that wrapper executes a crafted bash script (`hook`) that resolves the `pre-commit` package path via Node's `require.resolve` (supporting Yarn Plug'n'Play), then runs `index.js`. The `Hook` class in `index.js` reads the project's `package.json`, normalizes the `pre-commit`/`precommit` configuration into an ordered list of npm scripts, and executes them sequentially using `cross-spawn`. If any script fails with a non-zero exit code, the commit is aborted with a clear error message. The tool gracefully handles missing packages (exits 0 to avoid blocking commits), environment quirks (emacs/magit's `GIT_LITERAL_PATHSPECS`, SourceTree's path issues), and provides backup/restore of existing hooks. This is a single-purpose utility library with a clean Node.js core and a well-tested bash wrapper.
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.
MediaCMS is a production-grade, self-hosted video and media content management platform built as a Django monolith with a React frontend. In production it ingests video, audio, image, and PDF uploads via a chunked Fine Uploader flow, transcodes video through FFmpeg into multiple MP4/HLS renditions matched by configurable encoding profiles, streams them through a customized video.js player, and supports subtitles (manual upload and Whisper transcription), chapter markers, video trimming/editing, playlists, comments with mention notifications, likes, reports, and PostgreSQL full-text search. It ships a REST API under /api/v1/, an editor/manager admin UI, RSS feeds with Yahoo Media RSS extensions, and a small Click-based CLI. The backend is organized into Django apps (files, users, actions, rbac, lti, saml_auth, identity_providers, migrationservice, uploader) with DRF serializers/views, Celery workers for encoding and notifications, Redis as broker, and Nginx serving protected media through an auth_request subrequest. A significant portion is education/LMS-focused: an LTI 1.3 tool provider with deep linking, SAML authentication, RBAC groups mapped to categories, Moodle filter and TinyMCE plugins, and a migration service that imports media, captions, and users from Kaltura, Panopto, and YouTube with quiet-hours scheduling and encrypted credentials. This gives the repository a mild data-pipeline flavor through the migration service, but its dominant character is a full web application. Engineering quality is strong for an open-source Django project: extensive pytest coverage across API, permissions, LTI, SAML, RBAC, migration providers, and pipeline tasks; a large Jest suite for frontend components, hooks, and stores; semantic-release and pre-commit CI; and a clean provider abstraction for migration sources. Weaknesses include legacy webpack-built minified bundles checked into static/, a mix of JSX and TSX across the frontend, duplicated iOS player code between the video-editor and chapters-editor tools, several TODO/FIXME markers, and version-sensitive external dependencies (yt-dlp, Moodle, LTI). Overall it is an actively maintained codebase with several genuinely reusable components, though it carries moderate legacy debt in its frontend tooling.
OmniXAI is a comprehensive explainable AI (XAI) library providing a unified interface for generating explanations across multiple data types (tabular, vision, text, time series, ranking, vision-language) and ML models. It implements both model-agnostic (LIME, SHAP, L2X, MACE) and model-specific (Grad-CAM, Integrated Gradients, decision tree) explanation methods. The library features a modular architecture with separate modules for data handling, preprocessing, explanation generation, visualization (Dash-based dashboard), and deployment (BentoML integration). Key design patterns include base classes for explainers and explanations, factory patterns for explainer instantiation, and composable preprocessing pipelines. The system supports end-to-end workflows from data preprocessing to explanation visualization and model serving.
This repository provides a Docker image for running a Palworld dedicated game server. It automates the full lifecycle: installation and updates via SteamCMD, configuration through environment variables (mapped to PalWorldSettings.ini and Engine.ini via envsubst), scheduled backups with retention policy, automatic restarts with player-aware grace periods, player join/leave detection via the Palworld REST API, and Discord-compatible webhook notifications for all major events. The container runs the game server as a non-root user (steam) and includes a CLI tool (restapicli) for administrative commands like announce, kick, ban, save, and shutdown. The architecture is a monolithic Docker container with multiple supervised background processes: the game server itself, a player detection loop, a cron scheduler (supercronic) for backups and restarts, and a game events log maintenance thread. All management scripts are written in Bash with a modular include structure, shellcheck compliance, and color-coded logging. The image also supports an optional companion sidecar container for a web operation panel and Discord status card. The codebase demonstrates solid shell scripting practices: error handling with set -e, function decomposition, environment variable validation, and concurrent-safe logging. While the components are tightly coupled to the Palworld game server domain, several utility modules (colored logging, process supervisor) are self-contained and could be extracted for reuse in other Docker-based projects.
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.
This is a personal dotfiles repository for a Linux development environment, managed declaratively with Nix (NixOS + Home Manager) and mise. It configures the entire user experience: shell (zsh, nushell), editor (Neovim with hundreds of plugins), terminal (WezTerm, Alacritty), window managers (Hyprland, Sway, i3), desktop widgets (Waybar, EWW, Conky), AI coding assistants (Claude Code, Codex), and a sophisticated security sandbox (firejail + tinyproxy) for network-isolated Neovim sessions. The repository is not a standalone application but a comprehensive, modular configuration system that turns a Linux machine into a highly optimized development workstation. Architecturally, the repo is organized around a Nix flake that defines system-level (NixOS) and user-level (Home Manager) configurations, with mise handling per-user tool versioning and dotfile symlinks. Configuration files are split into modular directories (e.g., `config.d/` for i3, sway, tmux; `lua/rc/pluginconfig/` for each Neovim plugin). The Neovim configuration alone contains over 150 plugin-specific setup files, each following a consistent pattern of calling `setup()` with keymaps. The zsh configuration uses a similar modular approach with `rc/pluginconfig/` and `rc/myplugins/` directories. Notable patterns include: mise tasks with pinned tool headers for CI efficiency; pmy fuzzy-finder rules with separate options/subcommands text files for reusable CLI completions; Nushell autoload scripts that clone modules from GitHub with null fallback and state caching; and a comprehensive firejail profile for sandboxing Neovim with multiple network modes. The repository also includes CI workflows for linting, installation testing, and benchmarking shell/Neovim startup times. While the repo is actively maintained and well-structured, it is inherently personal—many configurations assume the author's hardware, preferences, and workflow. There is some legacy commented-out code and overlapping tool configurations (e.g., multiple window managers, multiple bar systems). However, the modular patterns and isolated components (pmy rules, Nushell autoload, zsh plugins, Neovim plugin configs) are reusable in other dotfiles or development environment projects.
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.
This repository is the official Google API client library for Go, providing auto-generated, typed client code for hundreds of Google REST APIs (e.g., Drive, Calendar, Gmail, YouTube, Cloud Compute, BigQuery). The codebase consists of two major parts: a code generator (`google-api-go-generator/`) that consumes Google Discovery Service JSON schemas and produces Go source files, and a shared hand-maintained runtime library (`googleapi/`, `internal/`, `transport/`, `option/`, etc.) that handles HTTP/gRPC transport, authentication (OAuth2, service accounts, API keys, ID tokens, mTLS), media upload/resumable transfer, pagination, error handling, and connection pooling. The generated clients follow a consistent pattern: `NewService(ctx, opts...)` creates a service struct with nested resource services, and API methods are exposed via fluent call builders with `Do()` and `Pages()` methods. The repository is explicitly in maintenance mode—only critical bugs and security fixes are accepted—and users are directed to newer Cloud Client Libraries (`cloud.google.com/go`) for active development. Despite this, the hand-maintained infrastructure is well-architected, thoroughly tested, and demonstrates high craftsmanship in areas like composable options, resumable uploads, generic pagination, and connection management.
DeepTide is a cross-platform terminal AI coding agent. The Rust workspace (deeptide-core, deeptide-host, deeptide-cli, deeptide-gui) implements the production agent engine: an interactive REPL session with an agent loop, tool dispatch (bash, edit, web, git, memory, MCP, LSP, vision, cron, planning), cross-provider model routing with local-first/cloud-escalation policies, cost tracking, tokens-per-second telemetry, tool usage observability, durable memory with BM25 retrieval ranking, session import/checkpoint/rewind, sensitive-file read protection, and a theme system for syntax highlighting and diffs. The CLI and GUI share a common host layer, and the npm package downloads prebuilt Rust binaries. Architecturally it is a multi-crate Rust workspace plus supporting native components: native/ds4 is a hard-forked DeepSeek V4 Flash Metal inference engine for local LLM execution, and native/dsgo is a Swift gateway that translates between Anthropic and OpenAI protocols with SSE streaming. Primary entry points are crates/deeptide-cli/src/main.rs (CLI), crates/deeptide-gui/src/main.rs (eframe/egui GUI), and bin.js (Bun launcher that delegates to @paean-ai/zero-cli). External dependencies include DeepSeek/Anthropic/OpenAI-compatible APIs, local Metal GPU inference, and GitHub Releases for binary distribution. The repo also contains 50+ self-contained HTML5 Canvas pixel-art games and Three.js showcases under samples/, which appear to be AI-generated demo content demonstrating agent output quality rather than core product code. These share heavily duplicated boilerplate (seeded RNG, localStorage save/load, bilingual i18n, screen state machines). The core Rust code is well-tested with integration tests covering routing, cost tracking, memory ranking, tool result summarization, and slash commands; live API tests are marked #[ignore]. Hybrid note: while primarily an application, it contains research-oriented elements such as memory capture benchmarks (benchmarks/auto_capture_bench.py), prompt cache layout benchmarks (benchmarks/cache_memory_bench.py), and deterministic puzzle generation algorithms with uniqueness verification.
PyLoxone is a production-grade Home Assistant custom integration for Loxone Miniserver home automation controllers. It provides bidirectional WebSocket communication with the Miniserver, entity platforms for sensors, switches, covers, lights, climate, alarm, media player, fan, select, text, and more, plus config flows, services, diagnostics, system health, and multi-Miniserver support. The repository also embeds `pyloxone_api`, a standalone Python client library for Loxone's proprietary protocol, and a CLI with a no-JavaScript web UI, making it both an HA integration and a reusable protocol library. Architecturally, this is a plugin-style application. Home Assistant invokes `config_flow.py` and `__init__.py` to create config entries; a per-entry coordinator creates a `LoxoneConnection` that manages authentication, token refresh, encryption, WebSocket framing, and reconnect logic. Parsed events are dispatched to `LoxoneEntity` subclasses over a shared event bus. The embedded client library is cleanly separated from HA platform code, with its own HTTP client, UDP discovery, binary message parser, and connection supervisor. The codebase relies on `aiohttp`, `websockets`, and `pycryptodome`. It has substantial unit test coverage, including binary protocol parsing, connection edge cases, entity commands, config flows, and historical regressions. CI workflows run validation and stale-issue management. Maintenance is active, though the project carries medium technical drift: broad dependency ranges, legacy cryptographic choices, some deprecated HA API usage, dead code remnants, and a tightly coupled WebSocket state machine that could break with Loxone firmware changes.
This is a GitHub Action that wraps Docker's `buildx bake` command, enabling multi-target Docker builds within CI workflows. It parses bake definition files (HCL or JSON), translates GitHub Action inputs into bake arguments (including support for provenance, SBOM, custom outputs, and build checks), executes the build, and generates a detailed job summary with optional build record upload. The action integrates tightly with the `@docker/actions-toolkit` library to manage Docker contexts, builder instances, and GitHub API interactions. While the core action is specific to GitHub Actions, a subaction (`subaction/matrix`) demonstrates a reusable pattern for generating a multi-dimensional GitHub Actions matrix from a bake definition's targets and fields, which can be extracted and adapted for other CI systems or deployment pipelines. The repository is well-maintained with daily dependency updates and comprehensive CI tests across various buildx versions and scenarios.
The Genome Analysis Toolkit (GATK4) is a production-grade bioinformatics framework developed by the Broad Institute for variant discovery and genotyping in high-throughput sequencing data. It provides a comprehensive suite of command-line tools for germline and somatic variant calling (HaplotypeCaller, Mutect2), copy number variation analysis (GermlineCNVCaller), structural variant detection (FindBreakpointEvidenceSpark), functional annotation (Funcotator), base quality score recalibration (BQSR), and read processing. The architecture is built around a plugin-style engine with walker base classes (ReadWalker, VariantWalker, LocusWalker) that define traversal patterns over genomic data, with extensive use of Apache Spark for distributed execution on clusters and cloud platforms (GCS, HDFS). Key entry points include the `gatk` wrapper script and individual tool classes registered via the Barclay argument parser, with workflows orchestrated through WDL/Cromwell pipelines. External dependencies include htsjdk for BAM/VCF I/O, BWA for alignment, PyMC3 for Bayesian CNV modeling, and PyTorch for deep learning-based variant scoring. The codebase is heavily tested with unit and integration tests, and supports both local and cloud-based execution.
This is the official Microsoft VS Code extension for PowerShell language support. It acts as a Language Server Protocol (LSP) client, communicating with the PowerShellEditorServices (PSES) server to provide IntelliSense, code navigation, debugging, Pester test integration, and ISE compatibility. The extension is implemented in TypeScript and uses standard VS Code extension patterns: activation via language and debug events, a `LanguageClient` for LSP, and a `DebugConfigurationProvider` for debug sessions. Features include console integration, command exploration, alias expansion, help completion, language model tools for Copilot/Chat, and remote file editing. The architecture is modular, with each feature in its own class under `src/features/`, all extending the `LanguageClientConsumer` base class. The extension also includes a session manager that handles PowerShell process lifecycle, platform-specific executable discovery, and telemetry. This is a pure application with no data science or research components.
This repository is the official documentation for the Binance Spot Exchange APIs. It provides comprehensive specifications for REST, WebSocket, FIX, and SBE (Simple Binary Encoding) protocols, covering trading, market data, account management, and user data streams. The documentation includes detailed endpoint references, authentication methods (HMAC, RSA, Ed25519), order types, filters, error codes, and FAQs. It also contains versioned SBE XML schemas for code generation and lifecycle management JSON files. While not an application itself, it serves as the authoritative reference for developers building trading bots, market-making systems, and integration tools for Binance Spot. The repository is well-structured with bilingual (English/Chinese) support and separate documentation for production, testnet, and demo environments.
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.
This repository implements a complete embedded IoT system for automated meter reading (water, gas, electricity) using an ESP32-CAM with on-device TensorFlow Lite inference. The firmware captures images, performs alignment and ROI extraction, runs digit and analog pointer recognition via quantized TFLite models, applies post-processing (consistency checks, rate limiting, decimal shift), and publishes readings via MQTT, InfluxDB (v1/v2), Webhook, or a built-in REST API. The architecture follows a modular flow-control pattern with separate components for camera control, image processing, neural network inference, configuration, logging, and output protocols. A full-featured web interface provides setup wizards, live data graphs, OTA updates, and file management. The system is designed for low-power edge deployment on ESP32 with PSRAM and SD card storage.