JUCE is a mature, cross-platform C++ application framework specializing in audio software development. It provides a comprehensive set of modules covering core utilities, GUI, graphics, audio processing, MIDI, DSP, and plugin formats (VST3, AU, AAX, LV2, ARA). The architecture is a modular monolith: each module (e.g., juce_core, juce_audio_basics, juce_gui_basics) is a self-contained library that can be selectively included. Key entry points include JUCEApplication for desktop apps, AudioProcessor for audio plugins, and Component for GUI widgets. Data flows center on audio buffers (AudioSampleBuffer), MIDI messages, and event-driven GUI updates via message queues. External dependencies are minimal at the API level, but the framework bundles many third-party libraries (Opus, FLAC, Vorbis, WebP, HarfBuzz, Box2D, etc.) for codec and graphics support. The repository also includes the Projucer IDE for project generation and build tooling (CMake helpers, resource file management).
This is a Neovim plugin that animates the cursor with a smear effect, inspired by Neovide's animated cursor. It works in any terminal by using floating windows and Unicode block characters to render a smooth, physics-based trailing cursor. The plugin listens to cursor movement events and interpolates the cursor position using a spring-damper system, drawing the smear as a quad with sub-cell precision. It supports configurable stiffness, damping, particles, and various rendering modes (vertical bar, horizontal bar, diagonal blocks, braille). The codebase is modular, with clear separation between animation logic, drawing, color management, and event handling. The drawing module is particularly noteworthy for its sophisticated use of Unicode symbols to achieve anti-aliased-like rendering in a terminal environment.
Claude HUD is a real-time statusline plugin for Claude Code, the AI coding assistant. It runs as a subprocess and renders a multi-line or compact HUD below the input field, displaying context usage, rate limits, active tools, running agents, todo progress, git/jj status, memory usage, and cost tracking. The system reads session data from stdin (JSON payload) and optionally parses the Claude Code transcript JSONL file for detailed tool/agent activity. It is highly configurable with ~60+ options for layout, colors, visibility, and i18n (English, Simplified/Traditional Chinese). The architecture is modular: a CLI orchestrator (src/index.ts) loads config, runs git/jj/memory/extra-cmd in parallel, then renders via a pure render layer. It uses no external npm dependencies, relying on Node.js built-ins and child processes. The codebase demonstrates strong engineering practices: extensive test coverage (unit, integration, golden snapshot tests), dependency injection for testability, atomic file writes for persistent state, and thorough sanitization of untrusted inputs to prevent terminal injection. It is actively maintained with frequent releases and CI/CD pipelines.
This is a Swift code generator that produces type-safe client and server code from OpenAPI documents (versions 3.0, 3.1, and preliminary 3.2). It is distributed as a Swift Package Manager build plugin, a command plugin, and a standalone CLI tool (`swift-openapi-generator`). The core architecture follows a pipeline: parse the OpenAPI document using YamsParser, translate the parsed representation into a structured Swift intermediate representation (IR) via a multiplex translator, and render the IR into Swift source files using a text-based renderer. The generated code is decoupled from specific HTTP transport libraries via `ClientTransport` and `ServerTransport` protocols, and supports middleware for cross-cutting concerns like logging, authentication, retrying, metrics, and tracing. The repository includes extensive examples covering a wide range of use cases: basic clients and servers, event streaming, multipart content, database integrations, and middleware stacks. The test suite is comprehensive, including unit tests, golden-file reference tests, and integration tests that compile and run generated code against mock transports. The project is actively maintained with a proposal process (SOAR) for feature additions and has a well-documented ecosystem of separate runtime and transport libraries.
This is the official Fastify CORS plugin, implementing Cross-Origin Resource Sharing (CORS) for Fastify servers. It provides comprehensive configuration for all standard CORS headers, including origin (string, regex, array, boolean, or dynamic function), methods, allowed headers, exposed headers, credentials, max age, cache control, and preflight handling. The architecture is a standard Fastify plugin that registers a configurable lifecycle hook (default onRequest) and a wildcard OPTIONS route to handle preflight requests. It supports dynamic configuration via a delegator callback or promise, and per-route CORS overrides via route config. The code is well-structured, thoroughly tested, and includes a particularly well-crafted `vary.js` module for managing the Vary header with caching. Dependencies are minimal and up to date.
tabline.wez is a WezTerm plugin that provides a customizable tab bar interface written in Lua. It displays information about tabs, windows, and system status (mode, workspace, battery, CPU, RAM, datetime, domain, etc.) in a configurable layout inspired by lualine.nvim. The architecture is modular with separate components for configuration management, status line rendering, tab formatting, utility functions, and individual information components. Key entry points are in plugin/init.lua which sets up WezTerm event handlers for 'update-status' and 'format-tab-title'. The plugin pulls data from the WezTerm API and system sources to dynamically update the display based on user activity and system status.
This is an Obsidian plugin that provides a highly configurable markdown linter and formatter. It implements over 50 individual rules organized by type (YAML, headings, content, spacing, footnotes, paste) using a clean rule-builder pattern with decorators. The plugin integrates deeply with the Obsidian editor, supporting lint-on-save, paste transformations, custom commands, regex replacements, and a comprehensive settings UI with tabs and search. It includes an extensive test suite (unit and integration) and auto-generates documentation from rule definitions. The architecture is modular: each rule is a self-registering class with typed options, examples, and option builders that also drive the settings UI. Shared utilities for YAML manipulation, markdown AST transformations, and ignore-type masking are well-isolated and reusable. The codebase is actively maintained with frequent commits and responsive issue triage.
This Obsidian plugin enables users to make HTTP API requests directly from within their notes using markdown code blocks. It processes 'req' language blocks to execute GET, POST, PUT, DELETE, PATCH, HEAD, and OPTIONS requests, with support for variable substitution from frontmatter, global variables, and cached responses. The plugin emphasizes security through comprehensive input validation, URL sanitization, JSONPath expression validation, and XSS prevention in output formatting. The architecture separates concerns between the main request processing logic, security utilities, and Obsidian-specific integration points. Key features include response caching via localStorage with unique identifiers, automatic variable resolution, JSONPath-based data extraction, customizable output formatting, and the ability to save responses to files or update frontmatter properties. The plugin implements defense-in-depth security practices to protect against common web vulnerabilities while providing a flexible API integration tool for knowledge workers.
Fork TS Checker Webpack Plugin is a mature, production-grade webpack plugin that offloads TypeScript type checking to a separate process to avoid blocking the webpack build. The architecture is centered around a plugin class that integrates with webpack's compilation lifecycle via tapable hooks. On each compilation, it collects file changes and spawns two types of workers (via child_process RPC): one for computing TypeScript issues (syntactic, semantic, declaration, global diagnostics) and another for computing file dependencies. Workers use a controlled TypeScript system with an in-memory file system (memfs) for artifacts and a passive file system that delegates writes to memory for read-only modes. The plugin supports incremental watching, project references (solution builder), tracing, and various output modes (write-dts, write-tsbuildinfo, write-references). Configuration is flexible via cosmiconfig and validated with JSON schema. The codebase is well-structured with clear separation of concerns: hooks, formatters, issue filtering, RPC infrastructure, and file system abstractions. It includes extensive unit and end-to-end tests covering various TypeScript versions and webpack configurations. The plugin is actively maintained with a robust CI/CD pipeline and semantic release.
This repository contains ASFFreeGames, a plugin for ArchiSteamFarm (ASF) that automatically collects free Steam games from Reddit and Redlib sources. The plugin monitors the ASFinfo Reddit user for posts containing "!addlicense asf" commands, extracts game identifiers from these posts, and uses ASF's addlicense command to claim those games for all logged-in bots. It operates on a configurable schedule (default 30 minutes) and can also be triggered manually via the "freegames" command. The architecture follows a plugin pattern with clear separation of concerns: core plugin logic handles ASF integration and scheduling, command processing manages user interactions, strategy objects encapsulate different data source approaches (Reddit vs Redlib), and specialized parsers handle the extraction of game information from HTML/JSON responses. The plugin maintains a persistent cache of already-claimed games to prevent duplicates and supports configuration options for filtering results (e.g., skipping free-to-play games or DLC). Notably, the project contains several high-quality, reusable utility components in the Maxisoft.Utils namespace. These include BitSpan (a high-performance bit array using span<long>), SpanDict (a dictionary implementation using spans with linear probing), OrderedDictionary (a dictionary that preserves insertion order), and RandomUtils (a Gaussian random number generator using the Box-Muller transform). These utilities demonstrate advanced .NET span usage and algorithmic implementation skills, with minimal dependencies making them suitable for extraction to other projects. The project is actively maintained with recent commits, comprehensive CI/CD workflows, and targets the latest .NET 9.0 framework. Dependencies appear current, and the codebase shows no significant technical debt or use of deprecated APIs. The plugin properly handles edge cases like rate limiting, network failures, and invalid responses while providing configurable logging options.
This repository implements an MCP (Model Context Protocol) server that exposes IDA Pro's disassembler, decompiler, debugger, and type system as a set of tools and resources consumable by LLM clients (Claude, Codex, Cursor, etc.). It operates in two distinct modes: an IDA GUI plugin that starts an MCP server on a configurable port, and a headless supervisor (`idalib-mcp`) that manages persistent worker processes for multiple databases. The architecture is a hybrid of a plugin and a standalone server, built on a custom, vendored MCP server implementation (`zeromcp`) with HTTP/SSE/stdio transports. The core API surface is defined via a decorator-based registration system (`@tool`, `@resource`, `@unsafe`, `@ext`) in `rpc.py`, which also handles output truncation middleware and JSON schema generation from TypedDicts. All IDA SDK calls are marshalled onto the main thread through a robust execution pipeline (`sync.py`) that manages timeouts, cancellation, and batch mode. The headless mode uses a supervisor/worker pattern (`idalib_supervisor.py`, `idalib_server.py`, `worker_lifecycle.py`) with health probing, idle TTL, and session management. A comprehensive compatibility layer (`compat.py`) provides version-gated shims for IDA 8.4 through 9.3. Key features include decompilation, disassembly, cross-references, memory read/write, patching, type declaration/inference, debugger control (breakpoints, step, registers), signature generation, and binary survey. Tool calls are always-on traced into the IDB as gzipped JSONL batches. The project includes an extensive test suite with a custom test framework, MCP spec regression tests, and CI running against multiple IDA versions in Docker containers. The codebase is actively maintained and demonstrates strong engineering practices, but the plugin mode is explicitly deprecated in favor of the official Hex-Rays IDA MCP Server. The heavy reliance on IDA's internal APIs and the vendored MCP server implementation represent ongoing maintenance risks. The code is well-structured with several genuinely reusable components, though some modules (e.g., `api_analysis.py`) are monolithic.
Engram is a persistent memory system for AI coding agents, providing local-first storage (SQLite with FTS5) and optional cloud sync (Postgres). It exposes memory tools via the Model Context Protocol (MCP), a local HTTP API, a Bubble Tea terminal UI, and plugins for Claude Code, Codex, OpenCode, Gemini CLI, and Obsidian. The architecture is a modular monolith: a single Go binary that can run as a CLI, background daemon, or HTTP server. Core data flows involve agents saving observations (memories) via MCP tools, which are stored locally and optionally replicated to a cloud backend. The cloud component includes a sync manager, authentication (managed tokens, project grants), a browser dashboard (HTMX + templ), and an admin API. The repository also includes a diagnostic/repair framework, project detection, and a self-test suite. Although primarily an application, it contains some data engineering patterns (chunk-based sync, mutation journal, audit logs) that are more typical of data pipelines. The codebase is well-structured with extensive tests, but its complexity and tight coupling of internal packages limit the reusability of individual components outside the project.
no-neck-pain.nvim is a Neovim plugin that centers the focused buffer in the middle of the screen by creating empty side buffers. It provides a non-opinionated, highly configurable zen-like editing experience without the intrusive UI changes typical of other 'distraction-free' plugins. The plugin manages window layout across multiple tabs, supports splits/vsplits, and integrates with popular file trees (NvimTree, Neo-tree), dashboards (alpha, snacks), and other tools like undotree, neotest, nvim-dap-ui, outline, and aerial. The architecture is modular Lua with clear separation into configuration, state management, UI creation, color handling, and utility modules. The core logic revolves around dynamic layout scanning via Neovim's winlayout API, event-driven re-initialization, and per-tab state tracking.
Prefire is a Swift developer tool that scans SwiftUI source files, extracts `#Preview` macros and `PreviewProvider` declarations, and generates automated snapshot tests plus an interactive "Playbook" component catalog. It is not a data project: it is a CLI/code generator with a runtime library and SwiftPM/Xcode build-tool plugins. The real pipeline is: a build plugin invokes the `prefire` binary with target/source/config arguments; the binary parses sources using SwiftSyntax for `#Preview` macro ranges and a Sourcery fork for `PreviewProvider` types; a fingerprint-based cache avoids re-parsing unchanged files; Stencil templates (one for snapshot tests, one for playbook models) render generated Swift code; snapshot tests run against swift-snapshot-testing and the bundled Prefire runtime, while `PlaybookView` renders the generated `PreviewModels` inside an app.
This is an OpenCode plugin that provides isolated branch workspaces using devcontainers or git worktrees. It enables developers to work on multiple branches simultaneously with full container isolation (devcontainers) or lightweight filesystem isolation (worktrees). The plugin manages the entire lifecycle: creating clones or worktrees, allocating unique ports from a configurable range, copying gitignored secrets, and intercepting bash commands to run inside the target container or worktree directory. It also offers session state persistence, background job tracking for non-blocking container starts, and unified workspace management with cleanup of stale workspaces. The codebase is well-architected with clean separation into core modules (clones, config, devcontainer, git, jobs, paths, ports, worktree, workspaces) and a main plugin entry point that registers tools and bash interception hooks. It uses Node.js built-in test runner with comprehensive unit and integration tests. The plugin demonstrates strong engineering practices including file-based locking for concurrency, atomic writes, security-conscious command construction (shell quoting, Docker filter sanitization), and support for both Docker and Podman runtimes.
This repository provides a Vite plugin (`@defstudio/vite-livewire-plugin`) that enables hot reload for Laravel Livewire components without a full page refresh. It watches for changes in Blade templates and Livewire PHP classes, then sends a custom event to the browser. The injected client-side script listens for this event and calls `$refresh` on all Livewire components, preserving their state. The plugin also supports optional CSS/JS refresh, an opt-in checkbox for toggling hot reload, and configurable watch patterns. It is a single-file TypeScript plugin with a robust configuration parser that accepts strings, arrays, or objects. The code is well-structured, includes comprehensive tests, and follows modern Vite plugin conventions. The repository is actively maintained with recent releases and CI workflows, though the last commit date appears anomalous (future date).
Kopy is a Kotlin compiler plugin that generates an ergonomic DSL for immutable updates on data classes. It adds `copy`, `set`, `update`, and `updateEach` functions to data classes annotated with `@Kopy`, enabling deep nested property changes without manual `copy` chains. The plugin uses `kotlin.concurrent.atomics.AtomicReference` for thread-safe snapshots and integrates as a Gradle plugin. The codebase is a multi-module Gradle project with a compiler plugin module (`kopy-compiler`), a Gradle plugin module (`kopy-gradle-plugin`), a runtime annotations module (`kopy-runtime`), and a configuration enums module (`kopy-args`). It includes extensive test data for FIR and IR transformations, covering diagnostics, box tests, visibility, inheritance, serialization, and edge cases. The project is actively maintained, with a well-structured architecture and high test coverage.
claude-mem is a persistent memory system for AI coding assistants, primarily targeting Claude Code but also supporting Codex, Cursor, Windsurf, OpenClaw, and other platforms. It captures observations, summaries, and user prompts from coding sessions via lifecycle hooks (SessionStart, PostToolUse, etc.), stores them in SQLite (local) or Postgres (server), and injects relevant context into future sessions to maintain continuity across agent interactions. The system operates as a background worker daemon (Bun) or a multi-user server (Express + BullMQ + Valkey) with API key authentication, team/project scoping, and rate limiting. Architecturally, claude-mem is a hybrid of a CLI plugin and a standalone server. The CLI component integrates into IDEs via hook scripts and MCP servers, while the server component provides REST APIs for memory management, search, and cloud sync. It features a dual-storage backend (SQLite for local, Postgres for server) with vector search via ChromaDB and full-text search via SQLite FTS5. The system includes a React-based viewer for browsing memory feeds, telemetry (opt-out PostHog), and a Cloudflare Workers-based sync hub for cross-device synchronization. The codebase demonstrates strong engineering practices with well-abstracted components (search strategies, provider abstraction, atomic file operations, telemetry scrubbing) but carries some technical debt from its dual-runtime evolution (legacy worker vs. server-beta) and extensive Windows-specific workarounds. It is actively maintained with frequent releases and comprehensive test coverage.
This repository is a curated collection of tips, scripts, and a Claude Code plugin (dx) that enhances developer workflows with Claude Code. It is primarily a knowledge base and tooling repository, not a standalone application. The core deliverable is the dx plugin, which bundles skills for GitHub Actions debugging, conversation half/quarter-cloning, context handoffs, Reddit/HN research, private GitHub search, and version checks. The repository also includes a custom status line script (context-bar.sh), a setup script for recommended configurations, and extensive markdown content documenting 49 tips for using Claude Code effectively. The architecture is a mix of bash scripts, skill definitions (markdown with YAML frontmatter), and a plugin manifest. The standout component is the half-clone-conversation.sh script, a 400+ line bash utility that clones Claude Code conversations with careful edge-case handling, cross-platform support (macOS, Linux, Windows Git Bash), and a comprehensive 19-test suite. The repository demonstrates high craftsmanship in its bash scripting, thorough testing, and detailed documentation of workarounds for platform limitations (e.g., Reddit's blocking, GitHub's private repo search).
This repository implements **flutter_blue_plus**, a Flutter plugin library for Bluetooth Low Energy (BLE) communication across Android, iOS, macOS, Linux, and Web platforms. It provides a unified Dart API to perform BLE scanning, connect to devices, discover GATT services/characteristics/descriptors, read/write data, subscribe to notifications, and manage bonding and MTU negotiation. The architecture follows Flutter's federated plugin pattern: a common platform interface package defines abstract contracts and serialization messages, while separate packages implement the native side using MethodChannel (Android Java, iOS/macOS Objective-C, Linux Dart/BlueZ, Web JS interop). The library is designed for production use, featuring per-device operation queues via a mutex factory, robust error handling, streaming state updates, and conveniences like automatic subscription cleanup on disconnect. It is commercially licensed, requiring a paid license for commercial use. The codebase is well-structured with clear separation of concerns, though it carries a moderate amount of deprecated API surface and some platform-specific workarounds. The example app demonstrates all major features and serves as both a test harness and reusable UI pattern for BLE exploration.