The repository provides a command-line tool for computing VMAF (Video Multi-method Assessment Fusion) scores between reference and distorted video streams. It automates preprocessing steps required for accurate VMAF assessment, including deinterlacing, scaling, frame rate adaptation, and temporal synchronization. The tool supports both CPU and GPU-accelerated VMAF computation via libvmaf and libvmaf_cuda, and can process multiple video pairs using glob patterns. The architecture follows a three-layer design: the CLI layer handles argument parsing and output formatting, the VMAF layer orchestrates preprocessing and scoring, and the FFmpeg layer provides low-level wrappers for FFmpeg/FFprobe subprocesses and filterchain management. This separation of concerns makes the FFmpeg wrapper component particularly reusable for other multimedia processing tasks. The tool outputs results in JSON, XML, CSV, or to stdout, and includes features such as automatic sync window search, reverse sync, end-sync option, VMAF model selection (HD and 4K), and CAMBI heatmap generation. It is designed for Linux and macOS, with Docker support for both CPU and GPU environments.
Gyroflow is a cross-platform desktop and mobile application for video stabilization using gyroscope and IMU data. It ingests telemetry from a wide range of cameras (GoPro, Sony, Insta360, DJI, Canon, RED, Blackmagic, etc.), applies lens distortion correction, rolling-shutter compensation, and smoothing algorithms, then exports stabilized video via FFmpeg with GPU acceleration. The architecture is a Rust core library (gyroflow-core) with a Qt/QML GUI, GPU backends (OpenCL, wgpu/Vulkan/Metal/DirectX, Qt RHI), and a rendering pipeline supporting hardware encoding. It also includes advanced features like optical-flow-based synchronization, lens calibration, adaptive zoom, and NLE plugin installation. The codebase is large and well-structured, with trait-based algorithm dispatch for distortion models, smoothing, optical flow, and pose estimation. It demonstrates strong engineering in GPU interop, signal processing, and computer vision. However, it uses a custom Rust-like dialect (macros that transpile to Rust/C++) which increases onboarding complexity, and there are many platform-specific conditionals and some unwrap-heavy error handling. The project is actively maintained with a large community and frequent updates.
NVIDIA cuOpt is a GPU-accelerated optimization solver library covering linear programming (LP), mixed-integer programming (MIP), quadratic programming (QP), second-order cone programming (SOCP), and vehicle routing problems (VRP, PDP, TSP). The codebase is predominantly an application: it provides multiple deployment forms—a C++ shared library, Python bindings (Cython), a Java JNI interface, a CLI tool (`cuopt_cli`), a gRPC server for remote solves, and a FastAPI-based HTTP server (`cuopt_server`). It also includes comprehensive CI/CD pipelines, benchmarks, and documentation. However, it exhibits a hybrid nature due to its strong research character: advanced algorithmic innovations (e.g., primal-dual hybrid gradient with adaptive step sizing, novel MIP presolve techniques, lattice propagation, deterministic parallel branch-and-bound, SIMD-accelerated MPS parsing, and diversity-based routing heuristics) are deeply embedded in the core solvers. The system is architected as a layered monolith: common utilities and linear algebra form the base, solver-specific modules (PDLP, dual simplex, barrier, branch-and-bound, routing heuristics) sit above, and language bindings and server endpoints wrap the C++ core. Key data flows include parsing MPS/LP files or building problems programmatically, dispatching to the appropriate GPU solver, and retrieving solutions via C structs, Python objects, or protobuf messages. External dependencies include CUDA, cuSPARSE, RMM, NCCL, gRPC, Protobuf, and optionally PaPILO for presolve. The repository is actively maintained with frequent commits and nightly CI, though the presence of deprecated modules and experimental features indicates moderate technical drift.
The system-monitoring-center is a Linux desktop application for real-time system resource monitoring and management. It provides a tabbed interface displaying CPU, memory, disk, network, GPU, sensors, processes, services, users, and system information. The application allows users to monitor performance metrics, manage processes and services, and view detailed hardware information through a modular architecture. Built with Python and Tkinter using the Sun Valley theme, the application follows a modular structure where each tab (CPU, Memory, etc.) implements a consistent interface (tab_gui, initial_func, loop_func). Core system data is gathered by the Libsysmon module via /proc, /sys, and system commands (dmidecode, lspci, etc.). The GUI features interactive charts, process/service management capabilities, and supports internationalization across 15+ languages. Configuration is managed through a version-aware system in Config.py. Key reusable components include Common.py for generic GUI utilities (sortable treeviews, search entries, charting canvases) and Config.py for persistent settings management. The application demonstrates good engineering practices with clear separation of concerns, active maintenance, and low technical drift despite Linux-specific dependencies.
GPU-T is a Linux desktop utility for comprehensive GPU information and monitoring, positioned as a GPU-Z alternative for Linux. It provides real-time sensor data (clocks, temperatures, power, fan speeds), static hardware specifications from JSON databases and sysfs, and detection of API capabilities (Vulkan, OpenCL, CUDA, etc.) through a modular probe system. The application follows the MVVM pattern with Avalonia UI and features a sidecar process for NVIDIA-specific NVAPI/NVML interactions to ensure stability and isolate native interop. Hardware detection relies on sysfs paths, external tool execution, and vendor-specific databases, with user override capabilities for hardware specifications. The modular design separates concerns into probes for hardware polling, advanced providers for feature detection, and utilities for common tasks like settings management and shell command execution.
Koharu is a desktop application for manga and comic translation, built with a Rust backend (Tauri) and a React/TypeScript frontend. It orchestrates a multi-stage ML pipeline: page import, layout detection (YOLO, RT-DETR), speech bubble segmentation, OCR (PP-OCR, Manga OCR), translation (local LLMs via llama.cpp or cloud APIs), and inpainting (LaMa, FLUX.2, AOT-GAN). The system includes a custom deep learning framework (`koharu-torch`) with inference-only ports of common vision models, a scene graph for versioned project state, and a WebGPU/WASM canvas for interactive editing. The application supports multiple hardware backends (CUDA, ROCm, Vulkan, Metal) and can run entirely offline. Architecturally, the project is a monorepo with over 30 Rust crates and two JavaScript packages. The backend is organized around clearly separated concerns: model inference (`koharu-ml`), pipeline orchestration (`koharu-pipeline`), project state (`koharu-scene`), persistent storage (`koharu-storage`), and rendering (`koharu-renderer`/`koharu-rasterizer`). The frontend provides an editor with panels for page management, canvas, inspection, and an AI agent panel that uses OpenAI's Codex protocol for tool-driven project editing. The translation subsystem abstracts over local and remote providers with a common prompt and schema interface. While the primary purpose is an application, the ML model implementations are notable for their fidelity to upstream Python references, including exact preprocessing (LetterBox padding, pixel normalization) and postprocessing (NMS, mask decoding). This makes the repository valuable as a reference for Rust ports of computer vision models. However, the codebase is tightly coupled to specific model architectures and pinned revisions, limiting direct reuse without significant adaptation. The UI component library (`packages/ui`) and several backend abstractions (e.g., configuration, storage format, runtime dependency graph) are designed for reusability and could be extracted with minimal effort.
KAITO (Kubernetes AI Toolchain Operator) is a production-grade Kubernetes operator that automates the full lifecycle of large language model (LLM) deployments. It reconciles custom resources—Workspace, InferenceSet, RAGEngine, MultiRoleInference, and ModelMirror—to provision GPU nodes, download or stream model weights from HuggingFace or Azure Blob, run inference servers (vLLM or HuggingFace Transformers), perform fine-tuning (LoRA/QLoRA), and manage RAG pipelines with vector stores (FAISS/Qdrant) and output guardrails. The operator supports multi-cloud node provisioning (Azure GPU provisioner, Karpenter, BYO) and features like prefill-decode disaggregation, model mirroring, and benchmark metrics collection. The system architecture is a collection of Go controllers using controller-runtime, with admission webhooks for CRD validation and a set of Python services for inference, tuning, and RAG. Key entry points: cmd/workspace/main.go (workspace controller), cmd/ragengine/main.go (RAG engine controller), presets/workspace/inference/vllm/inference_api.py (vLLM inference service), and presets/ragengine/main.py (RAG FastAPI service). Data flows: user creates a Workspace CR → controller creates NodeClaims, provisions GPU nodes, downloads/streams model weights → creates StatefulSet with inference service → exposes Service. For RAG: user creates RAGEngine CR → controller deploys vector store and inference service → user indexes documents via API → chat completions with retrieval augmentation. Notable engineering patterns include a plugin-based model registry (KaitoModelRegister), a generator pattern (WorkspaceGeneratorContext with chainable manifest modifiers), an abstract NodeProvisioner interface with multiple implementations, and a hot-reloadable guardrails system with Prometheus metrics. The codebase has extensive test coverage: unit tests with mock clients, integration tests for controllers, and end-to-end tests using Ginkgo that validate real cluster behavior. The project is actively maintained with frequent commits, CI/CD workflows, and versioned documentation.
pytorch-forecasting is a deep learning library for time series forecasting, providing implementations of state-of-the-art models such as Temporal Fusion Transformer, N-BEATS, N-HiTS, DeepAR, PatchTST, TiDE, TimeXer, and many others. Built on PyTorch and PyTorch Lightning, it offers a complete pipeline from data preprocessing (TimeSeriesDataSet, encoders, samplers) through model training (with GPU support, callbacks, hyperparameter tuning via optuna) to prediction and evaluation (point, quantile, and distributional metrics). The library supports multivariate forecasting, static and time-varying covariates, categorical features, and multiple targets. A major v2 refactoring is underway, introducing a new data module layer and simplified package interface, though the v2 API is explicitly marked as experimental and unstable. The codebase is well-tested with automated integration tests across all models and metrics, and employs a composition pattern for metrics (supporting weighting, aggregation, and distribution losses) and a layered architecture for models (base classes, package containers, building blocks).
This repository implements `cuda_tile`, an MLIR-based compiler dialect and toolchain for GPU tile programming, primarily targeting NVIDIA CUDA architectures. It defines a rich set of operations for tile-level computation (arithmetic, matrix multiply, memory views, atomics, control flow) with explicit memory ordering and synchronization. The project includes a custom bytecode serialization format (.tileirbc) with versioned backward compatibility, allowing efficient IR transport and JIT compilation. Key tools are `cuda-tile-opt` (dialect testing), `cuda-tile-translate` (MLIR-to-bytecode conversion), `cuda-tile-optimize` (bytecode-to-bytecode optimization passes), and `cuda-tile-tblgen` (TableGen-based code generation for bytecode readers/writers). Python bindings enable programmatic IR construction. The architecture is a set of modular libraries (dialect, bytecode, optimizer, C API) that can be integrated into larger compiler pipelines. External dependencies are LLVM/MLIR at a pinned commit and CUDA. The codebase demonstrates high engineering rigor with extensive test coverage (bytecode stability, version compatibility, round-trip, transformation passes) and careful version management for evolving the IR format. While primarily a compiler infrastructure application, the project's focus on low-precision matrix operations (FP8, FP4) and tensor core optimizations touches on ML research areas.
nvml-wrapper is a Rust workspace providing safe, high-level bindings to the NVIDIA Management Library (NVML). It is a library crate, not an application: there are no binaries, servers, or CLIs. The workspace is split into `nvml-wrapper-sys` (low-level FFI bindings, including runtime loading of `libnvidia-ml.so`/`nvml.dll` via `libloading`) and `nvml-wrapper` (a safe, typed API). The primary entry point is `Nvml::init()`, which loads the NVML library and returns a handle; from there, `Device` exposes 100+ methods for querying GPU state such as memory, clocks, temperature, power, ECC, NvLink, vGPU, MIG, and GPM metrics. The crate also supports mutating operations like setting application clocks and fan speed, and includes a `legacy-functions` feature for older NVML versions.
PopSift is a CUDA-accelerated SIFT (Scale-Invariant Feature Transform) feature extraction library. It provides a C++ library (libpopsift) with an asynchronous API for enqueuing images and retrieving features, and two command-line demo applications (popsift-demo, popsift-match). The library implements the full SIFT pipeline (Gaussian pyramid, extrema detection, orientation assignment, descriptor computation) on NVIDIA GPUs, supporting multiple algorithmic variants (PopSift, VLFeat, OpenCV) for research comparison. It is designed for high-performance real-time feature extraction and can be integrated via CMake. Despite its research origins (Simula Research Laboratory), the codebase is well-structured with modular CUDA kernels, debug utilities, and parallel primitives. The library is actively used in computer vision projects and maintains compatibility with recent CUDA versions while preserving legacy fallbacks.
This repository is an extensive collection of over 500 standalone shader examples, compute shader implementations, and supporting C# scripts for Unity, authored by Przemysław Zaworski. It covers a wide breadth of real‑time graphics techniques including raymarching, procedural texture generation, vertex/tessellation/geometry shaders, compute‑based physics, image post‑processing (bloom, HDR, SSAO), fluid simulation, grid‑based simulations (Voronoi, Marching Cubes), and advanced rendering like DirectX Raytracing path tracing. The codebase is primarily educational and demonstrative; each file typically implements a single effect or technique in a self‑contained manner, often with references to original Shadertoy sources, ReShade conversions, or published papers. While many examples are functional and well‑structured, others include incomplete fixes or stale comments, and overall the repository serves as a large reference library rather than a production application. The quality is average—many components are boileplate‑heavy ports—but several pieces, such as the Marching Cubes compute shader with indirect draw, the multipass fluid simulation, and the volume rendering tools, exhibit solid craftsmanship and are extractable for reuse.
IPEX-LLM (Intel Extension for PyTorch for Large Language Models) is a library and toolkit designed to accelerate LLM inference and fine-tuning on Intel hardware (CPU, GPU, NPU) through low-bit quantization (INT4, FP8, etc.), hardware-specific optimizations, and seamless integration with popular LLM ecosystems. The core functionality centers around the `optimize_model` function and optimized model loaders that enable efficient INT4/FP8 inference with minimal code changes. It provides integrations with Hugging Face Transformers, vLLM, LangChain, LlamaIndex, and serving solutions like FastAPI and FastChat. Despite its utility for LLM acceleration on Intel platforms, the project is explicitly archived with no active maintenance, updates, or security patches, limiting its long-term viability.
The Awesome-Triton-Kernels repository is a static collection of links to external projects that provide Triton kernels for GPU acceleration. It does not contain any source code, build scripts, or executable components. Its sole purpose is to serve as a reference guide for developers looking to integrate Triton kernels into their applications. The repository consists of only a README file and an MIT license. The README categorizes links by kernel type (e.g., transformers, matrix operations, quantization) and provides brief descriptions with hyperlinks to the respective projects. There is no architecture, no data flow, and no external dependencies beyond the internet connectivity required to follow the links. From a maintenance perspective, the repository shows recent commit activity (as of 2026-01-27) and has no open issues, suggesting it is actively maintained as a reference list. However, due to the absence of code, traditional software quality metrics such as architectural soundness or component reusability do not apply. The technical drift is considered low because there are no dependencies or code to become outdated.