Sqlvet is a static analysis CLI tool for Go projects that scans raw SQL queries embedded in Go source code to detect potential runtime errors at build time. It uses Go's SSA (Static Single Assignment) representation and call graph analysis to trace SQL query strings through function calls, handling common patterns like string concatenation, functions returning query strings, and pass-through functions like sqlx.Rebind. Extracted queries are parsed with a PostgreSQL grammar (via pg_query_go) to validate syntax, table/column names against a schema, and detect unsafe dynamic SQL that could lead to injection. The tool supports custom SQL function matchers via TOML configuration, allowing users to extend analysis to their own wrapper libraries. The architecture is a single Go binary with modular packages for configuration, schema parsing, query extraction, and SQL validation, with comprehensive test coverage including integration tests using real Go packages.
Constantine is a high-performance modular cryptography library implemented in Nim, with bindings for C, Rust, and Go. It provides production-grade implementations of elliptic curve arithmetic, pairings, BLS signatures, KZG polynomial commitments, and Ethereum-specific protocols (EIP-2537, EIP-4844, EIP-7594). The library is designed with constant-time operations to resist side-channel attacks, includes a custom lock-free work-stealing threadpool for parallel execution, and features hand-optimized assembly for x86 (ADX, BMI2) and ARM64. It also contains experimental GPU code generation (CUDA, AMD ROCm) via LLVM IR. The codebase is extensively tested against GMP, OpenSSL, and official Ethereum test vectors, and includes formal verification of field arithmetic via fiat-crypto. Despite its research components (Sage scripts, optimization papers), the dominant character is a reusable, production-oriented library for blockchain and zero-knowledge proof systems.
pytest-flask is a pytest plugin that provides fixtures and helpers for testing Flask applications. It is a library/plugin, not a standalone application. When installed, it registers itself via the `pytest11` entry point and automatically provides fixtures such as `client`, `client_class`, `config`, `live_server`, and `accept_*` headers. It also installs autouse fixtures that push a Flask request context during tests (so `url_for`, `session`, and `request` work without context managers), apply `pytest.mark.options` to the app config, and monkeypatch the app's response class to add JSON-aware comparison helpers. Architecturally, the plugin is a thin layer over pytest's fixture system and Flask's testing utilities. The core entry point is `src/pytest_flask/plugin.py`, which registers CLI options (`--live-server-port`, `--live-server-host`, `--live-server-wait`, `--no-start-live-server`, etc.) and markers. The `live_server` fixture (in `fixtures.py`) uses the `LiveServer` class (in `live_server.py`) to run the Flask app in a separate multiprocessing process, wait for TCP readiness via a socket probe, and shut down cleanly with SIGINT. The plugin depends only on pytest, Flask, and Werkzeug, plus the Python standard library. The codebase is small, well-typed, and thoroughly tested with a test suite that uses pytest's `pytester` to validate plugin behavior in isolated subprocesses. It supports Python 3.8-3.12 and is compatible with Flask 3.x. The project is actively maintained, with recent commits and CI covering multiple OSes and Python versions. It is not a data research repository; it is a developer tool for testing Flask applications.
Pybliometrics is a Python library that provides programmatic access to Elsevier's bibliographic databases (Scopus, ScienceDirect, and SciVal). It acts as a wrapper around the respective APIs, handling authentication, request throttling, caching, and response parsing. The library is designed for researchers and developers who need to extract bibliometric data for analysis, literature reviews, or academic workflows. The architecture follows a modular design with separate subpackages for each service (Scopus, ScienceDirect, SciVal) and a set of superclasses that encapsulate common functionality such as caching and HTTP request handling. Utility modules provide cross-cutting concerns like configuration management, parameter validation, and safe data extraction from JSON responses. This separation of concerns allows for maintainability and extension. Key features include automatic caching of API responses to reduce redundant requests, support for multiple API views (e.g., FULL, STANDARD) to control the level of detail returned, and the conversion of raw JSON data into structured Python objects (like namedtuples) for ease of use. The library also implements rate limiting and error handling specific to the Elsevier APIs.
Gutentag is a Ruby gem that provides tagging functionality for ActiveRecord models in Rails applications. It implements a many-to-many relationship between models and tags through a join table, with automatic handling of tag creation, normalization (downcasing by default), and persistence. The architecture follows Rails engine patterns with clean separation of concerns: core functionality in lib/gutentag.rb, ActiveRecord integration in lib/gutentag/active_record.rb, persistence logic in lib/gutentag/persistence.rb, and querying capabilities in lib/gutentag/tagged_with/. Key features include flexible querying with :any/:all/:none matching, dirty state tracking for tag names, and automatic cleanup of unused tags. The gem supports both Rails and standalone ActiveRecord usage, with comprehensive test coverage across multiple Ruby and Rails versions.
Whois is a Go library and command-line tool for performing WHOIS queries on domain names, IP addresses (IPv4 and IPv6), and ASNs. The library handles the complexity of WHOIS referral chains, server-specific quirks (such as those for ARIN and GoDaddy), and provides configurable options for timeout, dialer (for proxy support), and referral control. The CLI tool provides a user-friendly interface for querying WHOIS information and optionally outputting parsed JSON results using the whois-parser package. The project is actively maintained with regular commits, CI/CD workflows, and versioned releases.
FRDIntent is an iOS library designed to decouple view controller navigation through two primary mechanisms: an Intent-like system for internal app navigation (inspired by Android's Intent) and a URL router for handling deep links and app-to-app communication. The library separates these two concerns to avoid the limitations of tightly coupled navigation code, allowing developers to register view controllers against intent actions or URL patterns and launch them without direct dependencies. The architecture employs a protocol-oriented design where view controllers conform to protocols like `FRDIntentReceivable` to declare their ability to handle incoming intents. Core components include a singleton `FRDControllerManager` for managing internal navigation and a `FRDURLRoutes` singleton for processing incoming URLs. The URL routing system utilizes a Trie data structure (implemented in `Trie.swift`) for efficient pattern matching, supporting dynamic placeholders in URL paths (e.g., `/post/:postId`). Additionally, the library provides mechanisms for passing data between view controllers and handling results via callbacks, mirroring Android's `startActivityForResult` pattern. While the library demonstrates solid engineering practices—such as the reusable Trie implementation and clear separation of internal/external navigation concerns—it relies on singletons that may complicate testing and dependency injection. Recent updates (as indicated by the last commit in 2026) show the adoption of modern Swift concurrency features (`@MainActor`, `Task`), though some documentation and configuration files (like the README and podspec) exhibit inconsistencies regarding supported iOS and Swift versions. The inclusion of a demo app and unit tests aids in understanding and verifying the library's functionality.
xmlquery is a Go library for querying XML documents using XPath expressions. It provides functions to parse XML from various sources (string, file, URL, etc.), execute XPath queries, and manipulate the resulting node tree. The library features a caching mechanism for compiled XPath expressions to improve query performance and supports streaming parsing for large XML files to minimize memory usage. The architecture is modular, with separate concerns for parsing, querying, and node manipulation, and it relies on external dependencies for XPath expression handling and LRU caching.
Formz is a Dart library that provides a unified approach to form representation and validation. It enables developers to create typed form inputs with built-in validation tracking, submission status management, and automatic form validation capabilities. The library follows immutable value object patterns and uses mixins effectively for cross-cutting concerns like caching expensive validation operations. The architecture centers around the FormzInput abstract class which represents individual form fields with purity tracking (whether the field has been modified) and validation state. Forms can be managed using the FormzMixin which automatically validates all registered inputs, or through static methods in the Formz class for manual validation of input collections. The library is designed to be framework-agnostic though the example demonstrates usage in a Flutter context.
hermes-claude-auth is a runtime patching tool that enables hermes-agent to use Claude Code subscription credentials by bypassing Anthropic's server-side OAuth validation. It works through a Python import hook that monkey-patches hermes-agent's anthropic adapter to modify outgoing API requests with proper billing headers, system prompt restructuring, and Claude Code fingerprint matching. The tool consists of three main components: the core bypass logic (anthropic_billing_bypass.py) that implements complex request transformation, an import hook mechanism (sitecustomize_hook.py) for runtime patching, and installation/uninstallation scripts. The bypass handles billing header signing, system prompt relocation, tool name namespacing, Stainless header spoofing, tool pair repair, effort stripping for haiku models, temperature fixing for Opus 4.6, and account metadata mapping. It's designed to be idempotent and tracks upstream changes from the opencode-claude-auth project.
PocketRisu is a self-hosted AI roleplay chat platform, forked from RisuAI. It runs as a Node.js server with a Svelte 5 frontend, accessed via browser. The system supports multiple AI providers (OpenAI, Anthropic, Google Gemini, etc.) through a pluggable adapter pattern, and includes character management, lorebooks, plugins, MCP (Model Context Protocol) tools, translation, TTS, image generation, and a comprehensive data-driven settings system. Data is stored in SQLite with content-defined chunking for large values, and the architecture is a monolith with a client-server split: the server handles persistence, backup, asset manifests, and model job processing; the client handles UI, state management, and direct AI API calls (with optional server-side proxy). Key entry points include src/main.ts (client bootstrap), server/node/server.cjs (server), src/ts/storage/database.svelte.ts (central store), and src/ts/process/request/ (AI request handling). External dependencies include Node.js, SQLite, various AI provider APIs, MCP servers, and browser APIs (File System Access, IndexedDB). The codebase is well-tested with unit and integration tests, and features a sophisticated plugin system with sandboxed execution, a model preset registry with remote sync, and a chat delta sync mechanism for efficient data transfer.
CoBRA is a C++ library and CLI tool for simplifying mixed Boolean-arithmetic (MBA) expressions, commonly used in software obfuscation. It ingests expressions combining arithmetic (+, -, *) with bitwise (&, |, ^, ~) and shift operators and outputs a simplified equivalent form. The core engine uses a worklist orchestrator that coordinates 36+ passes, including signature-based transforms (CoB butterfly, ANF recovery), semilinear normalization with bit partitioning, decomposition (product, polynomial, template cores), ghost residual solving, and pattern matching. An optional Z3 verifier proves full-width equivalence. The tool can be used as a standalone CLI (`cobra-cli`), as an LLVM pass for automatic deobfuscation during compilation, or as a library (`cobra::Simplify()`). The codebase is well-structured with extensive test coverage (1195+ tests) and benchmark datasets from multiple research projects. While the core is tightly coupled internally, several generic utilities (Result type, profiling stubs, math helpers) are reusable independently.
IMDLBenCo is a comprehensive framework for image manipulation detection and localization (IMLD) research. It provides a unified interface for training, evaluating, and benchmarking deep learning models on standard forensic datasets. The architecture centers around a modular design with registries for models, datasets, and post-processing functions, enabling easy experimentation. Key components include dataset handlers with built-in augmentation and edge mask generation, a distributed training loop with mixed precision support, and evaluation metrics compatible with multi-GPU synchronization. The project serves as both a library for researchers and a reproducible benchmark for state-of-the-art IMLD methods.
This is a Next.js 16 starter template that combines Nextra 4 for documentation, Tailwind CSS 4 for styling, and comprehensive internationalization support. It provides a foundation for building documentation sites, blogs, and marketing landing pages with features like dark/light theme switching, responsive design, SEO optimizations, and pre-built UI components. The architecture centers around Next.js App Router with language-specific routing ([lang] segment), MDX-driven content in src/content/{lang}/, and a modular component system. Key strengths include a type-safe i18n system with compile-time checking, high-performance UI components like ScrollProgressBar (which uses requestAnimationFrame and lerp for smooth animation) and LinkPreview (which combines Radix UI hover cards with Framer Motion physics-based animations), and thoughtful separation of concerns between content, presentation, and logic. The template is actively maintained and stays current with modern web technologies.
tsbridge is a production-grade reverse proxy that exposes multiple backend services on a Tailscale tailnet using isolated tsnet nodes per service. It supports static TOML configuration and dynamic Docker label discovery, with hot-reload, graceful shutdown, Prometheus metrics, and a composable middleware chain (access log, whois identity lookup, request ID, body size limits, header sanitization). The architecture is a single Go binary that manages per-service tsnet.Server instances, each with its own state directory and listener. External dependencies are Tailscale (tsnet), Docker (optional), and Prometheus. The codebase demonstrates strong engineering practices: interface-based abstractions (TSNetServer, config.Provider), typed error hierarchy, secret resolution with redaction, debounced event handling with exponential backoff, and comprehensive unit and integration tests. It is actively maintained with CI/CD, dependabot, and regular dependency updates.
This repository implements a full 4G/5G telecommunications protocol stack (likely based on srsRAN) for software-defined radio applications. It provides implementations for User Equipment (UE), evolved Node B (eNB), gNB (next generation Node B), and Evolved Packet Core (EPC) network elements. The architecture follows a layered approach mirroring the telecommunications protocol stack (PHY, MAC, RLC, PDCP, RRC, NAS) with clear interfaces between layers. The system supports various SDR hardware platforms through a plugin-based radio frequency abstraction layer and can be used to build experimental 4G/5G networks for research and development. Key entry points include main.cc files in each application directory (srsenb, srsue, srsepc, srsgnb) and example applications in lib/examples/.
Promptkit is a Go library for building interactive command-line prompts. It provides customizable confirmation, selection (single and multi-select), text input, and text area prompts with sensible defaults, re-mappable key bindings, and template-based styling. Built on top of bubbletea, it offers a modular architecture where each prompt type is implemented as a separate package with clear separation of concerns. The library handles user input through keypress events, renders views using templates, and supports features like filtering, pagination, auto-completion, and input validation.
The AdvancedSharpAdbClient is a .NET library that provides a managed implementation of the Android Debug Bridge (ADB) protocol, enabling developers to interact with Android devices without relying on the external `adb.exe` executable. It offers a comprehensive suite of features including device connection management, shell command execution, application installation and uninstallation, file transfer via ADB sync service, screen capture, and device state monitoring. The library is designed with a strong emphasis on testability and loose coupling, utilizing interfaces and a factory pattern for dependency injection. Architecturally, the library is structured as a set of cohesive, loosely coupled components. Core communication is handled by `AdbSocket` (low-level TCP) and higher-level operations are exposed through `AdbClient`, `DeviceClient`, `PackageManager`, and `SyncService`. The library makes extensive use of interfaces to allow for easy mocking in unit tests and provides asynchronous counterparts for most operations to support non-blocking programming models. It targets a wide range of .NET frameworks (from .NET Framework 3.5 to .NET 10+) using conditional compilation and polyfills to maintain compatibility. The library demonstrates solid engineering practices through its use of the factory pattern for object creation, extension methods to enhance interface usability, and careful handling of binary data structures for statistics and framebuffer headers. Its comprehensive test suite, which includes mock implementations for various components, ensures reliability and facilitates safe evolution. While the broad target range introduces some complexity via conditional compilation symbols, the code remains well-organized and maintainable, reflecting a commitment to serving a diverse set of .NET applications requiring Android device interaction.
lv_font_conv is a Node.js-based command-line tool (with a web interface) that converts vector fonts (TTF, OTF, etc.) into bitmap fonts optimized for embedded systems, particularly the LVGL graphics library. It processes font files using opentype.js and an Emscripten-compiled FreeType WebAssembly module to extract glyph metrics and rasterize bitmaps. The tool supports subsetting, merging multiple fonts, kerning preservation, and configurable output formats (raw binary, LVGL-specific C arrays, and debug dumps) with adjustable bits-per-pixel (1-4) and optional RLE/XOR compression. The architecture follows a modular pipeline: argument parsing delegates to font data collection, which feeds into conversion logic that builds font tables (head, cmap, glyf, loca, kern) before format-specific writers produce the final output. Key entry points are the CLI script (lv_font_conv.js) and the web interface (web/index.html via parcel/bundler).
ngx-gantt is a mature Angular library for implementing interactive Gantt charts in web applications. It provides a comprehensive set of features including task visualization with drag-and-drop resizing, dependency linking, hierarchical data structures, virtual scrolling for large datasets, internationalization support, and extensive customization through templates. The library follows Angular best practices with a modular architecture, service-based design patterns, and utilizes modern Angular features like signals. It includes a robust test suite, documentation, and automated release processes.