Wasm guidance

[cveld]

Thanks for the great talk on WasmCon last Monday!
https://colocatedeventseu2026.sched.com/event/2Jd0B/streamlining-webassembly-builds-with-bunny-charalampos-mainas-anastassios-nanos-nubis-pc

I can't seem to find your wasm guidance in this repo? Where can I find it?

[cmainas]

Hello @cveld ,

sorry for that. We have not cleaned up the downstream wasm branches yet. I will clean it up and bring it up to date with the main branch. However, we have not decided yet if we will merge the wasm support with the libOS (there might be some differences in the bunnyfile etc.), so for the time being, we will have a separate branch.

I will reply here as soon as I bring everything up to date.

[cmainas]

Hello @cveld ,

I finally found some time to clean up the code and push a new branch which is up-to-date with the main branch of bunny. Specifically, the WASM support can be found in the wasm branch. I have also pushed a contianer image for that branch with the following reference: #syntax=harbor.nbfc.io/nubificus/bunny:wasm.

The reason for the cleanup is that for our use cases, we do not execute the WASM modules directly on the host, but we use actual tailored VMs for that. Therefore, we follow the "unikernel" paradigm even for WASM and execute it with urunc. As a result, bunny packages more artifacts and metadata alongside with the WASM module, which I do not think they will be useful for your use cases. Let me know if my assumption is wrong.

The current implementation in the branch is targeting C and Rust based applications. Once more, these applications are our use case, but it is quite straightforward to add support for more languages. Especially, if people are interested on that, I would be happy to assist and add support for new languages. In addition, the current implementation does not support the layered component system presented in the talk. We were hoping to get some feedback from more experienced WASM people about that before implementing it. Subsequently, we will not implement that for the time being and focus on the building and packaging of WASM modules. Again, any feedback is much more than welcome and useful for us.

Having said that let me provide a few examples:

NOTE: No prerequisites, except docker of course, is required.

C-based applications

In the case of C based applications, bunny will make use of wasi-sdk and the building process of the application should be based on a Makefile. In addition, the Makefile should use CC as a compiler and allow the addition of further CFLAGS and LDFLAGS. For example a C application like:

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("Argument count: %d\n", argc);

    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }

    return 0;
}

should have a Makefile like the following:

all:
        $(CC) $(CFLAGS) hello.c -o hello.wasm $(LDFLAGS)

basically bunny will execute make setting the following environment variables:

• CC=clang
• CFLAGS="--target=wasm32-wasi --sysroot=/opt/wasi-sdk/share/wasi-sysroot"

For the above application a bunnyfile could look like that:

#syntax=harbor.nbfc.io/nubificus/bunny:wasm
version: v0.1

platforms:
  framework: wasi
  monitor: wasmtime
  architecture: x86

app:
  name: hello
  from: local
  language: C

building the application is as simple as

docker build -f bunnyfile -t my/c/was/module .

this will generate a container image which contains the WASM module under the directory /.boot/app. Therefore, if you only care about the module, you can easily retrieve it with the following command:

docker build -f bunnyfile --output type=local,dest=./out .

The module will get placed in ./out/.boot/app.

NOTE: The WASM module follows WASI preview 1.

Rust-based applications

For Rust there are no specific requirements. bunny will build the WASM module using cargo using wasm32-wasip2 as a target, therefore any cargo based rust application should be built easily. A hello world example:

// main.rs
fn main() {
    println!("Hello from Rust WASI!");
}

and Cargo.toml:

[package]
name = "hello"
version = "0.1.0"
edition = "2024"

[dependencies]

the bunnyfile can look like that:

#syntax=harbor.nbfc.io/nubificus/bunny:wasm
version: v0.1

platforms:
  framework: wasi
  monitor: wasmtime
  architecture: x86

app:
  name: hello
  from: local
  language: rust

The commands to package and build the WASM module are the same with the C example.

I will keep updating this branch with the goal to be able to execute the produced WASM modules over run-wasi and crun.

Once more, please let me know if you have any feedback, or something that would fit better your use case.