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.
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.
Fastfetch is a high-performance, cross-platform system information fetcher designed for the command line. It detects and displays hardware (CPU, GPU, memory, disks, battery, displays, network, Bluetooth, etc.) and software (OS, kernel, desktop environment, window manager, packages, processes, etc.) with extensive customization options including ASCII art logos, images, and JSON output. The architecture is monolithic with a modular detection system: each subsystem (e.g., GPU, battery) has a platform-agnostic header and multiple platform-specific implementation files (Linux, macOS, Windows, BSDs, Haiku, Solaris, Android). The core common library provides dynamic string buffers (FFstrbuf), generic lists (FFlist), dynamic library loading helpers, file I/O, configuration parsing, and formatting utilities. Build configuration is CMake-based with optional dependencies (ImageMagick, libva, Lua, etc.). The codebase is written in modern C (C23) and demonstrates strong engineering practices with consistent patterns for module initialization, option parsing, JSON config generation, and error handling. It is actively maintained with frequent releases and broad platform support.
Squire is a rich text editor (RTE) library written in TypeScript, designed primarily for email composition where preserving arbitrary HTML from third-party sources is critical. Unlike modern RTEs that enforce a structured internal data model, Squire keeps the HTML as the source of truth, enabling it to handle complex nested blockquotes, lists, tables, and inline formatting without breaking external markup. It does not provide its own UI toolbar; instead it exposes a programmatic API that can be integrated with any framework, making it lightweight (~16KB gzipped) and flexible. Architecturally, Squire is a single-class library with tightly coupled internal modules for DOM manipulation, range handling, keyboard input, clipboard operations, and HTML cleaning. The core `Squire` class orchestrates a MutationObserver to track changes, manages undo/redo history via HTML snapshots, and intercepts browser default behaviors for keys like Enter, Backspace, Delete, and Tab to provide consistent cross-browser behavior. It supports inline formatting (bold, italic, underline, etc.), block formatting (lists, quotes, code blocks), image resizing, and automatic link detection. Squire is used in production by Fastmail, ProtonMail, Tutanota, Superhuman, and other email services, as well as in non-email apps like Google Earth. Its strength lies in its ability to accept and clean arbitrary HTML through a configurable sanitizer (e.g., DOMPurify) while preserving as much structural fidelity as possible. The codebase is well-maintained with a comprehensive test suite and follows modern ES module practices.
This repository provides `@lodev09/react-native-true-sheet`, a cross-platform bottom sheet component for React Native applications. It delivers a native-feeling sheet experience on iOS (using `UISheetPresentationController`), Android (using `BottomSheetBehavior` via Fabric), and Web (using a vendored vaul-based drawer). The library supports detent-based sizing, stacking, overlays, peek mode, keyboard avoidance, foldable devices, and deep integration with React Navigation and Expo Router. It also offers first-class support for `react-native-reanimated` worklet-based animations for smooth position transitions. The architecture is built on React Native's New Architecture (Fabric), with native implementations in Objective-C++ (iOS) and Kotlin (Android), plus a full web fallback. The core component (`TrueSheet`) exposes an imperative API (`present`, `dismiss`, `resize`) and static global methods. A provider pattern (`TrueSheetProvider`) enables context-based sheet registry and hooks. The navigation integration (`createTrueSheetRouter`) treats sheets as navigable screens with push/pop/resize actions, and the reanimated integration (`ReanimatedTrueSheet`) enables UI-thread animations via worklets. The codebase demonstrates high craftsmanship with clean separation of platform-specific code, a well-defined event system, and reusable patterns like the detent calculator, scrollable plugin, and background layering system. It includes comprehensive documentation, example apps, Jest mocks, and E2E testing infrastructure. The library is actively maintained with frequent releases and a detailed changelog.
Nushell is a modern, cross-platform shell that treats data as structured (tables, records) rather than raw text streams. It features a pipeline-based architecture where commands process structured data and can be composed using the pipe operator. The shell is built as a modular Rust workspace with distinct crates for the core engine, parsing, command implementation, plugin system, and CLI interface. Nushell emphasizes extensibility through a plugin system where plugins run as separate processes communicating via JSON-RPC, providing isolation and language flexibility. Key features include built-in support for various data formats (JSON, CSV, Excel, Parquet), SQL-like querying capabilities, interactive exploration, and cross-platform compatibility with Windows, macOS, and Linux.
ShareX is a comprehensive screenshot, image editing, and file sharing application for Windows. It features a modular architecture with separate libraries for screen capture, image editing, uploading, helpers, history, and tools. The application supports capturing screenshots/recordings, applying annotations and effects, uploading to over 50 services, and includes various productivity tools. Built with .NET/C# using a mix of Windows Forms and Avalonia UI frameworks, it employs MVVM patterns, plugin architectures for extensibility, and cross-cutting helper libraries. The system handles data flows from capture through editing to upload/storage, with history tracking for user convenience.
kubernetes-sigs/cri-tools is the official Kubernetes toolset for working with the Container Runtime Interface (CRI). It ships two binaries: crictl, a CLI used by developers and operators to inspect, debug, and manage pods, containers, images, and runtime state; and critest, a Ginkgo-based conformance/validation suite that exercises a CRI runtime implementation against the CRI spec, including security contexts, networking, streaming, image volumes, apparmor, selinux, metrics, and NRI plugin behavior. The codebase is a well-structured Go application with a clear split between CLI command implementations (cmd/crictl), validation specs (pkg/validate), reusable test framework helpers (pkg/framework), shared utilities (pkg/common), and benchmark infrastructure (pkg/benchmark).
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.
NeoHtop is a modern, cross-platform system monitor built with Svelte, Rust, and Tauri. It provides real-time monitoring of system processes, CPU usage, memory usage, network I/O, and disk statistics. The application features a beautiful, customizable UI with dark/light theme support, advanced process search and filtering (including regex support), process pinning, and the ability to kill processes. The architecture cleanly separates the Rust backend (which uses the sysinfo crate to gather system information) from the Svelte frontend (which displays the data and handles user interactions), communicating via Tauri's IPC mechanism.
node-newrelic is a production-grade APM agent library for Node.js, loaded into a host application via require('newrelic') or --require. It instruments Node's built-in modules and a broad ecosystem of third-party libraries—Express, Fastify, MongoDB, Redis, MySQL, AWS SDK, OpenAI, LangChain, gRPC, Kafka, and many more—to create transactions, segments, spans, metrics, errors, logs, and LLM events. These are aggregated in memory, sampled via priority queues, and harvested to the New Relic collector over HTTPS/gRPC, including infinite-tracing streaming. The agent also implements W3C tracecontext and New Relic distributed-tracing headers, supports serverless environments (AWS Lambda, Azure Functions), and includes an OpenTelemetry bridge for traces, metrics, and logs.
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 provides an all-in-one CLI/TUI application for launching and managing security testing tools. It features a curated catalog of 215+ tools across 21 categories, defined declaratively in YAML files and loaded into Python tool classes. The interactive REPL supports commands like /run, /search, /tags, /ai, /goal, and /find, with a rich console interface using prompt_toolkit and Rich. A headless engagement mode runs YAML-defined pipelines (e.g., subfinder → httpx → nuclei) and generates structured findings and Markdown reports. AI features are opt-in and use OpenAI-compatible endpoints or local Ollama, with built-in safety guardrails (charter injection, sanitization, anti-fabrication checks) and graceful degradation to offline behavior. The architecture is monolithic but modular, with clear separation between the tool catalog, execution engine, AI integration, and discovery module. The codebase demonstrates strong engineering practices: safe subprocess execution (list-form, cwd, skip if present), declarative YAML overlays, a fixed tag taxonomy enforced by tests, and extensive test coverage including monkeypatching of subprocess and AI transport. While the catalog inherently drifts as upstream tools become archived, the project includes audit scripts to manage this. Overall, it is a well-crafted, production-quality application for authorized security testing.
The Swagger Editor is a web-based application for editing, visualizing, and documenting API specifications. It supports multiple formats including OpenAPI (2.0/3.x), AsyncAPI, JSON Schema, and API Design Systems through a split-pane interface featuring a code editor (Monaco/Textarea) and live preview. Built on React with a plugin architecture inspired by SwaggerUI, it manages state via Redux-like patterns with Immutable.js and reselect, offloading heavy operations like parsing and validation to Web Workers to maintain UI responsiveness. Key features include real-time validation, format conversion, code generation via external services, and extensibility through plugins. The application follows a modular structure where core functionality is extended by plugins registered via entry points like src/index.tsx and src/App.tsx. Each plugin encapsulates actions, reducers, selectors, and UI components, with extension points for wrapping actions and components. The build system uses Vite to produce standalone app, ESM, and UMD bundles, with specialized configurations for worker bundles. Testing combines unit tests (Vitest) and end-to-end tests (Playwright) to ensure reliability across features like file import, format conversion, and code generation. Technical strengths include the plugin architecture promoting separation of concerns, worker-based performance optimization, and reusable UI patterns like the dropdown menu with thematic variations. Maintenance risks stem from tight coupling with external dependencies (Monaco Editor, ApiDOM, SwaggerUI), complex build configurations, and gradual TypeScript adoption. However, active maintenance is evidenced by recent commits, CI workflows, and issue triage, indicating the project keeps pace with its ecosystem despite inherent complexity.
Spring Session is a library that provides a robust, pluggable session management solution for Spring-based applications. It abstracts session storage behind a `SessionRepository` interface, supporting multiple backends including Redis, JDBC, and in-memory. The library seamlessly integrates with both Servlet and WebFlux stacks, replacing the standard `HttpSession` with a configurable, cluster-friendly alternative. It also offers deep integration with Spring Security for concurrent session control and remember-me authentication, and with WebSocket for session-aware messaging. The architecture is modular: `spring-session-core` defines the core API (Session, SessionRepository, FindByIndexNameSessionRepository, HttpSessionIdResolver) and provides the servlet filter (`SessionRepositoryFilter`) and reactive store (`SpringSessionWebSessionStore`). `spring-session-data-redis` implements Redis-backed repositories with support for indexing by principal name and expiration via sorted sets and keyspace notifications. `spring-session-jdbc` provides a JDBC-backed repository with dialect-specific SQL schemas and customizable queries. Configuration is annotation-driven (e.g., `@EnableRedisHttpSession`, `@EnableJdbcHttpSession`) and supports customization through beans like `CookieSerializer`, `SessionRepositoryCustomizer`, and `FlushMode`/`SaveMode`. Key data flows involve session creation, attribute modification, expiration, and principal-based lookup. The library uses events (`SessionCreatedEvent`, `SessionDeletedEvent`, `SessionExpiredEvent`) for lifecycle notifications and supports AOT compilation for GraalVM native images. External dependencies include Spring Framework, Spring Data Redis, Spring Data JDBC, Reactor, and optionally Jackson for JSON serialization. The build system uses Gradle with custom convention plugins for publishing, documentation, and release management.
Nuxt is a production-grade, open-source meta-framework for building full-stack web applications with Vue.js. It provides a comprehensive developer experience with file-based routing, server-side rendering (SSR), static site generation (SSG), incremental static regeneration (ISR), and a powerful module ecosystem. The repository is a monorepo containing the core framework (`@nuxt/nuxt`), a toolkit for module authors (`@nuxt/kit`), configuration schema (`@nuxt/schema`), and multiple builder integrations (Vite, Webpack, Rspack) plus a Nitro-based server engine (`@nuxt/nitro-server`). Architecturally, Nuxt operates in two phases: build-time and runtime. At build time, it loads configuration, installs modules, scans components and pages, generates optimized code (auto-imports, route definitions, plugin arrays), and bundles the application using the configured builder. At runtime, it handles SSR/CSR rendering, data fetching via `useFetch`/`useAsyncData`, state management with `useState`, routing with vue-router, and server-side logic via Nitro. The framework is highly extensible through hooks, modules, and layers, allowing customization at every level. Key entry points include `createNuxt`, `loadNuxt`, and `build` from `@nuxt/kit`, the CLI (`nuxi`), and runtime composables like `useFetch`, `useAsyncData`, `useHead`, and `useRouter`. External dependencies include Vue 3, Vite/Webpack/Rspack, Nitro, unhead, ufo, devalue, and many others. The codebase is actively maintained with a large test suite (unit, integration, e2e) and a sophisticated diagnostics system for developer feedback.
Baleia.nvim is a Neovim plugin that colorizes text with ANSI escape sequences (8, 16, 256 or TrueColor). It processes buffers containing ANSI codes, strips them from the text while applying appropriate syntax highlighting, and supports both manual and automatic colorization modes. The architecture features modular Lua components handling ANSI parsing (ansi.lua), lexical analysis (lexer.py), asynchronous processing (scheduler.lua), and Neovim highlight rendering (renderer.lua). The plugin integrates with Neovim's buffer system through autocommands and API functions, efficiently handling large files via chunked processing.
pco/pcodec is a high-performance lossless compression library specializing in numerical sequences (integers and floats). It implements a novel three-stage pipeline: mode selection (classic, dictionary, integer/float multiplier, float quantizer), delta encoding (consecutive, lookback, conv1), and binning with tANS entropy coding. The library achieves near-Shannon-entropy compression ratios, particularly for structured numeric data like time series, columnar store blocks, and scientific datasets. It provides multiple APIs: a core Rust crate (`pco`), Python bindings via PyO3 (`pcodec` on PyPI), Java bindings via JNI (`pco-jni` on Maven Central), a C API (`pco_c`), and a feature-rich CLI for compression, decompression, inspection, and benchmarking against many other codecs (zstd, snappy, parquet, blosc, etc.). The codebase includes a legacy predecessor (`quantile-compression/q_compress`) also maintained in the same workspace. The architecture is modular, with separate crates for bit I/O (`better_io`), type dispatch macros (`dtype_dispatch`), and extensive testing including format backward compatibility and corruption recovery. It is actively developed with CI pipelines for Rust, Python, and Java.
Crawlee is a production-grade Python web scraping and browser automation framework developed by Apify. It provides a unified async API for both static HTTP crawling (BeautifulSoup, Parsel, raw HTTP) and headless browser automation (Playwright, Stagehand), with an adaptive mode that dynamically chooses between them based on page characteristics. The architecture is modular: a context pipeline chains pre-navigation hooks, HTTP execution (via pluggable clients like httpx, curl-impersonate, or impit), parsing, and post-processing before dispatching to user-defined router handlers. Storage is abstracted behind Dataset, KeyValueStore, and RequestQueue interfaces with multiple backends (memory, filesystem, SQL, Redis). The framework includes autoscaling, session management, proxy rotation, browser fingerprint generation for anti-blocking, OpenTelemetry instrumentation, and a CLI for project scaffolding. It is designed for large-scale crawling with state persistence across runs and supports deployment on Apify, AWS Lambda, and Google Cloud Run.
Serilog.Settings.Configuration is a library that enables Serilog to read its configuration from Microsoft.Extensions.Configuration sources, primarily appsettings.json files. It bridges Serilog's configuration system with the .NET configuration ecosystem, allowing developers to configure sinks, enrichers, filters, and other logging components through standard configuration providers. The architecture centers around a ConfigurationReader that processes Serilog configuration sections, discovers relevant assemblies containing logging components, and invokes the appropriate Serilog configuration methods. Key features include support for static member access syntax (Type::Member), dynamic level switches, filter switches, nested configuration sections for wrappers like Async sinks, and sophisticated argument binding that handles complex types, arrays, and optional parameters. The library demonstrates strong engineering practices with comprehensive test coverage, multi-targeting for various .NET frameworks, clear semantic versioning, and active maintenance. It solves the common problem of configuration fragmentation in .NET applications by providing a unified approach to Serilog configuration that works with environment variables, JSON files, command-line arguments, and other configuration sources supported by Microsoft.Extensions.Configuration.