VectorWare maps Rust portable SIMD to NVIDIA GPU warps
The GPU-native software company has extended its runtime to support core::simd, allowing developers to execute vector operations natively on GPU hardware using familiar Rust abstractions.
VectorWare has announced the successful implementation of Rust’s portable SIMD (core::simd) for GPU programming, marking a significant expansion of its GPU-native software capabilities. The company, which describes itself as the first GPU-native software provider, has mapped the Rust abstraction to NVIDIA’s Single Instruction, Multiple Thread (SIMT) model. This development allows warp lanes to execute vector operations natively, enabling high-performance applications that utilise familiar Rust abstractions without requiring architecture-specific intrinsics or source code rewrites.
The implementation extends VectorWare’s previous work on mapping std::thread to GPU warps by introducing lane-level parallelism. While the earlier iteration allowed many concurrent threads to run on the GPU, it did not utilise the parallel lanes within each thread or warp. By treating a GPU warp as a wide vector unit, the new toolchain maps a Simd vector directly onto the hardware. For example, a Simd<i16, 32> assigns one element to each of the 32 lanes in an NVIDIA warp, allowing operations such as elementwise arithmetic and comparisons to compile into single warp instructions where every lane processes its element simultaneously.
Operations including reductions, shuffles, and mask selections are lowered to native warp instructions such as shuffle, vote, and ballot. VectorWare has built an intermediate representation encoded in Rust’s type system to manage these lane-level operations, ensuring that many invalid programs cannot be constructed at the type level. The team has also developed a reference interpreter for deterministic simulation and differential testing, allowing the same typed operations to run on the CPU for verification before execution on the GPU.
The toolchain permits unmodified CPU code using portable SIMD to run on the GPU, while GPU-aware code retains the ability to access low-level intrinsics if required. Although the current implementation targets NVIDIA hardware, the underlying intermediate representation is architecture-agnostic. VectorWare has designed the system to support AMD wavefronts and Vulkan subgroups in the future, leveraging the similar primitives and semantics exposed by those platforms.
VectorWare plans to explore lowering matrix-shaped SIMD to tensor cores and auto-vectorising scalar Rust loops into SIMD operations. The company notes that while portable SIMD remains unstable in Rust and requires nightly features, the abstraction offers zero-cost performance when vector width matches warp lane count. As the company continues to map threads and async to the GPU, it aims to compose these layers to provide developers with a consistent, high-performance platform for GPU-native application development.
