e-virt-table is a high-performance, canvas-based virtual data table library designed for building spreadsheet-like grids in web applications. It renders tens of thousands of rows and columns using a custom canvas drawing engine with virtual scrolling, fixed columns, cell editing, selection, autofill, copy/paste, sorting, filtering, tree data, cell merging, and undo/redo. The library is framework-agnostic (usable in plain JS, Vue 2/3, and React) and is distributed as an npm package with UMD/ESM/CJS formats. Its architecture follows a modular event-driven pattern: a central Context class manages state and communication between subsystems (Selector, Editor, Database, Scroller, History, Validator, FinderBar, etc.), while a Paint module abstracts canvas drawing operations. The configuration surface is extensive (~100 options via CSS variables and a Config object), enabling deep customization of appearance and behavior. The repository also includes a bilingual VitePress documentation site with hundreds of interactive examples, as well as a dev playground and a suite of system-level tests for border rendering and scrollbar modes.
QtKeychain is a cross-platform Qt library for securely storing passwords and secrets using platform-native keychain services. It provides a unified QKeychain::Job API (ReadPasswordJob, WritePasswordJob, DeletePasswordJob) that delegates to the appropriate backend: macOS/iOS Keychain, Windows Credential Store (or CryptProtectData), Linux via KWallet, libsecret, or GNOME Keyring, Android Keystore, Haiku's KeyStore, and a WebAssembly bridge using the Credential Management API. The library is primarily a thin abstraction layer with clean separation of platform concerns, an internal job queue for serialization, and a fallback mechanism to store data in plaintext via QSettings when no secure backend is available. It supports Qt 5 and Qt 6, requires C++11/17, and bundles translation files for several languages.
Pyversity is a Python library for diversifying search and retrieval results through re-ranking. It implements five diversification strategies (MMR, MSD, DPP, COVER, SSD) via a unified API, with a focus on reducing redundancy in recommendation and search systems. The library is lightweight, depending only on NumPy, and includes a comprehensive benchmark suite for evaluating strategies on real-world datasets. Architecture-wise, it features a clean separation between the core API, strategy implementations, data types, and utility functions, enabling extensibility and ease of use. The benchmark suite provides a modular pipeline for running experiments, computing metrics (nDCG, MRR, ILAD, ILMD), and generating reports, demonstrating strong engineering practices in experimental design and reproducibility.
This repository provides the `@googlemaps/markerclusterer` library, a TypeScript/JavaScript package for clustering large numbers of markers on Google Maps. The core `MarkerClusterer` class extends `google.maps.OverlayView` and orchestrates a pluggable pipeline: an `Algorithm` (default: SuperCluster) groups markers into `Cluster` objects, and a `Renderer` (default: SVG circles) visualizes them. It supports both legacy `google.maps.Marker` and modern `AdvancedMarkerElement`. The library is distributed as an npm package (UMD, ESM, IIFE) and includes examples with real-world coordinate data. External dependencies include the Google Maps JavaScript API runtime, the `supercluster` library for spatial indexing, and `@googlemaps/jest-mocks` for testing. The architecture emphasizes extensibility through well-defined interfaces, making it suitable for integration into larger mapping applications.
This is the official Supabase SSR library (`@supabase/ssr`), a TypeScript package that provides `createBrowserClient` and `createServerClient` functions for using Supabase authentication in server-side rendering frameworks like Next.js, Remix, SvelteKit, and React Router. The library manages user sessions entirely via cookies, handling cookie chunking (splitting large JSON payloads across multiple cookies to respect browser size limits), base64url encoding for safe cookie values, and PKCE code verifier lifecycle. It exposes a `getAll`/`setAll` cookie interface that framework adapters implement to read and write cookies from request/response objects. The server client uses lazy session initialization and writes updated tokens back to cookies on auth state changes, with cache-control headers to prevent CDN caching of auth responses. The package also includes a `clearAuthCookiesAtScopes` migration helper for cleaning up stale cookies after domain/path changes. The codebase is well-tested, actively maintained, and follows modern TypeScript practices with strict mode and no top-level side effects.
libfsrefs is a C library for reading and parsing the Microsoft Resilient File System (ReFS). It provides a forensic-oriented API to access volume headers, checkpoints, metadata blocks, file entries, and directory structures. The library is read-only and currently supports ReFS version 1 (experimental). It includes a command-line tool `fsrefsinfo` that outputs volume details and can generate bodyfile-format timelines for digital forensics. The architecture follows the libyal ecosystem pattern: layered parsing with abstractions for file I/O (libbfio), error handling (libcerror), and string encoding (libuna). The codebase is well-structured with extensive unit tests, OSS-Fuzz integration, and cross-platform build support via autotools and MSVC. While the library is not intended as a standalone application, it is a robust foundation for forensic tools that need to analyze ReFS volumes.
jinzhu/now is a lightweight, zero-dependency Go library for time manipulation. It provides comprehensive functions to compute the beginning and end of various time units (minute, hour, day, week, month, quarter, year, half-year), parse flexible date/time strings into Go `time.Time` values, and handle configurable week start days (e.g., Monday vs Sunday) and time zones. The core pattern is a `Now` struct wrapping `time.Time` with a `Config` for customization, enabling fluent calls like `now.With(t).BeginningOfMonth()`. The library is widely used (4.7k stars) and thoroughly tested, with careful DST handling and a clever partial-date parser that merges string components with contextual current time. It is a pure library without external dependencies, targeting Go 1.12+ and suitable for any Go project needing robust time calculations or flexible date parsing.
Mochiweb is a lightweight, battle-tested HTTP server library written in Erlang. It provides a full HTTP/1.1 server with support for chunked transfer encoding, compression (gzip, zstd), WebSocket upgrades, and multipart form parsing. The library is designed as a collection of composable, parameterized modules, with a core socket server (`mochiweb_socket_server`) that manages an acceptor pool and delegates request handling to user-provided callback modules. This architecture has made Mochiweb the foundation for numerous Erlang web frameworks, including Nitrogen, Chicago Boss, and Webmachine. Key entry points include `mochiweb_http:start/1` for starting a plain HTTP listener and `mochiweb_socket_server:start/3` for custom socket servers. Request handling flows through `mochiweb_request` (parsing, body streaming, file serving) and `mochiweb_response` (header encoding, streaming, compression). The library also ships with standalone utilities: `mochijson2` for JSON encoding/decoding, `mochiweb_html` for loose HTML tokenization, `mochiweb_util` for URL/header parsing, and `mochiweb_headers` for case-insensitive header dictionaries. While the core is production-grade and actively maintained, some internal modules use deprecated OTP APIs (e.g., `httpd_util:rfc1123_date/0`, `{ssl_imp, new}`) and the state format in `mochiweb_socket_server` includes backward-compatibility shims. The example projects and test suite are comprehensive, covering edge cases from RFC 7230 and WebSocket protocols. Overall, Mochiweb remains a solid choice for embedding an HTTP server in Erlang applications, with several components (especially `mochijson2` and `mochiweb_util`) that are widely reused in isolation.
js-beautify is a production-grade code formatter for JavaScript, CSS, and HTML, available as both a Node.js library/CLI and a Python package. The core architecture is a tokenizer-pipeline: source text is scanned by an InputScanner, tokenized by language-specific tokenizers (JavaScript, CSS, HTML), and then processed by a Beautifier that manages indentation, line wrapping, brace styles, and operator positioning via a stateful flag system. The Output class provides efficient indentation caching and wrap-point management. The tool supports a wide range of configuration options (indent size, brace style, attribute wrapping, template languages) and includes built-in unpackers for obfuscated scripts (P.A.C.K.E.R, JavascriptObfuscator, etc.). A web interface is also provided, built with CodeMirror and RequireJS. The project maintains near-identical JavaScript and Python implementations, sharing test data generated from Mustache templates to ensure parity. The codebase is well-structured with clear separation of concerns (core, language-specific, CLI, web), extensive test coverage (including regression tests for hundreds of GitHub issues), and a mature build/release pipeline. However, the dual-codebase requirement increases maintenance burden, and some parts (e.g., the web UI, Debian packaging) show signs of drift. The large test data files and complex matrix-based test generation add brittleness.
The numactl repository provides a set of userspace tools and a shared library (libnuma) for controlling Non-Uniform Memory Access (NUMA) memory allocation and CPU binding policies on Linux systems. The core tool, `numactl`, allows launching processes with specified memory placement policies (interleave, bind, preferred, local, weighted interleave) and CPU affinity. The library `libnuma` exposes a C API for applications to set these policies programmatically, interacting with the Linux kernel via system calls (mbind, set_mempolicy, etc.) and reading topology information from sysfs. Additional utilities include `numastat` for per-node memory statistics display, `memhog` for memory allocation testing, `migratepages` for manual page migration, and `numademo` for benchmarking NUMA performance characteristics. The codebase is written in C with autotools build system, maintains API/ABI compatibility through symbol versioning, and includes regression tests and fuzzing harnesses. It is the de facto standard library for NUMA policy management on Linux.
Fetch is a Scala library for simple and efficient data access, built on cats-effect. It provides a monadic abstraction (`Fetch[F, A]`) that automatically optimizes data fetching through batching, caching, deduplication, and parallel execution. Users define data sources by implementing the `DataSource` trait, specifying how to fetch individual identities or batches. The library then composes fetches using standard monadic and applicative combinators, transparently batching requests to the same source and running independent fetches concurrently. It supports custom caches, optional fetches, error handling, and debugging via a separate `fetch-debug` module. The architecture is a pure library with no runtime dependencies beyond cats-effect, making it suitable for both JVM and Scala.js. Key entry points include `Fetch.apply`, `Fetch.run`, `Fetch.runLog`, and `Fetch.runCache`. External dependencies are minimal: cats-effect, cats-core, and scalatest for testing.
FluentModbus is a .NET library that implements the Modbus protocol (TCP and RTU) for client and server communication. The library provides a full set of function codes (class 0, 1, and partial class 2) including read/write holding registers, coils, discrete inputs, input registers, and combined read-write operations. Both synchronous and asynchronous APIs are available. The server supports multiple unit identifiers, frame validation via a user-defined callback, events for register/coil changes, and configurable endianness. The client exposes high-level generic methods as well as low-level byte-oriented access. The codebase is well-structured with abstract base classes (MobusClient, ModbusServer), separate request handlers for TCP and RTU, and clean separation of concerns. Dependencies are minimal (logging abstractions, I/O, memory). The library includes comprehensive unit tests and samples.
Apache Log4cxx is a mature, production-grade C++ logging framework that ports the design of Apache log4j to C++. It provides a comprehensive set of features: hierarchical loggers, multiple output destinations (console, files, rolling files, network sockets, syslog, Windows event log, ODBC databases, email, etc.), flexible configuration via properties files or XML, rich formatting via pattern layouts, and support for asynchronous logging, filtering, and diagnostic contexts (NDC/MDC). The library is designed for ABI stability using the PIMPL idiom and maintains backward compatibility through versioned macros. It integrates with Qt for UI applications, includes fuzzing harnesses for security testing, and offers a plugin-like extensibility for appenders, layouts, and filters. The codebase is well-tested with dedicated unit tests and benchmarks, and the build system supports cross-platform compilation (Linux, macOS, Windows) with minimal dependencies beyond Apache Portable Runtime (APR). Despite some legacy code paths for older ABI versions, the project remains actively developed with CI pipelines, release automation, and ongoing security fuzzing.
JSONy is a high-performance JSON parsing and serialization library for the Nim programming language. It bypasses the intermediate JSON node step used by the standard library, directly converting between JSON strings and Nim data structures for improved speed and reduced garbage collection pressure. The library features a flexible hook system (newHook, postHook, parseHook, dumpHook, etc.) that allows customization of the serialization and deserialization process for complex scenarios like handling missing fields, renaming fields, processing enums, and working with JSON-in-json. It supports a wide range of Nim types including primitives, sequences, arrays, objects, ref objects, options, enums, tuples, sets, tables, and custom types via hooks. The implementation avoids StringStream overhead by working directly with memory buffers and parses numbers without intermediate string allocations.
Electron Router DOM is a library that facilitates the integration of react-router-dom with Electron applications, enabling window-based routing where each Electron window can have its own routing configuration. The library handles the complexities of loading URLs in development versus files in production, provides type-safe APIs for passing data between main and renderer processes via query parameters, and abstracts away the low-level Electron window management details. It follows a clean architecture with clear separation between main process utilities (registerRoute function) and renderer process components (Router component), supported by shared TypeScript types and utility functions. The library is designed to improve developer experience by eliminating manual management of Electron's loadURL and loadFile methods while maintaining compatibility with react-router-dom's routing patterns.
This repository provides an Angular wrapper for the dragula drag-and-drop library. It exposes a directive (`[dragula]`) to mark containers as part of a drag group, and a singleton service (`DragulaService`) to configure groups and subscribe to typed RxJS observables for all dragula events. The library supports two-way model binding (`[(dragulaModel)]`) to synchronize dragged data with component arrays, and offers a plugin system for mock drake objects during testing. The architecture cleanly separates concerns: the directive handles DOM registration and model updates, while the service manages group lifecycle and event relay from native dragula callbacks to Angular Observables. It is built with Nx monorepo tooling and includes a demo application, e2e tests, and CI/CD pipelines for building, testing, and publishing to npm. The codebase demonstrates mature Angular patterns, including proper lifecycle management, subscription handling, and typed event emitters.
YaFSDP is a specialized PyTorch library designed to optimize Fully Sharded Data Parallel (FSDP) training for Large Language Models (LLMs). It implements custom sharding strategies that claim up to 20% performance improvements over standard FSDP by reducing communication overhead and optimizing memory usage. The library provides two integration points: a modern composable API via the `fully_shard` function and a legacy-style `YaFSDP` wrapper class that integrates with the `accelerate` ecosystem. It supports advanced features like ragged parameter sharding, CUDA stream-based communication/computation overlap, and optional integration with the Yandex Collective Communication Library (YCCL) for high-performance collectives. The codebase demonstrates high engineering craftsmanship, particularly in its handling of distributed tensor operations and memory management. It utilizes custom tensor subclasses (`RaggedShardDTensor`) to manage non-uniform parameter sizes within sharded groups and implements low-level CUDA stream synchronization to hide communication latency. However, the library relies on internal PyTorch APIs (e.g., `torch._C`, `torch.distributed.fsdp.wrap._...`) and patches external libraries like `accelerate` and `transformers`, which introduces maintenance risks as upstream frameworks evolve.
buji-pac4j is a bridge library that integrates pac4j (a comprehensive security library supporting OAuth, CAS, SAML, OpenID Connect, etc.) with Apache Shiro. It automatically pushes pac4j authentication and authorization profiles into the Shiro security context, allowing developers to use pac4j's wide range of authentication mechanisms while leveraging Shiro for authorization and session management. The bridge is implemented as a set of classes that adapt pac4j's session store, profile manager, and framework adapter to Shiro's APIs, plus a custom Realm, SubjectFactory, and Token. It includes sophisticated logic to avoid unnecessary session renewal when the same user's profiles are updated (e.g., after token refresh), demonstrating deep understanding of both frameworks' internals. The library is production-ready, actively maintained, and used in legacy applications that want to adopt pac4j without fully migrating away from Shiro.
svelte-stripe is a Svelte component library that wraps Stripe Elements and Stripe.js, providing drop-in Svelte components for building payment UIs. It exposes context-based components such as Elements, PaymentElement, CardNumber, CardExpiry, and CardCvc, and handles Stripe.js loading, element lifecycle, and SSR safety. The repository also includes a SvelteKit demo application with examples for credit card, SEPA, iDEAL, and express checkout, plus server-side payment intent creation and webhook signature verification. It is a library and example app, not a data pipeline.
RVO2-3D is a C++ library implementing Optimal Reciprocal Collision Avoidance (ORCA) for multi-agent simulation in three-dimensional workspaces. It provides a simulator that manages agents with configurable parameters (radius, max speed, time horizon, etc.) and computes collision-free velocities each time step using a linear programming approach over ORCA half-planes. The library uses a k-d tree for efficient neighbor queries and optionally leverages OpenMP for parallel agent updates. The public API is exposed through the RVOSimulator class, with supporting types Vector3 and Plane. The codebase is written in C++98 for maximum compatibility, is thoroughly documented with Doxygen, and includes a single example (Sphere) that serves as both a demonstration and a test. The repository is well-maintained with CI across multiple platforms and build systems (CMake, Bazel), static analysis, and a quality declaration targeting ROS 2 Quality Level 2.