Bagisto is a production-ready open-source eCommerce platform built on Laravel with a modular monolith architecture. It provides a complete admin panel and storefront for managing multi-channel, multi-locale, multi-currency online stores. The system supports a wide range of product types (simple, configurable, bundle, grouped, downloadable, virtual, booking), payment gateways (Stripe, PayPal, Razorpay, PayU, PhonePe, PayGlocal), marketing promotions (cart rules, catalog rules), full-page caching, Elasticsearch integration, GDPR compliance, EU withdrawal management, RMA (returns), data import/export, and AI-powered features (MagicAI). The architecture is event-driven with listeners for cache invalidation, notifications, and indexing. The admin panel uses Vue 3 components with Blade templates, while the storefront is built with Tailwind CSS and Vue. The codebase is organized into ~40+ packages under packages/Webkul/, each with its own models, repositories, migrations, translations, and tests. Key entry points include the admin routes (packages/Webkul/Admin/src/Routes/web.php), shop routes (packages/Webkul/Shop/src/Routes/), and the installer wizard. The system relies on MySQL, Redis, Elasticsearch, and various external payment/shipping APIs. The core framework (Concord) provides facades for core services, ACL, menu, system config, and Elasticsearch. The DataGrid system offers a reusable abstraction for listing and filtering entities across the admin panel. Notable engineering highlights include the CurrencyFormatter trait for locale-aware currency display, the MediaFileName helper for safe file upload handling, the ForgetsPages trait for full-page cache invalidation, and the DynamicMailTransport for configurable email delivery. The event-driven architecture with listeners and the repository pattern are consistently applied across all modules.
CodeGraph is a Python command-line tool that performs static analysis on Python source code to generate dependency graphs. It parses Python files to extract functions, classes, and import statements, then builds a graph showing how these entities depend on each other. The tool outputs an interactive HTML visualization (using D3.js by default) or can export the data to CSV or print it to the console. The architecture is modular, consisting of a parser (using Python's tokenize module), a core module that builds the dependency graph, utility functions for file discovery, and a visualizer that supports both D3.js (interactive) and matplotlib (legacy) backends. The tool does not execute the code being analyzed, making it safe and fast for large codebases. Key strengths include a robust parser that handles various import styles and class inheritance, and a flexible visualization system that provides features like search, collapsing/expanding nodes, and detailed tooltips. The project is actively maintained with comprehensive tests and supports multiple Python versions.
AutoRAG is a production-grade, privacy-focused personal AI assistant and retrieval-augmented generation (RAG) agent. It provides a local-first search and answer engine that indexes federated datasources (Slack, Discord, KakaoTalk, GitHub, email, Obsidian, RSS, cloud drives, and more) via external CLI connectors, without migrating data. The system exposes a CLI, MCP server, TypeScript API, and a TUI (Pi interactive host), and powers a separate desktop Electron app. Its architecture is modular: a configurable agent (`AutoRAGAgent`) orchestrates multiple retrieval methods (BM25, semantic vectors, hybrid RRF, file-name search, web search), document parsing (PDF, DOCX, HWP, images via OCR), embedding (local Qwen3 model or external APIs), reranking (OpenRouter/Dazzi), and evidence judgment. A peer-to-peer layer (SimpleX) enables policy-controlled file sharing with injection and PII gates. The repository also contains a legacy Python codebase (`legacy/`) focused on automated RAG pipeline evaluation and QA dataset generation, which is in maintenance mode but still provides reusable metrics and pipeline components. This is a hybrid project where the dominant character is a modern TypeScript application, with significant data/research heritage in the legacy Python portion.
PyGCL is a PyTorch-based library for Graph Contrastive Learning (GCL) that provides modular components for building GCL models. The library implements graph augmentation techniques, contrasting architectures, contrastive objectives, and negative sampling strategies. It features clean abstractions that separate concerns across different graph frameworks (PyG and DGL), standardized evaluation utilities, and comprehensive examples demonstrating usage. The architecture follows a modular design with distinct modules for augmentors, losses, models, evaluation, and utilities, allowing users to mix and match components to build custom GCL algorithms.
Beaneater is a Ruby client library for the beanstalkd work queue. It provides a simple, thread-safe interface to interact with beanstalkd servers, enabling job enqueuing, reservation, and management through tubes (queues). The library handles connection management with automatic retry and reconnection logic, supports job lifecycle operations (delete, bury, release, etc.), and includes a processor registration system for automated job handling with retry and error recovery. Communication with beanstalkd occurs via the native TCP protocol, and the library translates responses into Ruby objects using optimized struct conversions. Key features include timeout configuration, tube watching/waiting, and statistics introspection.
The UTCP-MCP Bridge is a multi-language implementation that exposes Universal Tool Calling Protocol (UTCP) tools as Model Context Protocol (MCP) tools, enabling MCP clients like Claude Desktop to discover and call any UTCP-registered tool. The system consists of MCP servers (in Node.js/TypeScript, Python, Rust, and a web-based implementation) that initialize a UTCP client, register providers from configuration, and expose standard MCP tools for tool management (register/deregister manuals, call tools, search tools, list tools, get tool info, and get required variables). The architecture cleanly separates MCP server concerns from UTCP client operations, with each language implementation following similar patterns but idiomatic to its ecosystem. The bridge handles MCP specification nuances like proper content block preservation for binary data and provides dynamic provider management through REST APIs in the web UI.
The official Buildkite CLI (`bk`) is a production-grade Go command-line client for the Buildkite CI/CD platform. It interacts with Buildkite's REST and GraphQL APIs to manage pipelines, agents, builds, jobs, clusters, secrets, teams, and more. The architecture follows a command-pattern with Kong-based parsing, a centralized factory for dependency injection, and a rich set of I/O primitives (spinners, pagers, confirmation prompts) that produce structured output (JSON, YAML, text tables). It includes advanced authentication flows (OAuth device/PKCE), token refresh, keyring-backed credential storage, and self-update capabilities. The codebase demonstrates strong engineering discipline with extensive parallel tests, mock HTTP servers, and a composable error handling framework.
CC Switch is a desktop application built with Tauri (Rust backend + React/TypeScript frontend) that serves as a unified management hub for multiple AI coding assistants, including Claude Code, Claude Desktop, Codex, Gemini CLI, Grok Build, OpenCode, OpenClaw, and Hermes Agent. Its core function is provider switching: it manages configurations, API keys, OAuth tokens, and MCP servers across these tools, and provides a local HTTP proxy that routes API requests to different AI providers with failover, circuit breaking, and usage tracking. The application also includes session management, skills/prompts synchronization, cloud sync (S3/WebDAV), deep link import/export, and a usage dashboard with cost tracking. The architecture follows a command-service-DAO pattern in Rust, with a React frontend using TanStack Query for state management, react-hook-form for forms, and shadcn/ui components. The proxy subsystem is particularly sophisticated, implementing format conversion bridges between different AI API protocols (Anthropic Messages, OpenAI Chat/Responses, Gemini), streaming transforms, thinking budget optimization, cache injection, and content encoding handling with bomb protection. The frontend is organized around per-app provider forms, a universal provider panel, and settings pages for proxy, MCP, skills, and usage. Key features include: 50+ provider presets for third-party API relay services, one-click provider switching with live config backup/restore, a local proxy with auto-failover and circuit breaker, session history browsing across supported apps, skills installation from GitHub repos, prompt management with per-app sync, and usage statistics with custom pricing. The application supports i18n (English, Japanese, Chinese) and runs on Windows, macOS, and Linux.
This is a Nuxt 3 module that integrates Cloudflare Turnstile, a privacy-focused CAPTCHA alternative. It provides a Vue component (`<NuxtTurnstile>`) for client-side rendering of the Turnstile widget, a composable (`useScriptCloudflareTurnstile`) for script loading via `@nuxt/scripts`, and a server-side utility (`verifyTurnstileToken`) for token validation in Nitro endpoints. The module automatically handles script injection, token refresh, and exposes a reset method. It also supports an optional validation endpoint at `/_turnstile/validate`. The architecture follows the standard Nuxt module pattern: `src/module.ts` registers components, composables, and server handlers. External dependencies include Cloudflare's Turnstile API, `@nuxt/scripts`, `@nuxt/kit`, `defu`, and `pathe`. The codebase is well-structured, typed, and includes end-to-end tests with Playwright.
This repository provides Python bindings for the BLAKE3 cryptographic hash function, using the official Rust implementation via PyO3. It exposes a single `blake3` class that mimics the Python `hashlib` API, supporting incremental hashing, keyed hashing, key derivation, extendable output (XOF), multithreading via Rayon, and memory-mapped file hashing. The core implementation is in `src/lib.rs`, which demonstrates careful handling of Python buffer protocol types (signed/unsigned bytes), GIL release for long operations, and interior mutability with `Mutex` for thread safety. An experimental C implementation in `c_impl/` provides a fallback for platforms without Rust support. The package is published on PyPI as `blake3` and includes comprehensive test vectors, type stubs, and CI for multiple platforms and Python versions (3.8 to 3.14, including free-threaded).
This repository contains a single Kotlin script, `deep-clean.main.kts`, which is a command-line tool for cleaning build caches and temporary files in Gradle and Android projects. The script provides options to clean local project directories (like 'build' and '.gradle'), remove IDE project files, and optionally clear global caches (Gradle, Maven, IDE settings) when the '--nuke' flag is used. It also kills related processes such as the Gradle daemon and ADB server. The script is built using the Clikt library for command-line argument parsing and features a set of well-designed helper functions for safe file operations (including dry-run, backup, and verbose modes). These helper functions, particularly the extension functions on File and Sequence<File> for deletion and backup, are well-crafted and could be reused in other projects with minimal modification.
Uno is a modular C++ solver for nonlinearly constrained optimization (NLP, QP, LP). It implements a unification framework that combines interchangeable algorithmic ingredients—constraint relaxation strategies, inequality handling methods, Hessian models (exact, quasi-Newton, identity, zero), inertia correction, subproblem solvers (QP/LP), and globalization mechanisms (line search, trust region, filter, funnel). The solver supports both sequential quadratic programming (SQP) and interior-point methods, and can be configured via presets that mimic established solvers like filterSQP and IPOPT. The architecture is a library with a main orchestration loop in `Uno.cpp`. The user defines the optimization problem through callback functions (objective, gradient, Jacobian, Hessian) via a C API, which is then wrapped by interfaces for AMPL, Fortran, Julia, and Python. Internally, the solver builds a regularized KKT system, delegates subproblem solves to external libraries (HiGHS, BQPD, HSL MA27/57/86, MUMPS, SPRAL), and applies globalization to ensure convergence. The codebase is heavily templated and uses expression templates for linear algebra, factory patterns for component selection, and runtime dynamic loading for optional dependencies. Key entry points include `uno_optimize()` (C API), `UnoSolverWrapper::optimize()` (Python), and the AMPL executable `uno_ampl`. The solver is used in research and production environments via JuMP.jl, CasADi, pyOptSparse, and OpenMDAO. External dependencies include BLAS/LAPACK, HSL (proprietary), MUMPS, SPRAL, HiGHS, BQPD, and AMPL ASL. The project is actively maintained with extensive CI, cross-platform builds, and a growing ecosystem of language bindings.
InfluxDB 3 Core (IOx) is a production-grade, open-source time-series database written in Rust. It ingests data via line protocol (HTTP/gRPC), stores it in Apache Parquet on object storage (S3, Azure, GCP, local), and serves queries via SQL (DataFusion), InfluxQL, and FlightSQL. The architecture is a single binary (`influxdb3`) that combines an HTTP server (port 8181), gRPC FlightSQL endpoint, CLI, and an embedded Python processing engine for plugin-based triggers. The system is designed for low-latency last-value queries, high-throughput writes, and efficient columnar storage with catalog persistence as versioned binary logs and snapshots on object store. The codebase is a large Rust workspace (~40+ crates) with a clear separation of concerns: core libraries (`core/`) for query planning, Arrow utilities, authorization, and metrics; server crates (`influxdb3_*`) for catalog management, write buffering, processing engine, and system tables. Key entry points include `influxdb3/src/main.rs` (CLI), `influxdb3_server/src/unified_service/` (HTTP/gRPC routing), and `influxdb3_catalog/src/` (catalog operations). The query engine is built on a forked DataFusion with custom physical optimizers (gapfill, dedup, sort, union) and InfluxQL planning. External dependencies include object store backends, protobuf for gRPC, and Python (via PyO3) for plugins. The repository demonstrates high craftsmanship with several reusable patterns: a versioned binary record format for catalog persistence with forward-compatibility guarantees, a hook-based cache system with S3-FIFO eviction, a generic copy-on-write repository pattern, and a run-optimized merge sort for streaming sorted data. However, the large workspace, forked DataFusion pinned to a commit, and multiple catalog versions (v1–v4) introduce maintenance drift risks. The codebase is actively maintained with extensive tests, benchmarks, and CI/CD.
vue-jsx-vapor is a high-performance Rust-based compiler and build toolchain that transforms JSX into optimized Vue 3 code, supporting both the traditional Virtual DOM and the experimental Vapor Mode (direct DOM manipulation). It provides a comprehensive set of developer tools including bundler plugins (Vite, Rollup, Webpack, esbuild, Nuxt, etc.), compile-time macros (defineComponent, defineModel, defineSlots, defineExpose, defineStyle), an ESLint plugin with custom rules, and a Volar integration for type-safe JSX. The compiler leverages the oxc parser in Rust to achieve 35-50x faster transformation compared to Babel-based alternatives. The repository is structured as a monorepo with packages for the Rust compiler, runtime helpers, macros, ESLint rules, and the main vue-jsx-vapor package that ties everything together. It includes extensive snapshot tests, benchmarks, ecosystem CI against popular UI libraries, and a documentation site with interactive tutorials.
This repository contains the full implementation of the Marginfi v2 protocol, a decentralized lending and borrowing platform on Solana. The core is an Anchor-based Rust smart contract that manages deposits, borrows, repays, liquidations, orders, and flash loans across multiple assets. It integrates with external lending protocols (Kamino, Drift, Solend, JupLend) via cross-program invocation (CPI), allowing users to use positions from those protocols as collateral. The codebase also includes a comprehensive CLI tool (p0-cli) for admin operations and user interaction, a standalone type crate for shared data structures, multiple mock programs for integration testing, and extensive test suites (Rust integration tests, TypeScript bankrun tests, and fuzz testing with Trident and libfuzzer). The architecture is a single Solana program with a rich set of instruction handlers, supported by off-chain tooling. The repository demonstrates high engineering craftsmanship with well-structured code, reusable components, and thorough testing across many edge cases.
remindctl is a macOS command-line interface for Apple Reminders, built with Swift and Apple's EventKit framework. It provides a comprehensive set of commands to create, edit, complete, delete, and search reminders, manage lists, set due dates, alarms, recurrence, location triggers, and URLs. The application is structured as a modular library (RemindCore) containing the core EventKit interaction and business logic, and a CLI executable (remindctl) that uses the Commander library for command routing and argument parsing. The CLI supports multiple output formats (JSON, plain, table, quiet) and includes advanced features like fuzzy list name resolution, stable numeric indexing across reordered fetches, and a custom async timeout pattern for system operations. The codebase demonstrates strong Swift concurrency practices (async/await, actors), comprehensive unit tests, and a well-documented release pipeline with signed notarized binaries and Homebrew distribution.
This is a Prometheus exporter for AVM Fritz! home network devices (routers, repeaters, mesh, DECT smart home) that exposes metrics via a TR-064 SOAP API and the AVM AHA HTTP API. Production deployment is a standalone Python service listening on a configurable address:port (default 127.0.0.1:9787) and registering Prometheus metric families (fritz_*). The architecture is a single-process monolith with a clean capability discovery framework: each metric group is defined as a FritzCapability subclass that declares its TR-064 requirements, probes the device at startup, and generates metrics on each scrape. Devices are configured via a YAML file or environment variables, validated through attrs-based data classes. The exporter handles multi-device mesh scenarios, connection timeouts, offline devices with retry logic, and a concurrent scrape lock to avoid deadlocks. It also includes a data donation mode (--donate-data) that collects all available TR-064 actions from a device, sanitizes sensitive fields, and uploads anonymously to a project endpoint — a hybrid feature supporting both operational monitoring and community-driven compatibility research. External dependencies include the fritzconnection library for TR-064, prometheus_client for metric exposition, defusedxml for secure XML parsing, PyYAML for configuration, and requests for HTTP transport.
CacheControl is a Python library that adds HTTP caching to the popular `requests` library. It ports the caching algorithms from httplib2, providing a transparent caching layer for HTTP sessions. The library intercepts HTTP requests and responses, caching responses based on standard HTTP caching headers (Cache-Control, Expires, ETag) and optional heuristic rules. It supports multiple cache backends including in-memory dictionary, file-based cache (with separate body storage for memory efficiency), and Redis. The architecture is modular: a `CacheController` implements the core caching logic (freshness calculation, conditional requests, cache invalidation), while `CacheControlAdapter` integrates with requests' transport adapter system. The library also provides a CLI tool (`doesitcache`) for testing caching behavior. It is well-tested, type-annotated, and follows modern Python packaging practices.
Apollo Router is a production-grade GraphQL gateway written in Rust. It accepts incoming GraphQL HTTP requests, composes a supergraph schema from subgraph schemas, plans queries across subgraphs, and executes them through a tower-style service pipeline. It supports federation, subscriptions, persisted queries, demand control, entity caching, progressive overrides, connectors, and defer. Configuration is YAML-based and can be managed via Apollo GraphOS Uplink for schema/config propagation.
FlexMeasures is a Flask-based energy flexibility management platform that ingests time-series sensor data, forecasts future values, schedules flexible assets (batteries, heat pumps, industrial processes) using linear optimization, and reports on performance. It provides a REST API (v3.0), a web UI with interactive charts, a CLI for data management, and background job queues (RQ) for forecasting, scheduling, and automation. The architecture is a multi-tenant web application with PostgreSQL, Redis, and optional Sentry monitoring. It features a plugin system for custom data generators (forecasters, schedulers, reporters) and automation handlers. The codebase is well-tested with extensive unit and integration tests, and follows modern Python practices (type hints, Marshmallow schemas, Click CLI).