WebAssembly (kurz Wasm) ist ein kompaktes, plattformunabhängiges Bytecode-Format für den Browser. Seit Dezember 2019 ist die Kern-Spezifikation eine W3C-Empfehlung. WebAssembly ist keine Hochsprache, sondern ein Kompilationsziel: Programme aus C, C++, Rust oder Go werden zu .wasm-Dateien übersetzt und in der Browser-Engine nahezu nativ ausgeführt. Dieser Artikel stellt die wichtigsten Werkzeuge und Kommandos der Wasm-Toolchain vor.

WABT — WebAssembly Binary Toolkit

Das WABT (WebAssembly Binary Toolkit) enthält die zentralen Kommandozeilen-Werkzeuge, um Text- und Binärformat ineinander zu überführen:

wat2wasm add.wat -o add.wasm   # Text (WAT) nach Binär (WASM)
wasm2wat add.wasm -o add.wat   # Binär nach Text (Disassemblierung)
wasm-validate add.wasm         # Validierung gegen die Spezifikation
wasm-objdump -x add.wasm       # Sektionen, Importe, Exporte anzeigen
wasm-interp add.wasm --run-all-exports  # interpretierende Ausführung

Binaryen — Optimierungen

Binaryen ist eine Compiler-Infrastruktur des WebAssembly-Projekts. Ihr bekanntestes Werkzeug ist wasm-opt, das Wasm-Binärdateien optimiert und verkleinert:

wasm-opt input.wasm -O2 -o output.wasm   # Optimierungsstufe 2
wasm-opt input.wasm --minify -o out.wasm  # Namen minifizieren
wasm2js input.wasm -o output.js           # Wasm nach JS als Fallback

Runtimes außerhalb des Browsers

WebAssembly läuft nicht nur im Browser. Eigenständige Runtimes wie wasmtime (Bytecode Alliance, Rust) oder wasmer führen Wasm-Module als sichere, sandboxierte Prozesse aus und nutzen dafür die System-API WASI (WebAssembly System Interface):

wasmtime run hello.wasm
wasmer run hello.wasm

Kompilieren aus Hochsprachen

• Rust: cargo build --target wasm32-unknown-unknown erzeugt eine Wasm-Binärdatei; die Bindings an JavaScript liefert wasm-bindgen.
• C/C++: emcc aus dem Emscripten-Projekt kompiliert C- und C++-Code nach WebAssembly (Nachfolger von asm.js).
• Clang: clang --target=wasm32 -O3 übersetzt C direkt nach Wasm.
• Go: GOOS=js GOARCH=wasm go build erzeugt ein Wasm-Modul.

Im Browser

Die JavaScript-API lädt und instanziiert Module direkt:

WebAssembly.instantiateStreaming(fetch('add.wasm')).then(({ instance }) => {
  console.log(instance.exports.add(2, 3));
});

Verwandte Einträge: WAT — WebAssembly-Textformat, asm.js-Befehle, WebAssembly, WebGPU-Befehle, Rust-Befehle.

WAT (WebAssembly Text Format) ist die menschenlesbare Darstellung eines WebAssembly-Moduls. Jede .wat-Datei beschreibt exakt dasselbe Modul wie ihr binäres Gegenstück .wasm; das Werkzeug wat2wasm übersetzt zwischen beiden Formaten. WAT verwendet S-Ausdrücke — Klammern strukturieren Module, Funktionen und Anweisungen.

Modulaufbau

Ein Modul beginnt mit (module ...). Darin stehen Funktionen, Importe, Speicher, Tabellen und Exporte:

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

Stack-Maschine

WAT ist eine Stack-Maschine: Anweisungen legen Werte auf einen Operandenstapel und verarbeiten sie. Die wichtigsten Instruktionen:

• Konstanten: i32.const 42, f64.const 3.14
• Lokale Variablen: local.get, local.set, local.tee
• Arithmetik: i32.add, i32.sub, i32.mul, i32.div_s, i64.add, f32.add
• Kontrollfluss: call, return, if/else/end, block/loop/br/br_if
• Speicherzugriff: i32.load, i32.store
• Vergleiche: i32.eq, i32.lt_s, i32.gt_u

Importe, Speicher und Daten

(module
  (import "env" "log" (func $log (param i32)))
  (memory (export "memory") 1)
  (data (i32.const 0) "hallo")
  (func (export "run")
    i32.const 42
    call $log))

Ein Speicher wird in Seiten zu 64 KiB (65536 Bytes) angelegt. (data ...) schreibt Bytes an eine Speicheradresse — das ist die Grundlage für Strings und Puffer zwischen JavaScript und Wasm.

Werkzeuge für WAT

wat2wasm add.wat -o add.wasm          # Text nach Binär
wat2wasm add.wat -v                    # verbose: erklärt jedes Byte
wasm2wat add.wasm -o add.wat          # Binär zurück nach Text
wat2wasm --debug-names add.wat -o add.wasm  # Debug-Namen erhalten

Typen

Die Basis-Typen sind i32, i64, f32 und f64. Seit dem SIMD-Vorschlag kommen v128-Vektoren hinzu; Referenz-Typen (externref, funcref) ergänzen das Typsystem für die Integration mit JavaScript.

Verwandte Einträge: WebAssembly-Befehle, asm.js-Befehle, WebAssembly, JavaScript-Befehle.

asm.js ist ein striktes Teilset von JavaScript, das 2013 von Alon Zakai bei Mozilla eingeführt wurde. Es entstand aus dem Emscripten-Projekt (seit 2010), das C- und C++-Programme in JavaScript übersetzt. asm.js-Code trägt das Pragma "use asm"; und beschränkt sich auf typisierte Variablen und Zahlenoperationen — dadurch kann die Engine (SpiderMonkey) den Code vorab in nativen Maschinencode übersetzen (AOT) und fast native Geschwindigkeit erreichen. asm.js ist der direkte Vorläufer von WebAssembly, das 2017 im Browser Einzug hielt und asm.js seither weitgehend ablöste.

Modulaufbau

Ein asm.js-Modul ist eine normale Funktion mit drei Parametern: dem globalen Objekt, fremden Importen und dem Heap (einem ArrayBuffer):

function asmModule(global, foreign, heap) {
  "use asm";
  function add(a, b) {
    a = a | 0;          // Typannotation: 32-Bit-Integer
    b = b | 0;
    return (a + b) | 0;
  }
  return { add: add };
}

Typannotationen

Jede Zahl wird explizit typisiert, damit die Engine keine dynamischen Checks ausführen muss:

• x | 0 kennzeichnet einen 32-Bit-Integer
• +x kennzeichnet eine 64-Bit-Gleitkommazahl (double)
• x >>> 0 kennzeichnet einen vorzeichenlosen 32-Bit-Integer
• Der Heap ist ein ArrayBuffer, der über typisierte Sichten (Int32Array, Float64Array) angesprochen wird

Aufruf aus JavaScript

var module = asmModule(global, foreign, new ArrayBuffer(65536));
var result = module.add(2, 3);   // 5

Befehle und Werkzeuge

asm.js wurde kaum von Hand geschrieben, sondern von Compilern erzeugt. Die Werkzeuge stammen aus der Emscripten-Toolchain:

emcc main.c -s ASM_JS=1 -o module.js    # klassische asm.js-Ausgabe
emcc main.c -o module.wasm              # heute: WebAssembly statt asm.js
emcc --minify 0 main.c -o module.js     # lesbare Ausgabe zum Debuggen

Bedeutung

asm.js zeigte, dass Browser-Code nahe an nativer Geschwindigkeit laufen kann, und ebnete den Weg für WebAssembly. Seit 2017 ist Wasm die bevorzugte Zielplattform; asm.js wird von den Engines weiterhin unterstützt, hat aber praktisch nur noch Bedeutung als Fallback für alte Browser.

Verwandte Einträge: WebAssembly-Befehle, WAT — WebAssembly-Textformat, WebAssembly, C/C++-Befehle, Rust-Befehle.

GNU Octave ist eine freie, MATLAB-kompatible Sprache für numerisches Rechnen. Entwickelt von John W. Eaton (erste Alpha 0.60 am 4. Januar 1993, GNU-Projekt, GPL), eignet sich Octave für lineare Algebra, Signalverarbeitung, Optimierung und Datenanalyse — die Syntax ist weitgehend identisch mit MATLAB-Befehlen, sodass viele .m-Skripte unverändert laufen.

Start und Ausführung

octave                     # interaktive Shell
octave --no-gui --silent   # Kopfzeilen unterdrücken
octave --eval "x = 2 + 3; disp(x)"   # Einzeiler
octave script.m            # Skript ausführen

Octave läuft als GUI, als Konsole oder als Teil eines Shell-Skripts (Batch-Modus).

Wichtige Befehle

• Hilfe: help plot, doc plot, lookfor suchbegriff
• Workspace: whos, who, clear, exist('x')
• Vektoren/Matrizen: x = linspace(0, 2*pi, 100), zeros(3), ones(2,4), eye(3), rand(2,2)
• Lineare Algebra: A b (lineares Gleichungssystem), eig(A), inv(A), det(A), transpose(A)
• Signalverarbeitung: fft(x), ifft(x), conv, filter
• I/O: save daten.mat x y, load daten.mat, fprintf('%f ', x), disp(x)

Pakete (Packages)

pkg list                 # installierte Pakete
pkg install -forge signal   # aus dem Octave-Forge-Repository
pkg load signal          # Paket für die Sitzung aktivieren

Octave-Forge bietet Pakete für Signalverarbeitung, Statistik, Optimierung, Symbolik und mehr.

Plotting

plot(x, sin(x), 'r-', x, cos(x), 'b--')
hold on; plot(x, x.^2); hold off
grid on; xlabel('Zeit'); ylabel('Amplitude'); title('Sinuskurve'); legend('sin','cos')
print('plot.png', '-dpng')   # in Datei exportieren

Frühere Octave-Versionen nutzten Gnuplot als Standard-Grafik-Backend; seit Octave 4.x ist der Qt-/OpenGL-Renderer Standard, Gnuplot bleibt optional verfügbar.

Praxis-Tipps

• Skripte in .m-Dateien schreiben, Funktionen in separaten Dateien definieren (Name = Dateiname).
• Mit A b statt inv(A) * b rechnen — schneller und numerisch stabiler.
• Vektorisieren: x.^2 statt Schleifen über Elemente.

Verwandte Grundlagen: Scilab-Befehle (freie MATLAB-Alternative), Python-Befehle (NumPy/SciPy), R-Befehle (Statistik).