Text format (WAT)

(module
  ;; line comment            (; block comment ;)
  (func $add (export "add") (param $a i32) (param $b i32)
    (result i32)
    local.get $a
    local.get $b
    i32.add)
)

;; flat (stack) form: what the binary encodes
local.get $x
i32.const 1
i32.add
local.set $x
 
;; folded form: operands nested, evaluated left to right
(local.set $x
  (i32.add (local.get $x) (i32.const 1)))
 
;; mixed is fine: folded expressions just push values
(i32.add (local.get $x) (i32.const 1))
local.set $x

(module
  (global $count (mut i32) (i32.const 0))
  (global $limit i32 (i32.const 100))  ;; immutable
 
  (func (export "bump") (param $by i32) (result i32)
    (local $tmp i32) (local $f f64)    ;; zero-initialized
    (local.set $tmp
      (i32.add (global.get $count) (local.get $by)))
    (global.set $count (local.get $tmp))
    local.get $tmp)                    ;; result
)

(module
  ;; n! with a loop: block = break target, loop = continue
  (func (export "fact") (param $n i32) (result i64)
    (local $acc i64)
    (local.set $acc (i64.const 1))
    (block $done
      (loop $next
        (br_if $done (i32.le_s (local.get $n) (i32.const 1)))
        (local.set $acc
          (i64.mul (local.get $acc)
                   (i64.extend_i32_u (local.get $n))))
        (local.set $n (i32.sub (local.get $n) (i32.const 1)))
        (br $next)))
    local.get $acc)
 
  ;; if / else with a result value
  (func (export "sign") (param $x i32) (result i32)
    (if (result i32) (i32.lt_s (local.get $x) (i32.const 0))
      (then (i32.const -1))
      (else (i32.const 1))))
)

;; switch via br_table: 0 → 10, 1 → 20, other → 99
(func $pick (param $i i32) (result i32)
  (block $default
    (block $one
      (block $zero
        (br_table $zero $one $default (local.get $i)))
      (return (i32.const 10)))    ;; after $zero
    (return (i32.const 20)))      ;; after $one
  i32.const 99)

(module
  (type $binop (func (param i32 i32) (result i32)))
  (table $ops 2 funcref)
  (elem (table $ops) (i32.const 0) func $add $mul)
  (func $add (type $binop)
    (i32.add (local.get 0) (local.get 1)))
  (func $mul (type $binop)
    (i32.mul (local.get 0) (local.get 1)))
 
  ;; apply(op, a, b): op 0 = add, 1 = mul
  (func (export "apply")
    (param $op i32) (param $a i32) (param $b i32)
    (result i32)
    (call_indirect $ops (type $binop)
      (local.get $a) (local.get $b) (local.get $op)))
)

(module
  (memory (export "memory") 1 100)   ;; 64 KiB .. 6.25 MiB
  (data (i32.const 0) "Hello, Wasm!")
  (data $blob "\01\02\03\04")         ;; passive segment
 
  (func (export "sum") (param $p i32) (param $n i32)
    (result i32)
    (local $acc i32) (local $end i32)
    (local.set $end
      (i32.add (local.get $p)
               (i32.shl (local.get $n) (i32.const 2))))
    (block $out
      (loop $go
        (br_if $out
          (i32.ge_u (local.get $p) (local.get $end)))
        (local.set $acc
          (i32.add (local.get $acc)
                   (i32.load (local.get $p))))
        (local.set $p (i32.add (local.get $p) (i32.const 4)))
        (br $go)))
    local.get $acc)
)

(module
  ;; imports come first in each index space
  (import "env" "log" (func $log (param i32)))
  (import "env" "memory" (memory 1))
  (import "env" "base" (global $base i32))
  (import "env" "tbl" (table 4 funcref))
 
  (global $ready (mut i32) (i32.const 0))
 
  (func $init
    (global.set $ready (i32.const 1))
    (call $log (global.get $base)))
  (start $init)       ;; runs during instantiation
 
  (func (export "ready") (result i32) (global.get $ready))
  (export "ready_flag" (global $ready))
)

const { instance } = await WebAssembly.instantiate(bytes, {
  env: {
    log: console.log,
    memory: new WebAssembly.Memory({ initial: 1 }),
    base: 42, // immutable i32 global: a plain number
    tbl: new WebAssembly.Table({
      element: "anyfunc", initial: 4,
    }),
  },
});

(module
  (memory (export "memory") 1)
  ;; out[i] = a[i] * b[i] for 4 floats at a time
  (func (export "mul4") (param $a i32) (param $b i32)
    (param $out i32)
    (v128.store (local.get $out)
      (f32x4.mul (v128.load (local.get $a))
                 (v128.load (local.get $b)))))
 
  ;; horizontal: lane extraction
  (func (export "lane2") (param $p i32) (result f32)
    (f32x4.extract_lane 2 (v128.load (local.get $p))))
)

(module
  (type $point (struct (field $x (mut f64))
                       (field $y (mut f64))))
  (type $bytes (array (mut i8)))
 
  (func (export "make") (param f64 f64) (result anyref)
    (struct.new $point (local.get 0) (local.get 1)))
 
  (func (export "x") (param $p anyref) (result f64)
    (struct.get $point $x
      (ref.cast (ref $point) (local.get $p))))
 
  (func (export "buf") (param $n i32) (result i32)
    (array.len
      (array.new $bytes (i32.const 0) (local.get $n))))
)

(module
  (tag $oops (export "oops") (param i32))
 
  (func $risky (param $x i32)
    (if (i32.lt_s (local.get $x) (i32.const 0))
      (then (throw $oops (local.get $x)))))
 
  ;; returns the payload if $risky threw, else 0
  (func (export "check") (param $x i32) (result i32)
    (block $caught (result i32)
      (try_table (catch $oops $caught)
        (call $risky (local.get $x)))
      (i32.const 0)))
)

# sizes and imports / exports at a glance
wasm-tools objdump app.wasm
wasm-tools print app.wasm | grep -E '^\s*\((import|export)'
 
# one function, folded, with byte offsets
wasm-tools print -f -p app.wasm | less
 
# where did the bytes go? (see also twiggy for Rust)
wasm-opt --func-metrics app.wasm -o /dev/null | head
 
# producers: which compiler and version built it
wasm-tools metadata show app.wasm

(module
  (import "env" "log" (func $log (param i32 i32)))
  (memory (export "memory") 1)
  (data (i32.const 0) "Hello from WAT")
  (func (export "main")
    (call $log (i32.const 0) (i32.const 14)))
)

const res = await fetch("/hello.wasm");
const bytes = await res.arrayBuffer();
let mem!: WebAssembly.Memory;
const { instance } = await WebAssembly.instantiate(bytes, {
  env: {
    log: (ptr: number, len: number) => console.log(
      new TextDecoder().decode(
        new Uint8Array(mem.buffer, ptr, len)),
    ),
  },
});
mem = instance.exports.memory as WebAssembly.Memory;
(instance.exports.main as () => void)();

import initWabt from "wabt";
 
const wabt = await initWabt();
const src = `(module (func (export "sq")
  (param i32) (result i32)
  (i32.mul (local.get 0) (local.get 0))))`;
const mod = wabt.parseWat("sq.wat", src);
const { buffer } = mod.toBinary({});
const { instance } = await WebAssembly.instantiate(buffer);
const sq = instance.exports.sq as (x: number) => number;
console.log(sq(12)); // 144

(module
  (memory (export "memory") 1)
  (global $top (mut i32) (i32.const 1024)) ;; after data
 
  (func (export "alloc") (param $n i32) (result i32)
    (local $p i32)
    (local.set $p (global.get $top))
    ;; round up to 8 bytes
    (global.set $top
      (i32.and (i32.add (i32.add (local.get $p)
                                 (local.get $n))
                        (i32.const 7))
               (i32.const -8)))
    ;; grow if needed: pages = ceil(top / 65536)
    (if (i32.gt_u (global.get $top)
          (i32.shl (memory.size) (i32.const 16)))
      (then (drop (memory.grow (i32.const 1)))))
    local.get $p)
 
  (func (export "reset") (global.set $top (i32.const 1024)))
)

(module
  (memory (export "memory") 1)
  (func (export "clear") (param $p i32) (param $n i32)
    (memory.fill
      (local.get $p) (i32.const 0) (local.get $n)))
  (func (export "move")
    (param $dst i32) (param $src i32) (param $n i32)
    (memory.copy
      (local.get $dst) (local.get $src) (local.get $n)))
)

(module
  (func $sum (export "sum") (param $n i64) (param $acc i64)
    (result i64)
    (if (result i64) (i64.eqz (local.get $n))
      (then (local.get $acc))
      (else
        (return_call $sum
          (i64.sub (local.get $n) (i64.const 1))
          (i64.add (local.get $acc) (local.get $n))))))
)

wasm-tools print app.wasm -o app.wat   # binary → text
$EDITOR app.wat
wasm-tools parse app.wat -o app2.wasm  # text → binary
wasm-tools validate app2.wasm
wasm-opt -Oz app2.wasm -o app.min.wasm
ls -l app.wasm app.min.wasm