NVIDIA/cuda-rust

Features

• GPU Kernel Programming - Compiles idiomatic Rust into NVIDIA GPU kernels, covering both thread-level and tile-based programming instead of C++.
• Tile-Based GPU Kernel Programming - Provides a tile-based kernel model where kernels operate on whole partitioned tensor tiles and the compiler maps tiles onto the GPU.
• GPU Kernel Development - Lets developers write NVIDIA GPU kernels in Rust instead of C++, with either direct thread-level control or higher-level tile-based code.
• Ahead-Of-Time Compilers - Ships a custom compiler backend that lowers idiomatic Rust to PTX ahead of time, keeping control over threads, blocks, warps and shared memory.
• Ownership & Borrowing - Extends Rust ownership and borrowing rules across GPU kernel launches, sharing immutable buffers and holding borrows until in-flight work completes.
• SIMT Thread-Level Programming - Offers direct control over threads, blocks, warps, cluster operations and shared memory through a custom compiler backend.
• Ownership and Borrowing - Applies Rust ownership and borrowing across CUDA kernel launches, using disjoint tensor partitions and borrows tracked until in-flight work completes.
• Disjoint Tensor Partitions - Splits a mutable tensor into disjoint sub-tensors, each owned by one tile program, so concurrent GPU writes cannot race.
• Just-In-Time Kernel Compilers - Compiles tile kernels at first launch through an intermediate representation into a binary tuned for the detected GPU architecture.
• Memory Safety - Extends Rust ownership rules over kernel launches by splitting mutable buffers into disjoint pieces, sharing immutable ones, and holding borrows until GPU work finishes.
• SIMT Execution Models - Gives direct control over threads, blocks, warps, cluster operations and shared memory through kernels compiled ahead of time to PTX.
• Asynchronous GPU Host Runtimes - Provides safe host wrappers for GPU contexts, streams, buffers and events, with lazy device operations composed and awaited asynchronously.
• Ahead-of-Time Kernel Compilation - Compiles thread-level Rust kernels to PTX ahead of time through a custom compiler backend, keeping direct control over threads, warps and shared memory.
• Lazy Asynchronous Task Modeling - Composes device operations as lazy values that are scheduled and awaited asynchronously so host code can overlap other work.
• Mixed-Model Kernel Execution - Runs tile-based and thread-level kernels on one stream over shared device buffers so each workload uses the model that suits it.
• GPU Resource Managers - Manages GPU contexts, streams, device buffers and events through safe Rust wrappers tied to scope lifetimes.
• Asynchronous GPU Tasking - Chains lazy GPU operations that are scheduled and awaited asynchronously, letting host code avoid blocking on each kernel launch.

Star history