MRML is a Rust-based implementation of the MJML (Mailjet Markup Language) parser and renderer. It provides a core library for converting MJML templates to responsive HTML email, along with CLI, WebAssembly, and Python bindings. The architecture is modular, with each MJML component following a consistent pattern for parsing, rendering, and serialization. The system supports template inclusion via pluggable loaders (memory, local, HTTP) and includes an HTTP server example for rendering MJML via a POST endpoint.
This repository is the official AWS SDK for Kotlin, a multi-platform SDK providing generated service clients for all AWS services, runtime libraries for credential resolution, HTTP signing, retries, and telemetry, as well as a high-level DynamoDB mapper with compile-time schema generation. The architecture is a multi-module Gradle project with code generation from Smithy models (via smithy-kotlin), runtime modules (aws-config, aws-http, aws-core, aws-endpoint, telemetry-cloudwatch), and a high-level library layer (hll/ddb-mapper). Key entry points for users are the generated service clients (e.g., S3Client.create), credential providers (DefaultChainCredentialsProvider), and the DynamoDbMapper. The SDK supports JVM, Android, and Kotlin Multiplatform. The codebase demonstrates strong engineering practices: extensive unit and integration tests, binary compatibility validation, a type-safe expression DSL for DynamoDB, a composable credential provider chain with caching, and a clean interceptor pipeline for the DynamoDB mapper. It is actively maintained with frequent releases and a well-defined versioning policy.
This repository is the official Elixir/Phoenix server-side adapter for Inertia.js (v3). It enables Phoenix developers to build modern server-driven single-page applications without constructing a separate JSON API. The library intercepts HTTP requests via a Plug, detects Inertia.js headers, and renders page data as JSON for XHR requests or embeds it in an HTML template for the initial load. It handles asset versioning (409 responses), partial reloads, server-side rendering (SSR) via a Node.js worker pool, and provides a rich set of controller helpers for managing props (deferred, shared, once, scroll, merge, etc.). The architecture is centered around a core Plug (`Inertia.Plug`), controller macros (`Inertia.Controller`), HEEx components (`Inertia.HTML`), an SSR supervisor (`Inertia.SSR`), and a Mix task for scaffolding (`inertia.install`). It achieves extensibility through Elixir protocols for pagination (`Inertia.Paginated`), error handling (`Inertia.Errors`), and SSR adapters (`Inertia.SSR.Adapter`), allowing seamless integration with libraries like Scrivener, Flop, and Ecto. The codebase exhibits high craftsmanship. The prop resolution engine in `controller.ex` uses a sophisticated system of tagged tuples and recursive resolution to handle lazy evaluation, caching, merging, and transformation—a non-obvious and elegant functional pattern. The SSR adapter pattern cleanly isolates the Node.js worker pool management behind a behaviour. The testing module provides comprehensive helpers for integration testing. The library is actively maintained, tracks upstream Inertia.js changes (Laravel parity), and uses modern Elixir/Phoenix conventions. This library is ideal for Phoenix teams who want the development speed of a modern SPA framework (React, Vue, Svelte) with the server-side control and simplicity of a traditional server-rendered application. It eliminates the need for a dedicated frontend API layer while providing features like partial page rendering, lazy-loaded components, and server-side rendering for SEO and initial load performance.
Necord is a NestJS module for creating Discord bots that integrates Discord.js with the NestJS dependency injection system. It provides decorators for defining Discord interactions (slash commands, context menus, message components, modals, etc.) and handles event listening through a discovery mechanism. The architecture follows NestJS patterns with modules, providers, and decorators, using explorer services to scan for decorated methods at runtime. Key features include automatic command registration, custom parameter decorators for interaction data, and advanced context management for asynchronous event handlers using Node.js async_hooks.
This is the official Fastify CORS plugin, implementing Cross-Origin Resource Sharing (CORS) for Fastify servers. It provides comprehensive configuration for all standard CORS headers, including origin (string, regex, array, boolean, or dynamic function), methods, allowed headers, exposed headers, credentials, max age, cache control, and preflight handling. The architecture is a standard Fastify plugin that registers a configurable lifecycle hook (default onRequest) and a wildcard OPTIONS route to handle preflight requests. It supports dynamic configuration via a delegator callback or promise, and per-route CORS overrides via route config. The code is well-structured, thoroughly tested, and includes a particularly well-crafted `vary.js` module for managing the Vary header with caching. Dependencies are minimal and up to date.
This repository provides `fastjsonschema`, a Python library for validating JSON data against JSON Schema drafts 04, 06, 07, and 2019-09. It achieves high performance by generating optimized Python validation code at compile time and executing it via `exec()`. The library's architecture uses a hierarchy of code generators (`CodeGeneratorDraft04` → `CodeGeneratorDraft06` → `CodeGeneratorDraft07` → `CodeGeneratorDraft2019`) to handle draft-specific keywords. A `RefResolver` manages URI resolution and `$ref` dereferencing. The project includes a comprehensive test suite (including the official JSON Schema Test Suite) and a CLI entry point (`__main__.py`) for generating validator code to a file. It is designed for maximum speed in repeated validation scenarios, and exposes `compile()`, `compile_to_code()`, and a convenience `validate()` function.
This is the official Dart documentation generator (`dartdoc`), exposed as `dart doc` in the Dart SDK. It parses Dart source code using the `analyzer` package, builds an in-memory model of packages, libraries, classes, enums, extensions, mixins, typedefs, and their members, then generates static HTML documentation. The architecture is a CLI tool with a clear separation of concerns: source analysis (model layer), template rendering (Mustachio engine), and output generation (HTML backend). Key entry points are `bin/dartdoc.dart` and `lib/src/dartdoc.dart` (the `Dartdoc` class orchestrating generation). The system relies on a custom template engine called Mustachio, which pre-compiles Mustache templates into optimized Dart render functions via an AOT compiler, avoiding runtime reflection. The generated HTML includes a client-side JavaScript frontend (`docs.dart.js`) providing search, dark/light theme toggle, copy-to-clipboard, and sidebar navigation. Configuration is handled through `dartdoc_options.yaml` files and command-line arguments, with a hierarchical option system that supports per-package overrides. The codebase demonstrates strong engineering practices: extensive test coverage (unit, integration, and golden HTML tests), a structured warning/error system, canonicalization logic for re-exported elements, and support for advanced Dart features like records, macros, sealed classes, and null safety. Several components are cleanly isolated and reusable, including the Mustachio template engine, a generic async task queue, a terminal progress bar, and a configurable source link generator.
Logux Server is a framework for building real-time collaborative servers using the Logux protocol. It synchronizes a log of operations between clients, server, and other clients via WebSocket. The server handles authentication, channel subscriptions, action processing (access, resend, process), and supports PostgreSQL for persistent log storage. The architecture is modular, with clear separation of concerns: base server, client management, context, action queues, and logging. It provides a rich API for defining action types and channels with callbacks, and includes test utilities (TestServer, TestClient) for integration testing. The codebase is well-structured, uses modern JavaScript (ESM, Node 22+), and demonstrates high craftsmanship with careful error handling, async patterns, and comprehensive test coverage (100% line coverage target).
The erldns repository is an Erlang/OTP-based authoritative DNS server that processes DNS queries through a modular pipeline architecture. It loads zone data from JSON or standard zone files, provides DNSSEC validation and signing, and includes features like query throttling, EDNS0 processing, and an HTTP-based Admin API for runtime zone management and monitoring. The system is built using OTP supervision trees, with separate supervisors for listeners, pipeline workers, and zone loading. Key architectural strengths include a reusable pipeline pattern for extensible query processing, a worker pool for asynchronous operations, a segmented cache abstraction for high-concurrency scenarios, and admission control mechanisms using CoDel and Cubic algorithms. The Admin API follows a middleware pattern allowing custom extensions, and the zone loading subsystem supports pluggable codecs for custom record types. The codebase demonstrates strong engineering practices with comprehensive testing, dependency management, and observability via telemetry.
Gettext is an internationalization (i18n) and localization (l10n) library for Elixir applications. It provides macros for marking strings in source code that need translation, extracts these strings into POT (Portable Object Template) files, and merges them with PO (Portable Object) files for different locales. At runtime, it looks up translations based on the current locale and supports features like pluralization, context-based translations, domain-specific messages, and string interpolation with compile-time optimization. The architecture follows a library pattern with clear separation between the API (Gettext module), backend behavior (Gettext.Backend), compilation (Gettext.Compiler), extraction (Gettext.Extractor), merging (Gettext.Merger), and specialized components for interpolation, pluralization, and fuzzy matching.
The Infomap repository provides a software implementation of the Infomap algorithm for multi-level network clustering based on the map equation. It offers a standalone command-line interface and language bindings for Python, R, and JavaScript, enabling users to detect community structure in various network types (including weighted, directed, bipartite, multilayer, and higher-order networks). The core algorithm is implemented in C++ with a modular design separating optimization, I/O, configuration, and output handling. The architecture emphasizes reusability and extensibility, featuring a parameter catalog system for managing options, a console utility for formatted terminal output, and safe string conversion utilities. The system supports multiple input and output formats, integrates with popular graph libraries (NetworkX, igraph), and includes advanced features such as entropy correction, teleportation, and regularization. Comprehensive test suites, benchmarking tools, and documentation ensure reliability and ease of use across different platforms and programming languages. While the repository includes example networks and tutorial notebooks for demonstration and validation, its primary focus is delivering a robust, reusable tool for network analysis rather than conducting specific data research. The codebase is actively maintained with continuous integration, regular releases, and cross-language binding consistency checks.
nette/http is a standalone PHP library providing HTTP abstraction for request/response handling, URL manipulation, session management, and file uploads. It is part of the Nette Framework ecosystem but is usable independently. The library offers immutable `Request` and `UrlImmutable` objects for safe processing, alongside mutable `Response` and `Session` for stateful operations. It includes security-focused features such as input sanitization, CSRF protection via `Sec-Fetch-*` headers (with fallback), SSRF protection via `UrlValidator` and `IPAddress`, and a proxy trust model for client IP resolution behind reverse proxies. The codebase is well-structured, with clear separation of concerns, comprehensive test coverage (Nette Tester), and strict static analysis (PHPStan level 8). It requires PHP 8.3-8.5 and depends on `nette/utils`. The repository is actively maintained with recent commits, CI on multiple OSes, and an issue tracker.
Shakapacker is a bridge to webpack or Rspack for Rails apps, supporting both webpack 5 and Rspack builds. It provides features like code splitting, Hot Module Replacement (HMR), CDN asset hosts, Subresource Integrity, and HTTP 103 Early Hints. The repository is well-maintained with a clear structure and documentation.
The OWASP AI Security Verification Standard (AISVS) is a community-driven, open-source framework providing a comprehensive set of verifiable security requirements for AI-enabled systems. Modeled after the OWASP Application Security Verification Standard (ASVS), it defines 12 control families (C01-C12) covering the entire AI lifecycle, from training data integrity and model lifecycle management to adversarial robustness and monitoring/logging. The repository is structured as a living standard with two parallel tracks: a locked, stable release (1.0/) and an active development version (1.01-dev/). Each requirement is backed by an extensive research wiki that details the threat landscape, notable incidents, tooling maturity, verification approaches, and open research questions. This makes the AISVS not just a checklist, but a deeply researched knowledge base for engineers, auditors, and security architects building and evaluating AI systems. It also includes appendices for a glossary, a controls inventory, and AI-assisted secure coding practices. Note: This is a documentation/specification repository, not a software application or data science project. Its quality is measured by the rigor of its research, the clarity of its requirements, and the maintainability of its structure.
PiPedal is a real-time audio effects processing system designed for guitarists, featuring a hybrid architecture with a C++ backend and React/TypeScript frontend. It hosts LV2/VST3 plugins to create customizable pedalboard chains, provides web-based remote control, manages Wi-Fi connectivity (including hotspot and P2P modes), handles MIDI input, and manages presets/snapshots of effect configurations. The system emphasizes low-latency audio processing for live performance and integrates with online services like Tone3000 for neural amp model downloads.
Patina is a deterministic, pattern-based AI text detection and humanization tool, primarily targeting Korean but supporting English, Chinese, and Japanese. It operates as a Node.js CLI (`patina-cli`), a web API (Vercel serverless), and an agent skill (Claude Code, Codex, Cursor). The core workflow: analyze source text for AI-typical patterns (stylometry, lexicon, discourse tells), build a structured prompt, invoke an LLM backend (OpenAI, Claude, Gemini, Kimi, etc.), verify meaning preservation (MPS/fidelity), and output a humanized rewrite with a deterministic audit trail. It enforces strict meaning guards (number safety, polarity, causation) and provides scoring, diff, and verification modes. The architecture is modular: a shared deterministic analysis core (`src/features/`) runs identically in Node and browser; a prompt builder assembles context from pattern packs, document types, and personas; multiple backend adapters abstract LLM invocation; and a verification pipeline ensures fidelity. The project includes extensive research infrastructure (benchmarking, human evaluation panels, corpus management) and a commercial Pro tier with Polar license validation. It is well-tested with over 200 unit/e2e tests, CI/CD, and security hardening (SSRF guards, input fencing, atomic writes).
SGLang-JAX is a high-performance LLM inference engine optimized for TPU/GPU hardware using JAX. It implements continuous batching, radix tree KV cache management, FlashAttention integration, tensor parallelism, and disaggregated serving (prefill-decode separation). The system provides OpenAI-compatible API endpoints for text generation, chat, embeddings, and tool use, with support for Mixture-of-Experts models, LoRA adaptation, quantization, and speculative decoding. Architecture features modular components: tokenizer manager, scheduler, model executor, memory hierarchy (including HiCache host-device transfer), optimized JAX/Pallas kernels, and LoRA adapter management. Designed for production serving workloads on TPU infrastructure with first-party support for Qwen, Llama, Gemma, DeepSeek, and multimodal models.
The e-invoice-eu repository is a monorepo providing a toolchain for generating EN16931-compliant electronic invoices (UBL, CII, Factur-X/ZUGFeRD, XRechnung) from spreadsheet data or JSON. It consists of a core TypeScript library, a CLI tool, a NestJS-based REST API server, and documentation. The core library implements a strategy pattern for format services, a factory for creating them, a mapping service for spreadsheet-to-invoice transformation, and validation services. The architecture is modular and well-tested, with clear separation of concerns.
AXorcist is a Swift library and CLI tool for macOS accessibility automation, wrapping the Accessibility (AX) APIs to inspect, query, and control UI elements programmatically. The core library provides a typed `Element` struct over `AXUIElement`, a command-response protocol with JSON envelopes, a powerful observer system with retry/backoff and process-generation tracking, input simulation (mouse, keyboard), and tree traversal with search criteria. The CLI (`axorc`) exposes commands like `find`, `tree`, `raw`, `permissions`, and `observe`, all producing structured JSON output. The architecture is modular with heavy use of Swift extensions, `@MainActor` isolation, and async/await concurrency. The codebase is well-structured, extensively tested (unit and integration tests), and follows modern Swift practices with pinned dependencies (Commander, swift-log) and strict concurrency checking. It is actively maintained with CI workflows for building, linting, and security scanning.
Vigil is an open-source AI SOC (Security Operations Center) platform that orchestrates autonomous threat hunting, incident response, and case management through a multi-agent architecture. The system ingests security findings from SIEMs (Splunk, Elastic, Azure Sentinel), EDRs (CrowdStrike, Microsoft Defender), and other sources via Kafka or webhooks, then uses LLM-driven agents (hunt, root_cause, adjudicate, investigate, compose, chat) to analyze, enrich, and respond. A TypeScript agent layer with event-sourced ledgers and budget enforcement runs investigations, while a Python daemon handles polling, deduplication, and orchestration. The platform exposes its own tools via MCP (Model Context Protocol) and integrates with 30+ external security tools through a descriptor-based plugin system. The frontend is a React SPA with a setup wizard, dashboards, and case management UI. Deployment is via Docker Compose or Helm, with PostgreSQL, Redis, and optional Kafka as backing services.