Flowcraft is a workflow orchestration framework for building, executing, and monitoring durable workflows. It provides a type-safe, composable API for defining workflows as directed graphs of nodes and edges, supporting both programmatic (fluent) and declarative (JSON) definitions. The framework enables progressive scaling from in-memory execution to distributed systems via adapters for message queues and cloud services, with built-in support for patterns like retries, timeouts, human-in-the-loop, batch processing, and subflows. Key architectural pieces include a dependency-free core runtime, a sophisticated context tracking system for efficient state persistence, a plugin-based adapter architecture for distributed execution, and LLM tooling for workflow introspection and control via natural language.
This repository is a TypeScript monorepo of 40+ markdown-it plugins, published as individual @mdit/plugin-* npm packages plus the @mdit/helper utility package. It is a developer-facing library ecosystem, not an application: each plugin extends markdown-it with additional Markdown syntax and rendering behavior, including alerts, containers, tabs, footnotes, task lists, definition lists, abbreviations, emoji, math (KaTeX and MathJax with full and slim variants), diagrams (PlantUML/UML), image controls (size, lazyload, mark), advanced links, attribute syntax, icons, layout directives (flex/grid/columns), file include/snippet (Node-only, file-system based), and text semantics (sub, sup, mark, ins, ruby, spoiler). The plugins are consumed primarily by static-site generators such as VuePress/VitePress and by any Node or browser pipeline that renders Markdown via markdown-it.
Jetpack Android Starter is a production-ready template for modern Android development built on Jetpack Compose and clean architecture principles. It provides a comprehensive foundation with feature modules for authentication, home, profile, and settings, integrated with Firebase for authentication, Firestore, and Crashlytics. The architecture follows a two-layer UI/Data pattern with Repository pattern, Hilt dependency injection, Room for local storage, DataStore for preferences, and WorkManager for background synchronization. UI is built with Compose Material 3, featuring custom reusable components and type-safe navigation using Kotlin Serialization. The template includes CI/CD via GitHub Actions, automated dependency updates, documentation generation, and performance optimizations like baseline profiles. It demonstrates strong engineering practices with clear separation of concerns, testable architecture, and reusable patterns that solve common Android development challenges.
This repository provides safe, idiomatic Rust bindings to the MuPDF C library (Artifex Software), enabling programmatic reading, rendering, creation, and editing of PDF and other document formats. It is a library crate organized as a Cargo workspace with three sub-crates: `mupdf` (high-level API), `mupdf-sys` (FFI layer that compiles MuPDF from source), and optional font crates (`mupdf-fonts-droid`, `mupdf-fonts-noto`, `mupdf-fonts-sil`). The architecture is a classic FFI wrapper: `mupdf-sys` exposes raw C functions via `bindgen`, while `mupdf` provides safe Rust types (`Document`, `Page`, `Pixmap`, `PdfDocument`, `Shape`, etc.) with automatic resource management, error handling, and thread-safety checks. Key entry points include `Document::open()` for loading files, `Page::to_pixmap()` for rasterization, `Shape` for programmatic drawing, and `PdfDocument` for PDF-specific operations like annotation manipulation, form filling, and incremental saving. The library supports extensive feature flags (e.g., `js`, `xps`, `svg`, `tesseract`, `docx-output`) that control which MuPDF subsystems are compiled. The codebase demonstrates high craftsmanship through its safe wrapper patterns, builder-style APIs (e.g., `Shape`), extensible trait design (`FontLoader`, `NativeDevice`), and comprehensive test coverage including snapshot-based rendering tests and link extraction round-trip tests. It is not a data research project; it is a software library for document processing.
specutils is an Astropy-affiliated Python library providing a unified framework for representing, reading, writing, analyzing, and manipulating 1D astronomical spectra. Its architecture centers on the `Spectrum` class, which encapsulates flux, spectral axis (via WCS), uncertainty, and mask data. The library is structured as a monolith with well-defined subpackages for spectra, IO, analysis, manipulation, and fitting, heavily leveraging the Astropy ecosystem (units, modeling, WCS, NDData) and GWCS. In production, specutils serves as a critical bridge between raw astronomical data and scientific analysis. Its primary data flow involves ingesting spectra from dozens of survey-specific FITS formats (SDSS, JWST, DESI, APOGEE, HST, etc.) via a plugin-based IO registry, transforming them into a standard `Spectrum` object, applying analysis (line flux, centroid, FWHM, template matching) or manipulation (resampling, smoothing, region extraction), and optionally writing results. The library handles complex real-world data concerns including uncertainty propagation, mask handling, and multi-dimensional flux arrays. The codebase demonstrates high craftsmanship through several genuinely reusable components: the `QuantityModel` wrapper for unit-aware Astropy modeling, the `SpectralRegion` class with interval algebra (union, intersection, XOR), the `data_loader` decorator pattern for extensible IO, and a family of resampling algorithms using the Strategy pattern. While some survey-specific loaders are inherently fragile due to format evolution, the core abstractions are robust, well-tested, and exhibit non-obvious domain expertise. Maintenance is active with recent commits and modern dependency pinning, resulting in low technical drift.
This is a multi-platform TypeScript library for programmatically controlling Elgato Stream Deck devices and the Corsair Galleon K100 keyboard. It provides a unified API over three distinct transport layers: USB HID via `node-hid` (Node.js), WebHID (browser), and TCP/IP (network-connected devices like the Stream Deck Studio and Network Dock). The architecture decouples hardware-specific details behind a service-oriented core: `PropertiesService`, `InputService`, `ButtonsLcdDisplayService`, `LcdSegmentDisplayService`, and `EncoderLedService` are injected into a `StreamDeckBase` class, allowing support for 15+ models (Original, Mini, XL, Plus, Plus XL, Neo, Pedal, Studio, etc.) with minimal duplication. Image processing is modular, with pluggable encoders (JPEG, bitmap) and header generators for different firmware generations. The `PreparedBuffer` pattern enables pre-computing and caching of image writes. The codebase is well-structured as a monorepo with separate packages for core logic, Node.js transport, WebHID transport, TCP transport, and a browser demo. Unit tests use Jest with snapshot testing for HID report payloads. The library is actively maintained, with recent commits, CI pipelines, and automated release-please workflows.
User Switching is a mature WordPress plugin providing instant switching between user accounts. The plugin allows administrators to switch to any user account from the Users screen, switch back to their original account, and 'switch off' (temporarily log out while retaining the ability to switch back). It integrates deeply with WordPress core authentication, using cookies to track originating users and session tokens to manage state. The code is entirely contained in a single main file (`user-switching.php`) that implements a singleton class with hooks and filters. It includes comprehensive integration tests (PHPUnit) and acceptance tests (Playwright) covering switching flows, capabilities, session handling, and command palette features. The plugin also provides explicit integration points for WooCommerce, BuddyPress, bbPress, and the WordPress REST API and command palette. The architecture is typical of a well-crafted WordPress plugin: event-driven via hooks, with clear separation between utility functions and the main class. It is not a library or framework but a self-contained plugin that can be dropped into any WordPress site meeting its requirements.
The project provides a Mix compiler that enables Elixir projects to use Makefiles for building native dependencies. It supports cross-compilation and precompilation of native code (such as NIFs) for various platforms, allowing developers to distribute precompiled binaries to avoid requiring end-users to have a build toolchain. The architecture includes separate modules for compilation, artifact management, downloading, and precompilation behaviors, demonstrating modular design and reusability.
EvoTrees.jl is a production-grade gradient-boosted decision tree (GBDT) library written entirely in Julia. It implements a histogram-based tree-growing algorithm with support for multiple loss functions (MSE, LogLoss, Poisson, Gamma, Tweedie, MAE, Quantile, MultiQuantile, credibility losses, Gaussian/Legistic MLE, and LambdaRank for ranking). The library provides both CPU (multi-threaded) and GPU (CUDA, ROCm, Metal via KernelAbstractions) backends, enabling efficient training and inference on diverse hardware. It is designed as a composable Julia package with a clean module structure, MLJ integration for seamless use within the Julia machine learning ecosystem, and serialization/deserialization via BSON for model persistence. At its core, the system implements a loss-type hierarchy (`src/loss.jl`) where each loss is an abstract type with inline scalar gradient/hessian functions that are shared across CPU and GPU code paths. The training algorithm binarizes features into 8-bit histograms, computes gradient statistics per bin, and finds optimal splits via gain scanning. Multi-target objectives (e.g., location/scale MLE) and monotonic constraints are supported. The library also includes SHAP value computation (Linear TreeShap), feature importance, tree plotting (Makie recipe), and a comprehensive callback system for evaluation and early stopping during training. While primarily a library for embedding in larger ML workflows, EvoTrees.jl also comes with an extensive collection of benchmarks, tutorials, and research experiments (credibility loss, multi-quantile, ranking). It is not a data-pipeline or analytics project but a well-architected software library that demonstrates advanced patterns in Julia numerics, GPU programming, and loss function abstraction. The repository is actively maintained, with regular commits, CI/CD, and comprehensive documentation built with Documenter.jl and Vitepress.
This is a Blender add-on for renaming various types of data in 3D scenes, including objects, materials, bones, collections, and other data blocks. It provides a comprehensive set of renaming tools accessible through Blender's interface, allowing users to add prefixes/suffixes, perform search and replace operations, transform text case, apply sequential numbering, and trim strings from names. The add-on features a variable system that enables dynamic naming patterns using placeholders like @n for numbers, @f for the current filename, @d for date, and others. It includes intelligent conflict handling that detects when Blender would automatically modify a requested name due to existing duplicates, and either skips the renaming or finds an alternative name rather than accepting Blender's default behavior which could cause confusion in batch operations. Architecturally, the add-on follows Blender's standard extension structure with clearly separated modules for operators (the actual renaming functions), user interface components, preferences, and utilities. It employs performance optimizations such as caching collection membership and object ownership relationships to avoid repeated lookups during batch renaming operations. The tool provides real-time feedback through popup windows showing what was renamed, what was skipped due to conflicts, and any warnings. The project maintains active development with regular updates and testing across multiple Blender versions (from 4.2 to 5.1 as shown in CI workflows). It includes a comprehensive test suite that validates functionality and performance benchmarks to ensure operations scale efficiently with scene complexity. The combination of thoughtful design, attention to edge cases, and ongoing maintenance makes it a reliable tool for managing naming conventions in Blender projects.
This repository contains Roslyn diagnostic analyzers and code fix providers for the xUnit.net test framework (v2 and v3, including Native AOT). It enforces best practices, detects common anti-patterns (e.g., misuse of Assert methods, serialization issues with theory data, incorrect async handling, and structural problems in test classes), and provides automated code fixes. The codebase is organized around version-aware context classes (XunitContext) that resolve xUnit types and version-specific behavior, allowing a single analyzer to target multiple xUnit versions. It includes a rich test suite using a custom CSharpVerifier base class, building on Microsoft.CodeAnalysis.Testing. The infrastructure is well-abstracted with reusable base classes for analyzers, suppressors, and fix providers, and the project is packaged as a NuGet package automatically referenced by xUnit projects.
This repository is a pure, generic microformats2 parser for PHP that makes HTML as easy to consume as a JSON API. It provides both functional and object-oriented interfaces for parsing microformats2 structured data from HTML documents. The parser handles all standard microformats2 property types (p-, u-, dt-, e-), implements implied property parsing, resolves relative URLs according to HTML and URI specifications, and includes backward compatibility for classic microformats markup. It features a robust test suite and follows PSR-0 autoloading standards.
Tailcall is a Rust library that provides stack-safe tail calls on stable Rust. It uses a lightweight trampoline runtime (Thunk) along with a proc-macro attribute `#[tailcall]` that transforms recursive functions. The macro can lower simple self-recursive functions into a direct loop (zero overhead), while more complex cases (mutual recursion, borrowed state) fall back to a type-erased fixed-size closure runtime. The core runtime is `no_std` compatible and uses inline storage for closures without heap allocation. The workspace includes the main `tailcall` crate (runtime), `tailcall-proc-macro` (proc-macro implementation), and integration test crates for both `std` and `no_std` environments, plus benchmarks demonstrating performance competitive with handwritten loops.
hie-bios is a Haskell library and CLI tool that manages the configuration and initialization of GHC API sessions for IDE tools like haskell-language-server. It finds and loads a 'Cradle' configuration from a `hie.yaml` file or via implicit detection (e.g., stack.yaml, cabal.project), then obtains the necessary GHC compiler flags by invoking build tools (cabal, stack, or a user-supplied script). It supports multiple cradle types (cabal, stack, bios, direct, multi, none) and handles the full lifecycle: locating the project root, parsing configuration, running build tools with wrapper scripts to capture flags, caching interface files, and setting up GHC's DynFlags and targets. The architecture is modular, with clear separation between config parsing, cradle resolution, process execution, and GHC session management. The code is well-structured, uses modern Haskell patterns (monad transformers, CPS for temporary files), and has an extensive test suite covering various project layouts and tool combinations. Key reusable components include the process utility module (HIE.Bios.Process) for running commands with temp-file outputs and caching, and the GHC version compatibility layer (HIE.Bios.Ghc.Gap).
Octopool is a production-grade GitHub API relay and caching proxy, deployed as a Cloudflare Worker with a companion Go CLI. It pools multiple GitHub identities (PATs, GitHub App installations) to share API quota, caches responses in D1 and edge cache, and applies string-rewrite policies to protect sensitive data. The CLI acts as a drop-in `gh` shim, routing eligible read commands through the relay before falling back to native `gh`. The system also supports token-free transports (public web pages, raw content, Git smart HTTP) to minimize API consumption. Architecture includes Durable Objects for coordination (pool identity selection, cache-fill ownership, policy revisioning), D1 for persistent cache and audit, and edge cache for low-latency reads. The codebase is dual-language (TypeScript for Worker, Go for CLI) with extensive unit and e2e tests, CI/CD, and a dashboard for monitoring.
ClawPDF is a zero-dependency PDFium WebAssembly library and CLI for Node.js and browsers. It extracts text, renders pages to RGBA bitmaps, and produces PNG bytes without runtime dependencies, native addons, or postinstall scripts. The library supports multiple input sources (file paths, URLs, Blobs, byte arrays) with configurable HTTP fetch timeouts and size budgets, password-protected PDFs, and text-first extraction with bounded image fallback. The CLI provides text extraction, JSON output, page rendering, and inline terminal image display for Kitty and iTerm2 protocols. The architecture is modular with clean separation of concerns: input normalization, engine lifecycle, document/page abstractions, render size resolution, PNG encoding, and extraction orchestration. The codebase demonstrates high craftsmanship with reusable components like the standalone PNG encoder and terminal inline image renderer.
Claw Code is a production-grade CLI application for AI-assisted coding, built primarily in Rust with a complementary Python parity workspace. It serves as a local agent harness that integrates with multiple LLM providers (Anthropic, OpenAI, xAI, DashScope, local OpenAI-compatible), manages conversational sessions, enforces workspace-scoped permissions, supports the Model Context Protocol (MCP) for external tool integration, and provides a plugin system for lifecycle hooks. The architecture is a multi-crate Rust workspace under `rust/`, with the main binary `claw` (from `rusty-claude-cli`), a core runtime crate (`runtime`) handling session persistence, permission enforcement, conversation loops, and MCP plumbing; an API client crate (`api`) for provider dispatch and streaming; a plugins crate for lifecycle management; and supplementary crates for tools, telemetry, and a workspace RAG service. The Python workspace (`src/`) is explicitly a non-production porting/parity mirror of a TypeScript archive, used for surface mapping and audit. The Rust code is well-structured, extensively tested, and demonstrates strong engineering practices—clean abstractions, reusable components, and defense-in-depth security (path validation, read-only command heuristics, approval tokens). Notable highlights include a permission enforcer with workspace boundary enforcement, a modular MCP client supporting multiple transports, a plugin system with manifest validation, and a session store with JSONL rotation and workspace fingerprint isolation. The repository is actively maintained (CI workflows, issue triage, recent commits) and shows low technical drift, though some modules have `#[allow(dead_code)]` annotations and the parity workspace adds maintenance overhead.
This repository is the official open-source companion to Anthropic's Claude Code—an agentic AI coding assistant that operates in the terminal. It is not the core Claude Code binary (distributed separately via npm/brew/install scripts), but rather the plugin ecosystem, example configurations, CI automation scripts, and infrastructure-as-code templates that extend and support the tool. The repo contains 13 first-party plugins (e.g., security-guidance, code-review, feature-dev, commit-commands, pr-review-toolkit, hookify, plugin-dev), each defining hooks, commands, agents, and skills that integrate with Claude Code's extensibility framework. It also provides production-grade Terraform modules for deploying a Claude Code Gateway on AWS (ECS Fargate + RDS + Bedrock) and GCP (Cloud Run + Cloud SQL + Vertex AI), along with enterprise MDM settings (macOS plist/mobileconfig, Windows ADMX, Intune scripts) and managed settings templates. A suite of GitHub Actions workflows handles automated issue triage, duplicate detection, lifecycle management, and code review, all using Claude Code itself as the automation engine. The repository is primarily a configuration and extension catalog rather than a standalone application; its value lies in demonstrating the plugin architecture and providing reusable patterns for AI-assisted development workflows.
This is the official Gemini CLI by Google, a terminal-based AI assistant that brings Gemini models to the command line. It is a large TypeScript monorepo with packages for the CLI (interactive UI built on Ink/React), core agent logic (context management, tool execution, routing, policy enforcement), SDK for programmatic agent sessions, A2A server for agent-to-agent communication, and supporting tooling (devtools, test utilities, caretaker agent for automated issue triage). The CLI supports slash commands, extensions (hooks, MCP servers, themes), skills, sandboxed execution, multiple authentication methods (OAuth, API key, Vertex AI), and rich terminal features like themes, keybindings, and mouse support. It includes an extensive evaluation framework for behavioral testing of agent capabilities. The architecture is modular with clear separation between UI, core agent loop, and extensibility layers, though the monorepo size introduces some coupling and test fragility.
The agent-skills repository provides a framework for enhancing AI coding agents with structured engineering workflows called 'skills'. Each skill encodes senior engineer best practices across the software development lifecycle (Define → Plan → Build → Verify → Review → Ship) through opinionated, process-driven guidelines. Skills are invoked automatically based on context or via slash commands and integrate with multiple AI agent tools (Claude Code, Gemini CLI, Antigravity, Codex, etc.) through tool-specific adapters. The system includes a meta-skill for dynamic skill routing, reusable agent personas for specialized tasks, and validation infrastructure to ensure consistency and prevent drift. It is designed to prevent agents from skipping critical steps by mandating concrete evidence (tests, build output) rather than relying on subjective assessments.