Sage is a high-performance proteomics database search engine implemented in Rust. It identifies peptides from tandem mass spectra by performing in silico digestion of a protein database (FASTA) and matching theoretical fragment ions to observed spectra. The system supports multiple input formats (mzML, MGF, Bruker TDF) and provides comprehensive quantification capabilities including isobaric labeling (TMT) and label-free quantification (LFQ). It also includes retention time prediction, ion mobility prediction, and statistical validation through linear discriminant analysis and false discovery rate control. The architecture is organized as a Cargo workspace with three crates: `sage` (core library), `sage-cli` (command-line interface), and `sage-cloudpath` (cloud storage abstraction). The CLI entry point in `sage-cli/src/main.rs` parses a JSON configuration file and invokes the `Runner` to orchestrate the search pipeline. The core library handles database construction (digestion, indexing, fragment generation), spectrum processing (deisotoping, charge deconvolution), scoring (X!Tandem hyperscore variants), and machine learning (LDA rescoring, KDE for posterior error probability, retention time alignment). Quantification modules extract ion chromatograms for LFQ and reporter ions for TMT. Key data flows: raw spectra and FASTA database are read (optionally from cloud storage), peptides are generated in silico with variable modifications, fragment ions are indexed and matched to spectra, PSMs are scored and rescored with LDA, FDR is controlled via picked-peptide and picked-protein methods, and results are output as TSV, Parquet, or PIN files. The system is designed for parallel execution using Rayon and can process large datasets efficiently. External dependencies include the `timsrust` library for Bruker TDF files, `object_store` for cloud storage access, and standard Rust crates for compression and serialization. The cloudpath crate provides a uniform interface for reading/writing data from local files, S3, GCS, and Azure, with automatic gzip handling.
This repository is a desktop application for game content creation, specifically designed for a Genshin Impact-like game. It provides a node-based visual scripting system (Graph Code) where users create logic using interconnected nodes representing game functions (combat, skills, UI, etc.). The application features a PyQt6-based GUI for graph editing, resource management, and previewing, along with automation capabilities for OCR, screen capture, and input simulation to interact with the editor. It includes a robust validation engine to ensure graph correctness, a layout engine for auto-arranging nodes, and export pipelines to produce game-ready formats (.gil and .gia). The architecture is monolithic with distinct modules for the GUI (app/ui/), automation (app/automation/), core engine (engine/), and CLI tools (app/cli/ and private_extensions/ugc_file_tools/). Key entry points are the main GUI launcher (app.cli.run_app), validation CLI (app.cli.graph_tools), and the unified UGC tools CLI (private_extensions/ugc_file_tools). Data flows involve graph creation/editing, validation, layout, export/testing, and automation-driven interactions. External dependencies include PyQt6, RapidOCR (onnxruntime), OpenCV, Pillow, and keyboard/mouse libraries for automation.
AMAI (Advanced Melee Artificial Intelligence) is a comprehensive replacement for Warcraft III's built-in melee AI. It provides a modular, table-driven AI system with a job scheduler, per-race strategies, hero micro, harass logic, and a Commander interface allowing human players to command allied AI opponents via chat or dialogs. The repository includes build tooling (Perl preprocessor, batch scripts) to compile AI scripts for multiple game versions (ROC, TFT, Reforged), an Electron-based desktop installer for injecting AI into maps, and extensive localization in 10 languages. The codebase is primarily JASS (the game's scripting language) with a custom preprocessor (eJASS) that supports conditional compilation and table inclusion. While the core AI logic is tightly coupled to Warcraft III, several patterns (job scheduling, command registration, preprocessor) are reusable in other game modding contexts.
This repository implements λ-RLM (Lambda Recursive Language Model), a framework for long-context reasoning that replaces free-form recursive code generation with a typed functional runtime grounded in λ-calculus. The system provides deterministic recursive decomposition, typed symbolic control flow, and bounded model calls at leaf subproblems. It features a modular architecture with pluggable LLM clients, sandboxed execution environments, and a benchmarking suite for comparison against standard RLM approaches. The core innovation is executing a pre-verified combinator chain (Φ) instead of open-ended LLM-driven while loops, guaranteeing termination and bounded cost.
This repository provides a production-ready documentation template built on Nuxt 4, Nuxt UI 4, and Nuxt Content 3. The codebase implements a static site generator for technical documentation with full-text search, automatic navigation, dark mode, and optimized OG images. It includes a built-in MCP (Model Context Protocol) HTTP server that exposes two tools (`list-pages` and `get-page`) for AI assistants to discover and read documentation content programmatically. Additionally, it integrates `nuxt-llms` to pre-render `/llms.txt` and `/llms-full.txt` files for LLM consumption. The architecture follows a standard Nuxt/Nitro server-rendered app with prerendering enabled, relying on modules for search, image optimization, and content management. The repo is explicitly a template intended for forking, with clean configuration-driven customization via `app.config.ts` and a well-documented content structure.
Pinkfish is a Python library for backtesting equity trading strategies, primarily used via Jupyter notebooks. It provides a modular framework with components for data fetching (Yahoo Finance via yfinance), trade logging, portfolio management, performance statistics, and signal generation. The core architecture revolves around a Strategy class pattern, a Portfolio class for multi-symbol backtesting, and a TradeLog class for simulating trade entries/exits with realistic open/close fills. The library includes a wide range of technical indicators (both custom and TA-Lib wrappers), comprehensive performance metrics (Sharpe, Sortino, drawdown, etc.), and support for signal notifications via Pushover/email. The codebase is well-structured with clear separation of concerns, but uses some global state in TradeLog and relies on a static stock market calendar, introducing minor maintenance risks. The examples cover diverse strategies such as momentum, moving average crossovers, and sector rotation, serving as both documentation and reusable templates.
This repository is a Node.js GitHub Bot that automates tasks in response to GitHub and Jenkins webhooks. It uses an Express.js server to receive webhooks, validates GitHub signatures, and emits normalized events via a central event emitter. Scripts in the `scripts` directory listen for these events to perform actions such as commenting on pull requests, updating GitHub status checks based on Jenkins builds, and enforcing CODEOWNERS reviews. The architecture separates webhook reception from processing, allowing for extensibility through additional scripts.
This repository provides **NEC2++**, a from-scratch C++ implementation of the Numerical Electromagnetics Code (NEC-2), a well-known Method of Moments (MoM) solver for wire and patch antenna simulation. The code is distributed as a standalone command-line tool (`nec2++`), a shared library (`libnecpp`) with a stable C API, and Python bindings (separate repository `python-necpp`). It reads standard NEC-2 input files (`.nec`) and produces output files with radiation patterns, impedances, near fields, and structure currents. The library is designed for embedding into optimization systems and GUI applications, supporting large models with tens of thousands of segments. Architecturally, the simulation is driven by a `nec_context` class that orchestrates geometry construction (via `c_geometry`), matrix assembly using Eigen's dense linear algebra, network solving, and result extraction. Input parsing uses an ANTLR 4 grammar to handle the free-format NEC card syntax, with a table-driven handler dispatch replacing a large switch statement. The ground model includes Sommerfeld/Norton integrals, implemented in both C (direct Fortran translation) and C++ wrappers. The codebase is well-tested, with a comprehensive test harness comparing outputs against the original Fortran NEC-2 and a C port (`nec2c`), plus unit tests using Catch2. The repository is actively maintained (last commit in 2026, recent PRs fixing bugs and adding features), uses C++17, and bundles a known version of Eigen (v3.4) for linear algebra, avoiding external BLAS/LAPACK dependencies. While the code has some legacy C sections and occasional commented-out dead code, the overall architecture is clean and extensible. Notable reusable components include the ANTLR grammar for parsing structured free-form input, the wire intersection algorithm in `nec_wire.h`, and the ground parameter abstraction in `nec_ground.h`.
This repository implements a threshold-based vertical autoscaling system for Proxmox VE virtual machines. It runs as a systemd service that periodically polls VM CPU and RAM usage via SSH commands (qm, pvesh) and adjusts CPU cores and RAM by 1 core or 512 MB when configurable high/low thresholds are crossed. The system includes host resource safety limits, per-VM threshold overrides, independent cooldowns for CPU and RAM, and optional billing tracking with CSV export and webhook notifications. It also provides a lightweight Prometheus metrics endpoint built on stdlib, supports Gotify and SMTP notifications, and offers a dry-run mode for safe evaluation. The architecture is a single-threaded polling loop with in-memory state, designed for simplicity and reliability rather than horizontal scaling or predictive analytics. The codebase is well-tested with over 290 unit tests and end-to-end tests against real Proxmox nodes, and includes comprehensive documentation via a VitePress site. Key reusable components include a generic SSH client with retry/backoff and host key policies, a thread-safe Prometheus metrics registry without external dependencies, and a configuration validation module that reports all errors at once.
pnpm-patch-i is a CLI tool that enhances the `pnpm patch` workflow by providing an interactive, user-friendly experience. It wraps pnpm's native patch command, placing the edit directory locally under `node_modules/.patch-edits/` with a human-readable name, automatically opening the editor, and waiting for user confirmation before committing the patch. The tool also supports applying patches directly from a source directory, with optional build and pack steps, and intelligently resolves `workspace:` and `catalog:` dependency specifiers from the source package's `pnpm-workspace.yaml`. The codebase is a single-module TypeScript application using `cac` for CLI parsing, `execa` for running pnpm commands, and `prompts` for user interaction. It is well-structured, actively maintained, and demonstrates solid engineering practices with clean async/await patterns and proper error handling.
The Dawn repository is a Ghost theme designed for the Ghost blogging platform (version >=5.0.0). It provides a responsive, feature-rich frontend for Ghost blogs, including templates for various page types, asset pipelines for CSS and JavaScript, and support for Ghost-native features like members, tags, authors, and comments. The theme emphasizes reader experience with adaptive navigation, infinite scroll pagination, lightbox galleries, and responsive embeds. Architecturally, it follows the standard Ghost theme structure with Handlebars templates for server-side rendering and client-side JavaScript enhancements. The build system uses Gulp and PostCSS to process assets, and leverages shared Ghost theme packages for base assets and translations. Key interactive components include a responsive dropdown menu, infinite scroll pagination with IntersectionObserver, a delegated lightbox for dynamic content, and responsive image handling via a custom Handlebars partial. While the theme is highly optimized for Ghost integration, it contains several reusable frontend patterns—such as adaptive navigation, infinite scroll pagination, and dynamic lightbox galleries—that could be adapted to other projects with minimal modification. The theme is actively maintained as part of the TryGhost/Themes monorepo, with recent commits indicating ongoing support.
PeriDyno is an open-source, GPU-accelerated multi-physics simulation framework built with a modular dataflow architecture. It primarily targets real-time simulation of peridynamics (deformable solids, fracture, granular media), particle-based fluids (SPH, dual-particle, DFSPH), rigid body dynamics (articulated vehicles, joints, stacking), height-field fluid simulation (ocean, capillary waves, granular flows), and volume/level-set methods (marching cubes, boolean operations, adaptive grids). The codebase is written in C++ with heavy use of CUDA for GPU compute, supplemented by a Vulkan backend for compute and rendering, and OpenGL/VTK for visualization. It provides multiple GUI frontends: Qt (desktop node editor), GLFW (lightweight), and Wt (web-based), unified under a common 'UbiApp' abstraction. The architecture is built around a node–module–pipeline pattern: simulation entities are 'Nodes' that host 'Modules' (solvers, mappers, visualizers) connected via typed 'Fields' (variables, arrays, instances) forming a directed acyclic graph. A scene graph manages the node hierarchy and execution order. The framework includes a plugin system for loading external solvers and I/O formats (OBJ, STL, FBX, GLTF, GMSH, MuJoCo XML, Alembic). Examples range from simple rigid body demos to complex fluid-structure interaction and photorealistic rendering with PBR. While the framework is production-oriented with extensive testing (Google Test) and CI, it retains research-grade elements: academic references in comments, experimental modules (dual-particle SPH, variational projection solvers), and mixed-language documentation (Chinese/English).
ChestShop is a mature Bukkit/Spigot/Paper plugin that enables players to create and operate shops using chests and signs. It provides a full economy-driven trading system: players place a sign on a chest to define a shop, set prices, and buy/sell items. The plugin handles shop creation, transaction validation, inventory management, and economic transfers, with extensive integration hooks for popular protection and economy plugins (Vault, Reserve, WorldGuard, GriefPrevention, PlotSquared, Lockette, etc.). The architecture is event-driven and modular, with a core plugin module and version-specific adapter modules to support Minecraft versions from 1.13 to 1.20.5. It uses a custom configuration system with annotations, a lightweight database layer (SQLite via ORMLite), and a comprehensive localization system supporting 40+ languages. The codebase is well-structured with clear separation of concerns, but carries technical debt from deprecated Bukkit APIs, manual database migrations, and tight coupling to many external plugin APIs.
This repository is a mature, production-grade WAMP v2 client library for Node.js and browsers. The actual code implements the Web Application Messaging Protocol with full pub/sub and RPC support over WebSocket, including auto-reconnect, multiple serializers (JSON, CBOR, MsgPack), and authentication methods (ticket, WAMP-CRA, cryptosign). The architecture is modular: a core Wampy class in `src/wampy.ts` accepts pluggable serializers via a common interface, and authentication plugins are registered in a hashmap. The library also includes a CLI tool (`cmd/cli.ts`) for rapid WAMP API debugging. External dependencies are minimal (WebSocket, Node.js crypto for cryptosign). The codebase is written in TypeScript with strict mode, dual ESM/CJS builds, and a comprehensive test suite covering connectivity, PubSub, RPC, and advanced features like progressive calls and Payload PassThru Mode. Despite large test files and some legacy patterns, the code is well-structured and follows promises/async-await throughout.
This repository provides a regularly updated list of all public npm package names (including scoped packages) as a large JSON array. The primary artifact is `names.json`, which is versioned with Git LFS and updated daily via a scheduled GitHub Actions workflow. The core logic resides in `script/build.js`, which fetches normalized repository data from the `all-the-package-repos` npm package, extracts package names, filters out purely numeric names, and writes the result as a pretty-printed JSON array. The package exposes a Node.js entry point (`require('all-the-package-names')`) returning the array, and a CLI command that outputs newline-delimited names. Tests verify the array structure, size, and exclusion of numeric names. While the codebase is minimal and straightforward, it is professionally maintained with CI/CD, automated releases, and LFS support for large data. It serves as a dependency for many npm ecosystem tools that need offline name lookups or filtering.
This is a full-stack todo application built with Next.js 15, React 19, and TypeScript. It features AI-powered natural language todo input, reminders via email, workspace collaboration, and a subscription model. The application uses a PostgreSQL database with Drizzle ORM for data storage, better-auth for authentication, and Resend for sending emails. The frontend is styled with Tailwind CSS and uses shadcn-ui components. Key architectural elements include API routes for todos, reminders, workspaces, and user settings, along with a cron job for processing reminders. The codebase demonstrates good engineering practices with reusable utilities for timezone handling, email sending, toast notifications, and a command palette.
This is a graphical editor for creating and managing bash scripts using a node-based interface. Users can visually construct bash scripts by dragging and dropping nodes representing different bash constructs (commands, flow control, variables, etc.) and connecting them to define execution flow. The application generates the corresponding bash script from the visual representation and allows users to run and view the output directly within the editor. The application follows a modular architecture with clear separation between the graph model (nodes and edges), the view (UI components), and the controller (application logic). It uses PySide6 for the GUI and implements features like project management, syntax highlighting, theme support, and undo/redo functionality. The code demonstrates good software engineering practices with proper encapsulation, reusable components, and attention to user experience details.
RiotSharp is a C# wrapper for the Riot Games API, providing access to League of Legends data including summoner information, match history, champion stats, leagues, and static game data. The library implements automatic rate limiting to comply with Riot's API constraints and includes caching for static data to minimize API calls. It features a layered architecture with separate projects for the core library, ASP.NET Core integration, and tests. The main entry point is the `RiotApi` class, which aggregates all endpoint interfaces via dependency injection. Key reusable components include a sophisticated rate limiter, a pluggable caching abstraction, a base class for static data endpoints, and custom JSON converters for enum serialization.
This repository provides a Ring adapter for Jetty web servers, enabling Clojure/Ring applications to run on Jetty 11 and 12 with support for modern web protocols. Despite its 'jetty9' name, it tracks recent Jetty releases and adds features like HTTP/2, HTTP/3, and WebSocket support that aren't in the official Ring Jetty adapter. The architecture centers around a core adapter that creates and configures Jetty Server instances, with separate implementations for synchronous and asynchronous Ring handlers. It cleanly separates concerns: connection handling (HTTP/HTTPS/HTTP/2/HTTP/3), request/response translation between Jetty and Ring models, and protocol-specific upgrades (WebSocket). The adapter supports virtual threads, SSL/TLS configuration, and serves as a drop-in replacement for the official ring-jetty-adapter while offering more recent Jetty versions and additional features. Notable for its quality implementation are the WebSocket bridge that properly translates between Jetty's WebSocketListener and Ring's WebSocket protocols, and the asynchronous handler implementation that correctly manages the race condition between handler completion and timeout using atomic state and Jetty's scheduling facilities. The optional HTTP/2 and HTTP/3 modules demonstrate good practices for extending the core adapter with dynamically loaded dependencies.
Ebib is a BibTeX database manager for GNU Emacs that provides a standalone interface for managing bibliographic references without editing raw .bib files. It features a two-window layout (index and entry buffers) and supports both BibTeX and biblatex formats. The system enables entry creation/editing, search/filtering, citation insertion into text buffers, external resource linking (files/URLs/DOIs), notes management (Org/Markdown), reading list tracking, and keyword handling. Built entirely in Emacs Lisp, it integrates with Emacs ecosystem tools like Ivy/Helm for completion, Org mode for notes/reading lists, and external utilities for DOI resolution and file viewing. The architecture is modular with separate modules for database logic, utilities, filters, notes, reading lists, and keywords, demonstrating good separation of concerns.