naga VS rust-gpu

That wouldn't have been all that different from WGSL though, the most important thing is that whatever WebGPU uses for its shaders can be translated to and from SPRIV (and WGSL does that too (e.g. via https://dawn.googlesource.com/tint and https://github.com/gfx-rs/naga).

Hey all, wanted to put this link in here, where I'm proposing changing the API for errors in naga, so Naga can take ownership of error presentation and actually Make Shader Compilation Messages Comfy™: https://github.com/gfx-rs/naga/issues/2317

EDIT: There is also naga but it does not take HLSL as input: https://github.com/gfx-rs/naga but you can use DirectXShaderCompiler to compile to SpirV, then use naga to compile to Metal.

And it seems that naga https://github.com/gfx-rs/naga Already has a working front/backend for wgsl.

This is basically Ray Tracing support in Blade. So far, only ray queries are supported. Unlike prior work on ray tracing in Rust, this is original due to all shader code being WGSL, see the Naga PR.

There's a compiler that can translate from WGSL to SPIR-V called naga. Having such a compiler is essential, since WebGPU is planned to use WGSL and browsers are expected to implement rendering via Vulkan (and probably Metal and DX12).

Not sure about on the CPU, but naga is a shading language transpiler you can write custom front/backends for.

The spec docs are actually pretty useful https://www.w3.org/TR/WGSL/ besides that I was using naga's tests for reference https://github.com/gfx-rs/naga/tree/master/tests

For cross-platform support look at WebGPU and Vulkan (e.g,: [0] [1]. Essentially, you would need to write the func in WGSL or GLSL, HLSL or MSL. Each of these can be cross-compiled to SPIR-V (what Vulkan needs) with cross-compilers such as spirv-cross and naga.

Sounds cool, but this requires yet another language to learn[0]. As someone who only has limited knowledge in this space, could someone tell me how comparable is the compute functionality of rust-gpu[1], where I can just write rust?

[0] https://github.com/Hugobros3/shady#language-syntax

[1] https://github.com/EmbarkStudios/rust-gpu

I don't do anything related to data science, but I feel like doing it in Rust would be nice.

You get operator overloading, so you can have ergonomic matrix operations that are typed also. Processing data on the CPU is fast, and crates like https://github.com/EmbarkStudios/rust-gpu make it very ergonomic to leverage the GPU.

I like this library for creating typed coordinate spaces for graphics programming (https://github.com/servo/euclid), I imagine something similar could be done to create refined types for matrices so you don't do matrix multiplication matrices of invalid sizes

Do you mean rust-gpu?

And https://github.com/EmbarkStudios/rust-gpu/tree/main/examples with the wgpu runner (here it runs the compute shader)

I don't know how major they are considered, but Embark Studios is doing quite a bit of Rust in the open source space, most notably (IMO) rust-gpu and kajiya

The examples in the rust-gpu repository are a good place to start

There's another project that's similar that's being used by an actual game company: https://github.com/EmbarkStudios/rust-gpu

They see specific advantages here that would outweigh that negative. It's not my space (I play games, but know next to nothing about graphics programming), but there's at least one argument in the other direction.

Could this approach work for compute shaders (GPGPU) as well? So far, I think https://github.com/EmbarkStudios/rust-gpu is the state of the art in that area, but it adds a specific Rust compiler backend for generating SPIR-V rather than leaving that up to the driver. That seems more complicated than it needs to be... but maybe it has advantages too? Thoughts?

https://github.com/embarkstudios/rust-gpu Allows you to create shaders (kernals) in Rust.

Also Embark Studios (formers DICE people) is doing a lot of work with Rust, all open source like Rust GPU https://github.com/EmbarkStudios/rust-gpu