WebAssembly 3.0 & WASI 0.3 Sandbox • Instant Memory Snapshots

Run untrusted plugins and background tasks safely with instant memory rollback.

vvm is a lightweight virtual machine for running third-party plugins, custom business rules, and serverless functions in a strict sandbox. It supports WebAssembly 3.0 and asynchronous WASI 0.3, includes a built-in V-to-WebAssembly compiler (vwasm), starts without JIT warm-up delays, and snapshots or restores memory in less than a microsecond.

End User Documentation Technical Documentation
Built-In V-to-Wasm Compiler Compiles V guest programs directly to .wasm in under 250 ms and runs modules without JIT warm-up delays.
Sub-Microsecond Snapshots Tracks changed memory in 4 KB chunks to clone sandboxes or undo failed runs in under a microsecond.
Fair Multi-Tenant Scheduling Time-slices CPU steps across concurrent plugins and automatically quarantines runaway tenant code.
Why It's Needed & Use Cases

Safe Sandboxes for Customer Plugins, Rules & Edge Functions

How vvm lets you run customer code and third-party modules safely without heavy containers or 60 MB+ JIT engines.

The Problem

Running a separate Docker container or microVM for every customer plugin consumes gigabytes of idle RAM and adds 100ms+ cold-start delays. Meanwhile, large C++ and LLVM JIT runtimes bring heavy external dependencies, unpredictable compilation pauses, and runtime code-generation security risks.

1. Core Capabilities Wasm 3.0 • WASI 0.3 • Sandboxed I/O

Run Untrusted Code Safely Inside Your Application

Execute third-party WebAssembly modules with strict memory boundaries, deterministic CPU step limits, and explicit WASI 0.3 permissions for files and network streams—no root access required.

Included: Single-pass compiler • WasmGC & exceptions • Official W3C spec test runner • Browser debugger.
2. Resource Efficiency High Sandbox Density

Run Thousands of Customer Sandboxes on One Server

Clone a pre-warmed sandbox in under a microsecond using 4 KB Copy-on-Write memory pages instead of keeping idle containers running. The entire runtime ships as a ~1.3 MB binary with zero C++ or Rust libraries.

Impact: Sub-microsecond instance cloning • Minimal idle memory • No JIT executable-memory attack surface.
3. Plugins & Rule Engines Built-In vwasm • Dynamic Linking

Write V Plugins Directly or Link Multi-Language Modules

Compile V guest programs straight to .wasm in under 250 ms with built-in vwasm, link modules from Rust, Go, TypeScript, or C dynamically, or build custom rule languages with lexical closures and fair CPU time-slicing.

Portability: Pause a running instance on an x86_64 server and resume it on an ARM64 machine.
4. Suite Integration Containers • Databases • Edge • AI

Shared Sandbox Engine for the trustnode.sh Suite

Runs WebAssembly workloads inside varc, executes transactional stored procedures inside vprevail (rolling back memory automatically if a transaction aborts), filters traffic in vgate, and sandboxes AI tool calls for vllm.

Integrations: varc Wasm workloads • vprevail procedures • vca module signatures • vgate edge routing.
Market Comparison

How vvm Compares to Other WebAssembly Runtimes

A look at how vvm's single-pass register runtime and 4 KB Copy-on-Write snapshots compare to traditional JIT engines.

Runtime Capability vvm (Wasm 3.0 & WASI 0.3) Wasmtime / Cranelift V8 Isolates / Node Wasm
Binary Size & Dependencies ~1.3 MB binary • Zero C/C++/Rust/LLVM dependencies 35 MB – 65 MB Rust/C++ binary 80 MB+ V8 C++ runtime
Execution Model Single-pass 16-byte register instruction engine Multi-tier Cranelift / Winch JIT Liftoff baseline + TurboFan JIT
Snapshot & Rollback Speed < 1 µs 4 KB Copy-on-Write pages + WasmGC heap OS process fork or full 64 KB page copy Full heap serialization (milliseconds)
WebAssembly 3.0 Support WasmGC, recursive types, try_table exceptions, tail calls, SIMD Varies by feature flags Tied to JavaScript garbage collector
Cross-Architecture Migration Move paused instances between x86_64 and ARM64 Not supported across JIT architectures Not supported across architectures
Debugging & Inspection Built-in web debugger with step-back replay External command-line debuggers (LLDB/GDB) Requires attaching Chrome DevTools
1. No JIT Attack Surface: Never generates executable machine code at runtime, avoiding JIT-spray and compiler vulnerabilities.
2. Fast Memory Rollbacks: Tracks modified memory in 4 KB pages so sandboxes can fork or reset in less than a microsecond.
3. Architecture Portable: Save a running call stack on an x86_64 server and resume execution on an ARM64 host.
Technical Reference

Technical Specifications

WebAssembly 3.0 bytecode execution, memory management, and WASI 0.3 runtime specifications.

REGISTER EXECUTION ENGINE

Single-Pass 16-Byte Instructions

Validates WebAssembly 3.0 binaries or WAT text and translates them in one linear pass into compact 16-byte register instructions, avoiding operand-stack overhead.

WASMGC, VWASM & LINKER

V-to-Wasm Compiler & Linking

Includes a built-in V-to-WebAssembly compiler (vwasm, < 250 ms), multi-module dynamic linking, WasmGC structs/arrays, and lexical closures in the language builder API.

EXCEPTIONS & TAIL CALLS

Structured Exceptions & Tail Calls

Implements WebAssembly 3.0 exception handling (tag, throw, try_table, exnref) and constant-stack tail-call instructions.

128-BIT VECTOR SIMD

236 Fixed-Width & Relaxed SIMD Ops

Supports 128-bit v128 vector math, lane shuffles, integer dot products, and WebAssembly 3.0 Relaxed SIMD fused multiply-add instructions.

MEMORY64 & FAIR SCHEDULING

4 KB CoW & Tenant Time-Slicing

Tracks 64-bit Memory64 changes in 4 KB sub-pages for sub-microsecond rollbacks, cross-arch migration, and deterministic multi-tenant CPU time-slicing.

WASI 0.3 & WEB DEBUGGER

Async Streams & Authenticated UI

Implements capability-scoped WASI 0.3 async streams and futures, OpenAPI 3.1 endpoints, 18 runnable examples, and a token-authenticated 4-role web debugger.

Product Roadmap & Releases

Stay Informed on vvm Releases

Follow recent and upcoming runtime milestones, and subscribe for release notifications, early access builds, or product briefings.

Release Highlights

Recent & Upcoming Milestones

WebAssembly 3.0 Core, Built-In vwasm Compiler & Dynamic Linker Available Now

Single-pass register engine, built-in V-to-WebAssembly compiler (vwasm), multi-module dynamic linker, WasmGC, closures, exceptions, tail calls, and 236 SIMD ops.

WASI 0.3 Async I/O, Multi-Tenant Time-Slicing & Web Debugger Available Now

WASI 0.3 async streams, sub-microsecond 4 KB memory snapshots, fair multi-tenant CPU time-slicing, x86_64/ARM64 migration, and authenticated 4-workspace web studio.

Native vgate Edge Filter & Sidecar Integration Available Now

Embeds directly inside vgate via the vgate.http ABI with 4 KiB CoW per-request isolation and Prometheus metrics, plus OIDC IAP/WAF/SOCKS5h sidecar protection for vvm studio.