VectorWare brings Rust's portable SIMD to GPU hardware
New implementation allows the same vector code to target both x86-64 CPUs and NVIDIA GPU warps without modification.
GPU-native startup VectorWare has successfully implemented support for Rust's portable SIMD (`core::simd`) on GPU hardware. This development allows developers to write a single set of SIMD code that compiles to both x86-64 CPU vector instructions and GPU warp operations without requiring any source code changes.
The implementation specifically maps Rust's generic `Simd<T, N>` types—such as `Simd<i16, 32>`—directly to NVIDIA's 32-lane warp model. In this configuration, a single instruction is issued across multiple lanes, with one element distributed per lane. To achieve this, VectorWare developed an intermediate representation (IR) encoded within Rust's type system to carry operation shape and lane count. According to VectorWare, this approach ensures zero overhead when compared to hand-written PTX.
The shift toward GPU-native Rust
Traditionally, GPU programming has been a siloed discipline, requiring specialized languages like CUDA or HLSL, or the use of complex wrappers to interface with hardware. VectorWare is attempting to dismantle this barrier by building a "GPU-native" software stack. The goal is to enable standard Rust abstractions—including async and threads—to run directly on GPU hardware.
This SIMD milestone completes a specific parallelism hierarchy for the stack. In this model, threads handle warp-level concurrency, SIMD manages intra-warp data distribution, and async functions coordinate the concurrency between them. By integrating these elements, the stack aims to treat the GPU as a first-class execution target rather than a peripheral accelerator.
Implications for high-performance computing
This development significantly reduces the friction associated with writing high-performance GPU code. By providing a portable abstraction for vectorization, developers no longer need to maintain separate codebases for different hardware architectures.
Furthermore, by leveraging Rust's strict type system to enforce GPU hardware constraints at compile time, the implementation offers a safer and more ergonomic path to maximum hardware utilization. This removes the need for the manual, error-prone process of writing PTX or CUDA code while maintaining the same level of performance.
Future architecture support
While the current implementation focuses on NVIDIA hardware, VectorWare notes that the approach is architecture-agnostic. This design opens the door for future support of AMD wavefronts and Vulkan subgroups, potentially extending Rust's portable SIMD capabilities across the entire modern GPU landscape. It remains to be seen how quickly these additional architectures will be integrated into the VectorWare stack.