Rust is a system language, so you should have the control you need. We intend to bring GPU details and APIs into the language and core / std lib, and expose GPU and driver stuff to the `cfg()` system.
(Author here)
(Author here)
I don't think this argument is promising. Its not about the power of the language, but the power of the abstractions you provide over the various GPU APIs.
In fact, I could argue one of the main selling points of Rust (memory safety) has limited applicability in GPU land, because lifetimes are not a thing like they are in CPU land.
I'm sure there's other benefits here, not least the tooling, but certainly the language is not the main selling point...
https://gist.github.com/LegNeato/a1fb3e3a9795af05f22920709d9...
Agreed, I don't think we'd ever pull in things like wgpu, but we might create APIs or traits wgpu could use to improve perf/safety/ergonomics/interoperability.
Get Nvidia, AMD, Intel and whoever else you can get into a room. Get LLVMs boys into the same room.
Compile LLVMIR directly into hardware instructions fed into the GPU, get them to open up.
Having to target an API is part of the problem, get them to allow you to write Rust that directly compiles into the code that will run on the GPU, not something that becomes something else, that becomes spirv that controls a driver that will eventually run on the GPU.
It's the same reason Safari is in such a sorry state. Why make web browser better, when it could cannibalize your app store?
CUDA is great for Python as well.
Maybe Intel and AMD should actually produce something worthwhile using.
Whichever part makes Safari completely fail at properly rendering Jira. A task even Firefox can do.
What evidence do you have that this is Safari’s fault and not Jira’s fault?
Give me a web browser and I will write code that will fail in it and work in other browsers.
* https://mlir.llvm.org/docs/Dialects/NVGPU/
Effectively standardise passing operations off to a coprocessor. C++ is moving into that direction with stdexec and the linear algebra library and SIMD.
I don’t see why Rust wouldn’t also do that.
Effectively why must I write a GPU kernel to have an algorithm execute on the GPU, we’re talking about memory wrangling and linear algebra almost all of the time when dealing with GPU in any way whatsoever. I don’t see why we need a different interface and API layer for that.
OpenGL et al abstract some of the linear algebra away from you which is nice until you need to give a damn about the assumptions they made that are no longer valid. I would rather that code be in a library in the language of your choice that you can inspect and understand than hidden somewhere in a driver behind 3 layers of abstraction.
I agree that, that would be ideal. Hopefully, that can happen one day with c++, rust and other languages. So far Mojo seems to be the only language close to that vision.
it baffles me that more people haven't heard about them. it's mighty impressive what they have achieved.