wasi-sdk

I used WASI to compile an existing 1990's 8-bit assembler cmdline tool written in C for use in a VSCode extension (https://marketplace.visualstudio.com/items?itemName=floooh.v...) - along with regular browser-based WASM compiled via Emscripten for the embedded emulators. For this use case the old-school POSIX-style WASI was just perfect and completely hassle-free via the WASI SDK (https://github.com/webassembly/wasi-sdk). Not sure what to think of all the bells and whistles that were added afterwards (esp the component model), the very first WASI standard was the perfect sweet-spot of simplicity and usefulness. I'm pretty sure I'll never need any of the things that were added afterwards (and I'm going to be slightly pissed when the simple use case - building and running POSIX code - gets more complicated).

In VSCode extensions this is trivial, this is how you create the 'executable': https://github.com/floooh/vscode-kcide/blob/main/src/wasi.ts ...and this is how you run it: https://github.com/floooh/vscode-kcide/blob/2dfc621aade4a2be... The asmx.wasm file is a vanilla POSIX cmdline tool which loads and saves files via fopen/fread/frwrite/fclose, and the tool has been compiled with the WASI SDK: https://github.com/WebAssembly/wasi-sdk The resulting VSCode extension (https://marketplace.visualstudio.com/items?itemName=floooh.v...) then even runs in the VSCode browser version (https://vscode.dev/) But AFAIK there's currently no easy way to get a similar easy to use WASI wrapper in browsers (it's definitely possible though because the VSCode browser version does it - VSCode basically has a filesystem abstraction which works for native filesyste

It's a runtime for WASI blobs (basically a WASM based standard for crossplatform command line tools), for instance: emcc hello.c -o hello.wasm wasmer hello.wasm Hello World! This uses Emscripten as C compiler, but alternatively you can use the wasi-sdk toolchain instead of Emscripten to build WASI blobs: - https://github.com/WebAssembly/wasi-sdk ...or Zig as C compiler: zig cc -target wasm32-wasi hello.c -o hello.wasm wasmer hello.wasm Hello World! ...or of course Zig as Zig compiler :) zig -target wasm32-wasi hello.zig wasmer hello.wasm Hello World! (not sure if the Rust toolchain comes with builtin WASI support, but probably yes). ...or instead of wasmer use another WASI runtime: - https://github.com/wasmerio/awesome-wasi?tab=readme-ov-file#... ...this is probably the best part of WASM and WASI, th

I would really love being able to take any POSIX command line tool, compile that to WASI, and run it on (at least) Linux, Windows and macOS like a regular executable without having to install a separate WASI runtime or any scare-popups showing up like on macOS. I'm a 'WASI convert' since I was able to take an ancient 8-bit assembler written in C89 in the mid-90's (http://xi6.com/projects/asmx/), compile that as-is with the WASI SDK (https://github.com/WebAssembly/wasi-sdk), and then integrate it into a VSCode extension (https://marketplace.visualstudio.com/items?itemName=floooh.v...). A similar problem I'd like to solve better is a shader cross-compiler (https://github.com/floooh/sokol-tools) which needs to run on Linux, macOS and Windows and takes too long to build locally, thus I currently need to distribute that as pre-built binaries.

There is the WASI SDK if you want to target WASI from C/C++: https://github.com/WebAssembly/wasi-sdk It comes with a libc implemented in WASM.

Just wrap the core functionality into a 'pure' WASM module which doesn't need to access 'system APIs', and then if needed write two thin wrappers, one for the 'web personality' and one for the 'WASI personality'. WASI has the advantage that many compilers support it directly, e.g. in Zig: > cat hello.zig const print = @import("std").debug.print; pub fn main() void { print("Hello World!\n", .{}); } > zig build-exe hello.zig -target wasm32-wasi > wasmtime hello.wasm Hello World! Or if you prefer C: > cat hello.c #include <stdio.h> int main() { printf("Hello World!\n"); } > zig cc hello.c -o hello.wasm -target wasm32-wasi > wasmtime hello.wasm Hello World! (I guess Rust can do the same, or for a purely clang-based solution see: https://github.com/WebAssembly/wasi-sdk)

A more lightweight tool than emscripten is the WASI SDK (https://github.com/WebAssembly/wasi-sdk/releases). It doesn't generate JS or HTML but you can run its output on the command line with wasmtime or wasmer.

There's also the https://github.com/WebAssembly/wasi-sdk repo which is kind of a meta-build-system for all this. But in FreeBSD we build all the pieces directly, here's our build recipes (with some hacks due to llvm's cmake code being stupid sometimes): compiler-rt (from llvm): https://github.com/freebsd/freebsd-ports/blob/main/devel/was... libc (from what you linked): https://github.com/freebsd/freebsd-ports/blob/main/devel/was... libc++ (from llvm): https://github.com/freebsd/freebsd-ports/blob/main/devel/was...

> C without the standard library (called “libc”) is pretty rough If you don't want to pull in musl or a traditional libc, there's a more Wasm-y solution known as the Web Assembly System Interface (WASI) [0] that delegates the libc functionality to the runtime. A WASI Wasm module can be compiled using clang, as in the article. The only difference is to use the WASI sysroot [1]. > optimization LTO and -O3 are great! I've also found the Twiggy [2] tool useful for more "manual" optimization. [0] https://wasi.dev [1] https://github.com/CraneStation/wasi-sdk/releases [2] https://rustwasm.github.io/twiggy/

Nice comprehensive writeup. The next step, beyond the basic allocator provided, would be to use wasi-sdk (https://github.com/cranestation/wasi-sdk) which provides a full musl-based libc, targeting the WASI interfaces. With this, you can invoke a C program with arguments, environment variables, and filesystem access.