DEV Community: Dario Castañé

Hello world from a WASM module in a static binary

Dario Castañé — Sat, 22 Feb 2025 12:27:38 +0000

These are some quick notes documenting a Saturday morning's experiment. All the steps were executed on Linux.

TL;DR: What?

Compiling a static binary that runs a compiled Ahead-of-Time (AOT) WASM module.

Ideally it'd have been WASM bytecode compiled to native code, but I couldn't find a way that didn't rely on the WASM runtime, invoking it from the command line or embedded in a C program.

Why?

I've been thinking and learning this week about WebAssembly and its potential since I read "WASM will replace containers".

I decided initially to use Wasmer and ended filing a question on their repository because their own native binary build command doesn't work as expected.

Finally, I landed on Bytecode Alliance's WebAssembly Micro Runtime (WAMR) wamrc compiler.

How?

The code

(module
  ;; Import the required WASI functions
  (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))

  ;; Define a buffer to store the message
  (memory (export "memory") 1)
  (data (i32.const 8) "Hello, World!\n")

  ;; Define the _start function
  (func $main (export "_start")
    ;; Setup the iovec array
    (i32.store (i32.const 0) (i32.const 8))    ;; pointer to the message
    (i32.store (i32.const 4) (i32.const 14))   ;; length of the message

    ;; Call fd_write
    (call $fd_write
      (i32.const 1)  ;; file_descriptor - 1 for stdout
      (i32.const 0)  ;; *iovs - pointer to the iovec array
      (i32.const 1)  ;; iovs_len - number of iovec entries
      (i32.const 20) ;; nwritten - where to store the number of bytes written
    )
    drop ;; Discard the result
  )
)

This is WebAssembly Text. Learn more here.

The tools

Everything had to be compiled from scratch.

wasm-opt isn't really required, so I'll skip it. I learnt about it while looking at these benchmarks, and I want these notes to keep track of the interesting tidbits I discovered.

The process

First, let's generate WASM bytecode from our WebAssembly Text code:

wat2wasm ./hello_world.wat -o ./hello_world.wasm

Next, compile it:

wamrc --format=aot -o ./hello_world.aot ./hello_world.wasm

For the last step, we need some C glue to embed the WAMR runtime:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "wasm_export.h"  // Now points to WAMR's core/iwasm/include/
#include "hello_world.h"

// Define a static pool buffer with proper alignment
#define POOL_SIZE (256 * 1024)  // 256 KB pool
static uint8_t global_pool_buf[POOL_SIZE] __attribute__((aligned(8)));  // 8-byte alignment

int main() {
    RuntimeInitArgs init_args;
    memset(&init_args, 0, sizeof(RuntimeInitArgs));

    // Configure memory pool
    init_args.mem_alloc_type = Alloc_With_Pool;  // Use pool allocator
    init_args.mem_alloc_option.pool.heap_buf = global_pool_buf;
    init_args.mem_alloc_option.pool.heap_size = sizeof(global_pool_buf);

    // Initialize the WAMR runtime
    if (!wasm_runtime_full_init(&init_args)) {
        printf("Runtime initialization failed.\n");
        return -1;
    }

    // Load the AOT module from the embedded blob
    char error_buf[128];
    wasm_module_t module = wasm_runtime_load(hello_world_aot, hello_world_aot_len, error_buf, sizeof(error_buf));
    if (!module) {
        printf("Load failed: %s\n", error_buf);
        return -1;
    }

    // Instantiate the module
    wasm_module_inst_t inst = wasm_runtime_instantiate(module, 65536, 65536, error_buf, sizeof(error_buf));
    if (!inst) {
        printf("Failed to instantiate: %s\n", error_buf);
        return -1;
    }

    // Call a function named "main" exported from the WASM module
    wasm_function_inst_t func = wasm_runtime_lookup_function(inst, "_start");
    if (!func) {
        printf("Function '_start' not found.\n");
        return -1;
    }

    wasm_exec_env_t env = wasm_runtime_create_exec_env(inst, 65536);
    if (!env) {
        printf("Failed to create environment.\n");
        return -1;
    }

    // Execute the function
    wasm_runtime_call_wasm(env, func, 0, NULL);

    // Cleanup
    wasm_runtime_deinstantiate(inst);
    wasm_runtime_unload(module);
    wasm_runtime_destroy();
    return 0;
}

The sharp reader may be asking "Where are the wasm_export.h and hello_world.h includes? The former is in wasm-micro-runtime/core/iwasm/include, and the later needs to be generated:

xxd -i hello_world.aot > hello_world.h

And we can compile and run it:

gcc -static $HOME/Code/hello-wasm/main.c $HOME/Code/wasm-micro-runtime/product-mini/platforms/linux/build/libiwasm.a -lm -I $HOME/Code/wasm-micro-runtime/core/iwasm/include -I $HOME/Code/hello-wasm -o $HOME/Code/hello-wasm/hello_world

$HOME/Code/hello-wasm/hello_world
Hello, World!

Note: it's not a perfect statically-linked binary. It depends on getaddrinfo, but this is better left out of scope right now.

Image by Duncan Cumming.

A portal between Ruby and Go (using FFI)

Dario Castañé — Tue, 06 Sep 2022 09:48:50 +0000

Thinking about migrating some huge REST APIs from Ruby to Go, I researched how to replace the Ruby code progressively with Go code.

I ended up with a possible FFI-based prototype. The solution is to have the Ruby code load a Go library and wrap the Go functions in Ruby classes and methods.

The Ruby side

The Ruby side is pretty straightforward. We must load the Go library and import the Go functions in Ruby classes and methods.

require 'ffi'

module Portal
  extend FFI::Library

  ffi_lib './libexample.so'

  class Example < FFI::Struct
    # This must be completely in sync with the C struct defined in Go code.
    layout :id, :int, :prefix, :pointer

    def initialize(prefix, id)
      self[:prefix] = FFI::MemoryPointer.from_string(prefix)
      self[:id] = id
    end

    # This feels convoluted, but it hides the fact that our function is loaded
    # outside of the "struct mirror" class.
    def greet
      Portal.greet(self)
    end
  end

  attach_function 'greet', [Example.by_value], :void
end

ex = Portal::Example.new('C', 137)
ex.greet

The Go side

The Go side is a bit more complex. We need to define a C-compatible struct and export the functions we want to use from Ruby.

The cool thing is that we can define the functions with the struct as the receiver.

package main

/*
struct example {
    int ID;
    char *Prefix;
};
*/
import "C"
import "fmt"

// This declaration is just an alias to the C struct.
type Example C.struct_example

//export greet
func (e Example) greet() {
    fmt.Printf("Hello from %s-%d\n", C.GoString(e.Prefix), e.ID)
}

func main() {}

The build

The build is also straightforward. We need to:

Compile the Go code to a shared library. This command will generate the CGO bindings.
Run the Ruby code.

go build -buildmode=c-shared -o libexample.so example.go
ruby portal.rb

The result

If we run the code, we get the following output:

Hello from C-137

The benefits

The main benefit of this approach is that we can progressively migrate the Ruby code to Go. We can start by replacing part by part, until we are ready to switch to a pure Go service.

It's not only possible to replace existing Ruby code. Now we can reuse RSpec/Minitest specs to test the new Go code. Instead of going for a full rewrite with no tests, we can start by testing the new code with the existing ones.

The (possible) drawbacks

Performance-wise this approach is not ideal. We are adding a layer of indirection. This probably adds some overhead to the calls. This is something we need to measure if applied to high-traffic services.

Simple Deno HTTP server running in Nanos unikernel

Dario Castañé — Wed, 25 Aug 2021 21:11:15 +0000

This short post shows how to get a self-executable Deno HTTP server to run in Nanos using Ops.

The server

const port = Number(Deno.env.get('PORT'));
const listener = Deno.listen({ port: port });

console.log(`http://localhost:${port}`);

for await (const conn of listener) {
  (async () => {
    const requests = Deno.serveHttp(conn);
    for await (const { respondWith } of requests) {
      respondWith(new Response("Hello world"));
    }
  })();
}

Compilation and local deployment

deno compile --allow-env --allow-net hello.ts
ops run -e HOME=/ -e PORT=8000 -p 8000 hello

The trick is to set the HOME variable. It can have any value, but / feels right.

Summary

In this post, we have seen a minimal Deno HTTP server working in a Nanos unikernel.

Hi, I'm Dario Castañé

Dario Castañé — Thu, 22 Jun 2017 07:25:50 +0000

I have been coding for too much years. I don't even remember. No, seriously, I was born in 1985 and I started to code in 1997.

You can find me on GitHub as imdario.

I live in Barcelona (Catalonia).

I work for Loyal Guru as tech lead.

I mostly program in these languages: Ruby, Go, etc. I consider myself a polyglot programmer.

I am currently learning more about blockchain, webcomponents, IoT, etc.

Nice to meet you and happy hacking <3