wasi-libc VS binaryen

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

The reference implementations and the most mature WebAssembly development pipeline called Bynarien is still built around C/C++, mainly because the amount of useful code people want to run in the browser was built with C/C++. The Rust community is building it’s own WebAssembly pipeline, however it’s in a state of Tier 2 without Host Tooling at the beginning of 2025. This means that while it is easily and safely used by developers even for production purposes, it lacks some native tooling. This is where we will rely on the Bynarien toolbox to patch in the holes where the Rust WASM pipeline is lacking.

I'm not sure there is a clear separation between applying heuristics and searching a space. Often in compilers you search a subset of a space using heuristics, and you can adjust those to control how much of the space you cover.

For example, here is a pass that reorders WebAssembly globals in Binaryen:

https://github.com/WebAssembly/binaryen/blob/main/src/passes...

We have a simple criteria for the quality of a solution - how big the binary size is with an order - but the space of possible orders is huge (every permutation that keeps every global after its dependencies). What we do is a targeted search of that space using some heuristics using parameters that work well enough and aren't too slow in practice.

The Binaryen wasm optimizer (mentioned in the article) is always open for contributions,

https://github.com/WebAssembly/binaryen

The end of the related work section cites both wasm-smith and the Binaryen fuzzer (https://github.com/WebAssembly/binaryen/wiki/Fuzzing) and says, "They both provide a fuzzer that turns a stream of bytes into a WebAssembly module in order to test implementations. Their fuzzers always generate semantically valid test cases, but lack the targeting and tuning that Xsmith provides."

I look forward to reading more about how they do the targeting and tuning.

Binaryen or the LLVM of wasm: https://github.com/WebAssembly/binaryen

Download Binaryen

Probably https://github.com/WebAssembly/binaryen/, there were various rust bindings to it.

The final phase of our compiler is code generation. This phase takes the AST and converts it to a set of executable instructions. In our case, WebAssembly. To accomplish this, we are going to use a popular WebAssembly compiler toolchain called binaryen.

In this guide, we will be using TypeScript and NodeJS. The concepts are highly portable, so feel free to use the environment you're most comfortable with. Our only major dependency, binaryen, has a simple C API. You are welcome to skip ahead to the next section if you're using a different language.

What are the size and performance benefits of processing the Wasm payload with wasm-opt?