MyBatisCodeHelper-Pro is an IntelliJ IDEA plugin that provides comprehensive MyBatis development support, including code generation from database schemas, method-name-to-SQL translation, real-time SQL auto-completion and correctness checking, MyBatis XML/Java interface navigation and refactoring, OGNL expression support, and a built-in MCP (Model Context Protocol) server for AI coding assistants. The repository contains only documentation, screenshots, and Velocity code-generation templates; the actual plugin source code is not included in this snapshot. Based on the extensive changelog and feature documentation, the plugin is actively maintained, supports recent IntelliJ versions, and offers a rich set of features for MyBatis developers. However, without access to the source code, the assessment of code craftsmanship and reusability is limited.
This repository provides a self-contained, single-file JavaScript library that renders an interactive SVG technology radar (aka 'tech radar') using D3.js v7. The radar visualizes technology entries arranged in concentric rings (e.g., ADOPT, TRIAL, ASSESS, HOLD) within four quadrants. Entries are positioned using a D3 force simulation to avoid overlap, and they support hover tooltips, hyperlinks, and visual indicators for movement (new, moved in/out). The library is configurable via a single `radar_visualization()` function that accepts a JSON configuration object specifying dimensions, colors, rings, quadrants, and entries. It is designed as a client-side library included via `<script>` tags and is served as static HTML. The codebase consists of a single monolithic JavaScript file (`radar.js`) with no modular decomposition, tests, or build pipeline. While well-implemented and functional, it lacks modern JavaScript modularization and testing infrastructure. The repository also includes historical release versions and a sample configuration (`config.json`) used by Zalando's own Tech Radar. There is no backend, data pipeline, or research component; it is purely a front-end visualization tool.
Apache ServiceComb Java Chassis is a comprehensive microservices framework for Java, providing service registration/discovery, RPC invocation (over REST, Highway, WebSocket), dynamic load balancing, circuit breaker, retry, rate limiting, and other governance capabilities. It follows a modular, SPI-based architecture with strong OpenAPI/Swagger integration for API contract generation. The framework supports multiple service registry backends (ServiceCenter, Nacos, Consul, etcd, ZooKeeper, local/lightweight) and is primarily used as a library within Spring Boot applications. The repository includes extensive demo modules for various transport, registry, and governance combinations, serving both as integration tests and example code. It is not a data or research project; all data flows are operational (configuration, metrics, tracing).
Smartparens is a mature Emacs minor mode for intelligent handling of parentheses, brackets, quotes, and other delimiters. It provides automatic pair insertion, wrapping, slurping/barfing (like Paredit), navigation by balanced expressions, and a strict mode that enforces structural balance. The core functionality is implemented in `smartparens.el`, with language-specific support modules for over 20 major modes (Python, Ruby, Rust, LaTeX, Clojure, etc.) that define custom pairs, skip-match predicates, and context-sensitive actions. The architecture is modular: the core exports a pair definition system (`sp-pair`, `sp-local-pair`) with fine-grained action hooks, context predicates, and prefix/suffix handling, while each language module registers its own configurations. The package is heavily customizable via `defcustom` and exposes interactive commands for everyday editing. The test suite is extensive, with over 60 test files using ERT and a custom macro framework that makes writing buffer-level behavior tests concise. The codebase demonstrates solid Emacs Lisp craftsmanship, with thoughtful use of macros, memoization, and backward-compatibility hacks. However, it shows signs of accumulated complexity, with some deprecated aliases, `defadvice` usage, and version-conditional code. The CI pipeline covers multiple Emacs versions and runs byte-compilation checks, indicating ongoing maintenance despite these legacy patterns. This is a well-known, actively developed package relied on by thousands of users. Its primary value is as an Emacs library, though patterns like the pair configuration system and test helper macros could inspire similar designs in other editor extensions or text-processing tools.
This repository is an Android library for GPU-accelerated real-time image and video processing, named 'android-gpuimage-plus' (CGE engine). It provides a comprehensive set of OpenGL ES shader-based filters (brightness, contrast, hue, saturation, vignette, sketch, liquify, color mapping, LUT, etc.) and a filter chain pipeline for applying multiple effects. The library supports camera preview with live filters, video playback with effects, and video recording to MP4 using an optional FFmpeg backend. It includes a demo application (cgeDemo) showcasing all features, including image editing, camera capture, video player, and face tracking (stub). The architecture is a Java/Kotlin API layer with JNI wrappers to a native C++ core that manages OpenGL ES contexts, shader programs, and frame buffer objects. External dependencies include OpenGL ES 2.0/3.0, optional FFmpeg (version 3.4.8), and Android Camera1/CameraX APIs. The library is published as an AAR artifact with variants for different page sizes (4KB and 16KB) and optional video module.
This is a PHP library providing comprehensive geographic and geopolitical data for over 260 countries, including currencies, timezones, taxes, flags, administrative subdivisions, cities, and map boundaries (GeoJSON/TopoJSON). The package is designed for applications that need offline access to richly structured country data, such as form validation, e-commerce tax calculation, map rendering, and localization. The core architecture leverages a lazy hydration pattern to load expensive data on demand, a custom extended Laravel Collection with case-insensitive and magic property access, and a configurable cache layer (PSR-16). Data is stored as thousands of static JSON files organized by type and country code, sourced from Natural Earth, mledoze, timezonedb, and other public datasets. Update scripts exist but are not automated, and the data snapshot has some stale entries (e.g., obsolete currency codes). The package shows solid engineering for its niche but has minimal test coverage and no automated data freshness checks.
Maid is a Ruby gem and CLI tool for automating filesystem hygiene. Users write declarative rules in Ruby (e.g. `Maid.rules { rule 'old downloads' { trash(dir('~/Downloads/*.iso')) } }`) that select files by glob, age, MIME type, image dimensions, EXIF GPS location, ZIP contents, SHA-1 duplicates, and macOS Spotlight metadata, then act on them with move, rename, trash, copy, remove, mkdir, or rsync sync operations. Safety is a core design point: operations respect a `noop`/dry-run mode, `move` refuses non-directory destinations, renames refuse to overwrite, trashing collides with a timestamped filename, and every action is logged to a rotating `~/.maid/maid.log` (5 × 10 MiB). The CLI (Thor-based, `bin/maid`) exposes `clean` (with `--noop`/`--force`), `daemon`, `logs`, `sample`, and `version` commands. Architecture is a monolithic gem with clear module separation: `Maid::App` (CLI), `Maid::Maid` (engine, defaults, trash path per XDG/macOS), `Maid::Tools` (40+ DSL methods mixed into rule context), `Maid::RuleContainer` (rule registration/following), `Maid::Watch`/`Maid::Repeat` (directory watching via listen, scheduling via rufus-scheduler), `Maid::Platform` (OS detection), and `Maid::Logger` (stdlib Logger wrapper). Rules execute via `instance_exec` against a Maid instance, giving user Ruby code full access to tool methods and helpers like `1.week.since?`. macOS-specific features (Spotlight `mdls`, `tag` labels, download provenance) degrade gracefully on Linux. The gem also ships Rake task helpers (`Maid::Rake::Task`) so file-management rules can be embedded in project Rakefiles. The project is actively maintained: v0.12.0 released 2026-10-17, Ruby 3.3+/3.4 support, security-motivated thor upgrade, and CI across Ubuntu/macOS on multiple Ruby versions. The test suite is substantial (22 spec files, FakeFS isolation, VCR cassettes for geocoder calls, coverage thresholds). Legacy patterns persist: several tools shell out to external binaries (`du`, `mdls`, `rsync`, `tag`, `locate`) and parse raw stdout, a deb-format `ChangeLog` sits alongside `CHANGELOG.md`, `.rubocop_todo.yml` carries 50+ outstanding offenses, and the README's stated Ruby floor (2.7+) is out of sync with the gemspec's enforced `>= 3.3.0`.
geometry3Sharp is a comprehensive C# library for 2D/3D geometric computing and triangle mesh processing. It provides a rich set of data structures (dynamic mesh, spatial indices, graphs) and algorithms (mesh editing, remeshing, simplification, boolean operations, distance queries, implicit surfaces, hole filling, smoothing, deformation). The library also includes I/O for common mesh formats (OBJ, STL, OFF), numerical solvers (sparse CG, SVD, eigen), and utilities like parallel loops and memory-efficient containers. It is designed for integration into real-time applications and Unity via conditional compilation. While the codebase shows signs of long development with some incomplete features and deprecated APIs, it remains a powerful and well-crafted tool for geometry processing tasks.
This is a TypeScript-first React library (`react-unity-webgl`) that embeds Unity WebGL builds into React applications. The `module/source` directory contains the actual npm package: a `Unity` forward-ref component that mounts a canvas and manages the Unity instance lifecycle, plus custom hooks (`useUnityContext`, `useUnityLoader`, `useEventSystem`, `useUnityMetricsInfo`) that encapsulate script loading, two-way Unity↔React event bridging, fullscreen/pointer-lock/screenshot controls, and performance metric polling. The repo is a monorepo with a Docusaurus documentation site (versioned v5 through current) and a Vite + React integration-test harness backed by two prebuilt Unity test projects (2022.1 and 6000.1). Architecturally, Unity instances push events to React through a global `dispatchReactUnityEvent` function wired into the hook-level event system; React sends messages back through `UnityInstance.SendMessage`. The library has no runtime dependencies beyond React peer support, relying on Unity's generated loader/framework/wasm output and on browser WebGL, IndexedDB, and sensor APIs. A notable implementation detail is a cleanup-on-unmount routine that swaps in a temporary detached canvas to safely call Unity's `Quit()` method. The codebase is well organized and strongly typed, with clear separation between components, hooks, and types. CI workflows for CodeQL, module validation, and documentation validation are present, and the last commit is recent. However, there are no automated unit tests (only a manual integration app), the lint script is a placeholder, CI uses older action versions, and the Unity version-specific bridge code will need maintenance as Unity evolves.
This repository provides a userspace C library for controlling WS2812/SK6812 RGB(RGBW) LEDs on Raspberry Pi single-board computers. The core architecture uses Raspberry Pi's DMA (Direct Memory Access) controller to feed data to the PWM, PCM, or SPI peripheral, generating the precise timing signals required by the LED protocol without burdening the CPU. The library is structured as a static/shared C library with a clean API (ws2811_init, ws2811_render, ws2811_fini) that abstracts hardware details such as GPIO configuration, clock setup, and memory allocation via the VideoCore mailbox interface. The code is well-documented with register-level header files (pwm.h, pcm.h, dma.h, clk.h, gpio.h) that could be reused in other Pi projects. Building is supported via both SCons and CMake, and Debian packaging files are included. The library is the foundational component for numerous language bindings (Python, Rust, Java, etc.) and is widely used in LED projects like unicorn-hat and pixel-art displays.
This repository is a comprehensive skill manager for AI agents, providing a CLI tool (Node.js and Python) to search, install, list, and update a large library of over 300 skill definitions. The skills are structured markdown files with YAML frontmatter, each defining a specific capability or workflow for an AI assistant (e.g., code review, security audit, database optimization, TDD orchestration). The application includes a catalog generation pipeline, validation scripts with baseline support, and CI checks to ensure skill quality and consistency. While the bulk of the repository is composed of skill content (instruction playbooks), the active software layer—the CLI, catalog builder, and validator—represents a well-engineered dual-language application with tests and automation.
This repository is a content-based Claude Code skill package rather than a conventional software service. It contains two agent skills — /tutor-setup and /tutor — that an LLM coding assistant executes using filesystem and WebFetch tools. tutor-setup scans a working directory, auto-detects whether it contains source code or documents, and generates an Obsidian StudyVault: concept notes, dashboards, exam-traps, and practice questions, with strict rules for source traceability, tag registries, wiki-linking, and folder conventions. tutor-setup operates through detailed phase models (D1-D9 for documents, C1-C9 for codebases), and codebase mode produces architecture maps, module notes, API surfaces, and onboarding exercises. tutor then reads that vault and runs interactive 4-question quiz rounds, updating concept-level progress files and a compact dashboard; it supports diagnostic, weak-area drill, section review, and hard-mode sessions, all governed by a zero-hint quiz design rule in references/quiz-rules.md. The implementation is almost entirely Markdown instructions plus two small Bash install/uninstall scripts; there is no compiled code, test suite, CI pipeline, or dependency manifest. The operational logic is prompt/instruction engineering that Claude Code interprets. External dependencies are Claude Code (or a compatible npx-skills-aware assistant), Obsidian for reviewing generated vaults, pdftotext/poppler for PDF extraction, and the assistant's built-in Read, Write, Edit, Glob, Grep, Bash, WebFetch, and AskUserQuestion tools. The data flow is unidirectional: source files in the CWD are scanned and extracted, transformed into StudyVault markdown, then quiz answers update concept files and dashboard aggregate stats. The skill enforces a CWD boundary to avoid accessing files outside the working directory. The strong point is unusually detailed and internally consistent procedural specification: mandatory source-content verification, per-topic coverage rules, tag registries, active-recall fold callouts, interlinking requirements, and self-review quality checklists. Weaknesses are the absence of automated tests/CI and versioned dependency pins, and behavior ultimately depends on the host LLM following prompt rules correctly. The README also references a different GitHub owner (RoundTable02) than the repository path (bevibing/tutor-skills), indicating a fork or repackage whose provenance should be verified before use. Overall, it fulfills its stated purpose well, and several Markdown modules are genuinely reusable as templates for other agent skills, study-vault generators, or adaptive quiz systems.
This repository is a documentation build system for producing a study guide for the Claude Certified Architect - Foundations exam. The core functionality resides in the `exam-preparation-guide.md` source file, which is transformed into PDF and EPUB formats via a Pandoc-based build script. The architecture is straightforward: a shell script (`scripts/build-release-assets.sh`) processes the Markdown with Pandoc, applying styling and metadata from the `publishing/` directory, and outputs artifacts to `dist/`. A GitHub Actions workflow (`.github/workflows/release.yml`) automates the build and release process when version tags are pushed. The system relies on external dependencies like Pandoc, XeLaTeX, and standard TeX Live packages for PDF generation. While not a complex software application, it demonstrates solid documentation engineering practices with a reusable build pipeline and clear separation of concerns between content, styling, and build automation.
EchoMimicV3 is a unified multi-modal and multi-task human animation model that generates realistic human videos from audio and/or text prompts. Built upon the Wan2.1-Fun-V1.1-1.3B-InP base model, it supports both talking-head and full-body animation with two versions: preview (standard quality) and flash (optimized for speed and lower VRAM). The system provides Gradio-based interactive demos (app.py, app_mm.py) for real-time video generation from user-uploaded media, command-line inference scripts (infer_flash.py, infer_preview.py, run_flash.sh) for batch processing, and deployment options for ComfyUI, ModelScope, and HuggingFace. Core functionality centers on audio-driven lip-sync and facial animation, with optional text guidance for pose/scene control, leveraging diffusion models, transformer architectures, and multimodal encoders (CLIP for images, T5 for text, Wav2Vec2 for audio).
Violin is an open-source video dubbing application that transcribes speech from any video, translates it into one of 33 languages, synthesizes a native-sounding voice-over using TTS (Cartesia Sonic 3, ElevenLabs, or OpenAI), and remuxes the result into a new video with optional SRT subtitles and in-video Q&A. The system provides three interfaces: a CLI tool (`violin <input> <output> --language <lang>`), a FastAPI web application with a browser UI for upload/download and real-time polling, and a Claude Code skill for invocation from a Claude session. The architecture follows a five-stage pipeline (audio extraction → Whisper transcription → LLM translation → TTS synthesis → video/audio merging with speed alignment) orchestrated by a shared `dub_video` function. Both the CLI and the API worker call the same core pipeline, with parameterized callbacks for progress reporting and cancellation. The API supports bring-your-own-key (BYOK) or server-provided free trial, job persistence via the filesystem, SQLite-based usage statistics, and periodic cleanup of stale jobs and orphaned temp directories. Configuration is YAML-based with deep-merge defaults, supporting pluggable providers per stage. The codebase is well-structured with separate modules for each pipeline stage, reusable cost tracking, and a prompt management system with safe format interpolation. Notable craftsmanship includes the `CostTracker` dataclass for per-job wall-clock and dollar-cost telemetry, the `transcriber.py` segment merging/deduplication logic for Whisper output, and the `api/stats.py` SQLite-backed stats with schema migration. The main weaknesses are the absence of unit tests (no test directory found) and some internal coupling of pipeline components to the global config object. The monolithic SPA frontend is functional but not independently reusable.
This repository is a complete mirror of the World of Warcraft game client's UI source code, provided by Blizzard for reference by addon developers. It contains hundreds of official Blizzard addons written in Lua and XML, covering every in-game interface element from action bars and unit frames to auction house, map, and housing systems. The architecture is heavily event-driven and based on a mixin composition pattern (CreateFromMixins), with extensive use of frame pools, data providers, and secure/taint-aware coding. The codebase is production-grade and actively maintained alongside the game's releases, making it the authoritative reference for WoW addon development. While nearly all components are tightly coupled to WoW's proprietary APIs, several isolated utility libraries (color math, vector math, bit flags, export/import streams) demonstrate patterns that could be extracted for general Lua projects.
This is a highly specialized Solana trading bot targeting memecoin platforms such as pump.fun, letsbonk.fun, and StonkFun. It snipes newly created tokens by listening for on-chain events through multiple real-time channels (Geyser gRPC, WebSocket logsSubscribe, blockSubscribe, and shred streams). The bot executes configurable buy strategies with dynamic priority fees, slippage control, and extreme-fast (zero-RPC) paths, then monitors positions with time-based or TP/SL exits before cleaning up token accounts. The architecture is a multi-process CLI application: each YAML-configured bot instance runs its own listener and trading loop, leveraging a platform abstraction layer to support multiple token launch platforms. External dependencies include Solana RPC nodes, WebSocket endpoints, and a Yellowstone gRPC Geyser plugin. While primarily a trading application, the repository also serves as a reference implementation for Solana transaction decoding, Anchor IDL parsing, and protocol reverse-engineering, with extensive offline regression tests and protocol documentation.
AIL Framework is a production-grade threat intelligence platform for collecting, processing, and analysing unstructured information leaks, with a strong focus on dark web, chat, and forum monitoring. The codebase implements a full pipeline: importers/feeders (Telegram, Discord, Matrix, forums, crawlers), Redis-backed queues, modular analysis workers (regex extraction, OCR, image similarity, language detection, YARA matching, credential/crypto/PGP detection), and a Flask web application with role-based access, REST APIs, dashboards, and investigation workflows. It exposes rich object models for items, messages, domains, users, CVEs, images, PDFs, and more, all linked through correlation and relationship engines. External integrations include MISP import/export, TheHive case creation, Meilisearch full-text search, passive DNS/SSH services, and AIL-to-AIL instance synchronisation over WebSockets.
VESC Tool is a cross-platform Qt/C++ desktop and mobile application for configuring, monitoring, and updating VESC (Vedder Electronic Speed Controller) devices. It provides a rich interface for firmware flashing, motor parameter detection (BLDC, FOC, hall sensors, encoders), real-time data visualization (currents, RPM, temperatures, IMU), data logging with GPS and map overlay, LispBM and QML scripting, and communication over serial, TCP, UDP, BLE, and CAN bus. The architecture is a monolith with a central VescInterface class handling all communication and configuration, and around 30+ UI pages dedicated to specific functions. It also includes a suite of reusable components such as a parameter configuration system, binary serialization utilities, code and markdown editors, and digital signal processing filters. The tool is actively maintained with support for multiple hardware versions and a growing ecosystem of third-party firmware and scripts.
ifuse is a command-line application that mounts directories of an iOS device locally using FUSE (Filesystem in Userspace). It communicates with the device via libimobiledevice to access AFC (Apple File Connection) services. The code is a single C file (src/ifuse.c) that implements all FUSE operations by translating them to AFC calls over USB. The device can be configured to mount the media partition, root filesystem (jailbroken), or app document/container folders. The architecture is monolithic: main() parses arguments, establishes a device connection via lockdownd, starts the appropriate service (AFC, AFC2, or House Arrest), and then calls fuse_main() with a set of callback functions. Those callbacks (getattr, readdir, open, read/write, truncate, etc.) use the AFC client API to perform file operations. The codebase is actively maintained (last commit April 2026) with current dependencies (libfuse3, libimobiledevice 1.4). However, it is tightly coupled to the device state and represents a single-module design with no unit tests. While functional and well‑structured for a typical C FUSE client, it offers no modular component that could be extracted and reused independently.