The Rust ecosystem continues to expand its capabilities in high-performance computing with CubeCL, a multi-platform compute language extension that enables developers to write GPU code directly in Rust. While the project has generated significant interest, community discussions reveal both enthusiasm for its potential and concerns about its current documentation and feature presentation.
Advanced Features Hidden Behind Minimal Documentation
Despite CubeCL's impressive capabilities, many community members have pointed out that the project's README fails to showcase its most powerful features. The current examples focus primarily on simple element-wise operations, which doesn't fully demonstrate the library's potential for advanced GPU computing tasks.
We support warp operations, barriers for Cuda, atomics for most backends, tensor cores instructions as well. It's just not well documented on the readme!
One of the project's main authors acknowledged this limitation, confirming that CubeCL actually supports sophisticated GPU programming techniques including warp operations (called Plane Operations in CubeCL), barriers, atomics, and even tensor core instructions. The team has even implemented TMA (Tensor Memory Accelerator) instructions for CUDA, but these advanced capabilities aren't prominently featured in the documentation.
Community Requests for More Complex Examples
Several developers suggested that the project would benefit from showcasing more complex examples, particularly matrix multiplication operations with mixed precision - a common requirement in AI workloads. One commenter specifically recommended replacing the current element-wise example with a GEMM with a twist demonstration that would better illustrate CubeCL's utility for AI applications.
The CubeCL team responded positively to these suggestions, with one contributor mentioning that support for newer data types like FP8 and FP4 is planned as their next project. However, they noted that hardware limitations are currently a bottleneck, as only one contributor has access to the necessary equipment to test these newer types.
Positioning in the GPU Programming Ecosystem
Community discussions also touched on how CubeCL compares to other GPU programming solutions. Several commenters drew parallels to Halide, OpenCL, and SYCL, with particular interest in how CubeCL's comptime feature differentiates it from these alternatives.
The comptime system allows developers to execute arbitrary code in kernels at compile time, providing more flexibility than traditional generics. This enables natural branching on compile-time configurations to select optimal algorithms for different hardware targets.
Some users questioned why OpenCL wasn't included as a backend alongside WGPU, CUDA, and ROCm/HIP. A CubeCL contributor explained that while the SPIR-V compiler has infrastructure to target both OpenCL and Vulkan, implementing an OpenCL runtime would require additional work. They also expressed interest in understanding OpenCL's performance characteristics on CPUs compared to more native implementations.
CubeCL Supported Runtimes:
- WGPU (cross-platform: Vulkan, Metal, DirectX, WebGPU)
- CUDA (NVIDIA GPUs)
- ROCm/HIP (AMD GPUs) - Work in Progress
- Planned: JIT CPU runtime with SIMD instructions via Cranelift
Key Features:
- Automatic vectorization
- Comptime (compile-time optimizations)
- Autotuning
- Support for warp operations, barriers, atomics, tensor cores
- Matrix multiplication with Tensor Core support
Connection to the Burn Framework
An important context that emerged from the comments is CubeCL's relationship with Burn, a deep learning framework developed by the same team. CubeCL serves as the computation backend for Burn, handling the tensor operations while Burn manages higher-level machine learning functionality like automatic differentiation, operation fusion, and dynamic computational graphs.
The need for CubeCL arose specifically from Burn's requirements: the ability to write GPU algorithms in a full-featured programming language while enabling runtime compilation for operation fusion, all while maintaining cross-platform compatibility and optimal performance. According to the developers, no existing tool met all these requirements in the Rust ecosystem.
The relationship between CubeCL and Burn explains many of the design decisions behind the library, including its focus on performance and cross-platform compatibility. It also positions CubeCL as an important component in the growing Rust-based machine learning ecosystem.
As the project matures, the community seems eager for more comprehensive documentation and examples that better showcase CubeCL's full capabilities. With planned support for newer data types and continued development, CubeCL appears poised to fill an important gap in Rust's GPU computing landscape, particularly for machine learning applications.
Reference: cubecl/cubecl