Open-source alternatives to Rust Cuda

This repository is a collection of reference implementations and programming examples for the CUDA Toolkit. It serves as a GPGPU implementation guide and a parallel computing reference, providing code for using graphics hardware to perform general-purpose calculations and high-performance parallel processing. The project provides specific samples for GPU kernel development and resource management. These include demonstrations of multi-GPU communication, peer-to-peer memory access, and system hardware inspection to coordinate distributed GPU resources. The codebase covers a wide range of capa

Claudes C Compiler is a self-contained C compiler toolchain that parses source code, optimizes intermediate representations, and generates machine code without relying on external assemblers, linkers, or toolchain dependencies. It translates C source files directly into standalone executable binaries, object files, or assembly text across multiple hardware architectures. The project provides built-in assembly and linking capabilities, processing architecture-specific assembly text, encoding instructions, combining object files and static archives, resolving symbols, applying relocations, and

This project is a collection of reference implementations and technical guides for building high-performance 3D applications and graphics experiments on Windows. It provides a library of samples covering the implementation of GPU compute frameworks, raytracing reference models, and shader optimization techniques. The repository includes specific demonstrations for modeling physical light behavior to create reflections and lighting effects, as well as tools for analyzing memory dumps and tracking real-time execution metrics on graphics hardware. It further provides guidance on managing shader

SD.Next is an all-in-one web interface and multi-backend inference engine for generating, editing, and processing images and videos using diffusion models. It functions as a comprehensive tool for diffusion model management and an automated image processing pipeline for bulk operations. The project is distinguished by its hardware-backend abstraction layer, which provides automatic detection and acceleration for NVIDIA CUDA, AMD ROCm, Intel OpenVINO, and DirectML. It features a headless generative API and a programmatic command interface, allowing users to trigger tasks via REST API or CLI wi

IREE is an MLIR-based compiler toolchain and runtime designed to translate machine learning models from various frameworks into optimized binaries for execution across diverse hardware targets. It provides a unified pipeline to ingest models from PyTorch, TensorFlow, JAX, and ONNX, lowering them into a common intermediate representation for deployment on CPUs, GPUs, and bare-metal embedded systems. The project distinguishes itself through a bytecode virtual machine and a hardware abstraction layer that decouple high-level model logic from specific hardware instruction sets. It supports sophis

CUDA.jl provides a programming interface for executing custom kernels and performing parallel array computing directly on NVIDIA graphics hardware using the Julia language. It serves as a framework for compiling and scheduling user-defined functions across multiple processing cores, enabling high-performance data processing and task synchronization. The library distinguishes itself through a custom compiler backend that translates high-level language functions into hardware-specific machine code. It manages complex hardware interactions through asynchronous stream scheduling, unified memory m

AISystem is a comprehensive AI full-stack infrastructure project covering the entire pipeline from AI chip architecture to high-level training frameworks. It encompasses the development of AI compiler frameworks, inference engines, and distributed training orchestrators designed to coordinate workloads across a heterogeneous compute stack of CPUs, GPUs, and NPUs. The project focuses on the deep integration of software and hardware, employing software-hardware co-design to align tensor layouts with physical memory structures. It provides specialized capabilities for accelerating Transformer mo

This project is a collection of reference implementations and benchmarks demonstrating the use of the Vulkan graphics and compute API. It provides a set of cross-platform examples and GPU programming patterns designed for high-performance rendering and hardware-accelerated tasks. The repository includes a suite of performance benchmarks used to measure API behavior across different hardware environments. It features a modular architecture that organizes rendering examples into isolated units, along with command-line utilities for the batch execution of sample sequences. The project covers se

Vulkan-Hpp is a header-only C++ binding library for the Vulkan graphics and compute API. It provides a type-safe wrapper around the Vulkan C API, allowing developers to interface with GPU hardware through a C++ interface that introduces no runtime CPU overhead. The library utilizes Resource Acquisition Is Initialization patterns to manage the lifecycle of Vulkan handles and objects, automating the release of GPU resources. It replaces C-style enumerations and bit-fields with strong typing and static type checking to catch invalid API parameter assignments during compilation. The project cove

TypeGPU is a tool for type-safe WebGPU development that enables writing shaders in TypeScript. It translates high-level TypeScript function definitions and structures into WebGPU Shading Language source code to automate shader generation and validate logic using a type system. The project provides a mechanism for cross-library GPU interoperability by sharing typed buffers without copying data to system memory. It also integrates the Model Context Protocol to allow AI agents to inspect generated shader code and diagnose runtime errors. The system manages WebGPU resource mapping through typed

This project is a CUDA programming course and technical guide focused on writing and optimizing GPU kernels for hardware acceleration. It provides structured learning resources for using the CUDA platform to execute operations on silicon architectures. The material covers the optimization of linear algebra kernels and the analysis of machine learning deployment. It includes guidance on identifying acceleration tools, mapping the deep learning ecosystem, and evaluating the frameworks used to move models from research to production environments. The scope extends to GPU performance optimizatio

TileLang is a Python-embedded domain-specific language compiler that JIT-compiles and autotunes GPU kernels. It uses a tile-based DSL, automatic software pipelining, and parallel autotuning to generate optimized GPU kernels at runtime. It supports tensor core operations with Pythonic syntax, automatic memory management, and thread mapping. The compiler searches over tile sizes, thread counts, and scheduling policies, compiling and benchmarking candidates in parallel to find the fastest kernel. It also caches compiled binaries and tuning results to disk for reuse across sessions. TileLang inc

regl is a declarative WebGL library that manages graphics state and GPU resources through functional commands instead of manual binding and state tracking. It provides a command-based drawing abstraction where shaders, attributes, and render state are encapsulated into reusable, compiled functions that can be executed efficiently. What sets regl apart is its scoped state inheritance system, which allows nested drawing commands to inherit and override render state from parent scopes for organized rendering. The library automatically recovers from GPU context loss by restoring buffer and textur

LWJGL is a cross-platform library that provides Java bindings to native APIs for graphics, audio, compute, windowing, and input. It enables Java applications to access low-level hardware-accelerated capabilities such as OpenGL and Vulkan rendering, OpenAL 3D audio, OpenCL GPU compute, and GLFW windowing and input handling. Under the hood, LWJGL dynamically resolves native function pointers at runtime, loads platform-specific shared libraries, and uses generated JNI bindings to bridge Java and native code. It offers explicit memory management through direct buffer access and stack-allocated me

The Forge is a low-level toolkit for building high-performance graphics engines and applications across desktop, mobile, and console platforms. It provides a cross-platform engine framework and a dedicated shader compiler that translates a single source into target-specific languages for various graphics APIs and hardware. The project includes a GPU memory and resource manager that utilizes unified root signatures for resource binding, alongside a ray tracing rendering pipeline that implements hardware-accelerated ray and path tracing queries. State management is handled through a high-perfor

gfx is a hardware-agnostic graphics API abstraction that translates a unified set of graphics and compute commands into native instructions for multiple GPU drivers. It provides a common interface for cross-platform rendering and general-purpose GPU compute programming. The project features an intermediate-representation shader translation system that converts source code and SPIR-V into target-specific languages. It employs a data-driven reference test framework to verify that graphics output remains consistent across different hardware platforms. Capabilities include parallel command buffe

MMdnn is a deep learning model converter and migrator designed to translate neural network architectures and weights between different frameworks such as TensorFlow, PyTorch, and Keras. It utilizes a standardized intermediate representation to decouple network structures and weights from specific framework implementations, enabling the transformation of pre-trained models across different environments. The project distinguishes itself by generating native Python reconstruction code from its intermediate representations, allowing models to be rebuilt and fine-tuned in target environments. It a

This project provides a comprehensive toolset for WebGPU, serving as a graphics API wrapper, compute shader framework, resource manager, and shader toolchain. It enables browser-based GPU acceleration by offloading memory-intensive tasks and data processing from the CPU to the GPU. The framework manages the full lifecycle of GPU operations, from requesting physical hardware adapters and initializing logical devices to configuring programmable render and compute pipelines. It specifically supports the coordination of parallel workgroups and collective subgroup operations for general-purpose co

VulkanTutorial is a comprehensive educational guide and instructional resource for implementing low-level rendering and compute pipelines using the Vulkan API. It serves as a GPU programming course and a step-by-step guide for building high-performance graphics applications from scratch. The project provides detailed instruction on the full graphics pipeline, including the compilation of shaders to SPIR-V bytecode, the configuration of rasterization states, and the implementation of 3D graphics pipelines. It also covers general-purpose GPU compute programming, focusing on the execution of par

FlashInfer is a library of high-performance GPU kernels purpose-built for accelerating large language model inference. It provides optimized implementations for attention operations (including flash attention, page attention, multi-head latent attention, and cascade attention) using paged key-value caches, fused kernel composition, and just-in-time compilation. The library also includes specialized kernels for mixture-of-experts layers, block-scaled low-precision quantization (FP8, FP4), and distributed collective communication. What distinguishes FlashInfer is its fused all-reduce communicat

AITemplate is an ahead-of-time deep learning compiler that translates PyTorch neural networks into standalone C++ source code. It functions as a PyTorch to C++ compiler and a GPU kernel fusion engine, producing self-contained executable binaries that run inference without requiring a Python interpreter or deep learning framework runtime. The project generates optimized CUDA and HIP C++ code specifically for NVIDIA TensorCores and AMD MatrixCores. It focuses on maximizing throughput for half-precision floating-point operations through a system that combines multiple neural network operators in

HIP is a C++ GPU kernel language and cross-platform runtime designed for writing portable high-performance compute applications. It provides a programming interface that allows a single source codebase to execute on both AMD and NVIDIA GPU architectures. The project functions as a compatibility layer that enables the conversion and migration of existing CUDA source code to run on AMD hardware. This is achieved through a syntax mapping that mirrors CUDA and a source-to-source translation process during compilation. The toolkit covers the broader surface of cross-platform GPGPU development, in

Rust-GPU is a compiler and toolchain that translates Rust source code into SPIR-V bytecode for execution on graphics and compute hardware. It provides a development environment for writing parallel compute kernels and graphics shaders using a custom LLVM backend that maps high-level language constructs to GPU-compatible memory layouts and instructions. The project enables cross-platform shader development, allowing the same Rust code to run across different GPU hardware and graphics APIs via the SPIR-V intermediate representation. It specifically supports the creation of general-purpose compu

This project is a high-performance C++ and CUDA neural network library designed for fast training and inference of small networks on NVIDIA GPUs. It serves as a specialized backend for neural radiance fields and coordinate-based networks, providing a fused GPU kernel library and a hash grid encoder for transforming raw input dimensions into high-dimensional representations. The library distinguishes itself through the use of C++ template metaprogramming and fused-kernel execution, which merge neural network layers into single GPU device functions to eliminate memory bottlenecks. It leverages

Clash is a functional hardware compiler and hardware description language compiler that translates strongly typed functional programs written in Haskell into synthesizable VHDL, Verilog, and SystemVerilog code. It serves as a development tool allowing digital designers to write hardware descriptions in functional languages and compile them directly to FPGA targets and physical netlists. The compilation infrastructure covers structural hardware compilation, including graph-based code normalization, functional language translation, and netlist generation. It features type-level clock domain saf

Neural Enhance is a deep learning image upscaler and restoration tool designed to increase image resolution and remove blur. It functions as a neural image restoration utility for eliminating noise and JPEG artifacts, and includes a framework for training and tuning custom neural network models against image datasets. The system utilizes a containerized environment to offload tensor calculations to GPU cores, speeding up neural network inference. It features a batch processing pipeline that queues multiple image files in sequence to maximize hardware throughput. Capabilities include domain-s

GB Studio is a visual integrated development environment and game engine for creating 8-bit games for Game Boy hardware. It functions as a retro hardware ROM compiler that transpiles graphical logic into native Z80 assembly and binary images compatible with original handhelds and emulators. The project serves as a cross-platform build tool, generating both native hardware ROMs and web-compatible builds from a single project source. It utilizes a drag-and-drop interface for game logic and scene design, allowing for the creation of game mechanics and asset placement without writing low-level ma