wasi-libc VS wasm-bindgen

WebAssembly has a set of extended interfaces collectively called the WebAssembly System Interface (WASI). This bit is chugging its way through standardization, due to be finalized in 2025. But if there is one thing we should have collectively learned from the standardization of HTML, CSS, HTTP, JavaScript, and onward, standards-based implementations often stabilize and reach production readiness far sooner than the standards body can walk its lumbering gate to a final ratification. While WASI continues to add new interfaces, the core interfaces (components, file system, environments, and so on) have long been stable, and have long been deployed into production.

https://wasi.dev/

wow I didn't know this was a thing. thanks for filling me in!

Standardization Efforts: Projects like WASI aim to create an ABI standard that facilitates better integration between WebAssembly and the host operating system. However, WASI’s full browser support, especially for web-specific APIs like WebGPU, is still a work in progress.

Now there are projects like WASI that allows for interfacing with system resources for WASM code this allows for devs to target WASM runtime for their apps sliding the apps to run locally on any OS without any porting required. This could be a game changer in the future like Docker and containers was in the past decade.

So it doesn’t seem like there has been progress on a pseudo-random number generator function for typst, but there are multiple other ways to solve this: 1. Just don’t. Typst has this functional philosophy, there one input always produces the same output. (not an answer to your question tho) 2. Interface with a webassembly module which has a random number generator. So you could e.g. compile c to wasm and statically link a libc version. You would then just have to export the rand() function. (You could use any lang for this, which has a stdlib with a pseudo random number generator) 3. Implement your own. Random number generators are actually not that hard something like an LCG isn’t to complex. (Id provide an example but im on my phone rn)

Actually WASI[0] will be a better alternative, IIRC extism serialize and deserialize the data that you want to pass every time, adding a lot of overhead.

[0] https://wasi.dev

Actually, it was in wasi-libc: https://github.com/WebAssembly/wasi-libc/blob/main/libc-bott...

Proper isolation in C# is only now becoming a thing, with .Net support for WASI, which is essentially a WebAssembly sandbox which can be given extremely granular privileges (such as access to spefic file system directories, or an effective virtual file system). As an upside, the idea is that it should be possible to write the WASI packages in more or less anything.

Wasm Labs dev here :)

In mod_wasm, there are some differences with a pure CGI implementation. When Apache boots, it loads the configuration and initializes the WasmVM. When a new HTTP request arrives, the VM is ready so you don't need to initialize a different process to manage it.

You still need to process the request and pass the data to the Wasm module. This step is done via STDIN through the WebAssembly System Interface (WASI) implementation [0]. The same happens in the opposite direction, as the module returns the data via STDOUT.

So, the CGI pattern is still there, but it doesn't require new processes and all the code runs in a sandbox.

However this is not the only way you can run a Wasm module. In this specific case, we use CGI via WASI. In other cases, you may compile a module to fulfill a specific API, like ProxyWasm [1] to create HTTP filters for proxies like Envoy.

- [0] https://wasi.dev/

- [1] https://github.com/proxy-wasm/spec

> I couldn't figure out a way to to get emscripten wasm code to play nice with wasm32-unknown-unknown

There is good news there, some people plan to work on making Emscripten and Rust work well in Wasm:

https://github.com/rustwasm/wasm-bindgen/pull/4014#issuecomm...

That said, WebAssembly’s ecosystem is still fragmented. Tools like Emscripten (C/C++), wasm-bindgen (Rust), and JSGo (Go) serve different languages, but this complicates the standardization of interactions with web APIs, limiting broader WASM integration with web development.

> Here's an example of Bevy WebGL vs Bevy WebGPU

I think a better comparison would be more representative of a real game scene, because modern graphics APIs is meant to optimize typical rendering loops and might even add more overhead to trivial test cases like bunnymark.

That said though, they're already comparable which seems great considering how little performance optimization WebGPU has received relative to WebGL (at the browser level). There are also some performance optimizations at the wasm binding level that might be noticeable for trivial benchmarks that haven't made it into Bevy yet, e.g., https://github.com/rustwasm/wasm-bindgen/issues/3468 (this applies much more to WebGPU than WebGL).

> They're 10k triangles and they're not overlapping... There are no textures per se. No passes except the main one, with a 1080p render texture. No microtriangles. And I bet the shader is less than 0.25 ALU.

I don't know your exact test case so I can't say for sure, but if there are writes happening per draw call or something then you might have problems like this. Either way your graphics driver should be receiving roughly the same commands as you would when you use Vulkan or DX12 natively or WebGL, so there might be something else going on if the performance is a lot worse than you'd expect.

There is some extra API call (draw, upload, pipeline switch, etc.) overhead because your browser execute graphics commands in a separate rendering process, so this might have a noticeable performance effect for large draw call counts. Batching would help a lot with that whether you're using WebGL or WebGPU.

I already knew that there was a good quality library unicode-segmentation in Rust, and Rust has a great WebAssembly toolchain called wasm-bindgen.

The binding of Rust (WASM) and JavaScript is done with the help of wasm-bindgen and wasm-pack -- https://github.com/rustwasm/wasm-bindgen/tree/main/examples/without-a-bundler

Another strange issue could be seen in the strict class heritage organized definition of the DOM, which can not be handled very well by rust because of a still unsolved bindgen issue (#210).

For a much simpler but less flexible approach there's wasm-pack for creating JS packages from Rust, and wasm-bindgen for easy interop. Both have very good documentation.

We encountered quite a few hurdles on our journey. For one, we had to build our own yew-webtransport and yew-websocket integration from scratch by adding WebTransport definitions to wasm-bindgen (pull request link). We also had to add WebTransport support to the h3 crate (pull request link). co-created by @ten3roberts

Go with your WebAssembly module idea. Since it sounds like your chess engine does not draw a UI, it shouldn't be too difficult. wasm-bindgen will be your best friend.