2

I've been trying to work with Blazor WASM to access hardware accelerated functionality supported by most GPUs, but not having much luck.

I have search Stack overflow but have not found much relevant information specific to WASM and more specifically access to the GPU like we have with DirectX (on the Windows side). I was hoping to find some sort of subset but not having much luck.

I realize WASM is supposed to take advantage of "common hardware capabilities" and because of the nature of code isolation there is always going to be some impact to performance in WASM (it'll never be as fast as native calls to DX). With that said, can anyone point me in a direction on how to get access to accelerated graphics via WASM?

Rob Ainscough
  • 576
  • 5
  • 14
  • 1
    That is a tough one I have only a little idea for you to check out. Unity uses webgl and Wasm so I would think that would be a great place to start looking, Webgl I mean. – Shuryno Apr 26 '23 at 12:31
  • 1
    Why use webassembly either use upcoming WebGPU or WebGL2. – Lee May 05 '23 at 08:22
  • @Lee not familiar with WebGPU or WebGL2 ... do they provide full access to the GPU hardware (on equivalent function level) as DX12? – Rob Ainscough May 09 '23 at 21:32
  • @RobAinscough I didn't used DirectX in the last 20 years. But WebGL2 comes close to OpenGL. WebGPU is fairly new I will evaluate it when it is stable supported by multiple browsers. – Lee May 10 '23 at 08:29
  • Do you happen to know specific accelerated features WebGL2 or WebGPU support ... ex: Variable Rate Shading, Mesh Shaders, pixel depth. I don't have much experience with OGL, is that a more supported feature set for WebGL2 an WebGPU? MS DX team has hinted at DX13 news soon ... probably the path I want to stay on with WASM. – Rob Ainscough May 12 '23 at 18:24

1 Answers1

0

I don't have experience with Blazor WASM or C# specifically, but you can probably use the C# bindings for wgpu-native, and it will give you access to the GPU if the host platform runtime supports it.

If you're targeting a web browser, WebAssembly binaries can use the GPU via browser APIs such as WebGPU or WebGL (currently, you need some Javascript glue code, but there are plans to support direct Web APIs access from WebAssembly without the JS middleman).

If you're targeting WASI to run outside a Web browser, you need to pick a runtime that supports GPU access or develop your own glue. For example, a simple Rust host application that uses wasmi and wgpu libraries could expose a GPU interface to your wasm application.

By the way, wgpu itself is a fantastic library and powers Firefox's WebGPU implementation, but it's not limited to a web context; you can deploy native software with it. For example, the Bevy game engine uses it as a GPU abstraction layer for games that run natively.

They also have some WebAssembly working examples on their website that uses WebGPU through WebAssembly-compiled code, with fallbacks to WebGL 2.

While the WebGPU specification supports only one language, WGSL, the wgpu library supports many shading languages, so you can use HLSL or GLSL if you want. The library will pick the most suited language for the host platform, namely DirectX for Windows, Metal for Mac/iOS, Vulkan for Linux/Android, and WebGPU/WebGL2 for Web.

About your question in the comments:

WebGL roughly maps in functionality with OpenGL ES 2.0, while WebGPU targets modern GPUs with lower-level access, so you have access to modern features such as Compute Shaders. It's a thin wrapper around DirectX12, Metal, and Vulkan.

The specs are still a work in progress and not a standard yet, but they have been relatively stable for a while, and Chrome launched WebGPU support earlier this year. As far as I know, Mesh shaders are not supported (yet), but the specs include the concept of language extensions, so they might be available eventually.

Other links that might be useful to you:

This excellent article about WebGPU contains some resources on using WebAssembly to interact with WebGPU with example implementations in C++ and Rust.

WebAssembly roadmap: They are currently working on implementing Garbage Collection, which will enable better integration with higher-level, garbage-collected languages such as C#.

Rafael Beckel
  • 2,199
  • 5
  • 25
  • 36