Better SVG is a VS Code extension that provides live SVG preview, inline SVG detection, and SVGO optimization. It supports a wide range of frameworks (React, Vue, Svelte, Astro, Blade, etc.) by converting JSX/TSX and framework-specific syntax to standard SVG before optimization and back. The extension includes a webview panel with zoom, pan, color picker, and dark background toggle, as well as gutter icons and hover previews for inline SVGs in code. The core logic is well-abstracted into pure modules (svgTransform, svgPreview, svgoPlugins) that are testable and potentially reusable outside the extension. The codebase is actively maintained, has comprehensive tests, and demonstrates high craftsmanship in handling edge cases like template literal interpolations, Blade directives, and multiline closing tags.
SheafUI is a UI component library designed for Laravel applications built with the TALL stack (Tailwind CSS, Alpine.js, Livewire, and Laravel Blade). It provides over 60 reusable components that developers can install via a CLI command and then fully own and customize. The components follow a copy-paste philosophy, meaning once installed, they are part of the project and can be modified freely. The library emphasizes developer experience, consistency, and flexibility, with each component documented and designed to work seamlessly with Laravel's ecosystem. The architecture is a collection of independent Blade components, each encapsulated in its own directory with its own Blade templates, configuration, and documentation. Key patterns include a global modal state management system using Alpine.js, a responsive layout system with persistent sidebar state, and extensible form inputs using Blade slots for prefixes, suffixes, and actions. The repository is actively maintained with recent commits and shows low technical drift, indicating it keeps pace with its dependencies.
FREE Browser is an Android web application focused on privacy and user control. It implements a tabbed browsing interface using Android WebView with extensive privacy protections including ad-blocking via StevenBlack host lists, cookie banner blocking using Mozilla's rule list, and fingerprint protection through JavaScript injection that spoofs canvas, WebGL, AudioContext, and font metrics. The application features granular controls for JavaScript, DOM storage, and cookies per domain, comprehensive bookmark and history management, download handling, and backup/restore functionality for all browser data. The architecture follows Android best practices with separate modules for browser functionality, database handling, preferences, and utility functions, using patterns like MVC, adapter patterns, and singleton for tab management.
dotenv.net is a lightweight .NET library for loading environment variables from .env files. It provides both a static API (DotEnv.Load, DotEnv.Read) and a fluent builder (DotEnv.Fluent) for configuring options such as file paths, encoding, trimming, overwrite behavior, directory probing, export syntax support, inline comment stripping, and variable expansion/interpolation. The library supports hierarchical environment cascade loading (e.g., .env, .env.local, .env.{Environment}) and integrates with Microsoft.Extensions.Configuration via a separate package (dotenv.net.Configuration). Internally, it consists of a parser that handles single/double quoted values, multi-line values, and escape sequences; a variable expander that resolves ${VAR}, $VAR, and default fallback syntax with circular dependency detection; and a reader that reads from files or streams, probes parent directories, and merges key-value pairs. The codebase is well-structured with comprehensive unit tests covering edge cases, and targets netstandard2.0/2.1 for broad compatibility.
iban4j is a mature, zero-dependency Java library for generating, validating, and parsing International Bank Account Numbers (IBAN) and Business Identifier Codes (BIC). It implements the full ISO 13616 and ISO 9362 standards, supporting over 90 countries with their specific BBAN structures. The library provides a fluent Builder pattern for IBAN construction, static utility methods in IbanUtil and BicUtil for validation, and an immutable Iban object that exposes country-specific fields like bank code, branch code, and national check digit. A standout feature is the extensible country-specific rules subsystem, which validates national check digits (e.g., French RIB key, Spanish modulo 11, Dutch '11-proef') via a pluggable SPI interface. The code is written in Java 11, follows Google Java Style, and has comprehensive test coverage with parameterized tests and custom Hamcrest matchers. Security-conscious design is evident in CharacterUtil, which strictly validates ASCII-only characters to prevent Unicode homograph attacks. The library is published to Maven Central and supports JPMS module system. It has no runtime dependencies.
The mdx-js/eslint-mdx repository provides ESLint integration for MDX (Markdown with JSX) files. It consists of two main packages: `eslint-mdx`, which serves as an ESLint parser capable of converting MDX syntax into an ESTree Abstract Syntax Tree (AST) that ESLint can process, and `eslint-plugin-mdx`, which offers a plugin containing processors, configurations, and rules to enable linting of both JavaScript/JSX code and Markdown content within MDX files via remark-lint integration. The architecture centers around a parser that transforms MDX into an ESTree AST, preserving the structure of both Markdown and JSX elements. This parser employs a sophisticated token restoration mechanism (located in `tokens.ts`) to ensure that the token stream matches the original source code, which is essential for ESLint rules that rely on token-level analysis (such as semicolon or quoting rules). The plugin complements this by providing a processor that integrates with remark-lint to lint Markdown content, allowing users to apply Markdown-specific linting rules alongside standard JavaScript linting. Additionally, the plugin includes configurations for code block linting, enabling ESLint rules to be applied to code snippets embedded within Markdown fenced code blocks. The project demonstrates strong engineering practices, including strict type coverage enforcement, comprehensive testing with 100% coverage thresholds, and active maintenance with up-to-date dependencies. It supports modern ESLint versions (8, 9, and 10) and Node.js versions (>=18), ensuring compatibility with contemporary toolchains. The separation of concerns between the parser and plugin, along with the isolation of complex logic like token restoration into dedicated modules, contributes to a clean and maintainable codebase that is well-suited for reuse in similar tooling scenarios.
This repository is the **Wow** framework, a comprehensive, production-grade event-sourcing and CQRS framework for building reactive, cloud-native applications in Kotlin and Java. It provides a full stack: domain modeling with aggregates, commands, events, and sagas; reactive command/event buses with multiple backends (MongoDB, Redis, Elasticsearch, Kafka); a query gateway with rich filter DSL and snapshot/event-stream queries; automatic OpenAPI generation; a compensation subsystem with a React dashboard for managing failed executions and retries; observability via OpenTelemetry; and BI tooling for ClickHouse. The architecture is modular (30+ Gradle modules) but deployable as separate services (e.g., compensation server, example server). It is actively developed with extensive tests (unit, contract, integration, JMH benchmarks) and comprehensive documentation.
CodExt is a Python library and command-line tool that extends the standard library's codecs with over 120 custom encodings for data transformation. It provides encoding/decoding functionalities across domains including base encodings (baseN, base45, base85, etc.), cryptography (Vigenère, RSA, XOR), compression (gzip, LZ77/LZ78), steganography, and language-based transformations (Leetspeak, Morse, Braille). The system features a heuristic-based guess mode for automated multi-layered decoding and a macro system for chaining codecs. Architected as a plugin-based library, it allows dynamic registration of new codecs and is designed for CTF, security, and data obfuscation tasks. The codebase demonstrates strong modularity with clear separation of concerns between core functionality, codec implementations, and utility modules.
fontspec is a mature LaTeX package that provides an automatic and unified interface for font selection in XeLaTeX and LuaLaTeX. It allows users to load OpenType, AAT, and Graphite fonts by name or filename, with full control over features such as ligatures, small caps, numerals, script/language selection, colour, scaling, and more. The architecture is modular: a core LaTeX3 (expl3) implementation wraps engine-specific code (XeTeX primitives or luaotfload) behind a consistent key-value interface, and provides both user commands (`\setmainfont`, `\fontspec`) and a programmable API (`\fontspec_*` conditionals) for other packages. The codebase is structured as literate `.dtx` files, generating both the package `.sty` files and comprehensive documentation. It includes an extensive test suite with over 100 test files that run on both XeTeX and LuaTeX, a fully automated CI/CD pipeline (testing, documentation, release), and is distributed on CTAN under the LPPL 1.3c license. The package is actively maintained by the LaTeX3 Project team, tracking OpenType specification updates and TeX engine changes, though its dual-engine support and large static data tables (language/script mappings) introduce some maintenance overhead.
This repository implements a Serilog sink for writing log events to Microsoft SQL Server and Azure SQL databases. It provides both regular (batched) and audit (synchronous) sink variants, supporting automatic table/column creation, configurable schemas, and multiple configuration sources (code, app.config, appsettings.json). The architecture emphasizes separation of concerns through platform abstractions for data access, dependency injection for testability, and strategy patterns for write operations (bulk copy vs. individual inserts). The sink processes log events via Serilib's pipeline, batching them for efficiency unless using the audit sink for critical events. Data is transformed into SQL-compatible values through specialized generators for standard columns (timestamp, level, etc.) and additional custom columns. The system handles type mapping, truncation, and formatting (XML for properties, JSON for log events) while supporting features like hierarchical property resolution, indexed columns, and clustered columnstore indexes for performance. Key strengths include a well-structured plugin architecture with clear extensibility points, comprehensive test coverage across multiple .NET frameworks, and proactive dependency management. The codebase demonstrates solid engineering practices through interface-based design, factory patterns for dependency resolution, and careful handling of edge cases like batch failures and transactional integrity. While supporting legacy configurations adds some complexity, the project maintains active development with recent updates addressing security, performance, and compatibility with newer SQL Client versions.
Lcapy is a Python library for symbolic linear circuit analysis and signal processing. It enables analysis of circuits in multiple domains (time, s-domain, frequency, discrete-time) using SymPy for symbolic mathematics. The library supports netlist-based circuit description, circuit solving via modified nodal analysis, transfer function analysis, noise analysis, state-space representation, and schematic generation using Circuitikz. It is designed for educational, research, and engineering applications in electrical engineering, providing both symbolic and numeric analysis capabilities.
cacache is a Node.js library implementing a content-addressable cache system. It provides key-based and content-addressable access to cached data with built-in integrity verification using Subresource Integrity (SRI) standards. The system is designed for high concurrency and fault tolerance, protecting against corruption, partial writes, and race conditions. It features a modular architecture separating concerns like index management, content storage, memoization, and verification/garbage collection.
The Planet Labs Python SDK provides both a programmatic interface and a command-line tool for interacting with Planet's satellite imagery and data APIs. It enables users to authenticate, search for imagery, create and manage orders, handle subscriptions, upload areas of interest, configure cloud storage destinations, and access mosaics. The SDK is designed with a clear separation of concerns, featuring asynchronous API clients with synchronous wrappers, a robust HTTP session with retry and rate-limiting logic, and a flexible authentication system supporting multiple methods (API key, OAuth user, OAuth M2M) and storage strategies. Key architectural elements include a base client class that handles common HTTP operations, service-specific clients for each Planet API, and a Click-based CLI that mirrors the SDK's functionality. The repository also includes reusable utilities for GeoJSON handling, search filter construction, order and subscription request building, and progress reporting for long-running operations. The codebase demonstrates strong engineering practices with extensive test coverage, clear documentation, and active maintenance.
ppxlib is the standard library for writing PPX rewriters in OCaml—compile-time preprocessors that transform the OCaml abstract syntax tree (AST). It provides a unified framework for defining extension points (`[%...]`), deriving generators (`[@@deriving ...]`), context‑free rewrite rules, and global transformations. The library abstracts over multiple OCaml compiler versions (4.08 through 5.06) via its own frozen AST definitions and bidirectional migration modules, insulating PPX authors from version-specific parsetree changes. The core architecture consists of a driver that orchestrates transformation phases (lint, preprocess, instrument, context‑free, global, last instrument) and can be compiled into standalone executables or used as a Dune build plugin. The codebase is actively maintained with extensive documentation, benchmark infrastructure (including a vendored ppx_sexp_conv for comparison), and a comprehensive test suite covering error embedding, code path tracking, and AST round‑tripping. Despite the complexity of cross‑version AST support, the internal APIs are cleanly separated into reusable components such as typed attribute handlers, composable deriving arguments, and a GADT‑based DSL for context‑free rules.
The progressr package provides a minimal, unifying API for reporting progress updates in R. It separates progress signaling (developer-controlled) from progress presentation (end-user controlled) using R's condition system. Developers create progressor functions to signal updates, while end users configure handlers to determine how progress is displayed (terminal, GUI, audio, notifications, or file-based). The architecture centers around a handler plugin system where `with_progress()` manages context and handler state. Key features include integration with parallel frameworks (future, furrr, plyr), Shiny compatibility via `withProgressShiny()`, and a global progression handler for R ≥ 4.0.0. The package emphasizes flexibility—handlers can be mixed and matched, progress reporting can be suppressed, and updates work seamlessly in iterative and parallel contexts. Software engineering rigor is evident through an extensive test suite (50+ test scripts in `inst/testme/`), continuous integration, semantic versioning, and comprehensive vignettes. The design avoids tight coupling—core components like `progressor()`, `with_progress()`, and `progress_aggregator()` are isolated and reusable. While dependencies on optional packages (cli, progress, beepr, etc.) introduce some maintenance complexity, the core remains stable and well-maintained with recent activity.
discord-haskell is a Haskell library for building Discord bots. It provides type-safe bindings to the Discord API, handling both REST requests and WebSocket gateway connections. The library features automatic rate limiting, resilient connection handling with reconnection logic, optional caching of guild/channel/user data, and comprehensive support for Discord interactions including slash commands, buttons, select menus, and modals. Built with a modular architecture separating gateway, REST, and type concerns, it uses ReaderT for dependency injection and provides a clean interface for bot developers.
The intl-t repository is a fully-typed, object-based internationalization (i18n) library for TypeScript, React, and Next.js applications. It provides a translation engine that allows developers to access nested translation objects via property traversal (e.g., `t.page.section.title`) with full TypeScript safety. The library supports ICU message formatting for plurals, selections, and variable injection, including the ability to embed React components within translated strings. Architecturally, the library is structured as a monorepo with separate packages for core logic, framework integrations (React and Next.js), utilities, formatting, type declaration generation, and locale definitions. The core package is framework-agnostic and uses proxies to enable lazy loading of locale-specific translation trees for code splitting. Framework-specific packages provide hooks, context providers, middleware, and routing helpers tailored to React and Next.js, including Next.js App Router support for server components and static rendering. The library emphasizes zero external dependencies, modern JavaScript features, and type safety. It includes a CLI tool for generating TypeScript definitions from JSON translation files, ensuring that translation keys are fully typed and IDE-friendly. The Next.js integration offers automatic locale detection, URL localization, and caching mechanisms optimized for server-side rendering and edge environments.
Goca is a CLI tool for generating Go applications following Clean Architecture principles. It scaffolds complete projects with domain, usecase, repository, and handler layers, supporting multiple databases (PostgreSQL, MySQL, MongoDB, etc.) and protocols (HTTP, gRPC, CLI, worker). The tool includes safety mechanisms (dry-run, backup, force), dependency injection generation, middleware creation, and Model Context Protocol (MCP) integration for AI-assisted development. Its architecture emphasizes layer separation and dependency management, generating production-ready code with built-in validation, testing scaffolding, and CI/CD pipeline generation.
Click-spinner is a minimal Python library that provides a terminal spinner interface for indicating progress during long-running operations where the duration is unknown. The core functionality resides in the Spinner class, which runs a background thread to animate a sequence of characters (spinner frames) while the main thread executes work. The spinner automatically detects whether output is redirected and respects terminal capabilities, with options to force display, disable the spinner, or emit a beep upon completion. Designed as a context manager, it integrates seamlessly with Click-based CLI applications but has no framework dependencies, relying solely on Python's standard library. The project includes comprehensive test coverage verifying behavior under various conditions like output redirection, disabling, and exception handling, supported by CI workflows testing across Python 3.8-3.14.
Workout Gate is a CLI tool that gates AI coding prompts (Claude Code and Codex) behind a physical exercise challenge. It installs a UserPromptSubmit hook that counts prompts and, when a challenge is due, blocks the prompt and opens a webcam window to count push-ups or squats via MediaPipe Pose. Each rep is persisted to disk immediately, so progress is saved if the window is closed. The system tracks debt (owed reps), stats, and streaks, and provides a CLI and web dashboard for configuration. The architecture is modular, with clear separation between the hook, challenge logic, pose detection, state persistence, and user interfaces. Key strengths include robust cross-process locking for shared state, a reusable hysteresis counter for rep counting, and thoughtful escape hatches to prevent lockout.