This repository is the official specification collection for the BNB Chain ecosystem, containing over 100 BEPs (BNB Chain Evolution Proposals) and a handful of BAPs (BNB Application Proposals). It is not a software application but a standards body: BEPs define protocol-level changes (hard forks, precompiles, consensus modifications) for BNB Beacon Chain, BNB Smart Chain, opBNB, and Greenfield, while BAPs define application-layer standards (token interfaces, agent lifecycle protocols). The repository is dominated by markdown documents following a strict template (preamble, summary, specification, rationale, backwards compatibility) and includes supporting assets such as test vectors (BLS12-381 JSON files), benchmark results, architecture diagrams, and formal JSON schemas. Many BEPs are direct ports of Ethereum EIPs adapted to BSC. The codebase is well-organized and actively maintained, but it is purely a specification repository with no executable code, making it a reference for developers implementing BNB Chain clients rather than a reusable software library.
EasySpider is a visual, no-code web scraping tool that combines an Electron desktop application, a Chrome browser extension, and a Python execution engine. Users design scraping workflows via a flowchart-based UI (Vue.js) where they define steps like opening pages, clicking elements, extracting data, looping, and conditional branching. The task definitions are saved as JSON graphs. The Python backend (ExecuteStage) loads these graphs and drives Chrome using Selenium with an undetected-chromedriver fork to evade bot detection. Extracted data can be written to CSV, Excel, JSON, or MySQL. The tool also includes OCR support (ddddocr), custom JavaScript/Python execution, and Cloudflare bypass capabilities. The architecture is a hybrid desktop app with a local HTTP server (Express) that spawns executor processes and communicates via WebSocket. The Chrome extension assists in element selection and XPath generation. While the tool is functional and popular (44k+ stars), the codebase exhibits significant duplication (e.g., identical task files across platform directories, duplicated Bootstrap and content scripts), hardcoded paths, monolithic executor scripts, and mixed-language strings. Several experimental modules (LLM, federated learning) are present but not integrated. The project is actively maintained with recent commits and packaging scripts, but technical debt and drift (Bootstrap 4, Vue 2, pinned Python dependencies) are moderate.
This repository is a comprehensive, high-quality Git command reference manual. It is not a software application or a data research project; it is a static documentation site consisting of a single, meticulously organized `README.md` file. The manual covers everything from basic configuration (`git config`) to advanced workflows (`git flow`, `git subtree`, `git bisect`), including practical examples, visual aids (GIFs, diagrams), and best practices. It is a valuable, up-to-date resource for developers of all skill levels, demonstrating high craftsmanship in technical writing and knowledge organization.
This is a Python application and library for singing voice conversion and real-time voice changing, forked from so-vits-svc and rebuilt around PyTorch, PyTorch Lightning, and a Click-based CLI. The actual code provides two user-facing entry points: the `svc` CLI with commands for inference, realtime microphone conversion, dataset preprocessing, training, clustering, and cleanup, and the `svcg` PySimpleGUI desktop application for interactive and realtime inference. Inference loads a HuBERT content encoder from Hugging Face, extracts pitch using CREPE, DIO, Harvest, or Parselmouth, then runs a VITS-style SynthesizerTrn with either HiFi-GAN or MS/MB-iSTFT decoders conditioned on speaker embeddings. Despite fastapi being listed as a dependency, no HTTP API server exists in the source; the project is a desktop/CLI tool, not a web service.
PrimeReact is a comprehensive React UI component library providing over 80 components including forms, data tables, overlays, menus, charts, and more. The repository also contains its official documentation website built with Next.js, featuring live demos, code snippets, accessibility guides, and theming documentation for both styled and unstyled (Tailwind) modes. The library follows a consistent architecture: each component extends a shared ComponentBase that defines default props, CSS classes, and pass-through theming support. It includes a custom hooks library, SVG icon set, and utility modules. However, the project is no longer under active development; only security fixes are published, with all new features and bug fixes moving to the PrimeUI fork. This has led to a growing divergence and a backlog of unresolved issues. The codebase shows signs of technical drift such as aging dependencies (Next.js 12), deprecated patterns, and extensive duplication in documentation and style definitions.
llm-action is a comprehensive resource hub for large language model engineering that combines theoretical explanations with practical implementation code. It covers the full LLM lifecycle including data engineering, training (full fine-tuning and parameter-efficient methods like LoRA/QLoRA), model compression (quantization, pruning, distillation), inference serving, deployment, and evaluation. The repository contains both educational documentation and runnable code examples, with particular emphasis on Chinese-language resources and domestic AI hardware adaptation (especially Huawei Ascend NPUs). While it serves as a knowledge base, its inclusion of actual training scripts, inference servers, and utility tools makes it primarily application-oriented rather than purely research-focused.
This repository is release infrastructure for the OpenClaw ecosystem, not an end-user application. It operates as the evidence ledger and release-automation hub for OpenClaw (an npm-distributed product with a signed macOS desktop app) and octopool (a Go CLI distributed via GitHub Releases and Homebrew). In production it generates and stores a structured evidence record for every release candidate under evidence/, containing JSON run metadata and human-readable markdown summaries that classify CI, release, Homebrew, npm, and macOS checks as blocking or advisory. The workflows and scripts in the repo drive macOS signing/notarization and appcast verification, npm dist-tag promotion, Homebrew formula updates, and safe automated commits of release evidence to main. Architecturally, the repository is a GitHub Actions-orchestrated automation layer over the GitHub API, npm registry, Apple notarization, and Homebrew. A central Full Release Validation workflow runs normal CI, plugin prerelease validation, Docker/QA validation, Telegram E2E, and an aggregation gate. The evidence shows frequent failures at the final verification step even when all child jobs succeed, indicating a brittle gate. Evidence commits use concurrency control and rebasing safeguards to prevent races. The repository also contains regression tests for the release scripts and workflow behavior. The system is well-crafted for its niche: it has real tests, structured schemas, explicit storage policies, and non-trivial recovery logic. However, it is tightly coupled to the OpenClaw/octopool release process, contains generated evidence bulk that grows over time, and relies on hardcoded runner/version pins and external services (GitHub Actions, npm, Apple) that make it vulnerable to ecosystem drift. Reuse is possible at the pattern level rather than as a drop-in product.
ytsurf is a single-file Bash script that turns the terminal into a YouTube frontend. It scrapes YouTube search results and channel pages via curl and perl, parses the embedded JSON with jq, and presents results in a fuzzy-finder (fzf, rofi, sentaku, or tv) with thumbnail previews rendered via chafa. Once a video is selected, the script delegates playback to mpv (or iina/syncplay) and downloading to yt-dlp. The tool supports audio-only mode, format selection, subscription management with a personalized feed, watch history, playlists, and queueing. It caches search results and feed data to avoid redundant network calls, uses a config file for persistent settings, and offers multi-selector support. While functionally rich and well‑structured for a shell script, the codebase is tightly coupled into a single file (∼1400 lines), lacks unit tests beyond basic CI sanity checks, and relies on scraping fragile YouTube HTML. The packaging (Nix, Homebrew, AUR) and CI (ShellCheck on Linux/macOS) demonstrate good distribution and quality assurance.
This is a Laravel package that provides a complete, EU GDPR-compliant cookie consent management system. It allows developers to register cookies under predefined or custom categories (essential, analytics, optional), define cookie descriptions, durations, and consent callbacks. The package includes Blade directives and a Facade for easy integration into Laravel views and controllers, as well as a JavaScript library for enhanced UX with AJAX-based consent handling. The architecture is a typical Laravel package: service provider, routes, controllers, views, translations, and a compiled assets pipeline. The backend handles cookie registration, consent storage (via a cookie), and response generation (scripts, cookies). The frontend provides a customizable notice modal with toggleable details and buttons. The package is well-structured with clear separation of concerns using traits for shared functionality (attributes, callbacks, translations, cookie collections). It supports multiple languages and allows full customization of views, styles, and scripts. The codebase is actively maintained, supports Laravel 9-13, and includes a comprehensive test suite.
This repository is a proxy subscription aggregation and distribution system. It periodically collects free proxy subscription links (Clash YAML and V2Ray URI formats) from multiple public sources, merges them, classifies nodes by TCP connectivity (reachable/unreachable/untested), and serves the resulting files via a Cloudflare Worker. The system is driven by a GitHub Actions workflow that runs every 12 hours, executing Python scripts to fetch, process, and commit updated subscriptions. The architecture is a data pipeline application with a serverless serving layer. Key entry points include main.py (orchestrating collection and merging), check_nodes.py (TCP connectivity classification), and worker/sub.mjs (Cloudflare Worker for serving with caching and ETag). External dependencies include requests, PyYAML, and the Cloudflare Workers runtime. The repository also includes a weekly commit history cleanup workflow to keep repository size small. The project is actively maintained with frequent updates and tests, though it relies on unstable external proxy sources.
This repository provides implementations of the Dynamic Time Warping Barycenter Averaging (DBA) algorithm in multiple programming languages (Java, Python, MATLAB, and Cython). The DBA algorithm computes the average of a set of time series under Dynamic Time Warping (DTW) by iteratively aligning each series to the current average and updating the average as the mean of aligned points. The repository includes the core algorithm, a multivariate extension, and versions with warping window constraints. The primary implementation is in Python (DBA.py), which is self-contained and requires only NumPy. The code is well-structured and demonstrates the iterative DTW-based averaging process, which is a non-trivial approach to time series averaging.
ACT.Hojoring is a mature Windows plugin suite for Advanced Combat Tracker (ACT) tailored to Final Fantasy XIV. It bundles three main plugins: SpecialSpellTimer (spell/cooldown timers, trigger matching, and raid timeline overlays), UltraScouter (target HP/distance/casting/enmity/radar overlays), and TTSYukkuri (multi-engine text-to-speech with Discord voice relay). The code is almost entirely C#/.NET Framework with WPF overlays, Prism MVVM, XML-serialized configuration, and a shared infrastructure library called FFXIV.Framework. Entry points are ACT plugin implementations (IActPluginV1.InitPlugin) that initialize workers, load settings, register config tabs, and start transparent click-through overlay windows.
This repository is a vast curated collection of over 100 open-source AI agent application templates and tutorials, spanning multiple frameworks (Agno, Google ADK, OpenAI SDK, LangGraph, CopilotKit, CrewAI) and deployment patterns (Streamlit, Next.js, FastAPI, CLI). It serves as a living portfolio of AI agent patterns: single-agent assistants, multi-agent teams, generative UI (CopilotKit + AG-UI), RAG pipelines with various vector stores (Qdrant, Chroma, LanceDB, FAISS), voice agents, always-on scheduled agents, and agent skills (code analysis, dependency health). The architecture is a monorepo of independent sub-projects, each with its own requirements, entry point, and often a README. External dependencies are heavy: nearly every app requires API keys for LLMs (OpenAI, Google, Groq, Together) and tools (Tavily, Firecrawl, SerpAPI, E2B), plus optional services (PostgreSQL, Qdrant, ElevenLabs). While the codebase is not a single integrated application, it provides a rich set of reference implementations for developers building AI agents.
This repository is a collection of C++ sample programs for deploying deep learning models on AXERA AI SoCs (NPU chips). It provides ready-to-run inference examples for a wide range of computer vision tasks including object detection (YOLOv5/6/7/8/9/10/11/26, YOLOX, YOLO-World, PPYOLOE+, RT-DETR, SCRFD), instance segmentation, oriented object detection (OBB), pose estimation, depth estimation, semantic segmentation, stereo matching, and more. Each example is a standalone command-line executable that loads a pre-compiled .axmodel, runs inference via the AX_ENGINE API, post-processes the outputs, and saves a result image. The code is organized per target chip (ax650, ax637, ax620e, ax615) with near-identical copies of examples across platforms, differing only in system initialization and minor chip-specific logic. The architecture is not a library or framework but a set of reference implementations demonstrating the integration of AXERA's NPU SDK. The primary data flow is: load image → preprocess (letterbox resize, color conversion) → push to engine → run synchronous inference → decode model outputs (e.g., anchor-based proposals, DFL, NMS) → draw bounding boxes/keypoints/masks → save output. External dependencies include the AX_ENGINE runtime, OpenCV for image processing, and standard C++ libraries. The build system uses CMake with per-chip toolchain files and GitHub Actions CI for cross-compilation verification. While the code is functional and covers a broad model zoo, it exhibits significant duplication across chip directories and hardcoded configuration (thresholds, image sizes, class names). The monolithic detection.hpp (~3500 lines) bundles many model-specific post-processing functions, increasing maintenance burden. There are no automated tests, and manual memory management is prevalent. Despite these quality issues, the repository serves its purpose as a practical reference for developers integrating AXERA hardware, and it stays current with recent model releases (YOLOv13, YOLO26, Depth Anything V2).
ggprism is an R package that extends ggplot2 to replicate the visual aesthetics of GraphPad Prism. It provides themes, color/fill/shape palettes, and specialized geoms/guides to create publication-ready plots matching Prism's default styling. Key functionalities include applying Prism-like themes via `theme_prism()`, using discrete palettes with `scale_*_prism()` functions, adding statistical annotations (e.g., p-value brackets) with `add_pvalue()` and `geom_bracket()`, and customizing axes with specialized guides like `guide_prism_offset()` for offset ticks. The package follows ggplot2 extension conventions, using ggproto for custom geoms, discrete_scale for scales, and guide objects for axis modifications. It includes built-in datasets (e.g., wing morphology data) and relies on standard R datasets in examples. External dependencies center on ggplot2, scales, and rlang, with optional packages like ggnewscale and patchwork used in vignettes.
TechEmpower Framework Benchmarks is a large-scale, multi-language benchmark suite for comparing the performance of web application frameworks. The repository contains hundreds of independent framework implementations (e.g., Go, Rust, Java, C#, Python, PHP) each implementing the same standard set of HTTP endpoints: JSON serialization, plaintext, single/multiple database queries, updates, fortunes (HTML), and cached queries. The core benchmark toolset (written in Python) orchestrates Docker-based builds, runs load tests via wrk, and verifies response correctness. The codebase is a federation of many small applications rather than a single system, with each framework's code living in its own directory under `frameworks/<language>/<name>/`. The architecture is highly standardized: every framework exposes the same routes, uses the same database schema (World and Fortune tables), and follows common optimization patterns like connection pooling, prepared statements, batch updates, and template caching. While the repository is actively maintained and the toolset is well-structured, the quality of individual framework implementations varies widely—some are expertly tuned for performance, while others are stubs or use outdated libraries. The primary value of this repository is as a reference for comparative performance numbers and as a collection of idiomatic, performance-focused code examples across many languages and frameworks.
Tera Term is a free software terminal emulator for Windows, supporting SSH, Telnet, serial port connections, and file transfer protocols (XMODEM, YMODEM, ZMODEM, Kermit, B-Plus, Quick-VAN). It includes a macro scripting language (TTL) for automation, a plugin system (TTX) for extensibility, and integration with Cygwin/MSYS2/Git Bash. The architecture is a Windows-native desktop application with multiple DLL components: the main terminal emulator (ttermpro.exe), SSH client (ttxssh.dll), proxy support (ttproxy.dll), macro engine (ttpmacro.exe), and various utility libraries. Key entry points include the main window creation in teraterm.cpp, the plugin loading in ttplug.cpp, and the macro interpreter in ttmmain.cpp. External dependencies include OpenSSL/LibreSSL for cryptography, zlib for compression, Oniguruma for regex, and Argon2 for password hashing. The codebase is extensive and long-lived, with compatibility layers for older Windows versions and multiple build systems (CMake, Visual Studio, MinGW).
This repository is a monorepo providing a React component library for swipeable views (carousels/ tabs) with touch and mouse support. It is split into multiple packages: `react-swipeable-views` (browser implementation), `react-swipeable-views-core` (shared utilities), `react-swipeable-views-utils` (higher-order components for auto-play, virtualize, and keyboard binding), and `react-swipeable-views-native` (experimental React Native support). The main component (`SwipeableViews`) uses CSS transitions and transforms to animate slides, with lazy loading and resistance effects. The HOCs provide composable enhancements: `autoPlay` adds timed auto-advance with visibility change handling, `virtualize` renders only a window of slides for large lists, and `bindKeyboard` enables arrow key navigation. The library is well-tested with mocha, chai, and sinon, and has a comprehensive documentation site built with Next.js. However, the codebase is dated (class components, outdated Babel and Next.js versions, no hooks) and maintenance appears stagnant, with many open issues and infrequent updates. The core utility functions are clean, reusable, and demonstrate good software engineering practices.
This repository is a collection of Home Assistant blueprints (YAML automation and script templates) that enable voice-controlled music playback via the Music Assistant integration. It provides three distinct options: a fully local intent-based automation using custom conversation triggers, an LLM-enhanced automation that leverages an external LLM conversation agent to parse natural language queries, and an LLM script that can be used as a tool by LLM conversation agents for more flexible music requests. The blueprints are well-structured with multi-language support (English, Dutch, French, German, Hungarian, Italian, Portuguese, Slovak, Spanish, Finnish) and demonstrate advanced use of Home Assistant's conversation triggers, Jinja2 templating, and integration with Music Assistant's play_media service. The repository is community-driven and actively maintained, with detailed documentation and changelogs. While tightly coupled to Home Assistant and Music Assistant, the blueprints exhibit good craftsmanship in handling target resolution, shuffle logic, and LLM prompt engineering.
I‑Simpa is a mature, open‑source desktop application for 3D numerical sound propagation modelling, designed for scientific acoustic simulations. The system provides a full GUI (built with wxWidgets and OpenGL) for defining acoustic scenes (sources, receivers, materials, meshes), running multiple calculation cores (particle tracing SPPS, classical theory TCR, and experimental TLM), and post‑processing results via point/surface receivers, impulse responses, and sound maps. It features a tree‑based data model with XML persistence, a Python scripting layer for automation and custom tools, and supports industry‑standard file formats (STL, PLY, GABE binary arrays). The codebase is predominantly C++ with a Boost.Python bridge, and is actively maintained by the Environmental Acoustic Research unit at Université Gustave‑Eiffel. The architecture follows a classic monolith pattern with clear separation: a core calculation library (`src/spps/`, `src/ctr/`), a 3D rendering engine (`src/isimpa/3dengine/`), a GUI layer (`src/isimpa/IHM/`), and a data manager with element/property tree. Python scripts in `SystemScript/` extend the UI through a plugin mechanism. While the project is functionally complete and validated against benchmarks, it exhibits moderate technical drift: bundled MathJax 2.7.5 (2018) for documentation, some French comments and variable names, and a few Python 2 remnants. Despite this, the component design—especially the octree spatial index, GABE binary I/O, and XML element tree—are cleanly abstracted and potentially reusable in other scientific or simulation contexts. The repository also includes extensive documentation and tutorials, though the experimental directivity feature is flagged as undocumented.