Dolphin is a document image parsing tool that uses a two-stage analyze-then-parse approach with a VLM (Qwen2.5-VL). It takes images or PDFs, performs layout analysis to detect elements (text, tables, formulas, code, figures) with reading order, then parses each element in parallel batches. Outputs structured JSON and Markdown with visualized layout. The codebase is well-structured, offering CLI entry points for page-level, element-level, and layout-only parsing. It demonstrates good engineering practices with batching, coordinate mapping, and post-processing for formula/special characters. The core implementation wraps the Hugging Face Qwen2.5-VL model and includes utility modules for layout string parsing, PDF conversion, and markdown generation. The architecture is a CLI application with minimal coupling, making the utility modules potentially reusable across document parsing projects.
FLARE-VM is a collection of PowerShell and Python scripts for automating the setup of a Windows-based reverse engineering virtual machine. The core installer (`install.ps1`) uses Chocolatey and Boxstarter to deploy a curated set of malware analysis tools, configure environment variables, registry settings, and taskbar layout. It provides both a GUI and CLI mode for package selection. The repository also includes a set of VirtualBox helper scripts (`virtualbox/`) for building, exporting, and cleaning VM snapshots, as well as monitoring network adapter status. These scripts are well-structured and can be reused independently for VirtualBox automation. The project is actively maintained by Mandiant (Google) and serves the malware analysis community.
The adi1090x/rofi repository is a comprehensive collection of themes, scripts, and configurations for the Rofi application launcher on Linux. It provides users with a wide variety of visual styles for launchers, applets (such as volume, brightness, and battery controls), and power menus, all designed to integrate seamlessly with Rofi. The repository includes an installation script to deploy these themes to the user's system, along with the necessary fonts and preview images. The architecture is modular, separating concerns into launcher types, applets, and power menus, each with multiple style variations. Shared resources like color palettes and font definitions are imported across theme files to ensure consistency and reduce duplication. The applet scripts utilize a shared bash library (`theme.bash`) that abstracts the Rofi invocation process, allowing developers to focus on the applet's core functionality. This demonstrates thoughtful design and reusability. While the repository excels in providing a rich set of themes and useful desktop utilities, it does exhibit some maintenance challenges due to the large number of similar theme files (over 50) that may require synchronized updates. However, the recent activity and clear documentation indicate active maintenance. The project primarily targets Rofi versions around 1.7.3-1.7.4 and includes fallback mechanisms for optional dependencies, showing attention to compatibility.
google-images-download is a Python application for searching and downloading images from Google Images. It functions as both a command-line tool and a library that can be imported into other Python scripts. The system uses Selenium with Chrome to handle JavaScript-heavy Google Images pages, automatically manages chromedriver via webdriver-manager, and supports extensive filtering options (size, color, format, usage rights, etc.). Key features include filename sanitization for cross-platform compatibility, metadata extraction, similar image search, and robust error handling for network issues. The architecture is monolithic with a clear separation between argument parsing, URL building, browser automation, and download execution.
This repository is the RR (Redpill Recovery) bootloader for Synology DSM, a tool that enables installing and booting Synology DiskStation Manager on non-Synology hardware. It provides an interactive initrd-based environment (TUI via dialog/whiptail) for configuring DSM model, version, addons, kernel modules, boot parameters, and then building a patched boot image. The system supports multiple deployment targets (raw image, OVA, VMX, VMDK, VHD, VHDX) and includes a GitHub Actions workflow for on-demand custom builds triggered by issue submissions. It also offers remote management via web interfaces (TTYD, DUFS, HTTP) and extensive internationalization with 15+ language translations. The architecture is modular with separate scripts for boot, init, menu, addon management, kernel module handling, and configuration persistence via YAML. While primarily an application, it includes data files (JSON/XLSX catalogs of models, addons, modules, patches) that serve as configuration metadata for the build process.
FlowGram is a comprehensive, production-grade visual workflow development framework from ByteDance. The codebase implements two distinct editing paradigms — fixed-layout (automatic positioning with composite nodes like loops, branches) and free-layout (node-position-free with lines) — both built on a shared plugin architecture using inversify for dependency injection. The framework includes a form engine with reactive fields, validation, and effects; a variable engine with AST-based type inference and scoped lifecycle; and a runtime engine capable of executing workflows with executors for LLM, HTTP, code (QuickJS sandbox), and conditions. The repository contains over 40 packages managed via Rush monorepo, encompassing core libraries, plugins (history, minimap, auto-layout, group, snap, clipboard, export), UI material libraries (Semi UI, Ant Design), a CLI tool for scaffolding, multiple demo applications, and comprehensive documentation. The system is actively maintained with regular commits, CI workflows, and E2E tests. Notable technical decisions include a local fork of the use-gesture library for canvas interaction, heavy decorator-based IoC, and support for both React 17 and 18. While the architecture is well-structured and extensible, the codebase shows signs of duplication between fixed and free layouts, numerous demo-specific components, and some deprecated APIs that indicate ongoing refactoring.
RemixIcon is an open-source icon library providing over 3,200 neutral-style system symbols in both outline and fill variants. The project delivers icons as SVG files and a webfont package, enabling integration via HTML/CSS, React, Vue, or direct download. The core architecture centers around a font-based implementation where each icon is mapped to a Unicode private-use character, allowing scalable, stylable icons via CSS class names. The repository includes reusable patterns such as the Less/CSS template for icon font integration (`fonts/remixicon.less`/`fonts/remixicon.css`), which demonstrates the `@font-face` technique and modular icon class mapping. Additionally, the `tags.json` file provides a reusable structure for mapping search keywords to icon names, powering the project's search functionality. Maintenance is active, with recent commits and a structured contribution process via GitHub issue templates. Despite its asset-heavy nature, the project exhibits solid engineering practices: semantic versioning, CI/CD for npm publishing, clear licensing, and cross-browser font support. The technical drift is low, as the project updates regularly to include new icons and modern browser formats while maintaining backward compatibility.
Helium is a Python library that provides a higher-level, more intuitive API for browser automation, built on top of Selenium. It simplifies common web automation tasks such as clicking buttons, filling forms, handling alerts, switching windows, and dragging elements by allowing developers to reference page elements by their visible labels rather than low-level CSS selectors or XPath expressions. Under the hood, Helium translates each high-level command into Selenium calls, managing implicit waits, iframe traversal, and window focus automatically. The library is designed for both interactive use (e.g., testing) and scripting (e.g., web scraping), and it seamlessly integrates with raw Selenium for advanced use cases. The architecture follows a layered pattern: a public API module (`helium/__init__.py`) exposes functions and GUI element classes; an implementation layer (`helium/_impl/__init__.py`) contains the core logic including element location via XPath construction, frame iteration, and error handling; and utility modules provide geometry, string, and system helpers. The codebase is well-organized with clear separation between API and implementation, though the main implementation file is large and tightly coupled. The library is actively used (over 8,300 stars) and though maintenance is low-effort, it remains functional with recent Selenium compatibility.
CyberStrikeAI is a full-stack, AI-native cybersecurity operations platform designed for autonomous penetration testing and red teaming. It orchestrates multiple AI agents using the CloudWeGo Eino ADK framework to plan and execute complex security assessments. The platform manages its own C2 (Command & Control) infrastructure with encrypted beacons and listeners, integrates with over 100 security tools via the Model Context Protocol (MCP), and maintains a persistent knowledge base and project fact graph. It features a comprehensive governance layer including Role-Based Access Control (RBAC), Human-in-the-Loop (HITL) approval workflows, tool execution guards, and detailed audit logging. The architecture is a monolithic Go-like backend serving a web SPA, with plugins for Burp Suite and Chrome. It supports multi-agent orchestration modes (single, deep, plan-execute, supervisor), a graph-based workflow engine, and integrations with various chat platforms (WeChat, Discord, Telegram). The codebase demonstrates high craftsmanship in its execution governance, process isolation, atomic update mechanism, and database schema reconciliation. A significant technical concern is the use of a non-standard Go dialect (featuring `func`, `type`, and `map` literals) tied to the Eino framework. This creates a hard dependency on a specific toolchain and represents a major drift risk from the standard Go ecosystem, limiting portability and the ability to use standard tooling. Despite this, the project is actively maintained with extensive test coverage and a clear focus on production-grade security automation.
Jellyfish is an open-source, full-stack AI short drama studio application. It provides an end-to-end production pipeline for generating vertical short dramas from scripts: script parsing (division, element extraction, consistency checking), storyboard generation (shot breakdown, asset linking, camera language), image/video generation via multiple AI providers (OpenAI, Volcengine), and async task orchestration with Celery. The backend is built with FastAPI, SQLAlchemy 2.0 async, and Redis; the frontend uses React 18, TypeScript, Ant Design, and Vite. The application is production-oriented with Docker Compose deployment, GitHub Actions CI, and automated OpenAPI client generation. It emphasizes visual consistency through global seed, style inheritance, and asset reuse. While primarily an application, it includes a significant amount of AI/LLM agent code for script analysis, giving it a hybrid character with research-oriented structured extraction pipelines.
AgentTeams is a production-grade multi-agent orchestration platform that manages teams of LLM-powered worker agents on Kubernetes. It uses a central Manager controller that reconciles Custom Resource Definitions (Worker, Team, Human, Manager) with container backends (Docker, K8s), a Matrix chat layer for all agent communication, and an AI Gateway (Higress) for credential isolation. The system supports multiple worker runtimes (OpenClaw, QwenPaw, Hermes, DeepSeek Harness) through a plugin architecture, provides a CLI tool (`agt`) for resource management, and includes human-in-the-loop oversight via Matrix rooms. Key features include STS token-based credential management, role-based authorization, audit logging, file synchronization via MinIO/OSS, and a skill discovery and distribution system. The codebase is heavily tested with unit, integration, and end-to-end tests, but shows moderate technical drift due to legacy runtime coexistence (CoPaw EOL migration) and some duplicated shell scripts across runtimes.
This repository provides a transparent proxy package for OpenWrt using Mihomo (a clash-compatible rule-based proxy core) as the backend. It is a full LuCI application that allows users to configure proxy modes (redirect, TPROXY, TUN), manage subscriptions, define access control rules, and monitor logs through a web interface. The system is designed for OpenWrt ≥24.10 with firewall4 (nftables) and kernel ≥5.13. The architecture consists of three OpenWrt packages: `nikki` (main service and scripts), `mihomo-meta` (stable core), and `mihomo-alpha` (alpha variant). The service is managed via procd init script (`nikki.init`), which handles starting/stopping Mihomo, setting up routing rules and nftables tables, and scheduling tasks. Configuration is stored in UCI (OpenWrt's standard configuration system) and processed through a pipeline: UCI options → `mixin.uc` (ucode script) generates a JSON overlay → `yq` merges it with a base profile → final Mihomo config. Traffic interception rules are generated dynamically from a utpl template (`hijack.ut`) that produces nftables rulesets. Key entry points include the LuCI views (`app.js`, `profile.js`, `mixin.js`, `proxy.js`, `editor.js`, `log.js`) for web-based management, the init script for service lifecycle, and shell scripts for installation/upgrade. External dependencies are Mihomo core, `yq` for YAML processing, and standard OpenWrt tools (procd, nftables, ucode). The repository also includes a large hardcoded nftables set of Chinese IP prefixes (`geoip_cn.nft`) for bypassing mainland China traffic.
AltSnap is a native Windows desktop utility that lets users move, resize, and manage windows by holding Alt and dragging with the mouse. In production it runs as a tray application and loads a companion hooks.dll into its own process; that DLL installs low-level keyboard and mouse hooks, detects Alt+click/drag gestures, and manipulates window placement through Win32 APIs. It also implements Aero-style snapping, configurable snap layouts/zones, blacklists, global hotkeys, MDI handling, a large action system assignable to mouse buttons/titlebar clicks, and an optional elevation path. The project deliberately avoids DLL injection into other processes; instead, input is captured via WH_KEYBOARD_LL/WH_MOUSE_LL and heavy window movement is offloaded to a worker thread to keep the hooks responsive.
Amber is a Rust-based compiler that transpiles a high-level, statically-typed programming language into shell scripts (Bash, Zsh, Ksh). It provides a modern language with features like functions, type inference, generics, optional arguments, failable types, imports, loops, range expressions, array operations, and a standard library for file system, text, HTTP, math, and environment operations. The compiler architecture is modular: a CLI entry point (src/main.rs) dispatches to subcommands (build, run, eval, check, docs, test). The compilation pipeline (src/compiler.rs) orchestrates tokenization via heraclitus-compiler, parsing into a typed AST, type checking with control-flow analysis, translation to an intermediate fragment AST, optimization passes (unused variable removal, ephemeral variable elimination), and final shell code generation with post-processing (e.g., shell syntax checking). The system supports multiple shell targets and generates version-specific code. The codebase is well-structured with procedural macros (meta crate) for keyword registration and context management, and a comprehensive test suite using snapshot testing (insta). While alpha quality, the engineering is serious and the architecture shows thoughtful design patterns.
This repository is a curated 'awesome list' and comprehensive documentation hub for the Agent Skills ecosystem. It does not contain any executable application code, data pipelines, or machine learning models. Instead, it serves as a static directory of links to official projects (Anthropic, OpenAI, Google, Vercel, etc.), community-contributed skills, tutorials, and best-practice guides. The core value lies in its translated and aggregated documentation, including detailed guides on Skill design patterns, practical experience from Anthropic, and a complete build guide. It is a reference resource, not a software tool. Engineers and AI agents should use this repo to discover the Agent Skills specification, find relevant skills to install, and learn how to create their own. It is not a library or framework to be imported.
Gitlogue is a terminal-based Git history visualizer that replays commits as a cinematic typing animation with syntax highlighting. It loads a local Git repository, extracts diffs, and renders the changes character by character in a split-pane terminal interface (ratatui). The core architecture is a monolithic Rust binary using clap for CLI, git2 for Git operations, tree-sitter for syntax highlighting across 32 languages, and crossterm for terminal I/O. It supports multiple playback modes (random, chronological, watch) and includes a configuration system, 17 built-in themes, and a custom animation engine with step-based simulation and checkpoint/restore. Notable reusable components include the SelectableParagraph widget (isolated ratatui component for text selection and dimming) and the Theme system (extensible struct with ~40 named colors). The codebase is well-structured but exhibits moderate technical drift risk due to heavy tree-sitter dependency chain, rapid feature growth, and potential staleness with some language grammare updates. CI/CD is active but the release workflow is manual. Overall, gitlogue is a solid, professional terminal application that effectively delivers its claimed functionality.
WinDynamicDesktop is a Windows desktop application that replicates the macOS Mojave Dynamic Desktop feature, automatically changing the desktop wallpaper based on the time of day. Built with WinForms and .NET, it determines sunrise/sunset times using the device's location (via Windows location service or a geocoding API) and supports multiple monitors, lock screen synchronization, theme importing (from ZIP, JSON, or .ddw files), and localized translations across 50+ languages. The architecture includes a platform abstraction layer (DesktopHelper/UwpHelper for standard and UWP deployments), COM wrappers for wallpaper and power settings, SkiaSharp-based theme preview rendering, and an event-driven scheduler that responds to system events. It also features a PowerShell scripting interface for advanced customization, automatic updates via GitHub releases, and a config migration system for backward compatibility. The codebase is well-structured with clear separation of concerns, though it relies on external APIs (LocationIQ, POEditor) and Windows-specific COM interfaces, which introduce maintenance risk. The repository includes unit tests (sunrise calculations, system integration), CI/CD pipelines, and packaging scripts for installer and store distribution.
Notepad4 is a Windows-native text and code editor (fork of Notepad2-mod) built on the Scintilla editing engine. It provides syntax highlighting for over 80 programming and markup languages via custom lexer definitions in `src/EditLexers/`, a file browser plugin (matepath) with Explorer-like operations, dark mode, localization (11 languages), and a full suite of editing features including regex search (bundled Boost regex library), code folding, auto-completion, and file change monitoring. The architecture is a Win32 desktop application with heavy use of Windows Shell APIs, Direct2D, and custom dialog procedures. Key entry points are `src/Notepad4.cpp` for the main editor and `matepath/src/matepath.cpp` for the browser. The build system supports x64, ARM64, AVX2, and AVX512 via Visual Studio and MinGW. While the codebase has some legacy patterns (bundled older Boost regex, a few deprecated API calls), it is well-structured, actively maintained, and includes reusable components like the `OptionSet<T>` lexer configuration system, `SplitVector` gap buffer, and SIMD-optimized graphic utilities.
This repository implements a comprehensive toolkit for detecting and removing Google DeepMind's SynthID watermark from AI-generated images, primarily targeting Gemini models. It provides multiple bypass versions (V1–V4) that use pure signal-processing techniques—frequency-domain phase scrambling, JPEG degradation, elastic deformation, VAE round-tripping, and cross-color consensus codebook subtraction—to disrupt the embedded watermark while preserving visual fidelity. The codebase includes a drag-and-drop GUI, CLI tools, batch processing scripts, and a human-in-the-loop calibration workflow. It also contains extensive watermark investigation scripts that validated the watermark's presence in over 123,000 image pairs. While primarily an application (tool for watermark removal), it has a strong research character due to its analytical components and large-scale validation studies.
pytorch-forecasting is a deep learning library for time series forecasting, providing implementations of state-of-the-art models such as Temporal Fusion Transformer, N-BEATS, N-HiTS, DeepAR, PatchTST, TiDE, TimeXer, and many others. Built on PyTorch and PyTorch Lightning, it offers a complete pipeline from data preprocessing (TimeSeriesDataSet, encoders, samplers) through model training (with GPU support, callbacks, hyperparameter tuning via optuna) to prediction and evaluation (point, quantile, and distributional metrics). The library supports multivariate forecasting, static and time-varying covariates, categorical features, and multiple targets. A major v2 refactoring is underway, introducing a new data module layer and simplified package interface, though the v2 API is explicitly marked as experimental and unstable. The codebase is well-tested with automated integration tests across all models and metrics, and employs a composition pattern for metrics (supporting weighting, aggregation, and distribution losses) and a layered architecture for models (base classes, package containers, building blocks).