ChaosTools.jl is a Julia library providing tools for analyzing nonlinear dynamics and chaotic behavior. It offers functionality for calculating Lyapunov exponents, detecting chaos via methods like GALI and the 0-1 test, analyzing predictability, finding fixed points and periodic orbits, estimating signal periods, analyzing rare events through return time statistics, and performing dimensionality reduction. The package is designed to work with DynamicalSystems.jl and can be used as a standalone package or as part of the broader DynamicalSystems ecosystem. The architecture follows a modular organization with functions grouped by topic (chaos detection, dimensionality reduction, periodicity, etc.), leveraging Julia's multiple dispatch and type system for clean, reusable code.
This is a comprehensive security scanning tool for MCP (Model Context Protocol) servers, developed by Cisco AI Defense. It supports scanning tools, prompts, resources, and server instructions for vulnerabilities, malicious behavior, and operational readiness. The scanner uses a multi-engine architecture combining YARA rules, LLM-based semantic analysis, static dataflow/taint analysis (Python, JS/TS, Go, Java, etc.), behavioral alignment verification, VirusTotal hash lookups, and pip-audit vulnerability scanning. It can scan remote servers (SSE/HTTP), local stdio servers, static JSON files, and packages from PyPI or npm (sandboxed via Docker). The system provides a CLI tool (`mcp-scanner`), a FastAPI HTTP server (`mcp-scanner-api`), and a Python SDK for programmatic use. It also includes a Claude Code plugin for in-IDE scanning. The codebase exhibits strong engineering practices with modular analyzers, dependency injection, structured logging, and extensive test coverage. However, it has some technical drift risks due to heavy reliance on external LLM APIs, pinned LiteLLM version, and duplication in cross-file analysis modules.
Prosopo is a privacy-focused, self-hosted CAPTCHA alternative that provides multiple challenge types—image selection, puzzle (image jigsaw), proof-of-work, and frictionless (behavioral bot detection). The system comprises an Express-based provider API (with MongoDB and Redis for persistence and caching), a CLI for administrative tasks, client-side embeddable widgets (vanilla JS bundle, React/Angular/Vue/Svelte wrappers), and a suite of supporting libraries for cryptography, locale, datasets, and native Rust modules (JA4 TLS fingerprinting, Merkle tree acceleration, puzzle rendering). Bot detection is multi-layered: client-side behavioral data (mouse/keyboard/touch events, SIMD readings) is collected and server-side scored, combined with JA4 TLS fingerprint analysis, IP reputation (ipapi.is + MaxMind), DNS asymmetry detection, spam email heuristics, and custom decision machines per site key. The architecture is a monorepo with ~70 workspaces, leveraging Vite for bundling, Vitest for unit/integration tests, and Cypress for E2E visual regression testing. The provider enforces access policies (allow/block/restrict) via a Redis-backed rules engine and maintains usage counters for rate limiting. Asset sealing (AES-256-GCM) protects image CDN URLs, and puzzle difficulty is sampled with a CSPRNG-stratified ladder to frustrate solver calibration.
This repository implements the Dilithium post-quantum cryptographic signature algorithm as a Java Cryptography Extension (JCE) provider. It provides a complete implementation of the Dilithium algorithm (version 3.1) including key pair generation, signing, and signature verification. The architecture follows standard JCE provider patterns with clean separation between the core cryptographic implementation, provider interfaces, and algorithm-specific implementations. The library passes known-answer tests from the reference implementation and includes performance benchmarks.
Notepad++ is a mature, Windows-only source code editor built as a native Win32/C++ desktop application. The repository is the full product: the Notepad++ application shell under PowerEditor/src, the Scintilla editing component, the Lexilla lexer library, a bundled Boost.Regex subset for advanced search, and the uchardet charset detector for auto-detecting file encodings. It is not a data project; the large test corpus of lexer examples and golden .styled/.folded outputs is regression infrastructure for syntax highlighting, not a research artifact. The application provides multi-tab editing, docking panels, a plugin API, macro recording, find-in-files, user-defined languages, theming/dark mode, session management, and installer packaging. Entry points include winmain.cpp, Notepad_plus_Window.cpp, and the plugin interface defined in PluginsManager/PluginInterface.h.
django-init is a cookiecutter template for generating Django-based REST API projects. It provides a comprehensive starting point with Django 4.1, Python 3.9, Poetry dependency management, Django REST Framework, and optional features like Celery, GraphQL, ASGI, Docker, and various deployment configurations. The template generates projects with custom user models, JWT authentication, proper API versioning, and testing setup. What distinguishes this template is the quality of its reusable components in the base/ directory, particularly the custom DRF mixins for multiple serializers and per-action permissions, specialized routers for singleton resources, and thoughtful exception handling and response classes that demonstrate deep understanding of Django REST Framework's architecture.
Fabric.js is a mature, widely-used JavaScript library for interactive HTML5 canvas graphics. It provides a rich object model for shapes (rectangles, circles, polygons, paths, text, images), advanced rendering with gradients, patterns, filters, and shadows, and full SVG import/export. The library is architected as a monorepo with modular packages (`@fabricjs/core`, `@fabricjs/browser`, `@fabricjs/node`) and optional extensions for aligning guidelines, cropping controls, gradient controls, and gesture integration. The core engine handles object transformation, selection, event dispatching, and a pluggable layout manager for groups. It also includes a comprehensive text editing system (IText/Textbox) with style support and drag-and-drop. In production, Fabric.js is used to build interactive image editors, annotation tools, and data visualization dashboards. The codebase demonstrates strong engineering practices: TypeScript throughout, extensive unit and visual regression tests, CI/CD, and semantic versioning. However, some legacy code remains (e.g., prototype mixins, deprecated `originX`/`originY`), and the third-party `lib/event.js` gesture library is outdated. Overall, Fabric.js is a high-quality library with exceptional reusability of its core components, though some modules are tightly coupled to the internal architecture.
DistillKit is a production-ready toolkit for knowledge distillation of large language models, supporting both online and offline workflows. It features advanced logit compression techniques (polynomial approximation + quantization + bit-packing) that enable efficient offline distillation at scale. The toolkit provides composable loss functions (KL, JSD, TVD, ranking losses, hidden state alignment) and integrates with Hugging Face Transformers, TRL, and Accelerate. It powers Arcee AI's distilled model releases and includes CLI tools for easy experimentation.
AdaptiveCpp is a SYCL and C++ standard parallelism implementation targeting CPUs and GPUs from multiple vendors. It provides a complete heterogeneous computing stack including compiler infrastructure (LLVM-to-backend translators, optimization passes), runtime system (memory management, scheduling, event handling), and SYCL API headers. The project supports multiple backends (CUDA/HIP, OpenCL, Level Zero, Metal, Vulkan, OpenMP) and features compilation flows including LLVM JIT, source-level interop, and library-only modes. While primarily a production SYCL implementation, it contains research elements reflected in academic citations and experimental features like PCUDA and stdpar support. The codebase demonstrates strong modularity with clear separation between compiler, runtime, and API layers.
This repository is a semantic-release plugin that automates the publishing of npm packages. It implements four lifecycle steps: verifyConditions (validates configuration and authentication), prepare (updates package.json version and optionally creates a tarball), publish (publishes the package to the npm registry), and addChannel (adds a release to a dist-tag). The plugin supports both token-based authentication (via NPM_TOKEN) and OIDC-based trusted publishing for GitHub Actions, GitLab Pipelines, and CircleCI. It can publish to custom registries, handle scoped packages, and skip publishing for private packages or when npmPublish is false. The architecture is a set of exported async functions that receive pluginConfig and context from semantic-release, delegating to internal lib modules. External dependencies include the npm CLI (executed via execa), fs-extra for file operations, registry-auth-token for authentication, env-ci for CI provider detection, and @actions/core for OIDC token retrieval. The codebase is well-structured with clear separation of concerns, comprehensive error handling using AggregateError, and extensive test coverage with both unit and integration tests.
dpScreenOCR is a cross-platform desktop application for recognizing text from a selected screen region. It is built in C++ using the Tesseract OCR engine and Qt 5/6 for the graphical interface. The application runs as a system-tray utility: the user triggers a screen selection via a global hotkey, captures a portion of the screen, processes the image (grayscale conversion, upscaling, unsharp masking), and feeds it to Tesseract. Recognized text can be copied to the clipboard, added to a persistent history, or passed to an external executable. The architecture is modular, with separate libraries for OCR (dpso_ocr), system interaction (dpso_sys), image processing (dpso_img), network requests (dpso_net), sound playback (dpso_sound), configuration and history (dpso_ext), and a suite of cross-platform utilities (dpso_utils). Each module exposes a C API for C/C++ interoperability and includes platform-specific backends for X11 and Windows. The Qt UI provides a main window with recognition controls, a language manager for installing/updating Tesseract language packs, and export functionality for history. The project also packages a built-in gettext-compatible internationalization library (dp_intl) and supports 16 languages through Weblate. This is a pure application repository with no data analysis or machine learning training components. The code demonstrates solid engineering practices: clear separation of concerns, RAII resource management, comprehensive error handling, and an extensive CMake-based build system supporting multiple packaging formats (Unix bundle, Windows MSIX, Inno Setup). The test suite covers utility functions, geometry, SHA-256, version comparison, and platform-specific components, though the OCR pipeline itself has limited direct unit tests.
SNAFU is a Rust library for ergonomic error handling. It provides a `#[derive(Snafu)]` proc-macro that generates custom error types with automatic 'context selectors' (e.g., `ReadConfigSnafu`) and implements standard traits (`Display`, `Error`, `From`). The library also offers extension traits (`ResultExt`, `OptionExt`, `TryFutureExt`, `TryStreamExt`) to attach contextual information to underlying errors, macros (`ensure!`, `whatever!`) for concise error creation, and a `Report` type for user-facing error output. It supports `no_std` environments (with `alloc`) and includes backtrace capture, location tracking, and an unstable provider API for attaching arbitrary data to errors. The crate is mature and widely adopted, but contains some deprecated features (e.g., `backtraces-impl-backtrace-crate`) and a complex feature-flag matrix. The companion `snafu-derive` crate handles all proc-macro generation, and the architecture cleanly separates parsing, validation, and code generation.
ReactFlux is a modern, customizable web frontend for Miniflux, a self-hosted RSS reader. It is a client-side single-page application (SPA) built with React 19, Vite 8, and nanostores for fine-grained state management. The application provides a rich reading experience with multiple article layouts (list, card, column), dark/light/system themes, keyboard shortcuts, touch gestures, offline support via PWA, and internationalization (6 languages). It communicates exclusively with a Miniflux server through its REST API, handling authentication, feed/category management, article fetching, and status updates. The architecture follows a component-based design with clear separation of concerns: API layer (src/apis), state stores (src/store), custom hooks (src/hooks), reusable UI components (src/components/ui), and utility functions (src/utils). The codebase demonstrates good engineering practices with well-factored hooks for complex behaviors like optimistic entry actions, infinite scroll pagination, and long-press context menus. It also includes a settings schema with versioned migration and import/export, accessible modal and scroll area components, and a feed icon fetcher with fallback chain. While the project is actively maintained and uses modern dependencies, it lacks automated tests and has a large CSS footprint with many responsive overrides. The tight coupling to the Miniflux API and reliance on experimental React Compiler features introduce some maintenance risk. Overall, ReactFlux is a strong example of a feature-rich client-side application with reusable patterns, suitable for developers building similar RSS reader interfaces or learning advanced React patterns.
Vagrant is a mature, widely-used CLI tool for building and managing portable development environments. It orchestrates virtual machines and containers across multiple providers (VirtualBox, Hyper-V, Docker) with a plugin-based architecture. The system reads Vagrantfile configurations, executes a middleware action chain to manage machine lifecycle (up, provision, halt, destroy, snapshot, package), and supports guest OS-specific capabilities (network configuration, shared folders, hostname changes) via a capability host pattern. It includes built-in provisioners (Shell, Chef, Puppet, Ansible, Salt, Docker, Podman, File), communicators (SSH, WinRM, WinSSH), synced folder backends (NFS, rsync, SMB), and cloud integration with Vagrant Cloud. The codebase is predominantly Ruby with a newer Go-based plugin SDK. It has extensive unit and acceptance tests, a well-defined plugin API (V1/V2), and reusable utility modules. While the core is solid, the codebase shows signs of technical drift with deprecated features, version-specific workarounds, and a dual-language complexity.
Kaminari is a pagination library for Ruby on Rails and other web frameworks. It provides scope-based pagination for ActiveRecord models and generic arrays, with view helpers to render pagination controls. The architecture consists of three main components: kaminari-core (pagination logic), kaminari-activerecord (ActiveRecord adapter), and kaminari-actionview (view helpers). Key features include customizable pagination windows, optional count queries for performance, and support for multiple ORMs and template engines. The implementation demonstrates strong craftsmanship in its windowing algorithms, parameter handling, and the innovative 'without_count' optimization that avoids expensive COUNT queries by fetching one extra record.
ArgoX is a monolithic Bash script that automates the deployment and management of Xray (a proxy) and Cloudflare Argo tunnels on Linux VPS. It supports 12 proxy protocols (VLESS, Hysteria2, Trojan, Shadowsocks, etc.) with various transport and security layers, including Reality, WebSocket, XHTTP, and direct connections. The script handles the full lifecycle: dependency installation, binary download (Xray, cloudflared, jq, qrencode), configuration generation, service management (systemd/OpenRC), firewall rule management (iptables/UFW/firewalld), and client subscription file generation for V2rayN, Clash, Shadowrocket, Sing-box, and Throne. Architecturally, ArgoX is a single-file Bash script with a modular protocol system. It provides an interactive menu, CLI flags, long-parameter support, and a config-file mode for non-interactive/CI/CD deployment. Key features include Argo tunnel integration (temporary or fixed domain via Token/JSON/Cloudflare API), Hysteria2 Realm mode for NAT traversal, WARP outbound routing for ChatGPT unlocking, live traffic statistics via Xray API, and zero-downtime hot-reload for configuration changes. The script is actively maintained with frequent updates tracking upstream Xray and cloudflared releases. The primary data flow involves the user invoking the script, which detects the system, checks dependencies, downloads required binaries, generates inbound and outbound JSON configurations, starts services, and outputs node information and subscription URLs. Configuration changes are applied via Xray API hot-reload or service restart, with automatic firewall rule synchronization. The script is designed for minimal system dependencies, downloading jq and qrencode as static binaries and installing nginx only when needed.
An Obsidian plugin (Gemini Scribe) that integrates multiple AI providers (Gemini, Anthropic, OpenAI, Ollama) for chat, agent-based automation, and knowledge management within the Obsidian vault. The system provides a modular architecture with an agent loop that executes tools (vault operations, web search, RAG semantic search, image generation, deep research) with confirmation flows and diff previews. It features a declarative settings UI with per-feature provider routing, a skill system following the agentskills.io spec, MCP server integration, scheduled tasks, lifecycle hooks, and an evaluation harness for benchmarking agent behavior. The codebase demonstrates strong engineering practices: thorough unit testing (73%+ line coverage), clean module boundaries with leaf modules to prevent circular imports, and reusable patterns like typed event buses, retry decorators, and cancellation-safe streaming.
This repository is a comprehensive, open-source textbook for data structures and algorithms, known as 'Hello Algo'. It provides implementations of over 200 classic algorithms across 12 programming languages (Python, Java, C++, Go, Rust, etc.) and multiple human languages (Chinese, English, Japanese, Russian). The code is organized into chapters covering complexity analysis, arrays, linked lists, stacks, queues, hashing, trees, heaps, graphs, sorting, searching, divide-and-conquer, backtracking, dynamic programming, and greedy algorithms. Each algorithm is presented as a self-contained, runnable example with driver code and inline comments explaining the logic. The repository is not a production application but a pedagogical reference, making it valuable for students, educators, and self-learners. While the code is well-structured and consistent across languages, its high duplication across languages and translations means it is not designed for production reuse. However, the utility modules for tree/linked list construction and printing are cleanly isolated and can be extracted for other projects.
This is a Unity shader suite ('Unlit_WF_ShaderSuite') focused on providing custom unlit shaders for stylized rendering, particularly optimized for VRChat avatar and world creation. The package includes a comprehensive set of shaders for toon shading, outlines, special effects (fur, gems, water, particles), and various rendering modes (opaque, transparent, cutout). It features extensive editor tools for material conversion, validation, and batch processing, along with a shader preprocessing system that optimizes builds by stripping unused variants. The architecture centers around a modular shader system built from reusable .cginc include files, allowing extensive customization through keyword-based feature toggles. The package demonstrates strong craftsmanship in its editor extension systems, particularly the property hook architecture for custom material inspector controls and the material validation framework.
This repository is a curated list (awesome-list) of open-source quantitative finance libraries, packages, and resources. It provides a structured README.md organized by category, with inline language tags, and a pipeline that parses the list, enriches it with GitHub metadata (stars, last commit dates), and generates a static website deployed to GitHub Pages. The repo also includes automated tooling for pull-request review: a validation script that checks entry format, section placement, URL security, duplicate detection, and a full CI-driven PR review workflow. The core logic resides in parse.py (multi-threaded GitHub API enrichment), site/generate.py (static site generator), scripts/validate_readme.py (entry validation), and scripts/review_pr.py (automated PR review with offline URL reachability checks and cross-PR duplicate detection). The project is primarily a reference list, not an application or data pipeline, but it includes high-quality supporting tooling for maintainers and contributors.