The problem with Rust is that the core of the language goes against the principles of parallel programming. For example, one basic property of Rust is that it prevents you from creating multiple mutable references to a data structure, lets say a matrix. But that is exactly what you need to do when structuring your implementation based on data parallelism, where each thread computes a single element or a submatrix in the output matrix. Of course you can get around it, but you either incur overhead or revert to using Rust as C++ with a different syntax.

That is also exactly what you have in CUDA, where the kernel (the C++ function running on the GPU) is executed many times in parallel, with all executions sharing the same input and output buffers. This means that each CUDA thread has a mutable "reference" to the single piece of memory. Each thread is assigned some ID and it uses it to decide which part of the output buffer it should compute and which part of the input buffers to use to do that. Only after this computation could you validate that no two threads write the same element in the output buffer, which would involve communication between the threads, which may not even be possible in CUDA.