cgltf is a single-file, stb-style C library for parsing and writing glTF 2.0 files. It provides a comprehensive set of data structures mirroring the glTF spec, along with functions to parse JSON/GLB, load buffers, validate data, and write back glTF/GLB. The library is self-contained, requires no external dependencies, and includes an embedded copy of the JSMN JSON parser. It supports core glTF 2.0 and many extensions (KHR_materials_*, KHR_lights_punctual, EXT_mesh_gpu_instancing, etc.). The code is well-structured, uses C99, and is designed for easy integration into any C or C++ project. It is used by major projects like bgfx, Filament, and raylib. The writer component (cgltf_write.h) is separate but similarly crafted. The repository includes a comprehensive test suite and fuzz testing setup.
This repository provides a native PHP implementation of enumeration types, offering base Enum class, EnumSet for efficient set operations, and EnumMap for mapping enum keys to values. The Enum class implements the singleton pattern for enum values, ensuring that equivalent enum values are identical instances, and includes features like lazy constant discovery, inheritance support, and proper comparison handling. The EnumSet component stands out for its innovative bit vector implementation that automatically switches between integer storage (for small sets) and binary string storage (for large sets) to optimize memory usage and performance. It provides standard set operations (union, intersection, difference, symmetric difference) through efficient bitwise operations, making it particularly valuable for applications requiring efficient set manipulation on enum values. The library is well-maintained with comprehensive test suites, benchmarks, and support for multiple PHP versions. It follows semantic versioning and includes development tools for code quality checking. While the EnumSerializableTrait provides serialization support with noted caveats, the core enum functionality is robust and suitable for use in production PHP applications requiring type-safe enumeration patterns.
GPTLint is a linting tool that uses Large Language Models (LLMs) to enforce code quality rules. It employs a two-pass approach: a faster, cheaper LLM model identifies potential violations, and a more accurate, expensive model validates them to reduce false positives. The tool supports both built-in and custom rules defined in markdown files, caches results to avoid reprocessing unchanged files, and provides both a CLI and programmatic API. The architecture is modular, with separate components for configuration, rule parsing, linting, caching, and LLM abstraction.
Kubenix is a Nix-based framework for declarative Kubernetes management. It uses the NixOS module system to define Kubernetes resources, Helm charts, Docker images, and custom resources in a type-safe, composable manner. The project provides a CLI tool for applying manifests with diffing, pruning, and secret injection via vals. At its core, kubenix is a set of Nix library functions and modules that evaluate user configuration to produce Kubernetes YAML/JSON. It supports submodules (nested composable configurations), testing frameworks (including kubetest), and code generation from Kubernetes OpenAPI specs. The architecture is purely functional, leveraging Nix's lazy evaluation to merge and validate resources at build time. This is a hybrid project combining a library (Nix modules and functions) with an application (CLI tool), but it is classified as an application because its primary deliverable is a deployable package and CLI.
Irmin is an OCaml library for building mergeable, branchable, distributed data stores with Git-like version control semantics (snapshot, branching, merging, push/pull). It provides a content-addressable, immutable store with multiple pluggable backends: an in-memory store for prototyping, a Git-compatible store for interoperability, a high-performance on-disk pack-file store (irmin-pack) optimized for large-scale append-only workloads, a filesystem store, a chunked store, and a MirageOS unikernel adapter. The library exposes a rich API including tree operations, Merkle proofs, watches/notifications, remote synchronization, and a GraphQL server. It ships with a CLI tool (irmin), a client/server protocol over TCP/Unix sockets/WebSockets, and C bindings (libirmin) for non-OCaml consumers. The primary production consumer is the Tezos blockchain, which uses irmin-pack for its on-disk storage; the codebase includes Tezos-specific schemas, an explorer GUI, and trace replay benchmarks. The architecture is heavily functor-based, using OCaml first-class modules for dependency injection, which enables backend swapping and extensive code reuse across packages.
Protenix is a production-oriented PyTorch implementation of AlphaFold 3 for biomolecular structure prediction, maintained by ByteDance. It is best classified as an application rather than a pure research codebase: it ships a `protenix` CLI with commands for prediction, input conversion, MSA/template/RNA-MSA search, and data preparation, plus training/fine-tuning entry points, batch inference runners, Docker deployment, web-service helpers, and PyPI packaging. The code ingests PDB/CIF, FASTA, SMILES/SDF, and JSON descriptors covering proteins, DNA, RNA, ligands, ions, modified residues, covalent bonds, and contact/pocket constraints, then outputs predicted 3D CIF structures with confidence metrics such as pLDDT, PAE, pTM, and ipTM.
xgplayer is a production-grade, plugin-based HTML5 video player library maintained by ByteDance. It provides a core player package (`packages/xgplayer`) with UI controls, event/hook systems, device sniffing, i18n, and a rich plugin registry, plus separate npm packages for streaming protocols including HLS, FLV, DASH, MP4, and MPEG-TS transmuxing. The architecture is a monorepo of coordinated packages: streaming plugins built on shared networking, MSE, buffer, and error utilities; a custom type-level transmuxer that demuxes/remuxes FLV/TS/MP4 into fMP4 for Media Source Extensions; and extension packages for Chromecast/AirPlay, Google IMA ads, subtitles, and music visualization. In production this library plays both VOD and live streams in the browser, handles adaptive bitrate switching, DRM, low-latency manifest polling, and provides full control UI for desktop and mobile.
This repository is Confluent's official JavaScript client for Apache Kafka, wrapping the high-performance C library librdkafka via native Node.js addons. It provides two API surfaces: a legacy callback-based API (node-rdkafka) and a modern promisified API compatible with the popular KafkaJS library. The client supports all core Kafka operations: producing and consuming messages (including transactional and exactly-once semantics), admin operations (topic management, consumer groups, offsets), and stream-based interfaces. Additionally, it includes a full Schema Registry client (TypeScript) with serializers/deserializers for Avro, JSON Schema, and Protobuf, along with a rule execution engine supporting CEL (Common Expression Language), JSONata, and field-level encryption via pluggable KMS drivers (AWS, GCP, Azure, HashiCorp Vault, local). The architecture is layered: a C++ binding layer handles the Kafka protocol, while pure JavaScript/TypeScript implements schema management, rule evaluation, and encryption. Key entry points are `lib/index.js` (node-rdkafka), `lib/kafkajs/index.js` (KafkaJS), and `schemaregistry/index.ts` (Schema Registry). External dependencies include librdkafka, protobuf, avsc, axios, and cloud KMS SDKs. The codebase is production-grade with extensive unit, integration, and e2e tests, performance benchmarks, and CI/CD pipelines across multiple platforms.
Prefire is a Swift developer tool that scans SwiftUI source files, extracts `#Preview` macros and `PreviewProvider` declarations, and generates automated snapshot tests plus an interactive "Playbook" component catalog. It is not a data project: it is a CLI/code generator with a runtime library and SwiftPM/Xcode build-tool plugins. The real pipeline is: a build plugin invokes the `prefire` binary with target/source/config arguments; the binary parses sources using SwiftSyntax for `#Preview` macro ranges and a Sourcery fork for `PreviewProvider` types; a fingerprint-based cache avoids re-parsing unchanged files; Stencil templates (one for snapshot tests, one for playbook models) render generated Swift code; snapshot tests run against swift-snapshot-testing and the bundled Prefire runtime, while `PlaybookView` renders the generated `PreviewModels` inside an app.
This repository is the NVIDIA cuQuantum SDK, a comprehensive suite of GPU-accelerated libraries for quantum computing simulation. It provides high-performance implementations for state-vector simulation (cuStateVec), tensor network contraction and decomposition (cuTensorNet), density matrix evolution (cuDensityMat), Pauli propagation (cuPauliProp), and stabilizer simulation (cuStabilizer). The codebase includes Python bindings with both high-level APIs (e.g., NetworkState, DenseMixedState, Operator) and low-level Cython bindings, as well as C++ sample codes, a benchmark suite, and JAX extensions for differentiable quantum operations. The architecture is modular, with each quantum simulation method organized into its own subpackage under `cuquantum/`. The Python package exposes a consistent interface for circuit simulation, operator construction, and distributed execution via MPI/NCCL. Key entry points include the `cuquantum.tensornet`, `cuquantum.densitymat`, `cuquantum.stabilizer`, and `cuquantum.pauliprop` modules, along with the `cuquantum.bindings` for direct C API access. The repository also contains extensive tests and samples that validate correctness against analytical results and reference implementations. The codebase is actively maintained with recent commits and issue triage. It demonstrates strong engineering practices with reusable patterns for memory management, callback-based operator coefficients, distributed tensor layouts, and custom JAX differentiation. However, some experimental APIs and version inconsistencies (e.g., CITATION.cff vs pyproject.toml) indicate areas of potential drift. Overall, it is a high-quality, production-ready SDK for quantum computing research and development.
This repository is the official Sentry SDK for PHP, distributed as a Composer library. In production it captures PHP exceptions/errors, transactions/spans, profiling samples, structured logs, metrics, and cron monitor check-ins, then serializes them into Sentry envelope items and sends them through pluggable transports (HTTP, local agent, Spotlight). The public surface is src/functions.php plus SentrySdk/Hub/Scope state management; ClientBuilder assembles the client with integrations, options, and serializers. The architecture is a framework-agnostic library: Hub/Scope manages per-execution state, Client orchestrates capture pipelines, Event is the unified telemetry model, PayloadSerializer builds envelopes, and integrations hook into framework events. It supports PSR-7/PSR-3 and optional integrations with Monolog, Guzzle, OpenTelemetry, FrankenPHP, and RoadRunner. Data collection is governed by a policy layer with deny/allow-list PII filtering, HTTP body/cookie/header collectors, and stack frame variable sanitization. The codebase is mature and well-tested, but carries a long backward-compatibility tail: legacy data-collection flags coexist with newer data_collection options, metrics APIs are deprecated for 5.x, and the static analysis baseline contains a sizable number of mixed-type/nullability issues. The core abstractions remain clean and several utilities are genuinely reusable.
Codex Autoresearch is a Codex skill that enables autonomous, measurable experimentation on Git repositories. It provides a CLI tool that manages the lifecycle of experiments: initialization, iteration (commit, measure, keep/revert), blocking, status, history, report generation, stop, resume, and archive. The system supports both foreground (interactive) and background (detached controller with workers) modes. The architecture is cleanly separated into three Python modules: `autoresearch.py` (CLI entry point), `autoresearch_core.py` (core primitives for state management, Git operations, command execution, and process management), and `autoresearch_report.py` (read-only views: terminal table, TSV, and self-contained HTML report). The core library demonstrates high craftsmanship with strict JSON schema validation, atomic file writes, robust command execution with timeout and encoding detection, and cross-platform process tree termination. The system is designed for reliability: every experiment is a Git commit, non-improving trials are reverted, and all state is stored in an append-only event log (`events.jsonl`). The validation is strict; malformed or contradictory state is never reconstructed from logs or conversation. This makes the tool trustworthy for long-running autonomous optimization tasks. While the primary use case is as a Codex skill, the core library (`autoresearch_core.py`) contains reusable patterns for state management, command execution, and Git automation that could be extracted for other projects. The HTML report generator (`autoresearch_report.py`) is a self-contained component that produces beautiful, accessible reports with SVG charts and could be adapted for any event-driven experiment tracking system.
grex is a regular expression generator that creates regex patterns from user-provided test cases. It implements DFA construction, Hopcroft's minimization algorithm, and Brzozowski's algebraic method to produce Perl-compatible regexes. The system serves dual purposes as a command-line utility and a library with bindings for Rust, Python, and WebAssembly. Key features include Unicode grapheme handling, configurable character class conversions (digits/whitespace/word), case insensitivity, repetition detection, and syntax highlighting. The architecture separates core regex building logic from CLI, Python, and WASM extension points, enabling reuse across multiple contexts.
This repository is a full-stack web application that simulates the WeatherStar 4000, the iconic 1990s cable television weather display system. It is a monolith composed of a Node.js/Express backend (`index.mjs`) and a single-page application frontend built with client-side JavaScript modules (`server/scripts/modules/`). The backend serves an EJS template and acts as a caching proxy for external weather APIs, while the frontend renders a retro-styled, TV-like interface with scanlines, custom fonts, and modular weather displays. The primary data flow involves fetching real-time weather data from the National Weather Service (NWS/NOAA) API, Iowa State Mesonet, and the HRRR model archive. The application supports two deployment modes: a static mode where the frontend calls APIs directly, and a server mode where the Express backend proxies and caches requests to reduce load and improve performance. Static data for cities and stations is generated by a suite of CLI tools in the `datagenerators/` directory. The codebase demonstrates high craftsmanship in several areas. The `proxy/cache.mjs` module implements a sophisticated HTTP cache with stale-while-revalidate and request deduplication, a genuinely reusable component. The `future-radar/zarr.mjs` module includes a custom Zarr v2 reader with a Blosc/LZ4 decoder, showcasing non-obvious data engineering skill. The `utils/setting.mjs` module provides a clean, observable pattern for UI settings. The data generators, particularly `stations-postprocessor.mjs`, employ a priority-based conflict resolution system for cleaning airport data. The project is actively maintained, with a well-defined build process (Gulp), CI/CD pipelines (GitHub Actions), and pinned dependencies. Its primary risk is tight coupling to the NOAA API ecosystem, making it US-only. The test suite is a smoke test rather than comprehensive unit tests. Overall, it is a strong, well-architected codebase with several genuinely reusable components, scoring an 8.0 on the quality rubric.
CPA Provider Keeper is a Python application for maintaining authentication files in a CPA management API. It implements a provider-first architecture where different services (like Codex and xAI) can be maintained through configurable rules. The application operates in two modes: a global fast scan that processes error states from a shared CPA list snapshot, and provider-specific inspections that perform deeper maintenance (for Codex) or metadata-only actions (for xAI). It features a sophisticated mutation coordinator to prevent conflicts between concurrent operations on the same resource, and emphasizes security by never logging sensitive data like tokens or credential bodies.
Goeland is a self-hosted RSS/Atom feed to email digest tool written in Go. It fetches feeds from RSS/Atom/JSON sources, Imgur tags, and Miniflux instances, applies a composable chain of filters (e.g., unseen, today, digest, language, retrieve, replace), and sends beautiful responsive HTML emails via SMTP or writes to HTML files. It runs as a one-shot CLI command or as a persistent daemon with per-pipe cron scheduling. The architecture is modular: commands are defined with Cobra, configuration is read via Viper (TOML files with env overrides), logging uses Logrus with structured output support, and unseen entry tracking uses BoltDB. External dependencies include an SMTP server, Miniflux REST API, Imgur API, and optional CSS themes. The codebase demonstrates strong engineering practices: clean package boundaries, thorough unit tests (filter_test.go covers all filters including edge cases), security-conscious HTTP fetching with SSRF protection, internationalization support, and automated CI/CD with Docker multi-arch builds. It is production-stable and actively maintained.
This library provides a polyfill/shim for the IndexedDB API, implementing IndexedDB functionality using WebSQL as a backend storage mechanism. It works in both browser environments (leveraging native WebSQL where available) and Node.js (via websql-configurable/SQLite3). The library offers both invasive (automatically setting global indexedDB) and non-invasive (requiring explicit setup) versions. It implements the full IndexedDB specification including databases, object stores, indexes, transactions, and cursors, with proper handling of JavaScript value serialization through a structured cloning algorithm. The project features comprehensive test suites validating W3C compliance and active maintenance with regular updates to address compatibility issues and specification changes.
ArrayFire is a mature, production-grade tensor and array computing library implemented in C++, exposing both a C API (af_* functions) and a C++ API (af::array). It provides hundreds of accelerated numerical operations — dense and sparse linear algebra (LU, QR, SVD, Cholesky, solve), FFT and signal processing, image transforms and filtering, computer vision feature detection (FAST, SIFT, ORB, SUSAN, homography), statistics, and random number generation — across four hardware backends: CPU, CUDA, OpenCL, and oneAPI/SYCL. The architecture is layered: thin C API wrappers and C++ classes in src/api/c and src/api/cpp dispatch through a unified runtime layer (src/api/unified) that lazily loads backend shared libraries via a symbol manager; each backend implements the same templated operation set over device-resident arrays with backend-specific kernels under src/backend/*/kernel. The genuinely interesting engineering lives in src/backend/common: a JIT expression-tree system that fuses array operations into compiled kernels, deterministic hash-based kernel caching, a memory manager with JIT-pressure eviction heuristics, FFT plan caching, and cross-platform dynamic library loading. The test suite is unusually rigorous for a numerical library — well over 100 gtest programs covering correctness across all dtypes, large dimensions, random-number quality via PractRand, and death tests — while examples span image processing, machine learning, financial Monte Carlo, and PDE simulation. Maintenance is active (commits through 2026, CI workflows, source releases), but technical drift is medium: the oneAPI backend is explicitly incomplete with many operations stubbed as ONEAPI_NOT_SUPPORTED, deprecated compatibility APIs remain (include/af/compatible.h), the four backends duplicate a large amount of near-identical code, and some packaging artifacts (Tegra toolchain pinned to gcc-5, vendored vcpkg LAPACK patches, Debian postinst hardcoding MKL/CUDA paths) are stale. This is a software library rather than a data pipeline — there are no notebooks, datasets, or analytical artifacts — though its algorithms are directly applicable to computer vision and scientific computing workloads.
XGo (formerly Go+) is a Go-superset programming language delivered as a complete compiler toolchain. The repository implements the full language pipeline: a custom scanner (scanner/), parser (parser/), extended AST (ast/), semantic compiler (cl/), and code generator that lowers XGo source to standard Go via the gogen code builder. The xgo CLI (cmd/xgo) exposes subcommands for build, run, test, fmt, go, install, mod, pack, serve, watch, and version, wrapping the Go toolchain after transpilation. The language extends Go with command-style calls, keyword arguments, tuples, list/map/select comprehensions, error-wrapping operators (expr!, expr?), overloaded functions and operators, enums, domain-text literals, and classfile frameworks for domain-specific applications (spx games, MCP servers, shell scripts). The architecture follows a classic compiler design: XGo source → scanner → parser → AST → cl semantic analysis/code generation → gogen → Go source → standard Go toolchain. The tool/ package orchestrates module loading, go.mod management, and delegation to go build/run/test. A language server (x/langserver) with a bundled JSON-RPC2 library (x/jsonrpc2) supports editor tooling. Two notable sub-systems ship alongside the compiler: DQL (dql/), a unified query language over HTML/XML/JSON/YAML/Go AST trees, and TPL (tpl/), a grammar-based DSL parser generator used for domain-text literals. Hundreds of golden-test pairs (in.xgo/out.go) validate compiler output across Go versions 1.18-1.27. External dependencies include github.com/goplus/gogen (code builder), github.com/goplus/mod (module handling), github.com/qiniu/x (errors/streams), and cobra for CLI construction. The codebase forks several Go standard library internals (scanner, printer, ast) to support extended syntax, creating ongoing maintenance burden as Go evolves. Some features remain incomplete (panic("TODO") in matrix literal compilation, fully commented-out ast/resolve.go), and legacy naming aliases (gop vs xgo, gop.mod vs gox.mod) coexist throughout.
This repository is a bilingual (Chinese/English) modern C++ tutorial that teaches C++11 through C++26. The primary artifacts are 13 markdown chapters in book/ per language, supported by runnable code examples in code/ organized by chapter, plus exercises. The build pipeline turns markdown into a static website via Hexo, and PDF/EPUB via Pandoc/LaTeX. Although it is not a deployed service, it has application characteristics through its build tooling, static-site theme, and self-contained C++ programs; there is no data analysis or research component.