This repository is a Laravel package that provides comprehensive geographical data (countries, states, cities, timezones, currencies, languages) and IP geolocation functionality. It implements a facade-based interface (`World::countries()`) and RESTful API endpoints (`/api/countries`, etc.) for accessing the data, which is stored in JSON files and seeded into database tables via Artisan commands. The package includes localization support for over 20 languages, configurable modules, caching mechanisms, and middleware for automatic locale and geolocation handling. The architecture follows Laravel conventions with service providers, controllers, models, migrations, and seeders, while employing an Action pattern to separate query logic, transformation, and business rules.
This repository provides a single-header C/C++ library (utf8.h) for UTF-8 string manipulation. It implements a comprehensive set of functions mirroring the standard C string.h and strings.h APIs, but operating on UTF-8 encoded strings with codepoint-aware semantics. The library includes functions for length calculation (utf8len), comparison (utf8cmp, utf8casecmp), concatenation (utf8cat), searching (utf8chr, utf8str, utf8casestr), validation (utf8valid, utf8makevalid), case conversion (utf8lwr, utf8upr), and codepoint extraction (utf8codepoint, utf8rcodepoint). It supports C++14 constexpr for many functions and C++20 char8_t. The code is highly portable, tested across multiple compilers (gcc, clang, MSVC, tcc) and platforms (Linux, macOS, Windows), and includes extensive unit tests covering edge cases like invalid sequences, truncated strings, and case mapping for Latin, Greek, and Cyrillic scripts. The library is self-contained with no external dependencies beyond the standard C library.
Flannel is a layer 3 network fabric designed for Kubernetes that provides overlay networking between hosts. It runs a flanneld agent on each node to allocate subnet leases from a preconfigured address space using either Kubernetes API or etcd for storage. Traffic is forwarded via pluggable backend mechanisms including VXLAN, UDP, IPsec, host-gw, WireGuard, and cloud-specific integrations like Tencent VPC. The architecture separates concerns into backend management, subnet allocation, traffic management (iptables/nftables), and routing, with a plugin system enabling extensibility. Key entry points include the main daemon (main.go), backend registration system, subnet watchers, and traffic manager interfaces. The system handles IP address allocation, encapsulation, decapsulation, and traffic masquerading to enable pod-to-pod communication across nodes in a cluster.
This repository provides a comprehensive suite of GitHub Actions for automating Terraform and OpenTofu workflows in CI/CD pipelines. Each action (e.g., terraform-apply, terraform-plan, terraform-validate) is implemented as a standalone reusable workflow with standardized inputs, outputs, and Docker-based execution environments. The architecture features a common shell library (actions.sh) that handles tool installation, backend initialization, and shared utilities, while individual actions focus on specific operations like plan generation, state management, or pull request commenting. Key capabilities include version detection from multiple sources, backend fingerprinting for state identification, automated PR commenting with approval workflows, and support for both Terraform and OpenTofu. The project emphasizes reliability through extensive testing across versions and backends, with clear separation of concerns between action definitions, implementation logic, and documentation generation.
cuDF is a GPU-accelerated DataFrame library developed by NVIDIA as part of the RAPIDS ecosystem. It provides a pandas-compatible Python API (`cudf`), a Polars-compatible execution engine (`cudf_polars`), a zero-code-change pandas accelerator (`cudf.pandas`), distributed processing via Dask (`dask_cudf`), a streaming distributed execution engine (`cudf_streaming`), Kafka integration, Java bindings, and a low-level C++ library (`libcudf`). In production, cuDF accelerates data manipulation, ETL, analytics, and ML preprocessing on NVIDIA GPUs by executing columnar operations in CUDA kernels while managing GPU memory through RMM. The monorepo contains over 5000 files spanning C++, Python, Java, Rust, and shell, with extensive unit tests, benchmarks, CI pipelines, and documentation. Key architectural patterns include consistent stream/memory-resource propagation via `cudf::detail` namespaces, a result cache for aggregation reuse, a fast-slow proxy pattern for transparent GPU/CPU fallback, and a streaming actor model for distributed pipelines.
Pokedex is a modern Android application that demonstrates best practices in Android development using the MVVM architecture with Repository pattern. The app fetches and displays Pokémon data from the PokeAPI, featuring offline-first capabilities through Room database caching, pagination for efficient data loading, and smooth transition animations between list and detail views. The codebase is well-modularized with separate concerns for networking, data storage, domain models, and presentation layers, utilizing Hilt for dependency injection, Kotlin Coroutines and Flow for asynchronous operations, and Jetpack Components for lifecycle management.
Netpoll is a high-performance non-blocking I/O networking framework for Go, developed by ByteDance for RPC scenarios. It provides an event-loop server and dialer with zero-copy Reader/Writer APIs backed by a custom linked buffer (LinkBuffer). Under the hood, it uses epoll on Linux and kqueue on BSD, with an operator cache and a load-balanced poll manager. The architecture is a non-blocking reactor pattern: an event loop accepts connections, assigns them to pollers, and schedules OnRequest/OnConnect/OnDisconnect callbacks asynchronously via a goroutine pool. The library features connection health checking, idle timeout, and a connection reuse probe for client pools. It is production-ready and used by ByteDance's RPC framework Kitex and HTTP framework Hertz.
Hoppscotch is an open-source, multi-platform API development ecosystem that serves as a full-featured alternative to Postman. It supports REST, GraphQL, WebSocket, SSE, Socket.IO, and MQTT protocols, with advanced features like pre-request and test scripting (sandboxed), environment variables, team collaboration, mock servers, published documentation, AI assistant, and extensive import/export (Postman, Insomnia, OpenAPI, HAR, cURL). The monorepo is organized into packages: a Vue 3 frontend (hoppscotch-common), a NestJS/GraphQL/Prisma backend (hoppscotch-backend), a Tauri desktop app (hoppscotch-desktop), a Node.js CLI (hoppscotch-cli), a Tauri agent for interceptor (hoppscotch-agent), a shared kernel abstraction layer (hoppscotch-kernel), versioned data schemas (hoppscotch-data), a JavaScript sandbox engine (hoppscotch-js-sandbox), and self-hosted web/admin panels. The architecture emphasizes functional programming with fp-ts, reactive state management via RxJS DispatchingStores, dependency injection with dioc, and a kernel/relay pattern that abstracts HTTP execution across platforms. The codebase is actively maintained with extensive test coverage and demonstrates high craftsmanship in areas like versioned data migration, sandboxed script execution, and cross-platform kernel design.
Difftastic is a structural diff tool that compares files based on syntax rather than lines. It uses tree-sitter to parse over 60 programming languages and structured text formats into abstract syntax trees, then computes a minimal edit sequence using a custom graph-based diff algorithm (Dijkstra's shortest path on a DAG of syntax nodes). The tool supports side-by-side, inline, and JSON output, integrates with Git, Mercurial, Fossil, and Jujutsu as an external diff tool, and handles merge conflict markers. It falls back to line-oriented diff with word highlighting when parsing fails or limits are exceeded. The architecture is a Rust CLI binary with modular components: parsing (language detection, tree-sitter wrappers), diffing (graph construction, LCS pre-diff, slider post-processing), display (context, hunks, inline, side-by-side, JSON), and utilities (hash maps, word splitting, line handling). Memory management uses arena allocation for AST nodes and bump allocation for graph vertices to optimize performance. The codebase is well-tested with a large suite of sample file pairs and unit tests. Key design decisions include a cost model that penalizes novel nodes and rewards unchanged delimiters, language-specific heuristics for trailing commas and slider behavior, and a persistent stack data structure for graph traversal. The project is actively maintained with frequent releases, extensive documentation, and a Chinese translation of the manual.
Kotest is a multiplatform Kotlin testing framework that provides a rich DSL for defining tests in multiple spec styles (FunSpec, DescribeSpec, StringSpec, etc.), a comprehensive assertion library with over 200 matchers, property-based testing with arbitrary generators and shrinking, data-driven testing with tables, and a powerful extension system for lifecycle hooks and integrations (Spring, Testcontainers, Allure, MockServer). The framework runs on JVM, JS, Native, Wasm, and Android via custom test engines (JUnit5/6) and includes an IntelliJ plugin for gutter icons and test navigation. The architecture centers on a test execution engine with interceptors chaining around specs and test cases, configurable via project-level and spec-level configuration objects. Property testing uses composable `Arb` generators and `Exhaustive` enumerations with automatic shrinking and coverage statistics. Assertions follow a `Matcher<T>` pattern with extensible equality via the `Eq` typeclass. The build system uses Gradle convention plugins for consistent multiplatform publishing. Key entry points include `TestEngineLauncher`, spec style root scopes (e.g., `FunSpecRootScope`), and the `should`/`shouldNot` assertion DSL. Data flows: source code → test definitions → materialization → interceptor pipeline → execution → listener notifications → JUnit/compatible output. The framework is self-testing, using its own DSL for a large test suite.
This repository is a comprehensive Terraform module for provisioning and managing AWS EKS (Elastic Kubernetes Service) clusters. It provides a modular, production-grade interface to create clusters with all supporting resources: IAM roles, security groups, VPC networking, encryption (KMS), logging, addons, identity providers (OIDC/IRSA), and access entries. The root module orchestrates multiple sub-modules for compute resources including EKS managed node groups, self-managed node groups (autoscaling groups), Fargate profiles, Karpenter integration, hybrid node roles, and EKS capabilities (ACK, ArgoCD, KRO). The architecture follows standard Terraform module patterns with extensive use of `for_each`, `dynamic` blocks, and conditional creation. The codebase demonstrates high craftsmanship through its modular design, comprehensive test infrastructure, and detailed upgrade guides that document breaking changes across major versions (v17 through v21). It includes an internal user data rendering sub-module that supports AL2, AL2023, Bottlerocket, and Windows AMIs, with both cloud-init and custom template support.
A Python 3.14+ CLI tool (stdlib only) for detecting malware in packages from the Arch User Repository. It scans currently installed AUR packages, historical pacman logs, systemd services, eBPF rootkit artifacts, and npm/bun/yarn/pnpm caches against configurable campaign-based threat lists (e.g., the June 2026 atomic-lockfile attack, CHAOS RAT 2025, Russian spam campaigns). The architecture is modular: campaign configuration is data-driven (JSON), the scanner is split into focused mixin classes (PackageMixin, SystemMixin, CacheMixin) combined via the AurScanner class, and all results are typed dataclasses. The package runs with zero external dependencies, has comprehensive unit tests, and includes an integration layer (pacman hook + systemd timer) for continuous monitoring. The code demonstrates high craftsmanship: strict typing, defensive I/O, locale-safe date parsing, cache-efficient file scanning, and a clean exit-code scheme based on Nagios conventions.
MarkItDown is a Python library and CLI tool that converts a wide variety of file formats (PDF, DOCX, PPTX, XLSX, HTML, CSV, JSON, EPUB, Outlook MSG, images, audio, YouTube, RSS, IPYNB, ZIP, and more) into Markdown. Its primary production use is preparing documents for LLM ingestion, agent workflows, and text analysis pipelines. The architecture is a monorepo containing the core `markitdown` package, an OCR extension (`markitdown-ocr`) that uses LLM Vision for image text extraction, an MCP server (`markitdown-mcp`) exposing conversion as a tool for AI agents, and a sample plugin for third-party converters. The core library uses a plugin system based on `importlib.metadata.entry_points` to register converters, each implementing a `DocumentConverter` base class with `accepts()`/`convert()` methods and a priority-based dispatch. The main entry points are the `MarkItDown` class (Python API), the `markitdown` CLI, and the MCP server's `convert_to_markdown` tool. Data flows from local files, streams, HTTP responses, or URIs through converter selection (by MIME type, extension, or content inspection) to produce Markdown output. External dependencies include many optional format-specific libraries (pdfminer.six, python-docx, python-pptx, openpyxl, etc.), external binaries (exiftool, ffmpeg), cloud APIs (Azure Document Intelligence, Azure Content Understanding), and an OpenAI-compatible LLM client for image captioning and OCR.
This repository is the official FastAPI full-stack template, providing a production-ready starter for full-stack web applications. It consists of a FastAPI backend (Python 3.14, SQLModel ORM, PostgreSQL, Alembic migrations) and a React frontend (TypeScript, Vite, TanStack Router/Query, Tailwind CSS, shadcn/ui). The template ships with complete authentication (JWT, password hashing with Argon2/Bcrypt, password recovery via email), user and item CRUD, role-based access control, and a responsive dashboard UI. Deployment is handled via Docker Compose with Traefik, and the project includes comprehensive CI/CD pipelines for testing (pytest, Playwright) and deployment (FastAPI Cloud or self-hosted). While it is a template, the code is structured for immediate extension and includes many reusable patterns such as generic CRUD utilities, email templates written in React Email, and auto-generated OpenAPI client code for the frontend. The repository is not a data research project; it is a pure application template with no data pipelines, notebooks, or ML components. It is actively maintained, with frequent commits and a strong community following.
OpenSpec is an AI-native spec-driven development CLI tool that provides a lightweight agreement layer between humans and AI coding assistants. It manages structured 'changes' with proposals, delta specs, designs, and tasks, supporting 30+ AI coding tools (Claude, Cursor, Devin, Copilot, etc.) by generating per-tool skills and slash commands. The CLI features a store system for cross-repo planning, an artifact graph for tracking change progress, shell completion generation, and a validation system. The codebase is well-structured with extensive test coverage, reusable components (artifact graph, markdown parser, command generation adapters, store foundation), and security-conscious patterns (atomic writes, prototype pollution guards). It is actively maintained with a large community (70k+ stars).
Einops is a Python library that provides a uniform, readable, and reliable API for tensor manipulation across multiple deep learning frameworks (NumPy, PyTorch, TensorFlow, JAX, and others). It uses Einstein-like notation (e.g., 'b c h w -> b h w c') to express axis reordering, composition, decomposition, reduction, and repetition in a single, explicit string. The library is built around a core transformation engine that parses axis patterns into a cached 'TransformRecipe', which is then applied via a backend abstraction layer. This architecture allows einops to support 10+ frameworks with minimal code duplication, while also providing framework-specific layer wrappers (Rearrange, Reduce, EinMix) for seamless integration into model definitions. The library is designed for production and research use, with a focus on reducing errors from manual view/permute/transpose operations.
Arrow is a Python library providing enhanced date and time manipulation capabilities, serving as a drop-in replacement for datetime with improved usability. It offers timezone-aware objects, human-readable time deltas, flexible parsing/formatting, and time span generation. The architecture centers around an immutable Arrow class with factory methods for creation, supplemented by dedicated modules for parsing, formatting, localization, and utilities. The library follows Python best practices with type hints, comprehensive testing, and clear separation of concerns. Its locale system supports over 60 languages for internationalized date representation.
Hyperswitch is a composable open-source payments infrastructure built in Rust that provides a modular platform for processing payments through multiple connectors. The system handles the complete payment lifecycle including authorization, capture, refunds, and dispute management, while offering features like intelligent routing, 3DS authentication, revenue recovery, and analytics. Built with a microservices architecture using Actix-web, it features a plugin-based connector system, event-driven design with Redis/Kafka, and comprehensive SDK support for web and mobile platforms. The codebase demonstrates strong engineering practices with typesafe ID generation, robust encryption utilities, and well-abstracted interfaces that promote reusability and maintainability.
Nebula is a local-first security assessment workbench designed for penetration testing and red teaming operations. It functions as a desktop application built with a Tauri shell (Rust) wrapping a React/TypeScript frontend and a Python FastAPI backend sidecar. The system manages security engagements, scope policies, evidence collection, and AI-assisted analysis, emphasizing operator control, auditability, and data privacy through local-first execution and content-addressed artifact storage. The architecture follows a sidecar pattern where the Python Core service handles database operations (SQLite with Alembic), containerized command execution (Kali Linux via Docker/Podman), and AI provider integration. The frontend manages the UI state and terminal sessions via WebSocket. Key data flows involve user actions triggering API calls that validate against scope policies before executing commands in isolated containers, with all outputs stored as immutable artifacts for evidence integrity. The codebase demonstrates strong engineering practices with extensive test coverage (Pytest, Vitest, Playwright), a robust diagnostic system with secret redaction, and a policy engine for deterministic scope enforcement. It supports multiple AI providers and includes features for knowledge indexing, mission orchestration, and report generation. The project is actively maintained with recent commits and zero security alerts, though it is currently in alpha release.
This is a Material Design theme for Hexo, a static site generator. The theme provides a complete frontend solution for Hexo-powered blogs, featuring responsive design, dark mode support, multiple comment system integrations, lazy loading, and client-side search. It follows a modular architecture with EJS templates for layout organization, Stylus for CSS preprocessing, and JavaScript for interactive features. The theme is highly configurable through _config.yml and supports extensive customization via custom CSS/JS.