diff --git a/.gitattributes b/.gitattributes
index 0deaf2f3b..1ddf66bc3 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -7,6 +7,8 @@ rust/crates/truapi-server/src/wasm/generated_bridge.rs linguist-generated=true
 ios/truapi-host/Sources/TrUAPIHost/truapi*.swift linguist-generated=true
 ios/truapi-host/Sources/TrUAPIHost/Resources/truapi-container.js linguist-generated=true
 ios/truapi-host/Sources/truapi*FFI/include/** linguist-generated=true
+ios/truapi-host/Sources/TrUAPIHost/pvm_runtime.swift linguist-generated=true
+ios/truapi-host/Sources/pvm_runtimeFFI/include/** linguist-generated=true
 
 ios/truapi-provider/Sources/TrUAPIProvider/truapi_provider.swift linguist-generated=true
 ios/*-provider/Sources/*FFI/include/** linguist-generated=true
diff --git a/.github/PULL_REQUEST_TEMPLATE/release.md b/.github/PULL_REQUEST_TEMPLATE/release.md
index 477649b40..1cc6649e6 100644
--- a/.github/PULL_REQUEST_TEMPLATE/release.md
+++ b/.github/PULL_REQUEST_TEMPLATE/release.md
@@ -2,7 +2,7 @@
 
 > [!IMPORTANT]
 > The PR title must start with `release:` for the publish workflow to fire.
-> Example: `release: @parity/truapi 0.5.0, @parity/truapi-host 0.2.0, @parity/ios-host 0.2.0, @parity/android-host 0.1.0`.
+> Example: `release: @parity/truapi 0.5.0, @parity/truapi-host 0.2.0, @parity/pvm-browser-runtime 0.1.0, @parity/ios-host 0.2.0, @parity/android-host 0.1.0`.
 > Don't rewrite the squash commit subject in the merge dialog — the
 > `release:` prefix has to land on `main`.
 
@@ -16,6 +16,7 @@
 - [ ] Ran `npm run version-packages` to consume the changeset
 - [ ] `js/packages/truapi/package.json` version is bumped
 - [ ] `js/packages/truapi-host/package.json` version is bumped when releasing the host
+- [ ] `js/packages/pvm-browser-runtime/package.json` declares the requested browser-runtime version
 - [ ] The PR title includes `@parity/ios-host <version>` when publishing the iOS host
 - [ ] Regenerated iOS bindings and container outputs are committed; CI builds and simulator-tests the XCFramework, publishes it, then commits `Package.swift`
 - [ ] The PR title includes `@parity/android-host <version>` when publishing the Android host AAR; nothing in the tree records that version, so there is no manifest to bump
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 3a3970d06..9428bb861 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -72,7 +72,7 @@ jobs:
             # Trim whitespace around comma-separated targets.
             target="${target#"${target%%[![:space:]]*}"}"
             target="${target%"${target##*[![:space:]]}"}"
-            if [[ ! "${target}" =~ ^(@parity/truapi|@parity/truapi-host|@parity/ios-host|@parity/android-host)[[:space:]]+([^[:space:]]+)$ ]]; then
+            if [[ ! "${target}" =~ ^(@parity/truapi|@parity/truapi-host|@parity/pvm-browser-runtime|@parity/ios-host|@parity/android-host)[[:space:]]+([^[:space:]]+)$ ]]; then
               echo "::error::Unsupported release target '${target}' in subject: ${subject}"
               exit 1
             fi
@@ -93,6 +93,7 @@ jobs:
                 cli_version="${declared_version}"
                 ;;
               @parity/truapi-host) path="js/packages/truapi-host" ;;
+              @parity/pvm-browser-runtime) path="js/packages/pvm-browser-runtime" ;;
               @parity/ios-host)
                 if [[ ! "${declared_version}" =~ ^[0-9]+\.[0-9]+\.[0-9]+([+-][0-9A-Za-z.-]+)?$ ]]; then
                   echo "::error::Invalid iOS host version '${declared_version}'."
@@ -167,6 +168,7 @@ jobs:
         uses: dtolnay/rust-toolchain@5b842231ba77f5c045dba54ac5560fed2db780e2 # stable
         with:
           toolchain: stable
+          targets: wasm32-unknown-unknown
 
       - if: steps.version.outputs.proceed == 'true'
         uses: Swatinem/rust-cache@f0d9c3887740aee45f6153b24b3a6b815192ec16 # v2
@@ -188,6 +190,9 @@ jobs:
             npm run build --prefix js/packages/truapi-host
             npm run build:wasm --prefix js/packages/truapi-host
           fi
+          if grep -q '^@parity/pvm-browser-runtime|' <<< "${STEPS_VERSION_OUTPUTS_PACKAGES}"; then
+            npm run build --prefix js/packages/pvm-browser-runtime
+          fi
         env:
           STEPS_VERSION_OUTPUTS_PACKAGES: ${{ steps.version.outputs.packages }}
 
diff --git a/.gitignore b/.gitignore
index 34260c5fb..917af5987 100644
--- a/.gitignore
+++ b/.gitignore
@@ -68,3 +68,4 @@ js/packages/truapi/dist/generated/
 js/packages/truapi-host/src/generated/
 js/packages/truapi-host/dist/generated/
 js/packages/truapi-host/dist/wasm/
+js/packages/pvm-browser-runtime/dist/
diff --git a/Cargo.lock b/Cargo.lock
index 5a3f46235..decc781da 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1510,7 +1510,7 @@ version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef975e30683b2d965054bb0a836f8973857c4ebf6acf274fe46617cd285060d8"
 dependencies = [
- "foldhash",
+ "foldhash 0.2.0",
  "libm",
  "portable-atomic",
  "siphasher",
@@ -1592,6 +1592,12 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
 [[package]]
 name = "foldhash"
 version = "0.2.0"
@@ -1941,6 +1947,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
  "allocator-api2",
+ "foldhash 0.1.5",
+ "serde",
 ]
 
 [[package]]
@@ -1951,7 +1959,7 @@ checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
  "allocator-api2",
  "equivalent",
- "foldhash",
+ "foldhash 0.2.0",
  "serde",
  "serde_core",
 ]
@@ -1964,7 +1972,7 @@ checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
 dependencies = [
  "allocator-api2",
  "equivalent",
- "foldhash",
+ "foldhash 0.2.0",
 ]
 
 [[package]]
@@ -2620,6 +2628,12 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
 [[package]]
 name = "libc"
 version = "0.2.189"
@@ -3148,6 +3162,12 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
+[[package]]
+name = "picosimd"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7823ffd00d2b55ebe51750a19f47f2a33cb1f1d135f5cba893379b81c4d44856"
+
 [[package]]
 name = "pin-project"
 version = "1.1.13"
@@ -3201,6 +3221,78 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
 
+[[package]]
+name = "polkavm"
+version = "0.37.0"
+source = "git+https://github.com/paritytech/polkavm.git?rev=3df1d0309c4c81a1aad0a755d83570d203bba1d9#3df1d0309c4c81a1aad0a755d83570d203bba1d9"
+dependencies = [
+ "libc",
+ "log",
+ "picosimd",
+ "polkavm-assembler 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=3df1d0309c4c81a1aad0a755d83570d203bba1d9)",
+ "polkavm-common 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=3df1d0309c4c81a1aad0a755d83570d203bba1d9)",
+ "polkavm-linux-raw 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=3df1d0309c4c81a1aad0a755d83570d203bba1d9)",
+]
+
+[[package]]
+name = "polkavm"
+version = "0.37.0"
+source = "git+https://github.com/paritytech/polkavm.git?rev=8cc3c5601aa614b0f6dfac2ae3ee271942b3c997#8cc3c5601aa614b0f6dfac2ae3ee271942b3c997"
+dependencies = [
+ "libc",
+ "log",
+ "picosimd",
+ "polkavm-assembler 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=8cc3c5601aa614b0f6dfac2ae3ee271942b3c997)",
+ "polkavm-common 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=8cc3c5601aa614b0f6dfac2ae3ee271942b3c997)",
+ "polkavm-linux-raw 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=8cc3c5601aa614b0f6dfac2ae3ee271942b3c997)",
+]
+
+[[package]]
+name = "polkavm-assembler"
+version = "0.37.0"
+source = "git+https://github.com/paritytech/polkavm.git?rev=3df1d0309c4c81a1aad0a755d83570d203bba1d9#3df1d0309c4c81a1aad0a755d83570d203bba1d9"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "polkavm-assembler"
+version = "0.37.0"
+source = "git+https://github.com/paritytech/polkavm.git?rev=8cc3c5601aa614b0f6dfac2ae3ee271942b3c997#8cc3c5601aa614b0f6dfac2ae3ee271942b3c997"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "polkavm-common"
+version = "0.37.0"
+source = "git+https://github.com/paritytech/polkavm.git?rev=3df1d0309c4c81a1aad0a755d83570d203bba1d9#3df1d0309c4c81a1aad0a755d83570d203bba1d9"
+dependencies = [
+ "log",
+ "picosimd",
+ "polkavm-assembler 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=3df1d0309c4c81a1aad0a755d83570d203bba1d9)",
+]
+
+[[package]]
+name = "polkavm-common"
+version = "0.37.0"
+source = "git+https://github.com/paritytech/polkavm.git?rev=8cc3c5601aa614b0f6dfac2ae3ee271942b3c997#8cc3c5601aa614b0f6dfac2ae3ee271942b3c997"
+dependencies = [
+ "log",
+ "picosimd",
+ "polkavm-assembler 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=8cc3c5601aa614b0f6dfac2ae3ee271942b3c997)",
+]
+
+[[package]]
+name = "polkavm-linux-raw"
+version = "0.37.0"
+source = "git+https://github.com/paritytech/polkavm.git?rev=3df1d0309c4c81a1aad0a755d83570d203bba1d9#3df1d0309c4c81a1aad0a755d83570d203bba1d9"
+
+[[package]]
+name = "polkavm-linux-raw"
+version = "0.37.0"
+source = "git+https://github.com/paritytech/polkavm.git?rev=8cc3c5601aa614b0f6dfac2ae3ee271942b3c997#8cc3c5601aa614b0f6dfac2ae3ee271942b3c997"
+
 [[package]]
 name = "polling"
 version = "3.11.0"
@@ -3318,6 +3410,28 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "pvm-gpu-wire"
+version = "0.1.0"
+
+[[package]]
+name = "pvm-runtime"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "log",
+ "polkavm 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=3df1d0309c4c81a1aad0a755d83570d203bba1d9)",
+ "polkavm 0.37.0 (git+https://github.com/paritytech/polkavm.git?rev=8cc3c5601aa614b0f6dfac2ae3ee271942b3c997)",
+ "pvm-gpu-wire",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+ "uniffi",
+ "wasm-encoder",
+ "wasmi",
+ "wasmparser 0.240.0",
+]
+
 [[package]]
 name = "qrcode"
 version = "0.14.1"
@@ -4469,6 +4583,16 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
+[[package]]
+name = "string-interner"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a3275464d7a9f2d4cac57c89c2ef96a8524dba2864c8d6f82e3980baf136f9b"
+dependencies = [
+ "hashbrown 0.15.5",
+ "serde",
+]
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -5287,6 +5411,7 @@ dependencies = [
  "p256",
  "parity-scale-codec",
  "parking_lot",
+ "pvm-runtime",
  "rand 0.8.7",
  "scale-decode",
  "scale-info",
@@ -5820,6 +5945,16 @@ version = "0.2.126"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c31d56021e873866c968588ed85ccdf56db5c426e44afdb4618c39895104b920"
 
+[[package]]
+name = "wasm-encoder"
+version = "0.240.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06d642d8c5ecc083aafe9ceb32809276a304547a3a6eeecceb5d8152598bc71f"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.240.0",
+]
+
 [[package]]
 name = "wasmi"
 version = "0.40.0"
@@ -5833,7 +5968,7 @@ dependencies = [
  "wasmi_collections",
  "wasmi_core",
  "wasmi_ir",
- "wasmparser",
+ "wasmparser 0.221.3",
 ]
 
 [[package]]
@@ -5841,6 +5976,9 @@ name = "wasmi_collections"
 version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e80d6b275b1c922021939d561574bf376613493ae2b61c6963b15db0e8813562"
+dependencies = [
+ "string-interner",
+]
 
 [[package]]
 name = "wasmi_core"
@@ -5868,6 +6006,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d06bfa36ab3ac2be0dee563380147a5b81ba10dd8885d7fbbc9eb574be67d185"
 dependencies = [
  "bitflags",
+ "indexmap",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.240.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b722dcf61e0ea47440b53ff83ccb5df8efec57a69d150e4f24882e4eba7e24a4"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+ "serde",
 ]
 
 [[package]]
diff --git a/Makefile b/Makefile
index e4a7687db..47b937cfe 100644
--- a/Makefile
+++ b/Makefile
@@ -238,9 +238,9 @@ uniffi-kotlin: ## Regenerate Kotlin UniFFI bindings from the truapi-server cdyli
 		--language kotlin \
 		--out-dir $(UNIFFI_KOTLIN_OUT)
 
-# Android ABIs to cross-compile the cdylib for. arm64 + armv7 cover physical
-# devices; x86_64 covers the emulator on Intel/Apple-silicon hosts.
-ANDROID_ABIS ?= arm64-v8a armeabi-v7a x86_64
+# Android ABIs supported by both TrUAPI and PolkaVM. arm64 covers physical
+# devices; x86_64 covers emulators. PolkaVM does not support 32-bit armv7.
+ANDROID_ABIS ?= arm64-v8a x86_64
 ANDROID_JNILIBS := android/truapi-host/src/main/jniLibs
 
 android-jni: ## Cross-compile libtruapi_server.so for Android ABIs into jniLibs (needs cargo-ndk + NDK).
@@ -444,7 +444,8 @@ xcframework: uniffi ## Build truapi_server.xcframework for iOS device + simulato
 	rm -rf $(XCFRAMEWORK_OUT) $(XCFRAMEWORK_HEADERS)
 	mkdir -p $(XCFRAMEWORK_HEADERS)
 	cp $(UNIFFI_SWIFT_TMP)/truapiFFI.h $(UNIFFI_SWIFT_TMP)/truapi_platformFFI.h \
-		$(UNIFFI_SWIFT_TMP)/truapi_serverFFI.h $(XCFRAMEWORK_HEADERS)/
+		$(UNIFFI_SWIFT_TMP)/truapi_serverFFI.h $(UNIFFI_SWIFT_TMP)/pvm_runtimeFFI.h \
+		$(XCFRAMEWORK_HEADERS)/
 	cp $(UNIFFI_SWIFT_TMP)/truapi_serverFFI.modulemap $(XCFRAMEWORK_HEADERS)/module.modulemap
 	slices=""; \
 	for target in $(XCFRAMEWORK_TARGETS); do \
diff --git a/Package.swift b/Package.swift
index 8d53ea063..6a2eccabf 100644
--- a/Package.swift
+++ b/Package.swift
@@ -81,11 +81,18 @@ let package = Package(
             pkgConfig: nil,
             providers: []
         ),
+        .systemLibrary(
+            name: "pvm_runtimeFFI",
+            path: "ios/truapi-host/Sources/pvm_runtimeFFI/include",
+            pkgConfig: nil,
+            providers: []
+        ),
         binaryTarget,
         .target(
             name: "TrUAPIHost",
             dependencies: [
-                "truapiFFI", "truapi_platformFFI", "truapi_serverFFI", "truapi_serverFFI_binary",
+                "truapiFFI", "truapi_platformFFI", "truapi_serverFFI",
+                "pvm_runtimeFFI", "truapi_serverFFI_binary",
             ],
             path: "ios/truapi-host/Sources/TrUAPIHost",
             resources: [.copy("Resources/truapi-container.js")]
diff --git a/README.md b/README.md
index 9b338dc3e..b71f30770 100644
--- a/README.md
+++ b/README.md
@@ -54,7 +54,10 @@ const transport = createTransport(createMessagePortProvider(port));
 const truapi = createClient(transport);
 
 const result = await truapi.accountManagement.accountGet({
-  productAccountId: { dotNsIdentifier: "my-product.dot", derivationIndex: { tag: "Index", value: 0 } },
+  productAccountId: {
+    dotNsIdentifier: "my-product.dot",
+    derivationIndex: { tag: "Index", value: 0 },
+  },
 });
 ```
 
@@ -193,9 +196,11 @@ signer, then runs the wrapped command with the host already live. The product
 reaches it through a development-only `<script>` tag:
 
 ```jsx
-{process.env.NODE_ENV === "development" && (
-  <script src="http://127.0.0.1:9955/bootstrap.js" />
-)}
+{
+  process.env.NODE_ENV === "development" && (
+    <script src="http://127.0.0.1:9955/bootstrap.js" />
+  );
+}
 ```
 
 The host serves that script itself, so the page needs no package, no imports,
@@ -316,8 +321,8 @@ Pushes to `main` build and deploy:
 ## Release
 
 See [`docs/RELEASE_PROCESS.md`](docs/RELEASE_PROCESS.md) for how to ship
-`@parity/truapi` and `@parity/truapi-host` to npm, and the iOS host and
-Android host artifacts alongside them.
+`@parity/truapi`, `@parity/truapi-host`, and `@parity/pvm-browser-runtime`
+to npm, with the iOS and Android host artifacts alongside them.
 
 ## Contributing
 
diff --git a/deny.toml b/deny.toml
index 1a454ec77..e5a99db32 100644
--- a/deny.toml
+++ b/deny.toml
@@ -41,6 +41,10 @@ exceptions = [
     # BSL-1.0 is permissive, but scope it so it cannot spread to other crates.
     { name = "clipboard-win", allow = ["BSL-1.0"] },
     { name = "error-code", allow = ["BSL-1.0"] },
+    # The host-neutral PVM runtime and wire protocol are intentionally MPL-2.0
+    # so their Rust and browser implementations retain file-level copyleft.
+    { name = "pvm-gpu-wire", allow = ["MPL-2.0"] },
+    { name = "pvm-runtime", allow = ["MPL-2.0"] },
     { name = "uniffi", allow = ["MPL-2.0"] },
     { name = "uniffi_bindgen", allow = ["MPL-2.0"] },
     { name = "uniffi_checksum_derive", allow = ["MPL-2.0"] },
diff --git a/docs/RELEASE_PROCESS.md b/docs/RELEASE_PROCESS.md
index 98b21f0ac..5bb774376 100644
--- a/docs/RELEASE_PROCESS.md
+++ b/docs/RELEASE_PROCESS.md
@@ -1,6 +1,7 @@
 # Release process
 
-The `@parity/truapi` and `@parity/truapi-host` npm packages are published by
+The `@parity/truapi`, `@parity/truapi-host`, and
+`@parity/pvm-browser-runtime` npm packages are published by
 [`paritytech/npm_publish_automation`](https://github.com/paritytech/npm_publish_automation).
 We never run `npm publish` locally or from a personal account; the
 `Release` workflow in `.github/workflows/release.yml` packs the packages
@@ -55,6 +56,7 @@ The PR title must start with `release:`. Convention:
 release: @parity/truapi 0.1.1
 release: @parity/truapi-host 0.1.1
 release: @parity/truapi 0.5.0, @parity/truapi-host 0.2.0
+release: @parity/pvm-browser-runtime 0.1.0
 release: @parity/android-host 0.1.0
 release: @parity/truapi 0.5.0, @parity/ios-host 0.5.0, @parity/android-host 0.1.0
 ```
@@ -82,8 +84,8 @@ On merge, CI runs as usual. When CI passes, the `Release` workflow:
    and validates it against the corresponding package manifest.
 3. Asks npm whether each `<package>@<version>` already exists. Versions the
    registry already serves are skipped, so re-runs are idempotent.
-4. Builds generated sources and the host WASM bundle, packs the tarballs, and
-   dispatches to `npm_publish_automation`.
+4. Builds generated sources and every requested package bundle, packs the
+   tarballs, and dispatches to `npm_publish_automation`.
 5. Polls the registry until every version being released is installable, for up
    to ten minutes.
 6. Creates and pushes tags and publishes GitHub Releases, for the confirmed
diff --git a/ios/truapi-host/Sources/TrUAPIHost/pvm_runtime.swift b/ios/truapi-host/Sources/TrUAPIHost/pvm_runtime.swift
new file mode 100644
index 000000000..633a0212a
--- /dev/null
+++ b/ios/truapi-host/Sources/TrUAPIHost/pvm_runtime.swift
@@ -0,0 +1,1747 @@
+// This file was autogenerated by some hot garbage in the `uniffi` crate.
+// Trust me, you don't want to mess with it!
+
+// swiftlint:disable all
+import Foundation
+
+// Depending on the consumer's build setup, the low-level FFI code
+// might be in a separate module, or it might be compiled inline into
+// this module. This is a bit of light hackery to work with both.
+#if canImport(pvm_runtimeFFI)
+import pvm_runtimeFFI
+#endif
+
+fileprivate extension RustBuffer {
+    // Allocate a new buffer, copying the contents of a `UInt8` array.
+    init(bytes: [UInt8]) {
+        let rbuf = bytes.withUnsafeBufferPointer { ptr in
+            RustBuffer.from(ptr)
+        }
+        self.init(capacity: rbuf.capacity, len: rbuf.len, data: rbuf.data)
+    }
+
+    static func empty() -> RustBuffer {
+        RustBuffer(capacity: 0, len:0, data: nil)
+    }
+
+    static func from(_ ptr: UnsafeBufferPointer<UInt8>) -> RustBuffer {
+        try! rustCall { ffi_pvm_runtime_rustbuffer_from_bytes(ForeignBytes(bufferPointer: ptr), $0) }
+    }
+
+    // Frees the buffer in place.
+    // The buffer must not be used after this is called.
+    func deallocate() {
+        try! rustCall { ffi_pvm_runtime_rustbuffer_free(self, $0) }
+    }
+}
+
+fileprivate extension ForeignBytes {
+    init(bufferPointer: UnsafeBufferPointer<UInt8>) {
+        self.init(len: Int32(bufferPointer.count), data: bufferPointer.baseAddress)
+    }
+
+    init(rawBufferPointer: UnsafeRawBufferPointer) {
+        self.init(
+            len: Int32(rawBufferPointer.count),
+            data: rawBufferPointer.baseAddress?.assumingMemoryBound(to: UInt8.self)
+        )
+    }
+}
+
+// Converter for `&[u8]` / `[ByRef] bytes` arguments.
+//
+// Conforms to `FfiConverter` so the compiler enforces the full converter
+// method set. Only the scope-bound `lower(_:_body:)` overload is sound —
+// zero-copy byte buffers only flow foreign -> Rust, and only in argument
+// position. The four protocol-witness methods (`lift`, `lower`, `read`,
+// `write`) `fatalError` at runtime if anyone reaches them.
+//
+// The scope-bound `lower` takes a closure because the `ForeignBytes`
+// pointer is only guaranteed valid for the duration of
+// `Data.withUnsafeBytes`. Callers must run the full FFI call inside
+// the closure body.
+fileprivate enum FfiConverterByRefBytes: FfiConverter {
+    typealias SwiftType = Data
+    typealias FfiType = ForeignBytes
+
+    static func lower<R>(_ value: Data, _ body: (ForeignBytes) throws -> R) rethrows -> R {
+        return try value.withUnsafeBytes { rawBuf in
+            try body(ForeignBytes(rawBufferPointer: rawBuf))
+        }
+    }
+
+    static func lower(_ value: Data) -> ForeignBytes {
+        fatalError("ByRef bytes cannot use the plain lower: returning ForeignBytes escapes the Data.withUnsafeBytes scope. Use the scope-bound lower(_:_body:) overload instead.")
+    }
+
+    static func lift(_ value: ForeignBytes) throws -> Data {
+        fatalError("ByRef bytes cannot be lifted: zero-copy &[u8] only flows foreign->Rust")
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data {
+        fatalError("ByRef bytes cannot be read from a buffer: zero-copy &[u8] is only supported in argument position, not nested in records/options/etc.")
+    }
+
+    static func write(_ value: Data, into buf: inout [UInt8]) {
+        fatalError("ByRef bytes cannot be written to a buffer: zero-copy &[u8] is only supported in argument position, not nested in records/options/etc.")
+    }
+}
+
+// For every type used in the interface, we provide helper methods for conveniently
+// lifting and lowering that type from C-compatible data, and for reading and writing
+// values of that type in a buffer.
+
+// Helper classes/extensions that don't change.
+// Someday, this will be in a library of its own.
+
+fileprivate extension Data {
+    init(rustBuffer: RustBuffer) {
+        self.init(
+            bytesNoCopy: rustBuffer.data!,
+            count: Int(rustBuffer.len),
+            deallocator: .none
+        )
+    }
+}
+
+// Define reader functionality.  Normally this would be defined in a class or
+// struct, but we use standalone functions instead in order to make external
+// types work.
+//
+// With external types, one swift source file needs to be able to call the read
+// method on another source file's FfiConverter, but then what visibility
+// should Reader have?
+// - If Reader is fileprivate, then this means the read() must also
+//   be fileprivate, which doesn't work with external types.
+// - If Reader is internal/public, we'll get compile errors since both source
+//   files will try define the same type.
+//
+// Instead, the read() method and these helper functions input a tuple of data
+
+fileprivate func createReader(data: Data) -> (data: Data, offset: Data.Index) {
+    (data: data, offset: 0)
+}
+
+// Reads an integer at the current offset, in big-endian order, and advances
+// the offset on success. Throws if reading the integer would move the
+// offset past the end of the buffer.
+fileprivate func readInt<T: FixedWidthInteger>(_ reader: inout (data: Data, offset: Data.Index)) throws -> T {
+    let range = reader.offset..<reader.offset + MemoryLayout<T>.size
+    guard reader.data.count >= range.upperBound else {
+        throw UniffiInternalError.bufferOverflow
+    }
+    if T.self == UInt8.self {
+        let value = reader.data[reader.offset]
+        reader.offset += 1
+        return value as! T
+    }
+    var value: T = 0
+    let _ = withUnsafeMutableBytes(of: &value, { reader.data.copyBytes(to: $0, from: range)})
+    reader.offset = range.upperBound
+    return value.bigEndian
+}
+
+// Reads an arbitrary number of bytes, to be used to read
+// raw bytes, this is useful when lifting strings
+fileprivate func readBytes(_ reader: inout (data: Data, offset: Data.Index), count: Int) throws -> Array<UInt8> {
+    let range = reader.offset..<(reader.offset+count)
+    guard reader.data.count >= range.upperBound else {
+        throw UniffiInternalError.bufferOverflow
+    }
+    var value = [UInt8](repeating: 0, count: count)
+    value.withUnsafeMutableBufferPointer({ buffer in
+        reader.data.copyBytes(to: buffer, from: range)
+    })
+    reader.offset = range.upperBound
+    return value
+}
+
+// Reads a float at the current offset.
+fileprivate func readFloat(_ reader: inout (data: Data, offset: Data.Index)) throws -> Float {
+    return Float(bitPattern: try readInt(&reader))
+}
+
+// Reads a float at the current offset.
+fileprivate func readDouble(_ reader: inout (data: Data, offset: Data.Index)) throws -> Double {
+    return Double(bitPattern: try readInt(&reader))
+}
+
+// Indicates if the offset has reached the end of the buffer.
+fileprivate func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Bool {
+    return reader.offset < reader.data.count
+}
+
+// Define writer functionality.  Normally this would be defined in a class or
+// struct, but we use standalone functions instead in order to make external
+// types work.  See the above discussion on Readers for details.
+
+fileprivate func createWriter() -> [UInt8] {
+    return []
+}
+
+fileprivate func writeBytes<S>(_ writer: inout [UInt8], _ byteArr: S) where S: Sequence, S.Element == UInt8 {
+    writer.append(contentsOf: byteArr)
+}
+
+// Writes an integer in big-endian order.
+//
+// Warning: make sure what you are trying to write
+// is in the correct type!
+fileprivate func writeInt<T: FixedWidthInteger>(_ writer: inout [UInt8], _ value: T) {
+    var value = value.bigEndian
+    withUnsafeBytes(of: &value) { writer.append(contentsOf: $0) }
+}
+
+fileprivate func writeFloat(_ writer: inout [UInt8], _ value: Float) {
+    writeInt(&writer, value.bitPattern)
+}
+
+fileprivate func writeDouble(_ writer: inout [UInt8], _ value: Double) {
+    writeInt(&writer, value.bitPattern)
+}
+
+// Protocol for types that transfer other types across the FFI. This is
+// analogous to the Rust trait of the same name.
+fileprivate protocol FfiConverter {
+    associatedtype FfiType
+    associatedtype SwiftType
+
+    static func lift(_ value: FfiType) throws -> SwiftType
+    static func lower(_ value: SwiftType) -> FfiType
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType
+    static func write(_ value: SwiftType, into buf: inout [UInt8])
+}
+
+// Types conforming to `Primitive` pass themselves directly over the FFI.
+fileprivate protocol FfiConverterPrimitive: FfiConverter where FfiType == SwiftType { }
+
+extension FfiConverterPrimitive {
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lift(_ value: FfiType) throws -> SwiftType {
+        return value
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lower(_ value: SwiftType) -> FfiType {
+        return value
+    }
+}
+
+// Types conforming to `FfiConverterRustBuffer` lift and lower into a `RustBuffer`.
+// Used for complex types where it's hard to write a custom lift/lower.
+fileprivate protocol FfiConverterRustBuffer: FfiConverter where FfiType == RustBuffer {}
+
+extension FfiConverterRustBuffer {
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lift(_ buf: RustBuffer) throws -> SwiftType {
+        var reader = createReader(data: Data(rustBuffer: buf))
+        let value = try read(from: &reader)
+        if hasRemaining(reader) {
+            throw UniffiInternalError.incompleteData
+        }
+        buf.deallocate()
+        return value
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lower(_ value: SwiftType) -> RustBuffer {
+          var writer = createWriter()
+          write(value, into: &writer)
+          return RustBuffer(bytes: writer)
+    }
+}
+// An error type for FFI errors. These errors occur at the UniFFI level, not
+// the library level.
+fileprivate enum UniffiInternalError: LocalizedError {
+    case bufferOverflow
+    case incompleteData
+    case unexpectedOptionalTag
+    case unexpectedEnumCase
+    case unexpectedNullPointer
+    case unexpectedRustCallStatusCode
+    case unexpectedRustCallError
+    case unexpectedStaleHandle
+    case rustPanic(_ message: String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .bufferOverflow: return "Reading the requested value would read past the end of the buffer"
+        case .incompleteData: return "The buffer still has data after lifting its containing value"
+        case .unexpectedOptionalTag: return "Unexpected optional tag; should be 0 or 1"
+        case .unexpectedEnumCase: return "Raw enum value doesn't match any cases"
+        case .unexpectedNullPointer: return "Raw pointer value was null"
+        case .unexpectedRustCallStatusCode: return "Unexpected RustCallStatus code"
+        case .unexpectedRustCallError: return "CALL_ERROR but no errorClass specified"
+        case .unexpectedStaleHandle: return "The object in the handle map has been dropped already"
+        case let .rustPanic(message): return message
+        }
+    }
+}
+
+fileprivate extension NSLock {
+    func withLock<T>(f: () throws -> T) rethrows -> T {
+        self.lock()
+        defer { self.unlock() }
+        return try f()
+    }
+}
+
+fileprivate let CALL_SUCCESS: Int8 = 0
+fileprivate let CALL_ERROR: Int8 = 1
+fileprivate let CALL_UNEXPECTED_ERROR: Int8 = 2
+fileprivate let CALL_CANCELLED: Int8 = 3
+
+fileprivate extension RustCallStatus {
+    init() {
+        self.init(
+            code: CALL_SUCCESS,
+            errorBuf: RustBuffer.init(
+                capacity: 0,
+                len: 0,
+                data: nil
+            )
+        )
+    }
+}
+
+private func rustCall<T>(_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
+    let neverThrow: ((RustBuffer) throws -> Never)? = nil
+    return try makeRustCall(callback, errorHandler: neverThrow)
+}
+
+private func rustCallWithError<T, E: Swift.Error>(
+    _ errorHandler: @escaping (RustBuffer) throws -> E,
+    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
+    try makeRustCall(callback, errorHandler: errorHandler)
+}
+
+private func makeRustCall<T, E: Swift.Error>(
+    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T,
+    errorHandler: ((RustBuffer) throws -> E)?
+) throws -> T {
+    uniffiEnsurePvmRuntimeInitialized()
+    var callStatus = RustCallStatus.init()
+    let returnedVal = callback(&callStatus)
+    try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler)
+    return returnedVal
+}
+
+private func uniffiCheckCallStatus<E: Swift.Error>(
+    callStatus: RustCallStatus,
+    errorHandler: ((RustBuffer) throws -> E)?
+) throws {
+    switch callStatus.code {
+        case CALL_SUCCESS:
+            return
+
+        case CALL_ERROR:
+            if let errorHandler = errorHandler {
+                throw try errorHandler(callStatus.errorBuf)
+            } else {
+                callStatus.errorBuf.deallocate()
+                throw UniffiInternalError.unexpectedRustCallError
+            }
+
+        case CALL_UNEXPECTED_ERROR:
+            // When the rust code sees a panic, it tries to construct a RustBuffer
+            // with the message.  But if that code panics, then it just sends back
+            // an empty buffer.
+            if callStatus.errorBuf.len > 0 {
+                throw UniffiInternalError.rustPanic(try FfiConverterString.lift(callStatus.errorBuf))
+            } else {
+                callStatus.errorBuf.deallocate()
+                throw UniffiInternalError.rustPanic("Rust panic")
+            }
+
+        case CALL_CANCELLED:
+            fatalError("Cancellation not supported yet")
+
+        default:
+            throw UniffiInternalError.unexpectedRustCallStatusCode
+    }
+}
+
+private func uniffiTraitInterfaceCall<T>(
+    callStatus: UnsafeMutablePointer<RustCallStatus>,
+    makeCall: () throws -> T,
+    writeReturn: (T) -> ()
+) {
+    do {
+        try writeReturn(makeCall())
+    } catch let error {
+        callStatus.pointee.code = CALL_UNEXPECTED_ERROR
+        callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
+    }
+}
+
+private func uniffiTraitInterfaceCallWithError<T, E>(
+    callStatus: UnsafeMutablePointer<RustCallStatus>,
+    makeCall: () throws -> T,
+    writeReturn: (T) -> (),
+    lowerError: (E) -> RustBuffer
+) {
+    do {
+        try writeReturn(makeCall())
+    } catch let error as E {
+        callStatus.pointee.code = CALL_ERROR
+        callStatus.pointee.errorBuf = lowerError(error)
+    } catch {
+        callStatus.pointee.code = CALL_UNEXPECTED_ERROR
+        callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
+    }
+}
+// Initial value and increment amount for handles.
+// These ensure that SWIFT handles always have the lowest bit set
+fileprivate let UNIFFI_HANDLEMAP_INITIAL: UInt64 = 1
+fileprivate let UNIFFI_HANDLEMAP_DELTA: UInt64 = 2
+
+fileprivate final class UniffiHandleMap<T>: @unchecked Sendable {
+    // All mutation happens with this lock held, which is why we implement @unchecked Sendable.
+    private let lock = NSLock()
+    private var map: [UInt64: T] = [:]
+    private var currentHandle: UInt64 = UNIFFI_HANDLEMAP_INITIAL
+
+    func insert(obj: T) -> UInt64 {
+        lock.withLock {
+            return doInsert(obj)
+        }
+    }
+
+    // Low-level insert function, this assumes `lock` is held.
+    private func doInsert(_ obj: T) -> UInt64 {
+        let handle = currentHandle
+        currentHandle += UNIFFI_HANDLEMAP_DELTA
+        map[handle] = obj
+        return handle
+    }
+
+     func get(handle: UInt64) throws -> T {
+        try lock.withLock {
+            guard let obj = map[handle] else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return obj
+        }
+    }
+
+     func clone(handle: UInt64) throws -> UInt64 {
+        try lock.withLock {
+            guard let obj = map[handle] else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return doInsert(obj)
+        }
+    }
+
+    @discardableResult
+    func remove(handle: UInt64) throws -> T {
+        try lock.withLock {
+            guard let obj = map.removeValue(forKey: handle) else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return obj
+        }
+    }
+
+    var count: Int {
+        get {
+            map.count
+        }
+    }
+}
+
+
+// Public interface members begin here.
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt8: FfiConverterPrimitive {
+    typealias FfiType = UInt8
+    typealias SwiftType = UInt8
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: UInt8, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt16: FfiConverterPrimitive {
+    typealias FfiType = UInt16
+    typealias SwiftType = UInt16
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt16 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterInt16: FfiConverterPrimitive {
+    typealias FfiType = Int16
+    typealias SwiftType = Int16
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Int16 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: Int16, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt32: FfiConverterPrimitive {
+    typealias FfiType = UInt32
+    typealias SwiftType = UInt32
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt64: FfiConverterPrimitive {
+    typealias FfiType = UInt64
+    typealias SwiftType = UInt64
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt64 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterBool : FfiConverter {
+    typealias FfiType = Int8
+    typealias SwiftType = Bool
+
+    public static func lift(_ value: Int8) throws -> Bool {
+        return value != 0
+    }
+
+    public static func lower(_ value: Bool) -> Int8 {
+        return value ? 1 : 0
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: Bool, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterString: FfiConverter {
+    typealias SwiftType = String
+    typealias FfiType = RustBuffer
+
+    public static func lift(_ value: RustBuffer) throws -> String {
+        defer {
+            value.deallocate()
+        }
+        if value.data == nil {
+            return String()
+        }
+        let bytes = UnsafeBufferPointer<UInt8>(start: value.data!, count: Int(value.len))
+        // Use Swift's native UTF-8 decoder; `String(bytes:encoding:.utf8)` goes
+        // through Foundation's NSString and silently strips a leading U+FEFF BOM.
+        // Invalid UTF-8 substitutes U+FFFD instead of trapping (unreachable
+        // given Rust's `String` invariant).
+        return String(decoding: bytes, as: UTF8.self)
+    }
+
+    public static func lower(_ value: String) -> RustBuffer {
+        return value.utf8CString.withUnsafeBufferPointer { ptr in
+            // The swift string gives us int8_t, we want uint8_t.
+            ptr.withMemoryRebound(to: UInt8.self) { ptr in
+                // The swift string gives us a trailing null byte, we don't want it.
+                let buf = UnsafeBufferPointer(rebasing: ptr.prefix(upTo: ptr.count - 1))
+                return RustBuffer.from(buf)
+            }
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String {
+        let len: Int32 = try readInt(&buf)
+        // See `lift` above for why we avoid Foundation's NSString-backed decoder here.
+        return String(decoding: try readBytes(&buf, count: Int(len)), as: UTF8.self)
+    }
+
+    public static func write(_ value: String, into buf: inout [UInt8]) {
+        let len = Int32(value.utf8.count)
+        writeInt(&buf, len)
+        writeBytes(&buf, value.utf8)
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterData: FfiConverterRustBuffer {
+    typealias SwiftType = Data
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data {
+        let len: Int32 = try readInt(&buf)
+        return Data(try readBytes(&buf, count: Int(len)))
+    }
+
+    public static func write(_ value: Data, into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        writeBytes(&buf, value)
+    }
+}
+
+
+
+
+public protocol NativePvmRuntimeProtocol: AnyObject, Sendable {
+
+    func backend() throws  -> String
+
+    func gpuReady() throws  -> Bool
+
+    func `init`() throws
+
+    func isExited() throws  -> Bool
+
+    func lastGasUsed() throws  -> UInt64
+
+    func sendGpuEvent(bytes: Data) throws
+
+    func sendInput(eventType: NativePvmInputEventType, code: UInt8, x: UInt16, y: UInt16) throws
+
+    func setGpuCapabilities(bytes: Data) throws
+
+    func takeAudio() throws  -> NativePvmAudioChunk?
+
+    func takeFrame() throws  -> NativePvmFrame?
+
+    func takeGpuBatch() throws  -> NativePvmGpuBatch?
+
+    func takeLog() throws  -> String?
+
+    func takeSave() throws  -> Data?
+
+    func takeTri2d() throws  -> NativePvmTri2dFrame?
+
+    func update() throws
+
+}
+open class NativePvmRuntime: NativePvmRuntimeProtocol, @unchecked Sendable {
+    fileprivate let handle: UInt64
+
+    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public struct NoHandle {
+        public init() {}
+    }
+
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    required public init(unsafeFromHandle handle: UInt64) {
+        self.handle = handle
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public init(noHandle: NoHandle) {
+        self.handle = 0
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public func uniffiCloneHandle() -> UInt64 {
+        return try! rustCall { uniffi_pvm_runtime_fn_clone_nativepvmruntime(self.handle, $0) }
+    }
+public convenience init(program: Data, assets: [NativePvmAsset], presentation: NativePvmPresentationProfile, audioEnabled: Bool, maxGasPerUpdate: UInt64)throws  {
+    let handle =
+        try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_constructor_nativepvmruntime_new(
+        FfiConverterData.lower(program),
+        FfiConverterSequenceTypeNativePvmAsset.lower(assets),
+        FfiConverterTypeNativePvmPresentationProfile_lower(presentation),
+        FfiConverterBool.lower(audioEnabled),
+        FfiConverterUInt64.lower(maxGasPerUpdate),uniffiCallStatus
+    )
+}
+    self.init(unsafeFromHandle: handle)
+}
+
+    deinit {
+        if handle == 0 {
+            // Mock objects have handle=0 don't try to free them
+            return
+        }
+
+        try! rustCall { uniffi_pvm_runtime_fn_free_nativepvmruntime(handle, $0) }
+    }
+
+
+
+
+open func backend()throws  -> String  {
+    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_backend(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func gpuReady()throws  -> Bool  {
+    return try  FfiConverterBool.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_gpu_ready(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func `init`()throws   {try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_init(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+}
+}
+
+open func isExited()throws  -> Bool  {
+    return try  FfiConverterBool.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_is_exited(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func lastGasUsed()throws  -> UInt64  {
+    return try  FfiConverterUInt64.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_last_gas_used(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func sendGpuEvent(bytes: Data)throws   {try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_send_gpu_event(
+            self.uniffiCloneHandle(),
+        FfiConverterData.lower(bytes),uniffiCallStatus
+    )
+}
+}
+
+open func sendInput(eventType: NativePvmInputEventType, code: UInt8, x: UInt16, y: UInt16)throws   {try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_send_input(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeNativePvmInputEventType_lower(eventType),
+        FfiConverterUInt8.lower(code),
+        FfiConverterUInt16.lower(x),
+        FfiConverterUInt16.lower(y),uniffiCallStatus
+    )
+}
+}
+
+open func setGpuCapabilities(bytes: Data)throws   {try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_set_gpu_capabilities(
+            self.uniffiCloneHandle(),
+        FfiConverterData.lower(bytes),uniffiCallStatus
+    )
+}
+}
+
+open func takeAudio()throws  -> NativePvmAudioChunk?  {
+    return try  FfiConverterOptionTypeNativePvmAudioChunk.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_take_audio(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func takeFrame()throws  -> NativePvmFrame?  {
+    return try  FfiConverterOptionTypeNativePvmFrame.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_take_frame(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func takeGpuBatch()throws  -> NativePvmGpuBatch?  {
+    return try  FfiConverterOptionTypeNativePvmGpuBatch.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_take_gpu_batch(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func takeLog()throws  -> String?  {
+    return try  FfiConverterOptionString.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_take_log(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func takeSave()throws  -> Data?  {
+    return try  FfiConverterOptionData.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_take_save(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func takeTri2d()throws  -> NativePvmTri2dFrame?  {
+    return try  FfiConverterOptionTypeNativePvmTri2dFrame.lift(try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_take_tri2d(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func update()throws   {try rustCallWithError(FfiConverterTypeNativePvmError_lift) {
+        uniffiCallStatus in
+    uniffi_pvm_runtime_fn_method_nativepvmruntime_update(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+}
+}
+
+
+
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNativePvmRuntime: FfiConverter {
+    typealias FfiType = UInt64
+    typealias SwiftType = NativePvmRuntime
+
+    public static func lift(_ handle: UInt64) throws -> NativePvmRuntime {
+        return NativePvmRuntime(unsafeFromHandle: handle)
+    }
+
+    public static func lower(_ value: NativePvmRuntime) -> UInt64 {
+        return value.uniffiCloneHandle()
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NativePvmRuntime {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+    public static func write(_ value: NativePvmRuntime, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmRuntime_lift(_ handle: UInt64) throws -> NativePvmRuntime {
+    return try FfiConverterTypeNativePvmRuntime.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmRuntime_lower(_ value: NativePvmRuntime) -> UInt64 {
+    return FfiConverterTypeNativePvmRuntime.lower(value)
+}
+
+
+
+
+public struct NativePvmAsset: Equatable, Hashable {
+    public var path: String
+    public var bytes: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(path: String, bytes: Data) {
+        self.path = path
+        self.bytes = bytes
+    }
+
+
+
+
+}
+
+#if compiler(>=6)
+extension NativePvmAsset: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNativePvmAsset: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NativePvmAsset {
+        return
+            try NativePvmAsset(
+                path: FfiConverterString.read(from: &buf),
+                bytes: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: NativePvmAsset, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.path, into: &buf)
+        FfiConverterData.write(value.bytes, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmAsset_lift(_ buf: RustBuffer) throws -> NativePvmAsset {
+    return try FfiConverterTypeNativePvmAsset.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmAsset_lower(_ value: NativePvmAsset) -> RustBuffer {
+    return FfiConverterTypeNativePvmAsset.lower(value)
+}
+
+
+public struct NativePvmAudioChunk: Equatable, Hashable {
+    public var samples: [Int16]
+    public var sampleRate: UInt32
+    public var channels: UInt32
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(samples: [Int16], sampleRate: UInt32, channels: UInt32) {
+        self.samples = samples
+        self.sampleRate = sampleRate
+        self.channels = channels
+    }
+
+
+
+
+}
+
+#if compiler(>=6)
+extension NativePvmAudioChunk: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNativePvmAudioChunk: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NativePvmAudioChunk {
+        return
+            try NativePvmAudioChunk(
+                samples: FfiConverterSequenceInt16.read(from: &buf),
+                sampleRate: FfiConverterUInt32.read(from: &buf),
+                channels: FfiConverterUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: NativePvmAudioChunk, into buf: inout [UInt8]) {
+        FfiConverterSequenceInt16.write(value.samples, into: &buf)
+        FfiConverterUInt32.write(value.sampleRate, into: &buf)
+        FfiConverterUInt32.write(value.channels, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmAudioChunk_lift(_ buf: RustBuffer) throws -> NativePvmAudioChunk {
+    return try FfiConverterTypeNativePvmAudioChunk.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmAudioChunk_lower(_ value: NativePvmAudioChunk) -> RustBuffer {
+    return FfiConverterTypeNativePvmAudioChunk.lower(value)
+}
+
+
+public struct NativePvmFrame: Equatable, Hashable {
+    public var width: UInt32
+    public var height: UInt32
+    public var argb: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(width: UInt32, height: UInt32, argb: Data) {
+        self.width = width
+        self.height = height
+        self.argb = argb
+    }
+
+
+
+
+}
+
+#if compiler(>=6)
+extension NativePvmFrame: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNativePvmFrame: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NativePvmFrame {
+        return
+            try NativePvmFrame(
+                width: FfiConverterUInt32.read(from: &buf),
+                height: FfiConverterUInt32.read(from: &buf),
+                argb: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: NativePvmFrame, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.width, into: &buf)
+        FfiConverterUInt32.write(value.height, into: &buf)
+        FfiConverterData.write(value.argb, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmFrame_lift(_ buf: RustBuffer) throws -> NativePvmFrame {
+    return try FfiConverterTypeNativePvmFrame.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmFrame_lower(_ value: NativePvmFrame) -> RustBuffer {
+    return FfiConverterTypeNativePvmFrame.lower(value)
+}
+
+
+public struct NativePvmGpuBatch: Equatable, Hashable {
+    public var bytes: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(bytes: Data) {
+        self.bytes = bytes
+    }
+
+
+
+
+}
+
+#if compiler(>=6)
+extension NativePvmGpuBatch: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNativePvmGpuBatch: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NativePvmGpuBatch {
+        return
+            try NativePvmGpuBatch(
+                bytes: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: NativePvmGpuBatch, into buf: inout [UInt8]) {
+        FfiConverterData.write(value.bytes, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmGpuBatch_lift(_ buf: RustBuffer) throws -> NativePvmGpuBatch {
+    return try FfiConverterTypeNativePvmGpuBatch.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmGpuBatch_lower(_ value: NativePvmGpuBatch) -> RustBuffer {
+    return FfiConverterTypeNativePvmGpuBatch.lower(value)
+}
+
+
+public struct NativePvmTri2dFrame: Equatable, Hashable {
+    public var width: UInt32
+    public var height: UInt32
+    public var drawCount: UInt32
+    public var vertexCount: UInt32
+    public var indexCount: UInt32
+    public var bytes: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(width: UInt32, height: UInt32, drawCount: UInt32, vertexCount: UInt32, indexCount: UInt32, bytes: Data) {
+        self.width = width
+        self.height = height
+        self.drawCount = drawCount
+        self.vertexCount = vertexCount
+        self.indexCount = indexCount
+        self.bytes = bytes
+    }
+
+
+
+
+}
+
+#if compiler(>=6)
+extension NativePvmTri2dFrame: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNativePvmTri2dFrame: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NativePvmTri2dFrame {
+        return
+            try NativePvmTri2dFrame(
+                width: FfiConverterUInt32.read(from: &buf),
+                height: FfiConverterUInt32.read(from: &buf),
+                drawCount: FfiConverterUInt32.read(from: &buf),
+                vertexCount: FfiConverterUInt32.read(from: &buf),
+                indexCount: FfiConverterUInt32.read(from: &buf),
+                bytes: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: NativePvmTri2dFrame, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.width, into: &buf)
+        FfiConverterUInt32.write(value.height, into: &buf)
+        FfiConverterUInt32.write(value.drawCount, into: &buf)
+        FfiConverterUInt32.write(value.vertexCount, into: &buf)
+        FfiConverterUInt32.write(value.indexCount, into: &buf)
+        FfiConverterData.write(value.bytes, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmTri2dFrame_lift(_ buf: RustBuffer) throws -> NativePvmTri2dFrame {
+    return try FfiConverterTypeNativePvmTri2dFrame.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmTri2dFrame_lower(_ value: NativePvmTri2dFrame) -> RustBuffer {
+    return FfiConverterTypeNativePvmTri2dFrame.lower(value)
+}
+
+
+public
+enum NativePvmError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {
+
+
+
+    case Runtime(detail: String
+    )
+    case DuplicateAsset(path: String
+    )
+    case RuntimePoisoned
+
+
+
+
+
+
+    public var errorDescription: String? {
+        String(reflecting: self)
+    }
+
+}
+
+#if compiler(>=6)
+extension NativePvmError: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNativePvmError: FfiConverterRustBuffer {
+    typealias SwiftType = NativePvmError
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NativePvmError {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+
+
+
+
+        case 1: return .Runtime(
+            detail: try FfiConverterString.read(from: &buf)
+            )
+        case 2: return .DuplicateAsset(
+            path: try FfiConverterString.read(from: &buf)
+            )
+        case 3: return .RuntimePoisoned
+
+         default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: NativePvmError, into buf: inout [UInt8]) {
+        switch value {
+
+
+
+
+
+        case let .Runtime(detail):
+            writeInt(&buf, Int32(1))
+            FfiConverterString.write(detail, into: &buf)
+
+
+        case let .DuplicateAsset(path):
+            writeInt(&buf, Int32(2))
+            FfiConverterString.write(path, into: &buf)
+
+
+        case .RuntimePoisoned:
+            writeInt(&buf, Int32(3))
+
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmError_lift(_ buf: RustBuffer) throws -> NativePvmError {
+    return try FfiConverterTypeNativePvmError.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmError_lower(_ value: NativePvmError) -> RustBuffer {
+    return FfiConverterTypeNativePvmError.lower(value)
+}
+
+
+
+public enum NativePvmInputEventType: Equatable, Hashable {
+
+    case keyDown
+    case keyUp
+    case buttonDown
+    case buttonUp
+    case pointerMove
+    case pointerDelta
+    case surfaceMetrics
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension NativePvmInputEventType: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNativePvmInputEventType: FfiConverterRustBuffer {
+    typealias SwiftType = NativePvmInputEventType
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NativePvmInputEventType {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+
+        case 1: return .keyDown
+
+        case 2: return .keyUp
+
+        case 3: return .buttonDown
+
+        case 4: return .buttonUp
+
+        case 5: return .pointerMove
+
+        case 6: return .pointerDelta
+
+        case 7: return .surfaceMetrics
+
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: NativePvmInputEventType, into buf: inout [UInt8]) {
+        switch value {
+
+
+        case .keyDown:
+            writeInt(&buf, Int32(1))
+
+
+        case .keyUp:
+            writeInt(&buf, Int32(2))
+
+
+        case .buttonDown:
+            writeInt(&buf, Int32(3))
+
+
+        case .buttonUp:
+            writeInt(&buf, Int32(4))
+
+
+        case .pointerMove:
+            writeInt(&buf, Int32(5))
+
+
+        case .pointerDelta:
+            writeInt(&buf, Int32(6))
+
+
+        case .surfaceMetrics:
+            writeInt(&buf, Int32(7))
+
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmInputEventType_lift(_ buf: RustBuffer) throws -> NativePvmInputEventType {
+    return try FfiConverterTypeNativePvmInputEventType.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmInputEventType_lower(_ value: NativePvmInputEventType) -> RustBuffer {
+    return FfiConverterTypeNativePvmInputEventType.lower(value)
+}
+
+
+
+
+public enum NativePvmPresentationProfile: Equatable, Hashable {
+
+    case framebuffer
+    case tri2d
+    case webGpuRaster
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension NativePvmPresentationProfile: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNativePvmPresentationProfile: FfiConverterRustBuffer {
+    typealias SwiftType = NativePvmPresentationProfile
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NativePvmPresentationProfile {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+
+        case 1: return .framebuffer
+
+        case 2: return .tri2d
+
+        case 3: return .webGpuRaster
+
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: NativePvmPresentationProfile, into buf: inout [UInt8]) {
+        switch value {
+
+
+        case .framebuffer:
+            writeInt(&buf, Int32(1))
+
+
+        case .tri2d:
+            writeInt(&buf, Int32(2))
+
+
+        case .webGpuRaster:
+            writeInt(&buf, Int32(3))
+
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmPresentationProfile_lift(_ buf: RustBuffer) throws -> NativePvmPresentationProfile {
+    return try FfiConverterTypeNativePvmPresentationProfile.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNativePvmPresentationProfile_lower(_ value: NativePvmPresentationProfile) -> RustBuffer {
+    return FfiConverterTypeNativePvmPresentationProfile.lower(value)
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer {
+    typealias SwiftType = String?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterString.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterString.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionData: FfiConverterRustBuffer {
+    typealias SwiftType = Data?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterData.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterData.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeNativePvmAudioChunk: FfiConverterRustBuffer {
+    typealias SwiftType = NativePvmAudioChunk?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeNativePvmAudioChunk.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeNativePvmAudioChunk.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeNativePvmFrame: FfiConverterRustBuffer {
+    typealias SwiftType = NativePvmFrame?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeNativePvmFrame.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeNativePvmFrame.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeNativePvmGpuBatch: FfiConverterRustBuffer {
+    typealias SwiftType = NativePvmGpuBatch?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeNativePvmGpuBatch.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeNativePvmGpuBatch.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeNativePvmTri2dFrame: FfiConverterRustBuffer {
+    typealias SwiftType = NativePvmTri2dFrame?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeNativePvmTri2dFrame.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeNativePvmTri2dFrame.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceInt16: FfiConverterRustBuffer {
+    typealias SwiftType = [Int16]
+
+    public static func write(_ value: [Int16], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterInt16.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Int16] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [Int16]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterInt16.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeNativePvmAsset: FfiConverterRustBuffer {
+    typealias SwiftType = [NativePvmAsset]
+
+    public static func write(_ value: [NativePvmAsset], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeNativePvmAsset.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [NativePvmAsset] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [NativePvmAsset]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeNativePvmAsset.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+private enum InitializationResult {
+    case ok
+    case contractVersionMismatch
+    case apiChecksumMismatch
+}
+// Use a global variable to perform the versioning checks. Swift ensures that
+// the code inside is only computed once.
+private let initializationResult: InitializationResult = {
+    // Get the bindings contract version from our ComponentInterface
+    let bindings_contract_version = 30
+    // Get the scaffolding contract version by calling the into the dylib
+    let scaffolding_contract_version = ffi_pvm_runtime_uniffi_contract_version()
+    if bindings_contract_version != scaffolding_contract_version {
+        return InitializationResult.contractVersionMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_backend() != 56657) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_gpu_ready() != 61888) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_init() != 58620) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_is_exited() != 14672) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_last_gas_used() != 63988) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_send_gpu_event() != 11805) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_send_input() != 59274) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_set_gpu_capabilities() != 28903) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_audio() != 21780) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_frame() != 8124) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_gpu_batch() != 14686) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_log() != 61835) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_save() != 52485) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_tri2d() != 20193) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_method_nativepvmruntime_update() != 28698) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_pvm_runtime_checksum_constructor_nativepvmruntime_new() != 25625) {
+        return InitializationResult.apiChecksumMismatch
+    }
+
+    return InitializationResult.ok
+}()
+
+// Make the ensure init function public so that other modules which have external type references to
+// our types can call it.
+public func uniffiEnsurePvmRuntimeInitialized() {
+    switch initializationResult {
+    case .ok:
+        break
+    case .contractVersionMismatch:
+        fatalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
+    case .apiChecksumMismatch:
+        fatalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+}
+
+// swiftlint:enable all
\ No newline at end of file
diff --git a/ios/truapi-host/Sources/pvm_runtimeFFI/include/module.modulemap b/ios/truapi-host/Sources/pvm_runtimeFFI/include/module.modulemap
new file mode 100644
index 000000000..6c0b83bd7
--- /dev/null
+++ b/ios/truapi-host/Sources/pvm_runtimeFFI/include/module.modulemap
@@ -0,0 +1,7 @@
+module pvm_runtimeFFI {
+    header "pvm_runtimeFFI.h"
+    export *
+    use "Darwin"
+    use "_Builtin_stdbool"
+    use "_Builtin_stdint"
+}
\ No newline at end of file
diff --git a/ios/truapi-host/Sources/pvm_runtimeFFI/include/pvm_runtimeFFI.h b/ios/truapi-host/Sources/pvm_runtimeFFI/include/pvm_runtimeFFI.h
new file mode 100644
index 000000000..2423d9d8e
--- /dev/null
+++ b/ios/truapi-host/Sources/pvm_runtimeFFI/include/pvm_runtimeFFI.h
@@ -0,0 +1,698 @@
+// This file was autogenerated by some hot garbage in the `uniffi` crate.
+// Trust me, you don't want to mess with it!
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+// The following structs are used to implement the lowest level
+// of the FFI, and thus useful to multiple uniffied crates.
+// We ensure they are declared exactly once, with a header guard, UNIFFI_SHARED_H.
+#ifdef UNIFFI_SHARED_H
+    // We also try to prevent mixing versions of shared uniffi header structs.
+    // If you add anything to the #else block, you must increment the version suffix in UNIFFI_SHARED_HEADER_V4
+    #ifndef UNIFFI_SHARED_HEADER_V4
+        #error Combining helper code from multiple versions of uniffi is not supported
+    #endif // ndef UNIFFI_SHARED_HEADER_V4
+#else
+#define UNIFFI_SHARED_H
+#define UNIFFI_SHARED_HEADER_V4
+// ⚠️ Attention: If you change this #else block (ending in `#endif // def UNIFFI_SHARED_H`) you *must* ⚠️
+// ⚠️ increment the version suffix in all instances of UNIFFI_SHARED_HEADER_V4 in this file.           ⚠️
+
+typedef struct RustBuffer
+{
+    uint64_t capacity;
+    uint64_t len;
+    uint8_t *_Nullable data;
+} RustBuffer;
+
+typedef struct ForeignBytes
+{
+    int32_t len;
+    const uint8_t *_Nullable data;
+} ForeignBytes;
+
+// Error definitions
+typedef struct RustCallStatus {
+    int8_t code;
+    RustBuffer errorBuf;
+} RustCallStatus;
+
+// ⚠️ Attention: If you change this #else block (ending in `#endif // def UNIFFI_SHARED_H`) you *must* ⚠️
+// ⚠️ increment the version suffix in all instances of UNIFFI_SHARED_HEADER_V4 in this file.           ⚠️
+#endif // def UNIFFI_SHARED_H
+#ifndef UNIFFI_FFIDEF_RUST_FUTURE_CONTINUATION_CALLBACK
+#define UNIFFI_FFIDEF_RUST_FUTURE_CONTINUATION_CALLBACK
+typedef void (*UniffiRustFutureContinuationCallback)(uint64_t, int8_t
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_DROPPED_CALLBACK
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_DROPPED_CALLBACK
+typedef void (*UniffiForeignFutureDroppedCallback)(uint64_t
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_FREE
+#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_FREE
+typedef void (*UniffiCallbackInterfaceFree)(uint64_t
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_CLONE
+#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_CLONE
+typedef uint64_t (*UniffiCallbackInterfaceClone)(uint64_t
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_DROPPED_CALLBACK_STRUCT
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_DROPPED_CALLBACK_STRUCT
+typedef struct UniffiForeignFutureDroppedCallbackStruct {
+    uint64_t handle;
+    UniffiForeignFutureDroppedCallback _Nonnull free;
+} UniffiForeignFutureDroppedCallbackStruct;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_U8
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_U8
+typedef struct UniffiForeignFutureResultU8 {
+    uint8_t returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultU8;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U8
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U8
+typedef void (*UniffiForeignFutureCompleteU8)(uint64_t, UniffiForeignFutureResultU8
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_I8
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_I8
+typedef struct UniffiForeignFutureResultI8 {
+    int8_t returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultI8;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I8
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I8
+typedef void (*UniffiForeignFutureCompleteI8)(uint64_t, UniffiForeignFutureResultI8
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_U16
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_U16
+typedef struct UniffiForeignFutureResultU16 {
+    uint16_t returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultU16;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U16
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U16
+typedef void (*UniffiForeignFutureCompleteU16)(uint64_t, UniffiForeignFutureResultU16
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_I16
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_I16
+typedef struct UniffiForeignFutureResultI16 {
+    int16_t returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultI16;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I16
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I16
+typedef void (*UniffiForeignFutureCompleteI16)(uint64_t, UniffiForeignFutureResultI16
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_U32
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_U32
+typedef struct UniffiForeignFutureResultU32 {
+    uint32_t returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultU32;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U32
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U32
+typedef void (*UniffiForeignFutureCompleteU32)(uint64_t, UniffiForeignFutureResultU32
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_I32
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_I32
+typedef struct UniffiForeignFutureResultI32 {
+    int32_t returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultI32;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I32
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I32
+typedef void (*UniffiForeignFutureCompleteI32)(uint64_t, UniffiForeignFutureResultI32
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_U64
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_U64
+typedef struct UniffiForeignFutureResultU64 {
+    uint64_t returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultU64;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U64
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U64
+typedef void (*UniffiForeignFutureCompleteU64)(uint64_t, UniffiForeignFutureResultU64
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_I64
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_I64
+typedef struct UniffiForeignFutureResultI64 {
+    int64_t returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultI64;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I64
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I64
+typedef void (*UniffiForeignFutureCompleteI64)(uint64_t, UniffiForeignFutureResultI64
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_F32
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_F32
+typedef struct UniffiForeignFutureResultF32 {
+    float returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultF32;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_F32
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_F32
+typedef void (*UniffiForeignFutureCompleteF32)(uint64_t, UniffiForeignFutureResultF32
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_F64
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_F64
+typedef struct UniffiForeignFutureResultF64 {
+    double returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultF64;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_F64
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_F64
+typedef void (*UniffiForeignFutureCompleteF64)(uint64_t, UniffiForeignFutureResultF64
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_RUST_BUFFER
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_RUST_BUFFER
+typedef struct UniffiForeignFutureResultRustBuffer {
+    RustBuffer returnValue;
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultRustBuffer;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER
+typedef void (*UniffiForeignFutureCompleteRustBuffer)(uint64_t, UniffiForeignFutureResultRustBuffer
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_VOID
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_RESULT_VOID
+typedef struct UniffiForeignFutureResultVoid {
+    RustCallStatus callStatus;
+} UniffiForeignFutureResultVoid;
+
+#endif
+#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_VOID
+#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_VOID
+typedef void (*UniffiForeignFutureCompleteVoid)(uint64_t, UniffiForeignFutureResultVoid
+    );
+
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_CLONE_NATIVEPVMRUNTIME
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_CLONE_NATIVEPVMRUNTIME
+uint64_t uniffi_pvm_runtime_fn_clone_nativepvmruntime(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_FREE_NATIVEPVMRUNTIME
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_FREE_NATIVEPVMRUNTIME
+void uniffi_pvm_runtime_fn_free_nativepvmruntime(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_CONSTRUCTOR_NATIVEPVMRUNTIME_NEW
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_CONSTRUCTOR_NATIVEPVMRUNTIME_NEW
+uint64_t uniffi_pvm_runtime_fn_constructor_nativepvmruntime_new(RustBuffer program, RustBuffer assets, RustBuffer presentation, int8_t audio_enabled, uint64_t max_gas_per_update, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_BACKEND
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_BACKEND
+RustBuffer uniffi_pvm_runtime_fn_method_nativepvmruntime_backend(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_GPU_READY
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_GPU_READY
+int8_t uniffi_pvm_runtime_fn_method_nativepvmruntime_gpu_ready(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_INIT
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_INIT
+void uniffi_pvm_runtime_fn_method_nativepvmruntime_init(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_IS_EXITED
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_IS_EXITED
+int8_t uniffi_pvm_runtime_fn_method_nativepvmruntime_is_exited(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_LAST_GAS_USED
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_LAST_GAS_USED
+uint64_t uniffi_pvm_runtime_fn_method_nativepvmruntime_last_gas_used(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_SEND_GPU_EVENT
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_SEND_GPU_EVENT
+void uniffi_pvm_runtime_fn_method_nativepvmruntime_send_gpu_event(uint64_t ptr, RustBuffer bytes, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_SEND_INPUT
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_SEND_INPUT
+void uniffi_pvm_runtime_fn_method_nativepvmruntime_send_input(uint64_t ptr, RustBuffer event_type, uint8_t code, uint16_t x, uint16_t y, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_SET_GPU_CAPABILITIES
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_SET_GPU_CAPABILITIES
+void uniffi_pvm_runtime_fn_method_nativepvmruntime_set_gpu_capabilities(uint64_t ptr, RustBuffer bytes, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_AUDIO
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_AUDIO
+RustBuffer uniffi_pvm_runtime_fn_method_nativepvmruntime_take_audio(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_FRAME
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_FRAME
+RustBuffer uniffi_pvm_runtime_fn_method_nativepvmruntime_take_frame(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_GPU_BATCH
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_GPU_BATCH
+RustBuffer uniffi_pvm_runtime_fn_method_nativepvmruntime_take_gpu_batch(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_LOG
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_LOG
+RustBuffer uniffi_pvm_runtime_fn_method_nativepvmruntime_take_log(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_SAVE
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_SAVE
+RustBuffer uniffi_pvm_runtime_fn_method_nativepvmruntime_take_save(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_TRI2D
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_TAKE_TRI2D
+RustBuffer uniffi_pvm_runtime_fn_method_nativepvmruntime_take_tri2d(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_UPDATE
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_FN_METHOD_NATIVEPVMRUNTIME_UPDATE
+void uniffi_pvm_runtime_fn_method_nativepvmruntime_update(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUSTBUFFER_ALLOC
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUSTBUFFER_ALLOC
+RustBuffer ffi_pvm_runtime_rustbuffer_alloc(uint64_t size, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUSTBUFFER_FROM_BYTES
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUSTBUFFER_FROM_BYTES
+RustBuffer ffi_pvm_runtime_rustbuffer_from_bytes(ForeignBytes bytes, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUSTBUFFER_FREE
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUSTBUFFER_FREE
+void ffi_pvm_runtime_rustbuffer_free(RustBuffer buf, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUSTBUFFER_RESERVE
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUSTBUFFER_RESERVE
+RustBuffer ffi_pvm_runtime_rustbuffer_reserve(RustBuffer buf, uint64_t additional, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_U8
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_U8
+void ffi_pvm_runtime_rust_future_poll_u8(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_U8
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_U8
+void ffi_pvm_runtime_rust_future_cancel_u8(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_U8
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_U8
+void ffi_pvm_runtime_rust_future_free_u8(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_U8
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_U8
+uint8_t ffi_pvm_runtime_rust_future_complete_u8(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_I8
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_I8
+void ffi_pvm_runtime_rust_future_poll_i8(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_I8
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_I8
+void ffi_pvm_runtime_rust_future_cancel_i8(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_I8
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_I8
+void ffi_pvm_runtime_rust_future_free_i8(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_I8
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_I8
+int8_t ffi_pvm_runtime_rust_future_complete_i8(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_U16
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_U16
+void ffi_pvm_runtime_rust_future_poll_u16(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_U16
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_U16
+void ffi_pvm_runtime_rust_future_cancel_u16(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_U16
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_U16
+void ffi_pvm_runtime_rust_future_free_u16(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_U16
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_U16
+uint16_t ffi_pvm_runtime_rust_future_complete_u16(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_I16
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_I16
+void ffi_pvm_runtime_rust_future_poll_i16(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_I16
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_I16
+void ffi_pvm_runtime_rust_future_cancel_i16(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_I16
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_I16
+void ffi_pvm_runtime_rust_future_free_i16(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_I16
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_I16
+int16_t ffi_pvm_runtime_rust_future_complete_i16(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_U32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_U32
+void ffi_pvm_runtime_rust_future_poll_u32(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_U32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_U32
+void ffi_pvm_runtime_rust_future_cancel_u32(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_U32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_U32
+void ffi_pvm_runtime_rust_future_free_u32(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_U32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_U32
+uint32_t ffi_pvm_runtime_rust_future_complete_u32(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_I32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_I32
+void ffi_pvm_runtime_rust_future_poll_i32(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_I32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_I32
+void ffi_pvm_runtime_rust_future_cancel_i32(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_I32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_I32
+void ffi_pvm_runtime_rust_future_free_i32(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_I32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_I32
+int32_t ffi_pvm_runtime_rust_future_complete_i32(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_U64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_U64
+void ffi_pvm_runtime_rust_future_poll_u64(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_U64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_U64
+void ffi_pvm_runtime_rust_future_cancel_u64(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_U64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_U64
+void ffi_pvm_runtime_rust_future_free_u64(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_U64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_U64
+uint64_t ffi_pvm_runtime_rust_future_complete_u64(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_I64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_I64
+void ffi_pvm_runtime_rust_future_poll_i64(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_I64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_I64
+void ffi_pvm_runtime_rust_future_cancel_i64(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_I64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_I64
+void ffi_pvm_runtime_rust_future_free_i64(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_I64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_I64
+int64_t ffi_pvm_runtime_rust_future_complete_i64(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_F32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_F32
+void ffi_pvm_runtime_rust_future_poll_f32(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_F32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_F32
+void ffi_pvm_runtime_rust_future_cancel_f32(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_F32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_F32
+void ffi_pvm_runtime_rust_future_free_f32(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_F32
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_F32
+float ffi_pvm_runtime_rust_future_complete_f32(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_F64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_F64
+void ffi_pvm_runtime_rust_future_poll_f64(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_F64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_F64
+void ffi_pvm_runtime_rust_future_cancel_f64(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_F64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_F64
+void ffi_pvm_runtime_rust_future_free_f64(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_F64
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_F64
+double ffi_pvm_runtime_rust_future_complete_f64(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_RUST_BUFFER
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_RUST_BUFFER
+void ffi_pvm_runtime_rust_future_poll_rust_buffer(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_RUST_BUFFER
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_RUST_BUFFER
+void ffi_pvm_runtime_rust_future_cancel_rust_buffer(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_RUST_BUFFER
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_RUST_BUFFER
+void ffi_pvm_runtime_rust_future_free_rust_buffer(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_RUST_BUFFER
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_RUST_BUFFER
+RustBuffer ffi_pvm_runtime_rust_future_complete_rust_buffer(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_VOID
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_POLL_VOID
+void ffi_pvm_runtime_rust_future_poll_void(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_VOID
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_CANCEL_VOID
+void ffi_pvm_runtime_rust_future_cancel_void(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_VOID
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_FREE_VOID
+void ffi_pvm_runtime_rust_future_free_void(uint64_t handle
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_VOID
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_RUST_FUTURE_COMPLETE_VOID
+void ffi_pvm_runtime_rust_future_complete_void(uint64_t handle, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_BACKEND
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_BACKEND
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_backend(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_GPU_READY
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_GPU_READY
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_gpu_ready(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_INIT
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_INIT
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_init(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_IS_EXITED
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_IS_EXITED
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_is_exited(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_LAST_GAS_USED
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_LAST_GAS_USED
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_last_gas_used(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_SEND_GPU_EVENT
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_SEND_GPU_EVENT
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_send_gpu_event(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_SEND_INPUT
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_SEND_INPUT
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_send_input(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_SET_GPU_CAPABILITIES
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_SET_GPU_CAPABILITIES
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_set_gpu_capabilities(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_AUDIO
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_AUDIO
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_audio(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_FRAME
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_FRAME
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_frame(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_GPU_BATCH
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_GPU_BATCH
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_gpu_batch(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_LOG
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_LOG
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_log(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_SAVE
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_SAVE
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_save(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_TRI2D
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_TAKE_TRI2D
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_take_tri2d(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_UPDATE
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_METHOD_NATIVEPVMRUNTIME_UPDATE
+uint16_t uniffi_pvm_runtime_checksum_method_nativepvmruntime_update(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_CONSTRUCTOR_NATIVEPVMRUNTIME_NEW
+#define UNIFFI_FFIDEF_UNIFFI_PVM_RUNTIME_CHECKSUM_CONSTRUCTOR_NATIVEPVMRUNTIME_NEW
+uint16_t uniffi_pvm_runtime_checksum_constructor_nativepvmruntime_new(void
+
+);
+#endif
+#ifndef UNIFFI_FFIDEF_FFI_PVM_RUNTIME_UNIFFI_CONTRACT_VERSION
+#define UNIFFI_FFIDEF_FFI_PVM_RUNTIME_UNIFFI_CONTRACT_VERSION
+uint32_t ffi_pvm_runtime_uniffi_contract_version(void
+
+);
+#endif
+
diff --git a/ios/truapi-host/scripts/sync-bindings.sh b/ios/truapi-host/scripts/sync-bindings.sh
index 2305ca71f..76b5ec152 100755
--- a/ios/truapi-host/scripts/sync-bindings.sh
+++ b/ios/truapi-host/scripts/sync-bindings.sh
@@ -14,7 +14,7 @@ PACKAGE_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 TRUAPI_ROOT="$(cd "$PACKAGE_ROOT/../.." && pwd)"
 UNIFFI_OUT="$TRUAPI_ROOT/target/uniffi-swift-out"
 
-NAMESPACES="truapi truapi_platform truapi_server"
+NAMESPACES="truapi truapi_platform truapi_server pvm_runtime"
 
 CHECK_ONLY=0
 case "${1-}" in
diff --git a/js/packages/pvm-browser-runtime/LICENSE-MPL-2.0 b/js/packages/pvm-browser-runtime/LICENSE-MPL-2.0
new file mode 100644
index 000000000..fa0086a95
--- /dev/null
+++ b/js/packages/pvm-browser-runtime/LICENSE-MPL-2.0
@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
\ No newline at end of file
diff --git a/js/packages/pvm-browser-runtime/SOURCE b/js/packages/pvm-browser-runtime/SOURCE
new file mode 100644
index 000000000..0364263c9
--- /dev/null
+++ b/js/packages/pvm-browser-runtime/SOURCE
@@ -0,0 +1,10 @@
+PolkaVM App v2 browser runtime
+Source repository: https://github.com/paritytech/host-rust-core
+Source branch: feat/pvm-app-runtime
+Rust crate: rust/crates/pvm-runtime
+GPU wire crate: rust/crates/pvm-gpu-wire
+PolkaVM native revision: 8cc3c5601aa614b0f6dfac2ae3ee271942b3c997
+PolkaVM wasm revision: 3df1d0309c4c81a1aad0a755d83570d203bba1d9
+
+The package build compiles pvm-runtime for wasm32-unknown-unknown and bundles
+its bounded PVM worker plus the Tri2D/WebGPU Raster browser transport.
diff --git a/js/packages/pvm-browser-runtime/package.json b/js/packages/pvm-browser-runtime/package.json
new file mode 100644
index 000000000..8db754586
--- /dev/null
+++ b/js/packages/pvm-browser-runtime/package.json
@@ -0,0 +1,31 @@
+{
+  "name": "@parity/pvm-browser-runtime",
+  "version": "0.1.0",
+  "description": "Host-neutral PolkaVM App v2 browser runtime artifacts",
+  "license": "MPL-2.0",
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE-MPL-2.0",
+    "SOURCE"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test": "npm run build && node --test test/*.test.mjs"
+  },
+  "exports": {
+    "./runtime.wasm": "./dist/pvm-browser-runtime.wasm",
+    "./worker": "./dist/pvm-worker.js",
+    "./worker-entry": "./dist/pvm-wasm-worker-entry.js",
+    "./translator": "./dist/pvm-wasm-translated.js",
+    "./runtime-core": "./dist/pvm-runtime-core.js",
+    "./gpu-worker": "./dist/pvm-gpu-worker.js",
+    "./checksums": "./dist/SHA256SUMS"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/js/packages/pvm-browser-runtime/scripts/build.mjs b/js/packages/pvm-browser-runtime/scripts/build.mjs
new file mode 100644
index 000000000..7ee0f3ed6
--- /dev/null
+++ b/js/packages/pvm-browser-runtime/scripts/build.mjs
@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+import {
+  copyFile,
+  mkdir,
+  readFile,
+  rm,
+  writeFile,
+} from "node:fs/promises";
+import { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+
+const packageRoot = resolve(import.meta.dirname, "..");
+const repositoryRoot = resolve(packageRoot, "../../..");
+const dist = resolve(packageRoot, "dist");
+const source = resolve(packageRoot, "src");
+const wasm =
+  process.env.PVM_RUNTIME_WASM ??
+  resolve(
+    repositoryRoot,
+    "target/wasm32-unknown-unknown/release/pvm_runtime.wasm",
+  );
+
+if (process.env.PVM_RUNTIME_WASM === undefined) {
+  const build = spawnSync(
+    "cargo",
+    [
+      "build",
+      "--locked",
+      "--release",
+      "--target",
+      "wasm32-unknown-unknown",
+      "-p",
+      "pvm-runtime",
+    ],
+    { cwd: repositoryRoot, stdio: "inherit" },
+  );
+  if (build.status !== 0) process.exit(build.status ?? 1);
+}
+
+await rm(dist, { recursive: true, force: true });
+await mkdir(dist, { recursive: true });
+const translated = await readFile(resolve(source, "pvm-wasm-translated.js"));
+const runtimeCore = await readFile(resolve(source, "pvm-runtime-core.js"));
+const workerEntry = await readFile(resolve(source, "pvm-wasm-worker-entry.js"));
+await copyFile(wasm, resolve(dist, "pvm-browser-runtime.wasm"));
+await copyFile(resolve(source, "pvm-gpu-worker.js"), resolve(dist, "pvm-gpu-worker.js"));
+await copyFile(
+  resolve(source, "pvm-wasm-translated.js"),
+  resolve(dist, "pvm-wasm-translated.js"),
+);
+await copyFile(
+  resolve(source, "pvm-runtime-core.js"),
+  resolve(dist, "pvm-runtime-core.js"),
+);
+await copyFile(
+  resolve(source, "pvm-wasm-worker-entry.js"),
+  resolve(dist, "pvm-wasm-worker-entry.js"),
+);
+await writeFile(
+  resolve(dist, "pvm-worker.js"),
+  Buffer.concat([
+    translated,
+    Buffer.from("\n"),
+    runtimeCore,
+    Buffer.from("\n"),
+    workerEntry,
+  ]),
+);
+
+const files = [
+  "pvm-browser-runtime.wasm",
+  "pvm-worker.js",
+  "pvm-gpu-worker.js",
+  "pvm-wasm-translated.js",
+  "pvm-runtime-core.js",
+  "pvm-wasm-worker-entry.js",
+];
+const sums = [];
+for (const file of files) {
+  const bytes = await readFile(resolve(dist, file));
+  sums.push(`${createHash("sha256").update(bytes).digest("hex")}  ${file}`);
+}
+await writeFile(resolve(dist, "SHA256SUMS"), `${sums.join("\n")}\n`);
diff --git a/js/packages/pvm-browser-runtime/src/pvm-gpu-worker.js b/js/packages/pvm-browser-runtime/src/pvm-gpu-worker.js
new file mode 100644
index 000000000..375807456
--- /dev/null
+++ b/js/packages/pvm-browser-runtime/src/pvm-gpu-worker.js
@@ -0,0 +1,1884 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+/* global GPUBufferUsage, GPUMapMode, GPUTextureUsage */
+
+"use strict";
+
+const WIRE_VERSION = 1;
+const BATCH_HEADER_BYTES = 24;
+const COMMAND_HEADER_BYTES = 8;
+const EVENT_HEADER_BYTES = 24;
+const MAX_BATCH_BYTES = 4 * 1024 * 1024;
+const MAX_COMMANDS = 16_384;
+const MAX_DIAGNOSTIC_BYTES = 8 * 1024;
+const HANDLE_SLOT_MASK = (1 << 20) - 1;
+const HANDLE_LIVE_BIT = 1 << 12;
+const MAX_COMPILATIONS_PER_BATCH = 8;
+const MAX_PENDING_BATCHES = 4;
+const BATCH_ERROR_STALE_SURFACE = 4;
+const MAX_RENDER_PASSES_PER_BATCH = 16;
+const MAX_DRAWS_PER_BATCH = 8_192;
+const MAX_TOTAL_BUFFER_BYTES = 64 * 1024 * 1024;
+const MAX_TOTAL_TEXTURE_BYTES = 256 * 1024 * 1024;
+const resourceLimits = new Map([
+  ["buffer", 4_096],
+  ["texture", 512],
+  ["textureView", 1_024],
+  ["sampler", 128],
+  ["shader", 128],
+  ["bindGroupLayout", 128],
+  ["pipelineLayout", 64],
+  ["bindGroup", 512],
+  ["pipeline", 256],
+]);
+const bindGroupResourceKinds = new Map([
+  [1, "buffer"],
+  [2, "sampler"],
+  [3, "textureView"],
+]);
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+
+const formats = new Map([
+  [1, "rgba8unorm"],
+  [2, "rgba8unorm-srgb"],
+  [3, "bgra8unorm"],
+  [4, "bgra8unorm-srgb"],
+  [5, "depth24plus"],
+  [6, "depth32float"],
+]);
+const formatIds = new Map([...formats].map(([id, format]) => [format, id]));
+const vertexFormats = new Map([
+  [1, "float32"],
+  [2, "float32x2"],
+  [3, "float32x3"],
+  [4, "float32x4"],
+  [5, "uint32"],
+  [6, "uint32x2"],
+  [7, "uint32x4"],
+  [8, "unorm8x2"],
+  [9, "unorm8x4"],
+  [10, "snorm8x2"],
+  [11, "snorm8x4"],
+]);
+const indexFormats = new Map([
+  [1, "uint16"],
+  [2, "uint32"],
+]);
+const addressModes = new Map([
+  [1, "clamp-to-edge"],
+  [2, "repeat"],
+  [3, "mirror-repeat"],
+]);
+const filterModes = new Map([
+  [1, "nearest"],
+  [2, "linear"],
+]);
+const compareFunctions = new Map([
+  [1, "never"],
+  [2, "less"],
+  [3, "equal"],
+  [4, "less-equal"],
+  [5, "greater"],
+  [6, "not-equal"],
+  [7, "greater-equal"],
+  [8, "always"],
+]);
+const blendOperations = new Map([
+  [1, "add"],
+  [2, "subtract"],
+  [3, "reverse-subtract"],
+  [4, "min"],
+  [5, "max"],
+]);
+const blendFactors = new Map([
+  [1, "zero"],
+  [2, "one"],
+  [3, "src"],
+  [4, "one-minus-src"],
+  [5, "src-alpha"],
+  [6, "one-minus-src-alpha"],
+  [7, "dst"],
+  [8, "one-minus-dst"],
+  [9, "dst-alpha"],
+  [10, "one-minus-dst-alpha"],
+  [11, "src-alpha-saturated"],
+  [12, "constant"],
+  [13, "one-minus-constant"],
+]);
+const topologies = new Map([
+  [1, "point-list"],
+  [2, "line-list"],
+  [3, "line-strip"],
+  [4, "triangle-list"],
+  [5, "triangle-strip"],
+]);
+const frontFaces = new Map([
+  [1, "ccw"],
+  [2, "cw"],
+]);
+const cullModes = new Map([
+  [0, "none"],
+  [1, "front"],
+  [2, "back"],
+]);
+const samplerBindingTypes = new Map([
+  [1, "filtering"],
+  [2, "non-filtering"],
+  [3, "comparison"],
+]);
+const textureSampleTypes = new Map([
+  [1, "float"],
+  [2, "unfilterable-float"],
+  [3, "depth"],
+  [4, "sint"],
+  [5, "uint"],
+]);
+const vertexStepModes = new Map([
+  [1, "vertex"],
+  [2, "instance"],
+]);
+const textureAspects = new Map([
+  [1, "all"],
+  [2, "depth-only"],
+]);
+
+class ProtocolError extends Error {
+  constructor(message, commandIndex = 0xffffffff, errorCode = 1) {
+    super(message);
+    this.commandIndex = commandIndex;
+    this.errorCode = errorCode;
+  }
+}
+
+class Reader {
+  constructor(bytes) {
+    if (!(bytes instanceof Uint8Array)) {
+      throw new ProtocolError("GPU payload is not bytes");
+    }
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    this.offset = 0;
+  }
+
+  take(length) {
+    const end = this.offset + length;
+    if (!Number.isSafeInteger(end) || end > this.bytes.byteLength) {
+      throw new ProtocolError("GPU payload is truncated");
+    }
+    const value = this.bytes.subarray(this.offset, end);
+    this.offset = end;
+    return value;
+  }
+
+  u8() {
+    return this.take(1)[0];
+  }
+
+  u16() {
+    const offset = this.offset;
+    this.take(2);
+    return this.view.getUint16(offset, true);
+  }
+
+  u32() {
+    const offset = this.offset;
+    this.take(4);
+    return this.view.getUint32(offset, true);
+  }
+
+  i32() {
+    const offset = this.offset;
+    this.take(4);
+    return this.view.getInt32(offset, true);
+  }
+
+  u64() {
+    const offset = this.offset;
+    this.take(8);
+    const value = this.view.getBigUint64(offset, true);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new ProtocolError("GPU integer exceeds the safe range");
+    }
+    return Number(value);
+  }
+
+  f32() {
+    const offset = this.offset;
+    this.take(4);
+    const value = this.view.getFloat32(offset, true);
+    if (!Number.isFinite(value)) {
+      throw new ProtocolError("GPU descriptor contains non-finite float");
+    }
+    return value;
+  }
+
+  text(length) {
+    return textDecoder.decode(this.take(length));
+  }
+
+  zero(length) {
+    if (this.take(length).some(byte => byte !== 0)) {
+      throw new ProtocolError("GPU descriptor has nonzero reserved bytes");
+    }
+  }
+
+  finish() {
+    if (this.offset !== this.bytes.byteLength) {
+      throw new ProtocolError("GPU descriptor has trailing bytes");
+    }
+  }
+}
+
+function mapped(table, value, label) {
+  const result = table.get(value);
+  if (result === undefined) {
+    throw new ProtocolError(`unsupported GPU ${label} ${value}`);
+  }
+  return result;
+}
+
+function validHandle(id) {
+  return id !== 0 && (id & HANDLE_SLOT_MASK) !== 0 && id >>> 20 !== 0;
+}
+
+function resource(catalog, id, kind, commandIndex) {
+  const entry = catalog.get(id);
+  if (!entry || (kind && entry.kind !== kind) || entry.failed) {
+    throw new ProtocolError(
+      `invalid ${kind || "resource"} handle ${id}`,
+      commandIndex
+    );
+  }
+  return entry;
+}
+
+function createResource(catalog, slots, id, kind, descriptor, commandIndex) {
+  if (!validHandle(id) || catalog.has(id)) {
+    throw new ProtocolError(`invalid new ${kind} handle ${id}`, commandIndex);
+  }
+  const slot = id & HANDLE_SLOT_MASK;
+  const generation = id >>> 20;
+  const prior = slots.get(slot);
+  if (
+    (prior === undefined && generation !== 1) ||
+    (prior !== undefined &&
+      ((prior & HANDLE_LIVE_BIT) !== 0 ||
+        generation !== (prior & ~HANDLE_LIVE_BIT) + 1))
+  ) {
+    throw new ProtocolError(`stale new ${kind} handle ${id}`, commandIndex);
+  }
+  const entry = { kind, descriptor, value: null, failed: false };
+  catalog.set(id, entry);
+  slots.set(slot, generation | HANDLE_LIVE_BIT);
+  return entry;
+}
+
+function textureByteLength(descriptor) {
+  let width = descriptor.width;
+  let height = descriptor.height;
+  let total = 0;
+  for (let level = 0; level < descriptor.mipLevelCount; level++) {
+    const bytes = width * height * 4;
+    if (
+      !Number.isSafeInteger(bytes) ||
+      total > MAX_TOTAL_TEXTURE_BYTES - bytes
+    ) {
+      return MAX_TOTAL_TEXTURE_BYTES + 1;
+    }
+    total += bytes;
+    width = Math.max(1, Math.floor(width / 2));
+    height = Math.max(1, Math.floor(height / 2));
+  }
+  return total;
+}
+
+function adjustResourceStats(stats, entry, delta, commandIndex = 0xffffffff) {
+  const count = (stats.counts.get(entry.kind) || 0) + delta;
+  const limit = resourceLimits.get(entry.kind);
+  if (count < 0 || limit === undefined || count > limit) {
+    throw new ProtocolError(
+      `GPU ${entry.kind} resource quota exceeded`,
+      commandIndex
+    );
+  }
+  stats.counts.set(entry.kind, count);
+  if (entry.kind === "buffer") {
+    stats.bufferBytes += delta * entry.descriptor.size;
+    if (stats.bufferBytes < 0 || stats.bufferBytes > MAX_TOTAL_BUFFER_BYTES) {
+      throw new ProtocolError("GPU buffer memory quota exceeded", commandIndex);
+    }
+  } else if (entry.kind === "texture") {
+    stats.textureBytes += delta * textureByteLength(entry.descriptor);
+    if (
+      stats.textureBytes < 0 ||
+      stats.textureBytes > MAX_TOTAL_TEXTURE_BYTES
+    ) {
+      throw new ProtocolError(
+        "GPU texture memory quota exceeded",
+        commandIndex
+      );
+    }
+  }
+}
+
+function resourceStats(catalog) {
+  const stats = { counts: new Map(), bufferBytes: 0, textureBytes: 0 };
+  for (const entry of catalog.values()) {
+    adjustResourceStats(stats, entry, 1);
+  }
+  return stats;
+}
+
+function createBoundedResource(
+  catalog,
+  slots,
+  stats,
+  creations,
+  id,
+  kind,
+  descriptor,
+  commandIndex
+) {
+  const entry = createResource(
+    catalog,
+    slots,
+    id,
+    kind,
+    descriptor,
+    commandIndex
+  );
+  const creationCount = (creations.counts.get(kind) || 0) + 1;
+  if (creationCount > resourceLimits.get(kind)) {
+    throw new ProtocolError(
+      `too many GPU ${kind} creations in one batch`,
+      commandIndex
+    );
+  }
+  creations.counts.set(kind, creationCount);
+  if (kind === "buffer") {
+    creations.bufferBytes += descriptor.size;
+    if (creations.bufferBytes > MAX_TOTAL_BUFFER_BYTES) {
+      throw new ProtocolError(
+        "GPU buffer allocation budget exceeded",
+        commandIndex
+      );
+    }
+  } else if (kind === "texture") {
+    creations.textureBytes += textureByteLength(descriptor);
+    if (creations.textureBytes > MAX_TOTAL_TEXTURE_BYTES) {
+      throw new ProtocolError(
+        "GPU texture allocation budget exceeded",
+        commandIndex
+      );
+    }
+  } else if (kind === "shader" || kind === "pipeline") {
+    creations.compilations++;
+    if (creations.compilations > MAX_COMPILATIONS_PER_BATCH) {
+      throw new ProtocolError(
+        "too many GPU compilations in one batch",
+        commandIndex
+      );
+    }
+  }
+  adjustResourceStats(stats, entry, 1, commandIndex);
+  return entry;
+}
+
+function parseCommands(bytes) {
+  if (
+    bytes.byteLength < BATCH_HEADER_BYTES ||
+    bytes.byteLength > MAX_BATCH_BYTES
+  ) {
+    throw new ProtocolError("GPU batch length is invalid");
+  }
+  const reader = new Reader(bytes);
+  if (
+    textDecoder.decode(reader.take(4)) !== "EPG1" ||
+    reader.u16() !== WIRE_VERSION
+  ) {
+    throw new ProtocolError("GPU batch header is invalid");
+  }
+  reader.zero(2);
+  if (reader.u32() !== bytes.byteLength) {
+    throw new ProtocolError("GPU batch length does not match its header");
+  }
+  const commandCount = reader.u32();
+  const sequence = reader.u64();
+  if (!sequence || commandCount > MAX_COMMANDS) {
+    throw new ProtocolError("GPU batch sequence or command count is invalid");
+  }
+  const commands = [];
+  for (let index = 0; index < commandCount; index++) {
+    const opcode = reader.u16();
+    reader.zero(2);
+    const commandBytes = reader.u32();
+    if (commandBytes < COMMAND_HEADER_BYTES || commandBytes % 4) {
+      throw new ProtocolError("GPU command length is invalid", index);
+    }
+    const payload = reader.take(commandBytes - COMMAND_HEADER_BYTES);
+    commands.push({ opcode, payload, index });
+  }
+  reader.finish();
+  return { sequence, commands };
+}
+
+// Parsing stays centralized so every opcode's exact wire shape is auditable.
+// eslint-disable-next-line complexity
+function parseCommand(command) {
+  const reader = new Reader(command.payload);
+  const result = { opcode: command.opcode, index: command.index };
+  switch (command.opcode) {
+    case 1:
+      Object.assign(result, {
+        id: reader.u32(),
+        usage: reader.u32(),
+        size: reader.u64(),
+      });
+      break;
+    case 2: {
+      result.id = reader.u32();
+      reader.zero(4);
+      result.offset = reader.u64();
+      const length = reader.u32();
+      reader.zero(4);
+      result.data = reader.take(length).slice();
+      reader.zero(reader.bytes.byteLength - reader.offset);
+      break;
+    }
+    case 3:
+      Object.assign(result, {
+        id: reader.u32(),
+        width: reader.u32(),
+        height: reader.u32(),
+        mipLevelCount: reader.u16(),
+        sampleCount: reader.u16(),
+        format: mapped(formats, reader.u16(), "texture format"),
+      });
+      if (reader.u8() !== 1) {
+        throw new ProtocolError("unsupported texture dimension", command.index);
+      }
+      reader.zero(1);
+      result.usage = reader.u32();
+      break;
+    case 4: {
+      Object.assign(result, {
+        id: reader.u32(),
+        mipLevel: reader.u32(),
+        origin: { x: reader.u32(), y: reader.u32(), z: reader.u32() },
+        size: {
+          width: reader.u32(),
+          height: reader.u32(),
+          depthOrArrayLayers: reader.u32(),
+        },
+        bytesPerRow: reader.u32(),
+        rowsPerImage: reader.u32(),
+      });
+      const length = reader.u32();
+      result.data = reader.take(length).slice();
+      reader.zero(reader.bytes.byteLength - reader.offset);
+      break;
+    }
+    case 5:
+      Object.assign(result, {
+        id: reader.u32(),
+        addressModeU: mapped(addressModes, reader.u8(), "address mode"),
+        addressModeV: mapped(addressModes, reader.u8(), "address mode"),
+        addressModeW: mapped(addressModes, reader.u8(), "address mode"),
+        magFilter: mapped(filterModes, reader.u8(), "filter mode"),
+        minFilter: mapped(filterModes, reader.u8(), "filter mode"),
+        mipmapFilter: mapped(filterModes, reader.u8(), "filter mode"),
+      });
+      {
+        const compare = reader.u8();
+        result.compare = compare
+          ? mapped(compareFunctions, compare, "compare function")
+          : undefined;
+      }
+      result.maxAnisotropy = reader.u8();
+      result.lodMinClamp = reader.f32();
+      result.lodMaxClamp = reader.f32();
+      reader.zero(4);
+      break;
+    case 6: {
+      result.id = reader.u32();
+      const length = reader.u32();
+      result.source = reader.text(length);
+      reader.zero(reader.bytes.byteLength - reader.offset);
+      break;
+    }
+    case 7: {
+      result.id = reader.u32();
+      const count = reader.u32();
+      result.entries = [];
+      for (let i = 0; i < count; i++) {
+        const binding = reader.u32();
+        const visibility = reader.u32();
+        const kind = reader.u16();
+        const flags = reader.u16();
+        reader.zero(4);
+        const minBindingSize = reader.u64();
+        const parameter0 = reader.u32();
+        const parameter1 = reader.u32();
+        let entry;
+        if (kind === 1) {
+          if (parameter0 || parameter1 || flags & ~1) {
+            throw new ProtocolError(
+              "invalid buffer binding layout",
+              command.index
+            );
+          }
+          entry = {
+            binding,
+            visibility,
+            buffer: {
+              type: "uniform",
+              hasDynamicOffset: Boolean(flags & 1),
+              minBindingSize,
+            },
+          };
+        } else if (kind === 2) {
+          if (flags || minBindingSize || parameter1) {
+            throw new ProtocolError(
+              "invalid sampler binding layout",
+              command.index
+            );
+          }
+          entry = {
+            binding,
+            visibility,
+            sampler: {
+              type: mapped(
+                samplerBindingTypes,
+                parameter0,
+                "sampler binding type"
+              ),
+            },
+          };
+        } else if (kind === 3) {
+          if (flags || minBindingSize) {
+            throw new ProtocolError(
+              "invalid texture binding layout",
+              command.index
+            );
+          }
+          entry = {
+            binding,
+            visibility,
+            texture: {
+              sampleType: mapped(
+                textureSampleTypes,
+                parameter0,
+                "texture sample type"
+              ),
+              viewDimension:
+                parameter1 === 1
+                  ? "2d"
+                  : (() => {
+                      throw new ProtocolError(
+                        "unsupported texture view dimension",
+                        command.index
+                      );
+                    })(),
+              multisampled: false,
+            },
+          };
+        } else {
+          throw new ProtocolError(
+            "unsupported bind group layout entry",
+            command.index
+          );
+        }
+        result.entries.push(entry);
+      }
+      break;
+    }
+    case 8: {
+      result.id = reader.u32();
+      const count = reader.u32();
+      result.layouts = Array.from({ length: count }, () => reader.u32());
+      break;
+    }
+    case 9: {
+      result.id = reader.u32();
+      result.layout = reader.u32();
+      const count = reader.u32();
+      result.entries = [];
+      for (let i = 0; i < count; i++) {
+        const binding = reader.u32();
+        const resourceId = reader.u32();
+        const kind = reader.u16();
+        if (kind !== 1 && kind !== 2 && kind !== 3) {
+          throw new ProtocolError(
+            "unsupported bind group entry kind",
+            command.index
+          );
+        }
+        reader.zero(2);
+        reader.zero(4);
+        const offset = reader.u64();
+        const size = reader.u64();
+        result.entries.push({ binding, resourceId, kind, offset, size });
+      }
+      break;
+    }
+    case 10: {
+      Object.assign(result, {
+        id: reader.u32(),
+        layout: reader.u32(),
+        shader: reader.u32(),
+      });
+      const layoutCount = reader.u16();
+      const attributeCount = reader.u16();
+      const targetCount = reader.u16();
+      result.flags = reader.u16();
+      result.depthFormatId = reader.u16();
+      result.sampleCount = reader.u16();
+      result.topology = mapped(topologies, reader.u8(), "primitive topology");
+      result.frontFace = mapped(frontFaces, reader.u8(), "front face");
+      result.cullMode = mapped(cullModes, reader.u8(), "cull mode");
+      const stripIndex = reader.u8();
+      result.stripIndexFormat = stripIndex
+        ? mapped(indexFormats, stripIndex, "strip index format")
+        : undefined;
+      const depthCompare = reader.u8();
+      result.depthCompare = depthCompare
+        ? mapped(compareFunctions, depthCompare, "depth compare")
+        : undefined;
+      reader.zero(11);
+      result.layouts = [];
+      for (let i = 0; i < layoutCount; i++) {
+        result.layouts.push({
+          arrayStride: reader.u64(),
+          stepMode: mapped(vertexStepModes, reader.u8(), "vertex step mode"),
+          firstAttribute: (reader.zero(3), reader.u16()),
+          attributeCount: reader.u16(),
+        });
+      }
+      result.attributes = [];
+      for (let i = 0; i < attributeCount; i++) {
+        result.attributes.push({
+          format: mapped(vertexFormats, reader.u16(), "vertex format"),
+          shaderLocation: reader.u16(),
+          offset: reader.u64(),
+        });
+        reader.zero(4);
+      }
+      result.targets = [];
+      for (let i = 0; i < targetCount; i++) {
+        const format = mapped(formats, reader.u16(), "color target format");
+        const writeMask = reader.u16();
+        const color = {
+          operation: mapped(blendOperations, reader.u8(), "blend operation"),
+          srcFactor: mapped(blendFactors, reader.u8(), "blend factor"),
+          dstFactor: mapped(blendFactors, reader.u8(), "blend factor"),
+        };
+        const alpha = {
+          operation: mapped(blendOperations, reader.u8(), "blend operation"),
+          srcFactor: mapped(blendFactors, reader.u8(), "blend factor"),
+          dstFactor: mapped(blendFactors, reader.u8(), "blend factor"),
+        };
+        reader.zero(6);
+        result.targets.push({ format, writeMask, blend: { color, alpha } });
+      }
+      break;
+    }
+    case 11:
+    case 13:
+      result.id = reader.u32();
+      break;
+    case 12:
+      Object.assign(result, {
+        colorView: reader.u32(),
+        depthView: reader.u32(),
+        surfaceGeneration: reader.u32(),
+        flags: reader.u32(),
+        clearColor: {
+          r: reader.f32(),
+          g: reader.f32(),
+          b: reader.f32(),
+          a: reader.f32(),
+        },
+        clearDepth: reader.f32(),
+      });
+      break;
+    case 14:
+      Object.assign(result, {
+        slot: reader.u32(),
+        buffer: reader.u32(),
+        offset: reader.u64(),
+        size: reader.u64(),
+      });
+      break;
+    case 15:
+      Object.assign(result, {
+        buffer: reader.u32(),
+        format: mapped(indexFormats, reader.u32(), "index format"),
+        offset: reader.u64(),
+        size: reader.u64(),
+      });
+      break;
+    case 16: {
+      result.bindIndex = reader.u32();
+      result.bindGroup = reader.u32();
+      const count = reader.u32();
+      result.dynamicOffsets = Array.from({ length: count }, () => reader.u32());
+      break;
+    }
+    case 17:
+      result.values = Array.from({ length: 6 }, () => reader.f32());
+      break;
+    case 18:
+    case 19:
+      result.values = Array.from({ length: 4 }, () => reader.u32());
+      break;
+    case 20:
+      result.values = [
+        reader.u32(),
+        reader.u32(),
+        reader.u32(),
+        reader.i32(),
+        reader.u32(),
+      ];
+      break;
+    case 21:
+      break;
+    case 22:
+      Object.assign(result, {
+        source: reader.u32(),
+        destination: reader.u32(),
+        sourceOffset: reader.u64(),
+        destinationOffset: reader.u64(),
+        size: reader.u64(),
+      });
+      break;
+    case 23:
+      Object.assign(result, {
+        id: reader.u32(),
+        texture: reader.u32(),
+        format: mapped(formats, reader.u16(), "texture view format"),
+      });
+      if (reader.u8() !== 1) {
+        throw new ProtocolError(
+          "unsupported texture view dimension",
+          command.index
+        );
+      }
+      result.aspect = mapped(textureAspects, reader.u8(), "texture aspect");
+      result.baseMipLevel = reader.u16();
+      result.mipLevelCount = reader.u16();
+      result.baseArrayLayer = reader.u16();
+      result.arrayLayerCount = reader.u16();
+      break;
+    default:
+      throw new ProtocolError(
+        `unsupported GPU opcode ${command.opcode}`,
+        command.index
+      );
+  }
+  reader.finish();
+  return result;
+}
+
+class GpuEngine {
+  constructor(
+    canvas,
+    device,
+    context,
+    format,
+    limits,
+    dimensions,
+    testReadback,
+    testDeviceLoss
+  ) {
+    this.canvas = canvas;
+    this.device = device;
+    this.context = context;
+    this.format = format;
+    this.formatId = formatIds.get(format);
+    this.limits = limits;
+    this.resources = new Map();
+    this.handleSlots = new Map();
+    this.surfaceGeneration = 1;
+    this.deviceGeneration = 1;
+    this.lastSequence = 0;
+    this.stopped = false;
+    this.queue = Promise.resolve();
+    this.pendingBatches = 0;
+    this.testReadbacksRemaining = testReadback ? 8 : 0;
+    this.testDeviceLossPending = testDeviceLoss;
+    this.pendingResize = null;
+    this.resizeScheduled = false;
+    this.resize(dimensions, false);
+    device.addEventListener("uncapturederror", event => {
+      this.emitTextEvent(
+        4,
+        0,
+        1,
+        event.error?.message || "uncaptured WebGPU error"
+      );
+    });
+    void device.lost.then(info => {
+      if (!this.stopped) {
+        this.stopped = true;
+        this.emitTextEvent(7, 0, 1, info.message || "WebGPU device lost");
+      }
+    });
+  }
+
+  static async create(
+    canvas,
+    requirements,
+    dimensions,
+    testReadback,
+    testDeviceLoss
+  ) {
+    if (!globalThis.navigator?.gpu) {
+      throw new Error("WebGPU is unavailable");
+    }
+    const adapter = await navigator.gpu.requestAdapter();
+    if (!adapter) {
+      throw new Error("WebGPU adapter is unavailable");
+    }
+    const ceilings = {
+      maxTextureDimension2D: 4096,
+      maxBufferSize: 16 * 1024 * 1024,
+      maxBindingsPerBindGroup: 16,
+      maxBindGroups: 4,
+      maxVertexBuffers: 8,
+      maxVertexAttributes: 16,
+      maxColorAttachments: 4,
+    };
+    const requested = {};
+    for (const [name, ceiling] of Object.entries(ceilings)) {
+      const available = Number(adapter.limits[name]);
+      if (!Number.isFinite(available) || available <= 0) {
+        throw new Error(`WebGPU adapter omitted ${name}`);
+      }
+      requested[name] = Math.min(ceiling, available);
+    }
+    for (const [name, minimum] of Object.entries(
+      requirements.requiredLimits || {}
+    )) {
+      if (
+        !(name in requested) ||
+        !Number.isSafeInteger(minimum) ||
+        minimum <= 0 ||
+        requested[name] < minimum
+      ) {
+        throw new Error(`WebGPU does not satisfy required limit ${name}`);
+      }
+    }
+    if (
+      Array.isArray(requirements.requiredFeatures) &&
+      requirements.requiredFeatures.length
+    ) {
+      throw new Error(
+        "optional WebGPU features are unavailable in profile version 1"
+      );
+    }
+    const device = await adapter.requestDevice({
+      requiredFeatures: [],
+      requiredLimits: requested,
+    });
+    const context = canvas.getContext("webgpu");
+    if (!context) {
+      throw new Error("WebGPU canvas context is unavailable");
+    }
+    const format = navigator.gpu.getPreferredCanvasFormat();
+    if (!formatIds.has(format)) {
+      throw new Error(`unsupported WebGPU surface format ${format}`);
+    }
+    const limits = [
+      requested.maxTextureDimension2D,
+      requested.maxBufferSize,
+      requested.maxBindingsPerBindGroup,
+      requested.maxBindGroups,
+      requested.maxVertexBuffers,
+      requested.maxVertexAttributes,
+      requested.maxColorAttachments,
+      256 * 1024 * 1024,
+      64 * 1024 * 1024,
+      8192,
+      MAX_BATCH_BYTES,
+      16 * 1024 * 1024,
+    ];
+    return new GpuEngine(
+      canvas,
+      device,
+      context,
+      format,
+      limits,
+      dimensions,
+      testReadback,
+      testDeviceLoss
+    );
+  }
+
+  resize(dimensions, notify = true) {
+    const physicalWidth = Math.max(
+      1,
+      Math.min(this.limits[0], dimensions.physicalWidth >>> 0)
+    );
+    const physicalHeight = Math.max(
+      1,
+      Math.min(this.limits[0], dimensions.physicalHeight >>> 0)
+    );
+    const logicalWidth = Math.max(1, dimensions.logicalWidth >>> 0);
+    const logicalHeight = Math.max(1, dimensions.logicalHeight >>> 0);
+    const scale = Number(dimensions.scale);
+    if (!Number.isFinite(scale) || scale <= 0) {
+      throw new Error("invalid WebGPU surface scale");
+    }
+    const changed =
+      this.physicalWidth !== physicalWidth ||
+      this.physicalHeight !== physicalHeight ||
+      this.logicalWidth !== logicalWidth ||
+      this.logicalHeight !== logicalHeight ||
+      this.scale !== scale;
+    this.physicalWidth = physicalWidth;
+    this.physicalHeight = physicalHeight;
+    this.logicalWidth = logicalWidth;
+    this.logicalHeight = logicalHeight;
+    this.scale = scale;
+    this.canvas.width = physicalWidth;
+    this.canvas.height = physicalHeight;
+    this.context.configure({
+      device: this.device,
+      format: this.format,
+      alphaMode: "opaque",
+      usage:
+        GPUTextureUsage.RENDER_ATTACHMENT |
+        (this.testReadbacksRemaining > 0 ? GPUTextureUsage.COPY_SRC : 0),
+    });
+    if (notify && changed) {
+      this.surfaceGeneration++;
+      postBytes("capabilities", this.capabilities());
+      const payload = new Uint8Array(28);
+      const view = new DataView(payload.buffer);
+      for (const [offset, value] of [
+        [0, this.surfaceGeneration],
+        [4, physicalWidth],
+        [8, physicalHeight],
+        [12, logicalWidth],
+        [16, logicalHeight],
+      ]) {
+        view.setUint32(offset, value, true);
+      }
+      view.setFloat32(20, scale, true);
+      view.setUint16(24, this.formatId, true);
+      postBytes("event", makeEvent(6, 0, payload));
+    }
+  }
+
+  scheduleResize(dimensions) {
+    this.pendingResize = dimensions;
+    if (this.resizeScheduled) {
+      return;
+    }
+    this.resizeScheduled = true;
+    this.queue = this.queue
+      .then(() => {
+        const latest = this.pendingResize;
+        this.pendingResize = null;
+        this.resizeScheduled = false;
+        if (!this.stopped && latest) {
+          this.resize(latest);
+        }
+      })
+      .catch(error => {
+        postMessage({ type: "error", message: error.message || String(error) });
+        this.stopped = true;
+      });
+  }
+
+  capabilities() {
+    const bytes = new Uint8Array(56 + this.limits.length * 16);
+    const view = new DataView(bytes.buffer);
+    bytes.set(textEncoder.encode("EGC1"), 0);
+    view.setUint16(4, WIRE_VERSION, true);
+    view.setUint32(8, bytes.byteLength, true);
+    view.setUint16(12, this.formatId, true);
+    view.setUint32(16, this.physicalWidth, true);
+    view.setUint32(20, this.physicalHeight, true);
+    view.setUint32(24, this.logicalWidth, true);
+    view.setUint32(28, this.logicalHeight, true);
+    view.setFloat32(32, this.scale, true);
+    view.setUint32(36, this.surfaceGeneration, true);
+    view.setUint32(40, this.deviceGeneration, true);
+    view.setUint32(44, this.limits.length, true);
+    this.limits.forEach((value, index) => {
+      const offset = 56 + index * 16;
+      view.setUint16(offset, index + 1, true);
+      view.setBigUint64(offset + 4, BigInt(value), true);
+    });
+    return bytes;
+  }
+
+  submit(bytes) {
+    if (this.pendingBatches >= MAX_PENDING_BATCHES) {
+      this.emitBatchRejected(0xffffffff, 3, 0, "GPU submission queue is full");
+      return;
+    }
+    this.pendingBatches++;
+    this.queue = this.queue
+      .then(() => this.execute(bytes))
+      .catch(error => {
+        postMessage({ type: "error", message: error.message || String(error) });
+        this.stopped = true;
+      })
+      .finally(() => {
+        this.pendingBatches--;
+      });
+  }
+
+  // Validation is one atomic state transition across the complete opcode set.
+  // eslint-disable-next-line complexity
+  validate(batch) {
+    if (batch.sequence <= this.lastSequence) {
+      throw new ProtocolError("GPU sequence is not increasing");
+    }
+    const shadow = new Map(this.resources);
+    const slots = new Map(this.handleSlots);
+    let pass = false;
+    const stats = resourceStats(shadow);
+    const creations = {
+      counts: new Map(),
+      bufferBytes: 0,
+      textureBytes: 0,
+      compilations: 0,
+    };
+    let renderPasses = 0;
+    let draws = 0;
+    const commands = batch.commands.map(parseCommand);
+    for (const command of commands) {
+      const index = command.index;
+      switch (command.opcode) {
+        case 1:
+          if (!command.size || command.size > this.limits[1]) {
+            throw new ProtocolError("invalid buffer size", index);
+          }
+          command.resourceEntry = createBoundedResource(
+            shadow,
+            slots,
+            stats,
+            creations,
+            command.id,
+            "buffer",
+            command,
+            index
+          );
+          break;
+        case 2:
+          resource(shadow, command.id, "buffer", index);
+          break;
+        case 3:
+          if (
+            !command.width ||
+            !command.height ||
+            command.width > this.limits[0] ||
+            command.height > this.limits[0] ||
+            !command.mipLevelCount ||
+            command.mipLevelCount > 13 ||
+            command.sampleCount !== 1
+          ) {
+            throw new ProtocolError("invalid texture descriptor", index);
+          }
+          command.resourceEntry = createBoundedResource(
+            shadow,
+            slots,
+            stats,
+            creations,
+            command.id,
+            "texture",
+            command,
+            index
+          );
+          break;
+        case 4:
+          resource(shadow, command.id, "texture", index);
+          break;
+        case 5:
+          command.resourceEntry = createBoundedResource(
+            shadow,
+            slots,
+            stats,
+            creations,
+            command.id,
+            "sampler",
+            command,
+            index
+          );
+          break;
+        case 6:
+          if (!command.source.length || command.source.length > 1024 * 1024) {
+            throw new ProtocolError("invalid WGSL source", index);
+          }
+          command.resourceEntry = createBoundedResource(
+            shadow,
+            slots,
+            stats,
+            creations,
+            command.id,
+            "shader",
+            command,
+            index
+          );
+          break;
+        case 7:
+          if (command.entries.length > this.limits[2]) {
+            throw new ProtocolError("too many bind group entries", index);
+          }
+          command.resourceEntry = createBoundedResource(
+            shadow,
+            slots,
+            stats,
+            creations,
+            command.id,
+            "bindGroupLayout",
+            command,
+            index
+          );
+          break;
+        case 8:
+          if (command.layouts.length > this.limits[3]) {
+            throw new ProtocolError("too many pipeline bind groups", index);
+          }
+          command.layouts.forEach(id =>
+            resource(shadow, id, "bindGroupLayout", index)
+          );
+          command.resourceEntry = createBoundedResource(
+            shadow,
+            slots,
+            stats,
+            creations,
+            command.id,
+            "pipelineLayout",
+            command,
+            index
+          );
+          break;
+        case 9:
+          if (command.entries.length > this.limits[2]) {
+            throw new ProtocolError("too many bind group entries", index);
+          }
+          resource(shadow, command.layout, "bindGroupLayout", index);
+          for (const entry of command.entries) {
+            resource(
+              shadow,
+              entry.resourceId,
+              bindGroupResourceKinds.get(entry.kind) || "",
+              index
+            );
+          }
+          command.resourceEntry = createBoundedResource(
+            shadow,
+            slots,
+            stats,
+            creations,
+            command.id,
+            "bindGroup",
+            command,
+            index
+          );
+          break;
+        case 10:
+          resource(shadow, command.layout, "pipelineLayout", index);
+          resource(shadow, command.shader, "shader", index);
+          if (
+            command.layouts.length > this.limits[4] ||
+            command.attributes.length > this.limits[5] ||
+            command.targets.length > this.limits[6]
+          ) {
+            throw new ProtocolError(
+              "pipeline exceeds negotiated limits",
+              index
+            );
+          }
+          command.resourceEntry = createBoundedResource(
+            shadow,
+            slots,
+            stats,
+            creations,
+            command.id,
+            "pipeline",
+            command,
+            index
+          );
+          break;
+        case 11: {
+          const removed = resource(shadow, command.id, null, index);
+          adjustResourceStats(stats, removed, -1, index);
+          shadow.delete(command.id);
+          slots.set(command.id & HANDLE_SLOT_MASK, command.id >>> 20);
+          break;
+        }
+        case 12:
+          if (pass) {
+            throw new ProtocolError("nested render pass", index);
+          }
+          if (command.surfaceGeneration !== this.surfaceGeneration) {
+            throw new ProtocolError(
+              `render pass surface generation ${command.surfaceGeneration} ` +
+                `does not match current generation ${this.surfaceGeneration}`,
+              index,
+              BATCH_ERROR_STALE_SURFACE
+            );
+          }
+          if (command.colorView !== 0) {
+            throw new ProtocolError(
+              "render pass uses a non-surface color view",
+              index
+            );
+          }
+          renderPasses++;
+          if (renderPasses > MAX_RENDER_PASSES_PER_BATCH) {
+            throw new ProtocolError("too many render passes", index);
+          }
+          if (command.depthView) {
+            resource(shadow, command.depthView, "textureView", index);
+          }
+          pass = true;
+          break;
+        case 13:
+          if (!pass) {
+            throw new ProtocolError("pipeline set outside render pass", index);
+          }
+          resource(shadow, command.id, "pipeline", index);
+          break;
+        case 14:
+          if (command.slot >= this.limits[4]) {
+            throw new ProtocolError(
+              "vertex buffer slot exceeds negotiated limits",
+              index
+            );
+          }
+          if (!pass) {
+            throw new ProtocolError(
+              "vertex buffer set outside render pass",
+              index
+            );
+          }
+          resource(shadow, command.buffer, "buffer", index);
+          break;
+        case 15:
+          if (!pass) {
+            throw new ProtocolError(
+              "index buffer set outside render pass",
+              index
+            );
+          }
+          resource(shadow, command.buffer, "buffer", index);
+          break;
+        case 16:
+          if (command.bindIndex >= this.limits[3]) {
+            throw new ProtocolError(
+              "bind group index exceeds negotiated limits",
+              index
+            );
+          }
+          if (!pass) {
+            throw new ProtocolError(
+              "bind group set outside render pass",
+              index
+            );
+          }
+          resource(shadow, command.bindGroup, "bindGroup", index);
+          break;
+        case 17:
+        case 18:
+          if (!pass) {
+            throw new ProtocolError(
+              "render command outside render pass",
+              index
+            );
+          }
+          break;
+        case 19:
+        case 20:
+          if (!pass) {
+            throw new ProtocolError(
+              "render command outside render pass",
+              index
+            );
+          }
+          draws++;
+          if (draws > MAX_DRAWS_PER_BATCH) {
+            throw new ProtocolError("too many draw commands", index);
+          }
+          break;
+        case 21:
+          if (!pass) {
+            throw new ProtocolError("render pass is not active", index);
+          }
+          pass = false;
+          break;
+        case 22:
+          if (pass) {
+            throw new ProtocolError("buffer copy inside render pass", index);
+          }
+          resource(shadow, command.source, "buffer", index);
+          resource(shadow, command.destination, "buffer", index);
+          break;
+        case 23:
+          resource(shadow, command.texture, "texture", index);
+          command.resourceEntry = createBoundedResource(
+            shadow,
+            slots,
+            stats,
+            creations,
+            command.id,
+            "textureView",
+            command,
+            index
+          );
+          break;
+      }
+    }
+    if (pass) {
+      throw new ProtocolError("render pass was not ended");
+    }
+    return { commands, shadow, slots };
+  }
+
+  // Execution mirrors the validated opcode set and commits it transactionally.
+  // eslint-disable-next-line complexity
+  async execute(bytes) {
+    if (this.stopped) {
+      return;
+    }
+    let batch;
+    let validated;
+    try {
+      batch = parseCommands(bytes);
+    } catch (error) {
+      throw new Error(`malformed GPU batch: ${error.message}`);
+    }
+    try {
+      validated = this.validate(batch);
+    } catch (error) {
+      this.emitBatchRejected(
+        error.commandIndex ?? 0xffffffff,
+        error.errorCode ?? 1,
+        batch.sequence,
+        error.message
+      );
+      return;
+    }
+    this.device.pushErrorScope("validation");
+    this.device.pushErrorScope("out-of-memory");
+    const next = new Map(this.resources);
+    let encoder = null;
+    let pass = null;
+    let surfaceView = null;
+    let surfaceTexture = null;
+    let readback = null;
+    const removed = [];
+    const shaders = [];
+    const created = [];
+    try {
+      for (const command of validated.commands) {
+        const entry = command.resourceEntry;
+        switch (command.opcode) {
+          case 1:
+            entry.value = this.device.createBuffer({
+              size: command.size,
+              usage: command.usage,
+            });
+            next.set(command.id, entry);
+            created.push(entry);
+            break;
+          case 2:
+            this.device.queue.writeBuffer(
+              resource(next, command.id, "buffer", command.index).value,
+              command.offset,
+              command.data
+            );
+            break;
+          case 3:
+            entry.value = this.device.createTexture({
+              size: [command.width, command.height, 1],
+              mipLevelCount: command.mipLevelCount,
+              sampleCount: command.sampleCount,
+              dimension: "2d",
+              format: command.format,
+              usage: command.usage,
+            });
+            next.set(command.id, entry);
+            created.push(entry);
+            break;
+          case 4:
+            this.device.queue.writeTexture(
+              {
+                texture: resource(next, command.id, "texture", command.index)
+                  .value,
+                mipLevel: command.mipLevel,
+                origin: command.origin,
+              },
+              command.data,
+              {
+                offset: 0,
+                bytesPerRow: command.bytesPerRow,
+                rowsPerImage: command.rowsPerImage,
+              },
+              command.size
+            );
+            break;
+          case 5:
+            entry.value = this.device.createSampler(command);
+            next.set(command.id, entry);
+            created.push(entry);
+            break;
+          case 6:
+            entry.value = this.device.createShaderModule({
+              code: command.source,
+            });
+            next.set(command.id, entry);
+            created.push(entry);
+            shaders.push([entry, command.id]);
+            break;
+          case 7:
+            entry.value = this.device.createBindGroupLayout({
+              entries: command.entries,
+            });
+            next.set(command.id, entry);
+            created.push(entry);
+            break;
+          case 8:
+            entry.value = this.device.createPipelineLayout({
+              bindGroupLayouts: command.layouts.map(
+                id => resource(next, id, "bindGroupLayout", command.index).value
+              ),
+            });
+            next.set(command.id, entry);
+            created.push(entry);
+            break;
+          case 9:
+            entry.value = this.device.createBindGroup({
+              layout: resource(
+                next,
+                command.layout,
+                "bindGroupLayout",
+                command.index
+              ).value,
+              entries: command.entries.map(item => ({
+                binding: item.binding,
+                resource:
+                  item.kind === 1
+                    ? {
+                        buffer: resource(
+                          next,
+                          item.resourceId,
+                          "buffer",
+                          command.index
+                        ).value,
+                        offset: item.offset,
+                        size: item.size,
+                      }
+                    : resource(
+                        next,
+                        item.resourceId,
+                        item.kind === 2 ? "sampler" : "textureView",
+                        command.index
+                      ).value,
+              })),
+            });
+            next.set(command.id, entry);
+            created.push(entry);
+            break;
+          case 10: {
+            const buffers = command.layouts.map(layout => ({
+              arrayStride: layout.arrayStride,
+              stepMode: layout.stepMode,
+              attributes: command.attributes.slice(
+                layout.firstAttribute,
+                layout.firstAttribute + layout.attributeCount
+              ),
+            }));
+            const descriptor = {
+              layout: resource(
+                next,
+                command.layout,
+                "pipelineLayout",
+                command.index
+              ).value,
+              vertex: {
+                module: resource(next, command.shader, "shader", command.index)
+                  .value,
+                entryPoint: "vs_main",
+                buffers,
+              },
+              fragment: {
+                module: resource(next, command.shader, "shader", command.index)
+                  .value,
+                entryPoint: "fs_main",
+                targets: command.targets,
+              },
+              primitive: {
+                topology: command.topology,
+                frontFace: command.frontFace,
+                cullMode: command.cullMode,
+                stripIndexFormat: command.stripIndexFormat,
+              },
+              multisample: { count: command.sampleCount },
+            };
+            if (command.depthFormatId) {
+              descriptor.depthStencil = {
+                format: mapped(formats, command.depthFormatId, "depth format"),
+                depthWriteEnabled: Boolean(command.flags & 1),
+                depthCompare: command.depthCompare,
+              };
+            }
+            entry.value = this.device.createRenderPipeline(descriptor);
+            next.set(command.id, entry);
+            created.push(entry);
+            break;
+          }
+          case 11: {
+            const removedEntry = resource(
+              next,
+              command.id,
+              null,
+              command.index
+            );
+            removed.push(removedEntry);
+            next.delete(command.id);
+            break;
+          }
+          case 12: {
+            encoder ||= this.device.createCommandEncoder();
+            const colorAttachment = {
+              view: (surfaceView ??= (surfaceTexture ??=
+                this.context.getCurrentTexture()).createView()),
+              loadOp: command.flags & 1 ? "load" : "clear",
+              storeOp: command.flags & 2 ? "store" : "discard",
+              clearValue: command.clearColor,
+            };
+            const descriptor = { colorAttachments: [colorAttachment] };
+            if (command.depthView) {
+              descriptor.depthStencilAttachment = {
+                view: resource(
+                  next,
+                  command.depthView,
+                  "textureView",
+                  command.index
+                ).value,
+                depthLoadOp: command.flags & 4 ? "load" : "clear",
+                depthStoreOp: command.flags & 8 ? "store" : "discard",
+                depthClearValue: command.clearDepth,
+              };
+            }
+            pass = encoder.beginRenderPass(descriptor);
+            break;
+          }
+          case 13:
+            pass.setPipeline(
+              resource(next, command.id, "pipeline", command.index).value
+            );
+            break;
+          case 14:
+            pass.setVertexBuffer(
+              command.slot,
+              resource(next, command.buffer, "buffer", command.index).value,
+              command.offset,
+              command.size
+            );
+            break;
+          case 15:
+            pass.setIndexBuffer(
+              resource(next, command.buffer, "buffer", command.index).value,
+              command.format,
+              command.offset,
+              command.size
+            );
+            break;
+          case 16:
+            pass.setBindGroup(
+              command.bindIndex,
+              resource(next, command.bindGroup, "bindGroup", command.index)
+                .value,
+              command.dynamicOffsets
+            );
+            break;
+          case 17:
+            pass.setViewport(...command.values);
+            break;
+          case 18:
+            pass.setScissorRect(...command.values);
+            break;
+          case 19:
+            pass.draw(...command.values);
+            break;
+          case 20:
+            pass.drawIndexed(...command.values);
+            break;
+          case 21:
+            pass.end();
+            pass = null;
+            break;
+          case 22:
+            encoder ||= this.device.createCommandEncoder();
+            encoder.copyBufferToBuffer(
+              resource(next, command.source, "buffer", command.index).value,
+              command.sourceOffset,
+              resource(next, command.destination, "buffer", command.index)
+                .value,
+              command.destinationOffset,
+              command.size
+            );
+            break;
+          case 23:
+            entry.value = resource(
+              next,
+              command.texture,
+              "texture",
+              command.index
+            ).value.createView({
+              format: command.format,
+              dimension: "2d",
+              aspect: command.aspect,
+              baseMipLevel: command.baseMipLevel,
+              mipLevelCount: command.mipLevelCount,
+              baseArrayLayer: command.baseArrayLayer,
+              arrayLayerCount: command.arrayLayerCount,
+            });
+            next.set(command.id, entry);
+            created.push(entry);
+            break;
+        }
+      }
+      if (encoder && surfaceTexture && this.testReadbacksRemaining > 0) {
+        readback = this.device.createBuffer({
+          size: 3 * 256,
+          usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+        });
+        const sampleLocations = [
+          [this.physicalWidth >> 1, this.physicalHeight >> 1],
+          [
+            Math.min(8, this.physicalWidth - 1),
+            Math.min(8, this.physicalHeight - 1),
+          ],
+          [Math.max(0, this.physicalWidth - 20), this.physicalHeight >> 1],
+        ];
+        for (const [index, [x, y]] of sampleLocations.entries()) {
+          encoder.copyTextureToBuffer(
+            { texture: surfaceTexture, origin: { x, y } },
+            {
+              buffer: readback,
+              offset: index * 256,
+              bytesPerRow: 256,
+              rowsPerImage: 1,
+            },
+            { width: 1, height: 1, depthOrArrayLayers: 1 }
+          );
+        }
+      }
+      if (encoder) {
+        this.device.queue.submit([encoder.finish()]);
+      }
+    } catch (error) {
+      created.forEach(entry => entry.value?.destroy?.());
+      readback?.destroy();
+      void this.device.popErrorScope();
+      void this.device.popErrorScope();
+      throw error;
+    }
+    const outOfMemory = await this.device.popErrorScope();
+    const validation = await this.device.popErrorScope();
+    const gpuError = outOfMemory || validation;
+    if (gpuError) {
+      readback?.destroy();
+      created.forEach(entry => entry.value?.destroy?.());
+      this.emitBatchRejected(
+        0xffffffff,
+        outOfMemory ? 2 : 1,
+        batch.sequence,
+        gpuError.message
+      );
+      return;
+    }
+    this.resources = next;
+    this.handleSlots = validated.slots;
+    this.lastSequence = batch.sequence;
+    removed.forEach(entry => entry.value?.destroy?.());
+    shaders.forEach(([entry, handle]) =>
+      this.watchShader(entry, handle, batch.sequence)
+    );
+    await this.device.queue.onSubmittedWorkDone();
+    if (readback) {
+      await readback.mapAsync(GPUMapMode.READ);
+      const readbackBytes = new Uint8Array(readback.getMappedRange());
+      const samples = [0, 256, 512].map(offset =>
+        Array.from(readbackBytes.subarray(offset, offset + 4))
+      );
+      readback.unmap();
+      readback.destroy();
+      this.testReadbacksRemaining--;
+      postMessage({ type: "test-readback", samples });
+    }
+    postBytes("event", makeEvent(5, batch.sequence));
+    postMessage({ type: "presented", sequence: batch.sequence });
+    if (this.testDeviceLossPending && surfaceTexture) {
+      this.testDeviceLossPending = false;
+      this.device.destroy();
+    }
+  }
+
+  async watchShader(entry, handle, sequence) {
+    try {
+      const info = await entry.value.getCompilationInfo();
+      for (const message of info.messages) {
+        let severity = 3;
+        if (message.type === "error") {
+          severity = 1;
+        } else if (message.type === "warning") {
+          severity = 2;
+        }
+        const text = diagnosticBytes(message.message || "shader diagnostic");
+        const payload = new Uint8Array(32 + align4(text.bytes.byteLength));
+        const view = new DataView(payload.buffer);
+        view.setUint32(0, handle, true);
+        view.setUint16(4, severity, true);
+        view.setUint16(6, text.truncated ? 1 : 0, true);
+        view.setUint32(8, message.lineNum || 0, true);
+        view.setUint32(12, message.linePos || 0, true);
+        view.setUint32(16, message.offset || 0, true);
+        view.setUint32(20, message.length || 0, true);
+        view.setUint32(24, text.bytes.byteLength, true);
+        payload.set(text.bytes, 32);
+        postBytes("event", makeEvent(2, sequence, payload));
+        if (severity === 1) {
+          entry.failed = true;
+        }
+      }
+    } catch {}
+  }
+
+  emitBatchRejected(commandIndex, errorCode, sequence, message) {
+    const diagnostic = diagnosticBytes(
+      `surface_generation=${this.surfaceGeneration} ` +
+        `physical=${this.physicalWidth}x${this.physicalHeight} ` +
+        `logical=${this.logicalWidth}x${this.logicalHeight} ` +
+        `scale=${this.scale} last_sequence=${this.lastSequence}: ${message}`
+    );
+    const payload = new Uint8Array(16 + align4(diagnostic.bytes.byteLength));
+    const view = new DataView(payload.buffer);
+    view.setUint32(0, commandIndex, true);
+    view.setUint32(4, errorCode, true);
+    view.setUint32(8, diagnostic.bytes.byteLength, true);
+    view.setUint32(12, diagnostic.truncated ? 1 : 0, true);
+    payload.set(diagnostic.bytes, 16);
+    postBytes("event", makeEvent(1, sequence, payload));
+  }
+
+  emitTextEvent(type, sequence, errorCode, message) {
+    const text = diagnosticBytes(message);
+    const payload = new Uint8Array(12 + align4(text.bytes.byteLength));
+    const view = new DataView(payload.buffer);
+    view.setUint32(0, errorCode, true);
+    view.setUint32(4, text.bytes.byteLength, true);
+    view.setUint32(8, text.truncated ? 1 : 0, true);
+    payload.set(text.bytes, 12);
+    postBytes("event", makeEvent(type, sequence, payload));
+  }
+
+  reset() {
+    this.queue = this.queue
+      .then(() => {
+        if (this.stopped) {
+          return;
+        }
+        for (const entry of this.resources.values()) {
+          entry.value?.destroy?.();
+        }
+        this.resources.clear();
+        this.handleSlots.clear();
+        this.pendingResize = null;
+        this.lastSequence = 0;
+      })
+      .catch(error => {
+        postMessage({ type: "error", message: error.message || String(error) });
+        this.stopped = true;
+      });
+  }
+
+  stop() {
+    this.stopped = true;
+    for (const entry of this.resources.values()) {
+      entry.value?.destroy?.();
+    }
+    this.pendingResize = null;
+    this.resources.clear();
+    this.handleSlots.clear();
+    this.device.destroy();
+  }
+}
+
+function align4(value) {
+  return (value + 3) & ~3;
+}
+
+function diagnosticBytes(message) {
+  const encoded = textEncoder.encode(String(message));
+  if (encoded.byteLength <= MAX_DIAGNOSTIC_BYTES) {
+    return { bytes: encoded, truncated: false };
+  }
+  let end = MAX_DIAGNOSTIC_BYTES;
+  while (end > 0) {
+    try {
+      textDecoder.decode(encoded.subarray(0, end));
+      break;
+    } catch {
+      end--;
+    }
+  }
+  return { bytes: encoded.slice(0, end), truncated: true };
+}
+
+function makeEvent(type, sequence, payload = new Uint8Array()) {
+  const bytes = new Uint8Array(EVENT_HEADER_BYTES + payload.byteLength);
+  const view = new DataView(bytes.buffer);
+  bytes.set(textEncoder.encode("EGE1"), 0);
+  view.setUint16(4, WIRE_VERSION, true);
+  view.setUint16(6, type, true);
+  view.setUint32(8, bytes.byteLength, true);
+  view.setBigUint64(16, BigInt(sequence), true);
+  bytes.set(payload, EVENT_HEADER_BYTES);
+  return bytes;
+}
+
+function postBytes(type, bytes) {
+  postMessage({ type, bytes }, [bytes.buffer]);
+}
+
+let engine = null;
+
+onmessage = event => {
+  const message = event.data;
+  if (message?.type === "init" && !engine) {
+    void GpuEngine.create(
+      message.canvas,
+      message.requirements || {},
+      message.dimensions,
+      message.testReadback === true,
+      message.testDeviceLoss === true
+    )
+      .then(created => {
+        engine = created;
+        postBytes("capabilities", engine.capabilities());
+      })
+      .catch(error =>
+        postMessage({ type: "error", message: error.message || String(error) })
+      );
+  } else if (message?.type === "batch" && engine) {
+    engine.submit(new Uint8Array(message.bytes));
+  } else if (message?.type === "resize" && engine) {
+    engine.scheduleResize(message.dimensions);
+  } else if (message?.type === "reset" && engine) {
+    engine.reset();
+  } else if (message?.type === "stop" && engine) {
+    engine.stop();
+    engine = null;
+  }
+};
diff --git a/js/packages/pvm-browser-runtime/src/pvm-runtime-core.js b/js/packages/pvm-browser-runtime/src/pvm-runtime-core.js
new file mode 100644
index 000000000..8597b6360
--- /dev/null
+++ b/js/packages/pvm-browser-runtime/src/pvm-runtime-core.js
@@ -0,0 +1,406 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+/** Creates the bounded PolkaVM endpoint in a Worker or on a host thread. */
+globalThis.createPvmRuntime = endpoint => {
+  const postMessage = (message, transfers) => {
+    if (transfers) {
+      endpoint.postMessage(message, transfers);
+    } else {
+      endpoint.postMessage(message);
+    }
+  };
+
+  const FRAME_INTERVAL_MS = 1000 / 60;
+  const MAX_GAS_PER_UPDATE = 500_000_000;
+  const MAX_TRANSLATED_LOOPS_PER_UPDATE = 50_000_000;
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+
+  let pvm;
+  let translated;
+  let backend = "interpreter";
+  let running = false;
+  let timer;
+  let startedAt = 0;
+  let updateCount = 0;
+  const updateSamples = [];
+  const tickChannel = new MessageChannel();
+  tickChannel.port1.onmessage = tick;
+
+  function errorText() {
+    const pointer = pvm.pvm_browser_error_pointer();
+    const length = pvm.pvm_browser_error_length();
+    return decoder.decode(new Uint8Array(pvm.memory.buffer, pointer, length));
+  }
+
+  function check(status, operation) {
+    if (status !== 0) {
+      throw new Error(`${operation}: ${errorText()}`);
+    }
+  }
+
+  function stage(bytes) {
+    const source =
+      bytes instanceof Uint8Array
+        ? bytes
+        : new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const pointer = pvm.pvm_browser_staging_reserve(source.byteLength);
+    if (!pointer) {
+      throw new Error(`reserve browser runtime memory: ${errorText()}`);
+    }
+    new Uint8Array(pvm.memory.buffer, pointer, source.byteLength).set(source);
+  }
+
+  function addAsset(asset) {
+    const path = encoder.encode(asset.path.replace(/^\/+/, ""));
+    const bytes = new Uint8Array(asset.bytes);
+    const packed = new Uint8Array(path.byteLength + bytes.byteLength);
+    packed.set(path);
+    packed.set(bytes, path.byteLength);
+    stage(packed);
+    check(
+      pvm.pvm_browser_launch_add_asset(path.byteLength),
+      `mount browser asset ${asset.path}`,
+    );
+  }
+
+  function drainFrame() {
+    if (!pvm.pvm_browser_take_frame()) {
+      return;
+    }
+    const width = pvm.pvm_browser_frame_width();
+    const height = pvm.pvm_browser_frame_height();
+    const length = pvm.pvm_browser_frame_length();
+    const source = new Uint8Array(
+      pvm.memory.buffer,
+      pvm.pvm_browser_frame_pointer(),
+      length,
+    );
+    const pixels = new Uint8Array(length);
+    for (let index = 0; index < length; index += 4) {
+      pixels[index] = source[index + 2];
+      pixels[index + 1] = source[index + 1];
+      pixels[index + 2] = source[index];
+      pixels[index + 3] = source[index + 3];
+    }
+    postMessage({ type: "frame", width, height, pixels }, [pixels.buffer]);
+  }
+
+  function drainTri2d() {
+    if (!pvm.pvm_browser_take_tri2d?.()) {
+      return;
+    }
+    const length = pvm.pvm_browser_tri2d_length();
+    const bytes = new Uint8Array(
+      pvm.memory.buffer,
+      pvm.pvm_browser_tri2d_pointer(),
+      length,
+    ).slice();
+    postMessage({ type: "tri2d", bytes }, [bytes.buffer]);
+  }
+
+  function drainGpuBatches() {
+    while (pvm.pvm_browser_take_gpu_batch?.()) {
+      const length = pvm.pvm_browser_gpu_batch_length();
+      const bytes = new Uint8Array(
+        pvm.memory.buffer,
+        pvm.pvm_browser_gpu_batch_pointer(),
+        length,
+      ).slice();
+      postMessage({ type: "gpu-batch", bytes }, [bytes.buffer]);
+    }
+  }
+
+  function drainAudio() {
+    while (pvm.pvm_browser_take_audio()) {
+      const sampleRate = pvm.pvm_browser_audio_sample_rate();
+      const channels = pvm.pvm_browser_audio_channels();
+      const length = pvm.pvm_browser_audio_length() * 2;
+      const samples = new Uint8Array(
+        pvm.memory.buffer,
+        pvm.pvm_browser_audio_pointer(),
+        length,
+      ).slice();
+      postMessage({ type: "audio", sampleRate, channels, samples }, [
+        samples.buffer,
+      ]);
+    }
+  }
+
+  function drainSave() {
+    while (pvm.pvm_browser_take_save()) {
+      const length = pvm.pvm_browser_save_length();
+      const bytes = new Uint8Array(
+        pvm.memory.buffer,
+        pvm.pvm_browser_save_pointer(),
+        length,
+      ).slice();
+      postMessage({ type: "save", bytes }, [bytes.buffer]);
+    }
+  }
+
+  function drainLogs() {
+    while (pvm.pvm_browser_take_log()) {
+      const pointer = pvm.pvm_browser_log_pointer();
+      const length = pvm.pvm_browser_log_length();
+      const message = decoder.decode(
+        new Uint8Array(pvm.memory.buffer, pointer, length),
+      );
+      postMessage({ type: "log", message });
+    }
+  }
+
+  function tick() {
+    if (!running) {
+      return;
+    }
+    const before = performance.now();
+    try {
+      if (translated) {
+        translated.update(before - startedAt);
+      } else {
+        check(
+          pvm.pvm_browser_update(before - startedAt),
+          "update PolkaVM browser guest",
+        );
+        drainFrame();
+        drainTri2d();
+        drainGpuBatches();
+        drainAudio();
+        drainSave();
+        drainLogs();
+      }
+    } catch (error) {
+      running = false;
+      postMessage({ type: "error", message: error.message });
+      postMessage({ type: "terminated" });
+      return;
+    }
+    const elapsed = performance.now() - before;
+    updateCount++;
+    updateSamples.push(elapsed);
+    if (updateSamples.length > 600) {
+      updateSamples.shift();
+    }
+    if (updateCount % 120 === 0) {
+      const sorted = [...updateSamples].sort((a, b) => a - b);
+      const percentile = (value) =>
+        sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * value))];
+      postMessage({
+        type: "metrics",
+        updates: updateCount,
+        updateP50Ms: percentile(0.5),
+        updateP95Ms: percentile(0.95),
+        updateMaxMs: sorted[sorted.length - 1],
+      });
+    }
+    const delay = FRAME_INTERVAL_MS - elapsed;
+    if (delay > 0) {
+      timer = setTimeout(tick, delay);
+    } else {
+      tickChannel.port2.postMessage(null);
+    }
+  }
+
+  async function start(message) {
+    if (pvm || running) {
+      throw new Error("PolkaVM browser worker is already started");
+    }
+    const bootStarted = performance.now();
+    let translationMs = 0;
+    let compilationMs = 0;
+    let translatedWasmBytes = 0;
+    let cacheHit = false;
+    const instantiated = await WebAssembly.instantiate(message.runtime, {});
+    pvm = instantiated.instance.exports;
+    if (pvm.pvm_browser_abi_version() !== 1) {
+      throw new Error("PolkaVM browser runtime has an incompatible ABI");
+    }
+    const program = new Uint8Array(message.program);
+    stage(program);
+    const pendingOutputs = [];
+    try {
+      let module = message.compiledModule;
+      let bytes =
+        message.compiledBytes instanceof ArrayBuffer
+          ? new Uint8Array(message.compiledBytes)
+          : null;
+      cacheHit = module instanceof WebAssembly.Module || bytes !== null;
+      if (!(module instanceof WebAssembly.Module)) {
+        if (bytes === null) {
+          const translationStarted = performance.now();
+          check(
+            pvm.pvm_browser_translate_staged(),
+            "translate PolkaVM browser guest",
+          );
+          translationMs = performance.now() - translationStarted;
+          const pointer = pvm.pvm_browser_translation_pointer();
+          const length = pvm.pvm_browser_translation_length();
+          bytes = new Uint8Array(pvm.memory.buffer, pointer, length).slice();
+          const persistent = bytes.slice();
+          postMessage(
+            { type: "translated", cacheKey: message.cacheKey, bytes: persistent },
+            [persistent.buffer],
+          );
+        }
+        translatedWasmBytes = bytes.byteLength;
+        const compilationStarted = performance.now();
+        module = await WebAssembly.compile(bytes);
+        compilationMs = performance.now() - compilationStarted;
+        try {
+          postMessage({ type: "compiled", cacheKey: message.cacheKey, module });
+        } catch {}
+      }
+      translated = new globalThis.TranslatedPvmRuntime(
+        module,
+        message.assets,
+        (output, transfers = []) => {
+          if (running) {
+            postMessage(output, transfers);
+          } else {
+            pendingOutputs.push({ output, transfers });
+          }
+        },
+        MAX_TRANSLATED_LOOPS_PER_UPDATE,
+        message.audioEnabled,
+        message.gpuCapabilities instanceof ArrayBuffer
+          ? new Uint8Array(message.gpuCapabilities)
+          : null,
+      );
+      translated.initialize();
+      backend = "compiler";
+    } catch (error) {
+      translated = null;
+      pendingOutputs.length = 0;
+      console.warn(`PolkaVM translation failed; using interpreter: ${error}`);
+      const presentation =
+        message.graphicsProfile === "tri2d"
+          ? 1
+          : message.graphicsProfile === "webgpu-raster"
+            ? 2
+            : 0;
+      const begin = pvm.pvm_browser_launch_begin_v2;
+      if (typeof begin !== "function") {
+        throw new Error("PolkaVM interpreter does not support graphics profiles");
+      }
+      stage(program);
+      check(
+        begin(
+          MAX_GAS_PER_UPDATE,
+          message.audioEnabled ? 1 : 0,
+          presentation,
+        ),
+        "begin PolkaVM browser launch",
+      );
+      for (const asset of message.assets) {
+        addAsset(asset);
+      }
+      check(pvm.pvm_browser_launch_start(), "start PolkaVM browser launch");
+      if (message.graphicsProfile === "webgpu-raster") {
+        if (!(message.gpuCapabilities instanceof ArrayBuffer)) {
+          throw new Error("WebGPU capabilities are required before PVM initialization");
+        }
+        stage(new Uint8Array(message.gpuCapabilities));
+        check(
+          pvm.pvm_browser_set_gpu_capabilities(),
+          "set PolkaVM browser GPU capabilities",
+        );
+      }
+      try {
+        check(pvm.pvm_browser_init(), "initialize PolkaVM browser guest");
+      } catch (initError) {
+        drainLogs();
+        throw initError;
+      }
+      drainTri2d();
+      drainGpuBatches();
+      drainLogs();
+    }
+    startedAt = performance.now();
+    running = true;
+    postMessage({
+      type: "ready",
+      backend,
+      cacheHit,
+      translationMs,
+      compilationMs,
+      translatedWasmBytes,
+      startupMs: performance.now() - bootStarted,
+    });
+    for (const { output, transfers } of pendingOutputs) {
+      postMessage(output, transfers);
+    }
+    tick();
+  }
+
+  function sendInput(bytes) {
+    if (!running || bytes.byteLength !== 8) {
+      return;
+    }
+    if (translated) {
+      translated.sendInput(bytes);
+      return;
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    check(
+      pvm.pvm_browser_send_input(
+        bytes[0],
+        bytes[1],
+        view.getUint16(2, true),
+        view.getUint16(4, true),
+      ),
+      "send PolkaVM browser input",
+    );
+  }
+
+  function sendGpuEvent(bytes) {
+    if (!running || !pvm || !bytes.byteLength) {
+      return;
+    }
+    if (translated) {
+      translated.sendGpuEvent(bytes);
+      return;
+    }
+    stage(bytes);
+    check(pvm.pvm_browser_send_gpu_event(), "send PolkaVM browser GPU event");
+  }
+
+  endpoint.onmessage = (event) => {
+    const message = event.data;
+    if (message?.type === "start") {
+      void start(message).catch((error) => {
+        running = false;
+        postMessage({ type: "error", message: error.message });
+        postMessage({ type: "terminated" });
+      });
+    } else if (message?.type === "input") {
+      try {
+        sendInput(new Uint8Array(message.bytes));
+      } catch (error) {
+        running = false;
+        clearTimeout(timer);
+        postMessage({ type: "error", message: error.message });
+        postMessage({ type: "terminated" });
+      }
+    } else if (message?.type === "gpu-event") {
+      try {
+        sendGpuEvent(new Uint8Array(message.bytes));
+      } catch (error) {
+        running = false;
+        clearTimeout(timer);
+        postMessage({ type: "error", message: error.message });
+        postMessage({ type: "terminated" });
+      }
+    } else if (message?.type === "stop") {
+      running = false;
+      clearTimeout(timer);
+      translated?.stop();
+      pvm?.pvm_browser_reset();
+      postMessage({ type: "terminated" });
+    }
+  };
+};
diff --git a/js/packages/pvm-browser-runtime/src/pvm-wasm-translated.js b/js/packages/pvm-browser-runtime/src/pvm-wasm-translated.js
new file mode 100644
index 000000000..e726f993f
--- /dev/null
+++ b/js/packages/pvm-browser-runtime/src/pvm-wasm-translated.js
@@ -0,0 +1,1165 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+(() => {
+  const STATUS_FINISHED = -1;
+  const STATUS_ECALL = -2;
+  const STATUS_TRAP = -3;
+  const STATUS_OUT_OF_GAS = -4;
+  const INPUT_EVENT_BYTES = 8;
+  const MAX_INPUT_EVENTS = 4096;
+  const MAX_HOSTCALLS_PER_INIT = 1024 * 1024;
+  const MAX_HOSTCALLS_PER_UPDATE = 8192;
+  const MAX_HOSTCALL_BYTES = 32 * 1024 * 1024;
+  const MAX_LOG_BYTES = 4 * 1024;
+  const MAX_SAVE_BYTES = 1024 * 1024;
+  const MAX_AUDIO_SAMPLES = 48000 * 2;
+  const MAX_FRAME_BYTES = 16 * 1024 * 1024;
+  const MAX_TRI2D_BYTES = 8 * 1024 * 1024;
+  const MAX_GPU_BATCH_BYTES = 4 * 1024 * 1024;
+  const MAX_GPU_EVENT_BYTES = 64 * 1024;
+  const MAX_GPU_EVENTS = 256;
+  const MAX_GPU_SUBMITS_PER_UPDATE = 8;
+  const MAX_GPU_COMMANDS = 16_384;
+  const GPU_ERROR_MALFORMED_BATCH = -2;
+  const GPU_ERROR_QUOTA_EXCEEDED = -3;
+  const GPU_ERROR_INVALID_STATE = -5;
+  const IOV_MAX = 1024n;
+  const AT_FDCWD = BigInt.asUintN(64, -100n);
+  const ENOSYS = 38;
+  const EFAULT = 14;
+  const ENOENT = 2;
+  const EBADF = 9;
+  const EACCES = 13;
+  const EINVAL = 22;
+  const SYS_OPENAT = 56n;
+  const SYS_CLOSE = 57n;
+  const SYS_LSEEK = 62n;
+  const SYS_READ = 63n;
+  const SYS_READV = 65n;
+  const SYS_WRITEV = 66n;
+  const SYS_EXIT = 93n;
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+
+  function readMetadata(module) {
+    const sections = WebAssembly.Module.customSections(
+      module,
+      "epoca.pvm.meta",
+    );
+    if (sections.length !== 1) {
+      throw new Error("translated PolkaVM module has invalid metadata");
+    }
+    const bytes = new Uint8Array(sections[0]);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let offset = 0;
+    const requireBytes = (length) => {
+      if (offset + length > bytes.byteLength) {
+        throw new Error("translated PolkaVM metadata is truncated");
+      }
+    };
+    const readU16 = () => {
+      requireBytes(2);
+      const value = view.getUint16(offset, true);
+      offset += 2;
+      return value;
+    };
+    const readU32 = () => {
+      requireBytes(4);
+      const value = view.getUint32(offset, true);
+      offset += 4;
+      return value;
+    };
+    const readString = (length) => {
+      requireBytes(length);
+      const value = decoder.decode(bytes.subarray(offset, offset + length));
+      offset += length;
+      return value;
+    };
+    requireBytes(4);
+    if (decoder.decode(bytes.subarray(0, 4)) !== "EPM2") {
+      throw new Error("translated PolkaVM metadata has an incompatible ABI");
+    }
+    offset = 4;
+    const is64Bit = readU32() !== 0;
+    const names = [
+      "roAddress",
+      "roSize",
+      "roPhysical",
+      "rwAddress",
+      "rwSize",
+      "rwPhysical",
+      "heapBase",
+      "heapLimit",
+      "stackLow",
+      "stackHigh",
+      "stackPhysical",
+    ];
+    const layout = {};
+    for (const name of names) {
+      layout[name] = readU32();
+    }
+    const imports = [];
+    const importCount = readU32();
+    for (let index = 0; index < importCount; index++) {
+      const length = readU16();
+      imports.push(length ? readString(length) : null);
+    }
+    const exports = new Map();
+    const exportCount = readU32();
+    for (let index = 0; index < exportCount; index++) {
+      const name = readString(readU16());
+      const block = readU32();
+      if (!name || exports.has(name)) {
+        throw new Error("translated PolkaVM metadata has invalid exports");
+      }
+      exports.set(name, block);
+    }
+    if (offset !== bytes.byteLength) {
+      throw new Error("translated PolkaVM metadata has trailing data");
+    }
+    return { is64Bit, layout, imports, exports };
+  }
+
+  function errno(code) {
+    return BigInt.asUintN(64, -BigInt(code));
+  }
+
+  function normalizedPath(path) {
+    while (path.startsWith("./")) {
+      path = path.slice(2);
+    }
+    return path.replace(/^\/+/, "");
+  }
+
+  function signedByte(value) {
+    return value > 127 ? value - 256 : value;
+  }
+
+  function hidToCoreVm(code) {
+    if (code >= 0x04 && code <= 0x1d) {
+      return 0x61 + code - 0x04;
+    }
+    if (code >= 0x1e && code <= 0x26) {
+      return 0x31 + code - 0x1e;
+    }
+    const keys = new Map([
+      [0x27, 0x30],
+      [0x28, 0x0a],
+      [0x58, 0x0a],
+      [0x29, 0x1b],
+      [0x2a, 0x08],
+      [0x2b, 0x09],
+      [0x2c, 0x20],
+      [0x2d, 0x2d],
+      [0x56, 0x2d],
+      [0x2e, 0x3d],
+      [0x2f, 0x5b],
+      [0x30, 0x5d],
+      [0x31, 0x5c],
+      [0x33, 0x3b],
+      [0x34, 0x27],
+      [0x35, 0x60],
+      [0x36, 0x2c],
+      [0x37, 0x2e],
+      [0x63, 0x2e],
+      [0x38, 0x2f],
+      [0x54, 0x2f],
+      [0x46, 0x91],
+      [0x47, 0x92],
+      [0x48, 0x93],
+      [0x49, 0x94],
+      [0x4a, 0x96],
+      [0x4b, 0x98],
+      [0x4c, 0x95],
+      [0x4d, 0x97],
+      [0x4e, 0x99],
+      [0x4f, 0x82],
+      [0x50, 0x83],
+      [0x51, 0x81],
+      [0x52, 0x80],
+      [0x55, 0x2a],
+      [0x57, 0x2b],
+      [0x59, 0x97],
+      [0x5a, 0x81],
+      [0x5b, 0x99],
+      [0x5c, 0x83],
+      [0x5d, 0x35],
+      [0x5e, 0x82],
+      [0x5f, 0x96],
+      [0x60, 0x80],
+      [0x61, 0x98],
+      [0x62, 0x2e],
+      [0xe0, 0x9c],
+      [0xe1, 0x9a],
+      [0xe2, 0x9e],
+      [0xe4, 0x9d],
+      [0xe5, 0x9b],
+      [0xe6, 0x9f],
+    ]);
+    if (code >= 0x3a && code <= 0x45) {
+      return 0x84 + code - 0x3a;
+    }
+    return keys.get(code);
+  }
+
+  class TranslatedPvmRuntime {
+    constructor(module, assets, emit, maxGas, audioEnabled, gpuCapabilities = null) {
+      this.metadata = readMetadata(module);
+      this.instance = new WebAssembly.Instance(module, {});
+      this.pvm = this.instance.exports;
+      this.memories = [
+        this.pvm.memory_ro,
+        this.pvm.memory_rw,
+        this.pvm.memory_stack,
+      ];
+      if (
+        this.memories.some((memory) => !(memory instanceof WebAssembly.Memory))
+      ) {
+        throw new Error("translated PolkaVM module is missing guest memories");
+      }
+      this.assets = new Map(
+        assets.map((asset) => [
+          normalizedPath(asset.path),
+          new Uint8Array(asset.bytes),
+        ]),
+      );
+      this.emit = emit;
+      this.audioEnabled = audioEnabled;
+      this.gpuCapabilities =
+        gpuCapabilities instanceof Uint8Array ? gpuCapabilities.slice() : null;
+      this.gpuEvents = [];
+      this.gpuSubmits = 0;
+      this.gpuLastSequence = 0n;
+      this.maxGas = BigInt(maxGas);
+      this.input = [];
+      this.coreInput = [];
+      this.pointer = null;
+      this.timeMs = null;
+      this.clockStartedAt = performance.now();
+      this.hostcalls = 0;
+      this.hostcallBytes = 0;
+      this.resumePending = false;
+      this.stopped = false;
+      this.coreVm = this.metadata.exports.has("_pvm_start");
+      this.coreVmStarted = false;
+      this.palette = new Uint32Array(256);
+      this.palette.fill(0xffffffff);
+      this.audioChannels = 0;
+      this.audioSampleRate = 0;
+      this.fds = new Map();
+      this.nextFd = 3;
+      this.imports = this.metadata.imports;
+      this.exports = this.metadata.exports;
+      for (let index = 0; index < 13; index++) {
+        if (!(this.pvm[`r${index}`] instanceof WebAssembly.Global)) {
+          throw new Error("translated PolkaVM module is missing registers");
+        }
+      }
+    }
+
+    initialize() {
+      this.#resetBudget(MAX_HOSTCALLS_PER_INIT);
+      if (this.coreVm) {
+        this.#setupCoreVm();
+        return;
+      }
+      const init = this.exports.get("init");
+      if (init !== undefined) {
+        this.#run(init, false);
+      }
+    }
+
+    update(timeMs) {
+      if (this.stopped) {
+        return;
+      }
+      this.timeMs = timeMs;
+      this.gpuSubmits = 0;
+      this.#resetBudget(
+        this.coreVm && !this.coreVmStarted
+          ? MAX_HOSTCALLS_PER_INIT
+          : MAX_HOSTCALLS_PER_UPDATE,
+      );
+      if (this.coreVm) {
+        this.#run(this.exports.get("_pvm_start"), true);
+        this.coreVmStarted = true;
+        return;
+      }
+      const update = this.exports.get("update");
+      if (update === undefined) {
+        throw new Error("translated PolkaVM guest has no update export");
+      }
+      this.#run(update, false);
+    }
+
+    sendInput(bytes) {
+      if (this.stopped || bytes.byteLength !== INPUT_EVENT_BYTES) {
+        return;
+      }
+      if (!this.coreVm) {
+        if (this.input.length === MAX_INPUT_EVENTS) {
+          this.input.shift();
+        }
+        this.input.push(bytes.slice());
+        return;
+      }
+      const view = new DataView(
+        bytes.buffer,
+        bytes.byteOffset,
+        bytes.byteLength,
+      );
+      const type = bytes[0];
+      if (type === 1 || type === 2) {
+        const key = hidToCoreVm(bytes[1]);
+        if (key !== undefined) {
+          this.#queueCoreInput(key, type === 1 ? 1 : 0);
+        }
+      } else if (type === 3 || type === 4) {
+        const key =
+          bytes[1] >= 1 && bytes[1] <= 3 ? 0x9f + bytes[1] : undefined;
+        if (key !== undefined) {
+          this.#queueCoreInput(key, type === 3 ? 1 : 0);
+        }
+      } else if (type === 5) {
+        const current = [view.getUint16(2, true), view.getUint16(4, true)];
+        if (this.pointer) {
+          this.#queueCoreInput(
+            0xa3,
+            Math.max(-128, Math.min(127, current[0] - this.pointer[0])) & 0xff,
+          );
+          this.#queueCoreInput(
+            0xa4,
+            Math.max(-128, Math.min(127, current[1] - this.pointer[1])) & 0xff,
+          );
+        }
+        this.pointer = current;
+      } else if (type === 6) {
+        this.#queueCoreInput(
+          0xa3,
+          Math.max(-128, Math.min(127, view.getInt16(2, true))) & 0xff,
+        );
+        this.#queueCoreInput(
+          0xa4,
+          Math.max(-128, Math.min(127, view.getInt16(4, true))) & 0xff,
+        );
+      }
+    }
+
+    sendGpuEvent(bytes) {
+      if (
+        this.stopped ||
+        !(bytes instanceof Uint8Array) ||
+        bytes.byteLength < 24 ||
+        bytes.byteLength > MAX_GPU_EVENT_BYTES ||
+        decoder.decode(bytes.subarray(0, 4)) !== "EGE1"
+      ) {
+        return;
+      }
+      if (this.gpuEvents.length === MAX_GPU_EVENTS) {
+        this.gpuEvents.shift();
+      }
+      this.gpuEvents.push(bytes.slice());
+    }
+
+    stop() {
+      this.stopped = true;
+      this.input.length = 0;
+      this.coreInput.length = 0;
+      this.gpuEvents.length = 0;
+    }
+
+    #resetBudget(hostcalls) {
+      this.hostcalls = hostcalls;
+      this.hostcallBytes = MAX_HOSTCALL_BYTES;
+      this.pvm.pvm_set_gas(this.maxGas);
+    }
+
+    #run(entry, yieldOnFrame) {
+      let status;
+      if (this.resumePending) {
+        this.resumePending = false;
+        status = this.pvm.pvm_resume();
+      } else {
+        if (entry === undefined) {
+          throw new Error("translated PolkaVM entrypoint is missing");
+        }
+        status = this.pvm.pvm_begin(entry, this.maxGas);
+      }
+      for (;;) {
+        if (status === STATUS_FINISHED) {
+          if (this.coreVm) {
+            throw new Error("CoreVM guest exited");
+          }
+          return;
+        }
+        if (status === STATUS_TRAP) {
+          throw new Error(
+            `translated PolkaVM execution trapped at ${this.pvm.trap_pc.value}`,
+          );
+        }
+        if (status === STATUS_OUT_OF_GAS) {
+          throw new Error("translated PolkaVM guest ran out of gas");
+        }
+        if (status !== STATUS_ECALL) {
+          throw new Error(
+            `translated PolkaVM returned invalid status ${status}`,
+          );
+        }
+        const importIndex = this.pvm.ecall.value >>> 0;
+        const name = this.imports[importIndex];
+        if (!name) {
+          throw new Error(
+            `translated PolkaVM called unknown import ${importIndex}`,
+          );
+        }
+        this.hostcalls--;
+        const yielded = this.coreVm
+          ? this.#handleCoreVmCall(name)
+          : this.#handleCooperativeCall(name);
+        if (yielded && yieldOnFrame) {
+          this.resumePending = true;
+          return;
+        }
+        if (this.hostcalls === 0) {
+          // Resume on the next worker tick after completing this ECALL. Large
+          // assets can require more than one bounded hostcall slice, while
+          // returning here keeps each slice capped and the worker responsive.
+          this.resumePending = true;
+          return;
+        }
+        status = this.pvm.pvm_resume();
+      }
+    }
+
+    #reg(index) {
+      return BigInt.asUintN(64, this.pvm[`r${index}`].value);
+    }
+
+    #setReg(index, value) {
+      const normalized = this.metadata.is64Bit
+        ? BigInt.asIntN(64, BigInt(value))
+        : BigInt.asUintN(32, BigInt(value));
+      this.pvm[`r${index}`].value = normalized;
+    }
+
+    #u32(value) {
+      return Number(value & 0xffffffffn) >>> 0;
+    }
+
+    #range(address, length, write = false) {
+      address >>>= 0;
+      length >>>= 0;
+      const end = address + length;
+      if (end > 0x100000000) {
+        throw new Error(
+          "translated PolkaVM guest memory access is out of range",
+        );
+      }
+      const { layout } = this.metadata;
+      let memory;
+      let physical;
+      if (address >= layout.stackLow && end <= layout.stackHigh) {
+        memory = this.memories[2];
+        physical = address - layout.stackLow;
+      } else if (
+        address >= layout.rwAddress &&
+        end <= layout.rwAddress + this.memories[1].buffer.byteLength
+      ) {
+        memory = this.memories[1];
+        physical = address - layout.rwAddress;
+      } else if (
+        !write &&
+        address >= layout.roAddress &&
+        end <= layout.roAddress + layout.roSize
+      ) {
+        memory = this.memories[0];
+        physical = address - layout.roAddress;
+      } else {
+        throw new Error(
+          "translated PolkaVM guest memory access is out of range",
+        );
+      }
+      return new Uint8Array(memory.buffer, physical, length);
+    }
+
+    #read(address, length) {
+      this.#chargeBytes(length);
+      return this.#range(address, length).slice();
+    }
+
+    #write(address, bytes) {
+      this.#chargeBytes(bytes.byteLength);
+      this.#range(address, bytes.byteLength, true).set(bytes);
+    }
+
+    #chargeBytes(length) {
+      if (
+        !Number.isSafeInteger(length) ||
+        length < 0 ||
+        length > this.hostcallBytes
+      ) {
+        throw new Error(
+          "translated PolkaVM guest exceeded hostcall byte budget",
+        );
+      }
+      this.hostcallBytes -= length;
+    }
+
+    #readU64(address) {
+      const bytes = this.#range(address >>> 0, 8);
+      return new DataView(bytes.buffer, bytes.byteOffset, 8).getBigUint64(
+        0,
+        true,
+      );
+    }
+
+    #writeU64(address, value) {
+      const bytes = this.#range(address >>> 0, 8, true);
+      new DataView(bytes.buffer, bytes.byteOffset, 8).setBigUint64(
+        0,
+        BigInt.asUintN(64, value),
+        true,
+      );
+    }
+
+    #readCString(address) {
+      const output = [];
+      for (let offset = 0; offset < 255; offset++) {
+        let byte;
+        try {
+          byte = this.#range((address + offset) >>> 0, 1)[0];
+        } catch {
+          return null;
+        }
+        if (!byte) {
+          return new Uint8Array(output);
+        }
+        output.push(byte);
+      }
+      return null;
+    }
+
+    #handleCooperativeCall(name) {
+      const a0 = this.#reg(7);
+      const a1 = this.#reg(8);
+      const a2 = this.#reg(9);
+      const a3 = this.#reg(10);
+      const a4 = this.#reg(11);
+      switch (name) {
+        case "host_present_frame": {
+          const width = this.#u32(a1);
+          const height = this.#u32(a2);
+          const stride = this.#u32(a3);
+          const rowBytes = width * 4;
+          const length = rowBytes * height;
+          if (
+            !width ||
+            !height ||
+            stride !== rowBytes ||
+            length > MAX_FRAME_BYTES
+          ) {
+            this.#setReg(7, 1n);
+            return false;
+          }
+          const source = this.#read(this.#u32(a0), length);
+          const pixels = new Uint8Array(length);
+          for (let index = 0; index < length; index += 4) {
+            pixels[index] = source[index + 2];
+            pixels[index + 1] = source[index + 1];
+            pixels[index + 2] = source[index];
+            pixels[index + 3] = source[index + 3];
+          }
+          this.emit({ type: "frame", width, height, pixels }, [pixels.buffer]);
+          this.#setReg(7, 0n);
+          return false;
+        }
+        case "host_tri2d_submit": {
+          const length = this.#u32(a1);
+          if (!length || length > MAX_TRI2D_BYTES) {
+            this.#setReg(7, 1n);
+            return false;
+          }
+          const bytes = this.#read(this.#u32(a0), length);
+          this.emit({ type: "tri2d", bytes }, [bytes.buffer]);
+          this.#setReg(7, 0n);
+          return false;
+        }
+        case "epoca_gpu_capabilities": {
+          if (this.gpuCapabilities === null) {
+            this.#setReg(7, BigInt(GPU_ERROR_INVALID_STATE));
+            return false;
+          }
+          const capacity = this.#u32(a1);
+          const required = this.gpuCapabilities.byteLength;
+          if (capacity < required) {
+            this.#setReg(7, BigInt(-required));
+            return false;
+          }
+          this.#write(this.#u32(a0), this.gpuCapabilities);
+          this.#setReg(7, BigInt(required));
+          return false;
+        }
+        case "epoca_gpu_submit": {
+          const length = this.#u32(a1);
+          if (this.gpuCapabilities === null) {
+            this.#setReg(7, BigInt(GPU_ERROR_INVALID_STATE));
+            return false;
+          }
+          if (
+            !length ||
+            length > MAX_GPU_BATCH_BYTES ||
+            this.gpuSubmits === MAX_GPU_SUBMITS_PER_UPDATE
+          ) {
+            this.#setReg(
+              7,
+              BigInt(
+                this.gpuSubmits === MAX_GPU_SUBMITS_PER_UPDATE
+                  ? GPU_ERROR_QUOTA_EXCEEDED
+                  : GPU_ERROR_MALFORMED_BATCH,
+              ),
+            );
+            return false;
+          }
+          const bytes = this.#read(this.#u32(a0), length);
+          const sequence = this.#gpuBatchSequence(bytes);
+          if (sequence === null || sequence <= this.gpuLastSequence) {
+            this.#setReg(7, BigInt(GPU_ERROR_MALFORMED_BATCH));
+            return false;
+          }
+          this.gpuSubmits++;
+          this.gpuLastSequence = sequence;
+          this.emit({ type: "gpu-batch", bytes }, [bytes.buffer]);
+          this.#setReg(7, 0n);
+          return false;
+        }
+        case "epoca_gpu_receive": {
+          const event = this.gpuEvents[0];
+          if (event === undefined) {
+            this.#setReg(7, 0n);
+            return false;
+          }
+          const capacity = this.#u32(a1);
+          if (capacity < event.byteLength) {
+            this.#setReg(7, BigInt(-event.byteLength));
+            return false;
+          }
+          this.#write(this.#u32(a0), event);
+          this.gpuEvents.shift();
+          this.#setReg(7, BigInt(event.byteLength));
+          return false;
+        }
+        case "host_poll_input": {
+          const capacity = this.#u32(a1);
+          const count = Math.min(
+            Math.floor(capacity / INPUT_EVENT_BYTES),
+            this.input.length,
+          );
+          const output = new Uint8Array(count * INPUT_EVENT_BYTES);
+          for (let index = 0; index < count; index++) {
+            output.set(this.input.shift(), index * INPUT_EVENT_BYTES);
+          }
+          this.#write(this.#u32(a0), output);
+          this.#setReg(7, BigInt(output.byteLength));
+          return false;
+        }
+        case "host_time_ms": {
+          const timeMs = this.timeMs ?? performance.now() - this.clockStartedAt;
+          this.#setReg(7, BigInt(Math.max(0, Math.trunc(timeMs))));
+          return false;
+        }
+        case "host_sleep_ms":
+          this.timeMs =
+            (this.timeMs ?? performance.now() - this.clockStartedAt) +
+            Math.min(this.#u32(a0), 50);
+          return false;
+        case "host_audio_submit": {
+          if (!this.audioEnabled) {
+            this.#setReg(7, 3n);
+            return false;
+          }
+          const sampleCount = this.#u32(a1);
+          if (
+            !sampleCount ||
+            sampleCount % 2 ||
+            sampleCount > MAX_AUDIO_SAMPLES
+          ) {
+            this.#setReg(7, 1n);
+            return false;
+          }
+          const samples = this.#read(this.#u32(a0), sampleCount * 2);
+          this.emit(
+            { type: "audio", sampleRate: 48000, channels: 2, samples },
+            [samples.buffer],
+          );
+          this.#setReg(7, 0n);
+          return false;
+        }
+        case "host_asset_read": {
+          const nameLength = this.#u32(a1);
+          const offset = this.#u32(a2);
+          const destination = this.#u32(a3);
+          const capacity = this.#u32(a4);
+          if (!nameLength || nameLength > 1024) {
+            this.#setReg(7, 0n);
+            return false;
+          }
+          const assetName = decoder.decode(
+            this.#read(this.#u32(a0), nameLength),
+          );
+          const asset = this.assets.get(assetName);
+          if (!asset || offset >= asset.byteLength) {
+            this.#setReg(7, 0n);
+            return false;
+          }
+          const length = Math.min(
+            capacity,
+            asset.byteLength - offset,
+            16 * 1024 * 1024,
+          );
+          this.#write(destination, asset.subarray(offset, offset + length));
+          this.#setReg(7, BigInt(length));
+          return false;
+        }
+        case "host_save_submit": {
+          const length = this.#u32(a1);
+          if (!length || length > MAX_SAVE_BYTES) {
+            this.#setReg(7, 1n);
+            return false;
+          }
+          const bytes = this.#read(this.#u32(a0), length);
+          this.emit({ type: "save", bytes }, [bytes.buffer]);
+          this.#setReg(7, 0n);
+          return false;
+        }
+        case "host_log": {
+          const length = Math.min(this.#u32(a1), MAX_LOG_BYTES);
+          const message = decoder.decode(this.#read(this.#u32(a0), length));
+          this.emit({ type: "log", message });
+          return false;
+        }
+        default:
+          throw new Error(
+            `translated PolkaVM guest uses unsupported import ${name}`,
+          );
+      }
+    }
+
+    #gpuBatchSequence(bytes) {
+      if (
+        bytes.byteLength < 24 ||
+        decoder.decode(bytes.subarray(0, 4)) !== "EPG1"
+      ) {
+        return null;
+      }
+      const view = new DataView(
+        bytes.buffer,
+        bytes.byteOffset,
+        bytes.byteLength,
+      );
+      if (
+        view.getUint16(4, true) !== 1 ||
+        view.getUint16(6, true) !== 0 ||
+        view.getUint32(8, true) !== bytes.byteLength
+      ) {
+        return null;
+      }
+      const commandCount = view.getUint32(12, true);
+      const sequence = view.getBigUint64(16, true);
+      if (sequence === 0n || commandCount > MAX_GPU_COMMANDS) {
+        return null;
+      }
+      let offset = 24;
+      for (let index = 0; index < commandCount; index++) {
+        if (
+          offset + 8 > bytes.byteLength ||
+          view.getUint16(offset + 2, true) !== 0
+        ) {
+          return null;
+        }
+        const commandBytes = view.getUint32(offset + 4, true);
+        if (
+          commandBytes < 8 ||
+          commandBytes % 4 ||
+          commandBytes > bytes.byteLength - offset
+        ) {
+          return null;
+        }
+        offset += commandBytes;
+      }
+      return offset === bytes.byteLength ? sequence : null;
+    }
+
+    #setupCoreVm() {
+      let sp = BigInt(this.metadata.layout.stackHigh);
+      const argc = 1n;
+      sp -= (1n + argc + 1n + 0n + 1n + 4n) * 8n;
+      const addressInit = sp;
+      let pointer = sp;
+      this.#writeU64(Number(pointer), argc);
+      pointer += 8n;
+      const argument = encoder.encode("./quake\0");
+      sp -= BigInt(argument.byteLength);
+      this.#write(Number(sp), argument);
+      this.#writeU64(Number(pointer), sp);
+      pointer += 16n;
+      pointer += 8n;
+      this.#writeU64(Number(pointer), 6n);
+      this.#writeU64(Number(pointer + 8n), 4096n);
+      this.#setReg(1, sp);
+      this.#setReg(7, addressInit);
+    }
+
+    #queueCoreInput(key, value) {
+      if (!value && (key === 0xa3 || key === 0xa4)) {
+        return;
+      }
+      if (key === 0xa3 || key === 0xa4) {
+        const existing = this.coreInput.find((event) => event[0] === key);
+        if (existing) {
+          existing[1] =
+            Math.max(
+              -128,
+              Math.min(127, signedByte(existing[1]) + signedByte(value)),
+            ) & 0xff;
+          return;
+        }
+      }
+      if (this.coreInput.length === 256) {
+        this.coreInput.shift();
+      }
+      this.coreInput.push([key, value]);
+    }
+
+    #handleCoreVmCall(name) {
+      switch (name) {
+        case "pvm_set_palette": {
+          const palette = this.#read(this.#u32(this.#reg(7)), 256 * 3);
+          for (let index = 0; index < 256; index++) {
+            const offset = index * 3;
+            this.palette[index] =
+              palette[offset] |
+              (palette[offset + 1] << 8) |
+              (palette[offset + 2] << 16) |
+              0xff000000;
+          }
+          return false;
+        }
+        case "pvm_display": {
+          const width = this.#u32(this.#reg(7));
+          const height = this.#u32(this.#reg(8));
+          const length = width * height;
+          if (!width || !height || length > MAX_FRAME_BYTES / 4) {
+            throw new Error("CoreVM guest supplied invalid frame dimensions");
+          }
+          const indices = this.#read(this.#u32(this.#reg(9)), length);
+          const pixels = new Uint8Array(length * 4);
+          const rgba = new Uint32Array(pixels.buffer);
+          for (let index = 0; index < length; index++) {
+            rgba[index] = this.palette[indices[index]];
+          }
+          this.emit({ type: "frame", width, height, pixels }, [pixels.buffer]);
+          return true;
+        }
+        case "pvm_fetch_epoca_inputs":
+        case "pvm_fetch_inputs": {
+          const count = Math.min(
+            this.#u32(this.#reg(8)),
+            this.coreInput.length,
+          );
+          const output = new Uint8Array(count * 2);
+          for (let index = 0; index < count; index++) {
+            output.set(this.coreInput.shift(), index * 2);
+          }
+          this.#write(this.#u32(this.#reg(7)), output);
+          this.#setReg(7, BigInt(count));
+          return false;
+        }
+        case "pvm_asset_read": {
+          const nameLength = this.#u32(this.#reg(8));
+          const offset = this.#u32(this.#reg(9));
+          const destination = this.#u32(this.#reg(10));
+          const capacity = this.#u32(this.#reg(11));
+          if (!nameLength || nameLength > 1024) {
+            this.#setReg(7, 0n);
+            return false;
+          }
+          const assetName = decoder.decode(
+            this.#read(this.#u32(this.#reg(7)), nameLength),
+          );
+          const asset = this.assets.get(assetName);
+          if (!asset || offset >= asset.byteLength) {
+            this.#setReg(7, 0n);
+            return false;
+          }
+          const length = Math.min(
+            capacity,
+            asset.byteLength - offset,
+            16 * 1024 * 1024,
+          );
+          this.#write(destination, asset.subarray(offset, offset + length));
+          this.#setReg(7, BigInt(length));
+          return false;
+        }
+        case "host_audio_submit": {
+          if (!this.audioEnabled) {
+            this.#setReg(7, 3n);
+            return false;
+          }
+          const sampleCount = this.#u32(this.#reg(8));
+          if (
+            !sampleCount ||
+            sampleCount % 2 ||
+            sampleCount > MAX_AUDIO_SAMPLES
+          ) {
+            this.#setReg(7, 1n);
+            return false;
+          }
+          const samples = this.#read(this.#u32(this.#reg(7)), sampleCount * 2);
+          this.emit(
+            { type: "audio", sampleRate: 48000, channels: 2, samples },
+            [samples.buffer],
+          );
+          this.#setReg(7, 0n);
+          return false;
+        }
+        case "pvm_time_ms": {
+          const timeMs = this.timeMs ?? performance.now() - this.clockStartedAt;
+          this.#setReg(7, BigInt(Math.max(0, Math.trunc(timeMs))));
+          return false;
+        }
+        case "host_log": {
+          const length = Math.min(this.#u32(this.#reg(8)), MAX_LOG_BYTES);
+          const message = decoder.decode(
+            this.#read(this.#u32(this.#reg(7)), length),
+          );
+          this.emit({ type: "log", message });
+          return false;
+        }
+        case "pvm_yield":
+          return true;
+        case "pvm_init_audio": {
+          const channels = this.#u32(this.#reg(7));
+          const bitsPerSample = this.#u32(this.#reg(8));
+          const sampleRate = this.#u32(this.#reg(9));
+          if (
+            bitsPerSample !== 16 ||
+            channels < 1 ||
+            channels > 2 ||
+            sampleRate < 8000 ||
+            sampleRate > 96000
+          ) {
+            this.#setReg(7, 0n);
+          } else {
+            this.audioChannels = channels;
+            this.audioSampleRate = sampleRate;
+            this.#setReg(7, 1n);
+          }
+          return false;
+        }
+        case "pvm_output_audio": {
+          const frames = this.#u32(this.#reg(8));
+          const sampleCount = Math.min(frames * this.audioChannels, 1024 * 64);
+          if (this.audioChannels && sampleCount) {
+            const samples = this.#read(
+              this.#u32(this.#reg(7)),
+              sampleCount * 2,
+            );
+            this.emit(
+              {
+                type: "audio",
+                sampleRate: this.audioSampleRate,
+                channels: this.audioChannels,
+                samples,
+              },
+              [samples.buffer],
+            );
+          }
+          return false;
+        }
+        case "pvm_syscall":
+          return this.#handleCoreVmSyscall();
+        default:
+          throw new Error(
+            `translated CoreVM guest uses unsupported import ${name}`,
+          );
+      }
+    }
+
+    #handleCoreVmSyscall() {
+      const syscall = this.#reg(7);
+      const a1 = this.#reg(8);
+      const a2 = this.#reg(9);
+      const a3 = this.#reg(10);
+      if (syscall === SYS_READ) {
+        this.#setReg(7, this.#readFile(a1, a2, a3));
+      } else if (syscall === SYS_READV || syscall === SYS_WRITEV) {
+        if (!a3 || a3 > IOV_MAX) {
+          this.#setReg(7, errno(EINVAL));
+          return false;
+        }
+        let total = 0n;
+        for (let index = 0n; index < a3; index++) {
+          let address;
+          let length;
+          try {
+            address = this.#readU64(this.#u32(a2 + index * 16n));
+            length = this.#readU64(this.#u32(a2 + index * 16n + 8n));
+          } catch {
+            this.#setReg(7, errno(EFAULT));
+            return false;
+          }
+          const result =
+            syscall === SYS_READV
+              ? this.#readFile(a1, address, length)
+              : this.#writeFile(a1, address, length);
+          if (BigInt.asIntN(64, result) < 0n) {
+            this.#setReg(7, result);
+            return false;
+          }
+          total += length;
+        }
+        this.#setReg(7, total);
+      } else if (syscall === SYS_EXIT) {
+        if (a1 === 0n) {
+          throw new Error("CoreVM guest exited");
+        }
+        throw new Error(`CoreVM guest exited with status ${a1}`);
+      } else if (syscall === SYS_OPENAT) {
+        if (a1 !== AT_FDCWD) {
+          this.#setReg(7, errno(ENOSYS));
+          return false;
+        }
+        const pathBytes = this.#readCString(this.#u32(a2));
+        if (!pathBytes) {
+          this.#setReg(7, errno(EFAULT));
+          return false;
+        }
+        const path = normalizedPath(decoder.decode(pathBytes));
+        const flags = a3;
+        const asset = this.assets.get(path);
+        if (!asset) {
+          this.#setReg(7, errno(ENOENT));
+        } else if (flags & 3n) {
+          this.#setReg(7, errno(EACCES));
+        } else {
+          const fd = this.nextFd++;
+          this.fds.set(fd, { bytes: asset, position: 0n });
+          this.#setReg(7, BigInt(fd));
+        }
+      } else if (syscall === SYS_LSEEK) {
+        this.#setReg(7, this.#seekFile(a1, a2, a3));
+      } else if (syscall === SYS_CLOSE) {
+        const fd = this.#fdNumber(a1);
+        if (fd === null || !this.fds.delete(fd)) {
+          this.#setReg(7, errno(EBADF));
+        } else {
+          this.#setReg(7, 0n);
+        }
+      } else {
+        this.#setReg(7, errno(ENOSYS));
+      }
+      return false;
+    }
+
+    #fdNumber(value) {
+      return value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : null;
+    }
+
+    #readFile(fdValue, address, length) {
+      const fd = this.#fdNumber(fdValue);
+      const file = fd === null ? null : this.fds.get(fd);
+      if (!file) {
+        return errno(EBADF);
+      }
+      if (
+        address + length > 0x100000000n ||
+        length > BigInt(MAX_HOSTCALL_BYTES)
+      ) {
+        return errno(EFAULT);
+      }
+      const end =
+        file.position + length < BigInt(file.bytes.byteLength)
+          ? file.position + length
+          : BigInt(file.bytes.byteLength);
+      if (file.position >= end) {
+        return 0n;
+      }
+      const count = Number(end - file.position);
+      try {
+        this.#write(
+          this.#u32(address),
+          file.bytes.subarray(
+            Number(file.position),
+            Number(file.position) + count,
+          ),
+        );
+      } catch {
+        return errno(EFAULT);
+      }
+      file.position += BigInt(count);
+      return BigInt(count);
+    }
+
+    #writeFile(fdValue, address, length) {
+      if (fdValue !== 1n && fdValue !== 2n) {
+        return errno(EBADF);
+      }
+      if (
+        address + length > 0x100000000n ||
+        length > BigInt(MAX_HOSTCALL_BYTES)
+      ) {
+        return errno(EFAULT);
+      }
+      try {
+        const byteLength = Number(length);
+        this.#chargeBytes(byteLength);
+        const bytes = this.#range(this.#u32(address), byteLength);
+        const message = decoder.decode(bytes.subarray(0, MAX_LOG_BYTES));
+        if (message) {
+          this.emit({ type: "log", message });
+        }
+      } catch {
+        return errno(EFAULT);
+      }
+      return length;
+    }
+
+    #seekFile(fdValue, offsetValue, whence) {
+      const fd = this.#fdNumber(fdValue);
+      const file = fd === null ? null : this.fds.get(fd);
+      if (!file) {
+        return errno(EBADF);
+      }
+      const offset = BigInt.asIntN(64, offsetValue);
+      const fileLength = BigInt(file.bytes.byteLength);
+      if (whence === 0n) {
+        file.position = BigInt.asUintN(64, offset);
+      } else if (whence === 1n) {
+        file.position = BigInt.asUintN(
+          64,
+          BigInt.asIntN(64, file.position) + offset,
+        );
+        if (file.position > fileLength) {
+          file.position = fileLength;
+        }
+      } else if (whence === 2n) {
+        file.position = BigInt.asUintN(
+          64,
+          BigInt.asIntN(64, fileLength) + offset,
+        );
+        if (file.position > fileLength) {
+          file.position = fileLength;
+        }
+      } else {
+        return errno(EINVAL);
+      }
+      return file.position;
+    }
+  }
+
+  globalThis.TranslatedPvmRuntime = TranslatedPvmRuntime;
+})();
diff --git a/js/packages/pvm-browser-runtime/src/pvm-wasm-worker-entry.js b/js/packages/pvm-browser-runtime/src/pvm-wasm-worker-entry.js
new file mode 100644
index 000000000..00f73312a
--- /dev/null
+++ b/js/packages/pvm-browser-runtime/src/pvm-wasm-worker-entry.js
@@ -0,0 +1,7 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+globalThis.createPvmRuntime(globalThis);
diff --git a/js/packages/pvm-browser-runtime/test/artifacts.test.mjs b/js/packages/pvm-browser-runtime/test/artifacts.test.mjs
new file mode 100644
index 000000000..fed9d8829
--- /dev/null
+++ b/js/packages/pvm-browser-runtime/test/artifacts.test.mjs
@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import test from "node:test";
+
+const root = resolve(import.meta.dirname, "..");
+const dist = resolve(root, "dist");
+
+test("browser runtime artifacts match their published checksums", async () => {
+  const expected = new Map(
+    (await readFile(resolve(dist, "SHA256SUMS"), "utf8"))
+      .trim()
+      .split("\n")
+      .map((line) => {
+        const [digest, file] = line.split(/\s+/, 2);
+        return [file, digest];
+      }),
+  );
+  for (const file of [
+    "pvm-browser-runtime.wasm",
+    "pvm-worker.js",
+    "pvm-gpu-worker.js",
+    "pvm-wasm-translated.js",
+    "pvm-runtime-core.js",
+    "pvm-wasm-worker-entry.js",
+  ]) {
+    const bytes = await readFile(resolve(dist, file));
+    assert.equal(createHash("sha256").update(bytes).digest("hex"), expected.get(file));
+  }
+});
+
+test("Wasm runtime exports the neutral graphics profile ABI", async () => {
+  const bytes = await readFile(resolve(dist, "pvm-browser-runtime.wasm"));
+  const module = await WebAssembly.compile(bytes);
+  const exports = new Set(WebAssembly.Module.exports(module).map(({ name }) => name));
+  for (const name of [
+    "pvm_browser_launch_begin_v2",
+    "pvm_browser_take_tri2d",
+    "pvm_browser_set_gpu_capabilities",
+    "pvm_browser_send_gpu_event",
+    "pvm_browser_take_gpu_batch",
+  ]) {
+    assert.ok(exports.has(name), `missing ${name}`);
+  }
+});
diff --git a/package-lock.json b/package-lock.json
index 309fcde6d..7cfb23784 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,6 +16,14 @@
         "node": ">=22"
       }
     },
+    "js/packages/pvm-browser-runtime": {
+      "name": "@parity/pvm-browser-runtime",
+      "version": "0.1.0",
+      "license": "MPL-2.0",
+      "engines": {
+        "node": ">=22"
+      }
+    },
     "js/packages/truapi": {
       "name": "@parity/truapi",
       "version": "0.11.0",
@@ -428,6 +436,10 @@
         "node": ">= 8"
       }
     },
+    "node_modules/@parity/pvm-browser-runtime": {
+      "resolved": "js/packages/pvm-browser-runtime",
+      "link": true
+    },
     "node_modules/@parity/truapi": {
       "resolved": "js/packages/truapi",
       "link": true
diff --git a/package.json b/package.json
index 7996292e5..494efca41 100644
--- a/package.json
+++ b/package.json
@@ -8,12 +8,14 @@
     "node": ">=22"
   },
   "scripts": {
-    "build": "npm run build --prefix js/packages/truapi && cd playground && yarn build",
+    "build": "npm run build:pvm-browser && npm run build --prefix js/packages/truapi && cd playground && yarn build",
+    "build:pvm-browser": "npm run build --prefix js/packages/pvm-browser-runtime",
     "codegen": "./scripts/codegen.sh",
     "format": "prettier --write \"**/*.{ts,tsx,md}\"",
     "format:check": "prettier --check \"**/*.{ts,tsx,md}\"",
     "typecheck": "npm run typecheck --prefix js/packages/truapi && cd playground && npx tsc --noEmit --noUnusedLocals --noUnusedParameters",
-    "test": "cargo test --workspace && npm test --prefix js/packages/truapi",
+    "test": "cargo test --workspace && npm test --prefix js/packages/truapi && npm run test:pvm-browser",
+    "test:pvm-browser": "npm test --prefix js/packages/pvm-browser-runtime",
     "test:scripts": "node --test scripts/lib/*.test.mjs",
     "lint": "npm run format:check && npm run typecheck",
     "changeset": "changeset",
diff --git a/rust/crates/pvm-gpu-wire/Cargo.toml b/rust/crates/pvm-gpu-wire/Cargo.toml
new file mode 100644
index 000000000..895858625
--- /dev/null
+++ b/rust/crates/pvm-gpu-wire/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "pvm-gpu-wire"
+version = "0.1.0"
+edition = "2021"
+description = "Bounded host-neutral WebGPU Raster wire protocol for PolkaVM applications"
+license = "MPL-2.0"
+publish = false
+
+[lib]
+crate-type = ["rlib"]
diff --git a/rust/crates/pvm-gpu-wire/src/lib.rs b/rust/crates/pvm-gpu-wire/src/lib.rs
new file mode 100644
index 000000000..7ad01e36b
--- /dev/null
+++ b/rust/crates/pvm-gpu-wire/src/lib.rs
@@ -0,0 +1,1005 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#![no_std]
+
+use core::fmt;
+
+pub const GPU_WIRE_MAGIC: [u8; 4] = *b"EPG1";
+pub const GPU_WIRE_VERSION: u16 = 1;
+pub const GPU_BATCH_HEADER_BYTES: usize = 24;
+pub const GPU_COMMAND_HEADER_BYTES: usize = 8;
+pub const MAX_GPU_BATCH_BYTES: usize = 4 * 1024 * 1024;
+pub const MAX_GPU_COMMANDS: u32 = 16_384;
+pub const GPU_CAPABILITIES_MAGIC: [u8; 4] = *b"EGC1";
+pub const GPU_CAPABILITIES_HEADER_BYTES: usize = 56;
+pub const GPU_CAPABILITY_ENTRY_BYTES: usize = 16;
+pub const GPU_EVENT_MAGIC: [u8; 4] = *b"EGE1";
+pub const GPU_EVENT_HEADER_BYTES: usize = 24;
+pub const MAX_GPU_EVENT_BYTES: usize = 64 * 1024;
+pub const MAX_GPU_DIAGNOSTIC_BYTES: usize = 8 * 1024;
+pub const GPU_HANDLE_SLOT_BITS: u32 = 20;
+pub const GPU_HANDLE_SLOT_MASK: u32 = (1 << GPU_HANDLE_SLOT_BITS) - 1;
+pub const GPU_HANDLE_MAX_GENERATION: u32 = (1 << (32 - GPU_HANDLE_SLOT_BITS)) - 1;
+pub const MAX_GPU_SUBMITS_PER_TICK: u32 = 8;
+pub const MAX_GPU_UPLOAD_BYTES_PER_TICK: usize = 16 * 1024 * 1024;
+pub const MAX_GPU_QUEUED_BATCHES: usize = 4;
+pub const MAX_GPU_QUEUED_EVENTS: usize = 256;
+pub const MAX_GPU_BUFFERS: usize = 4_096;
+pub const MAX_GPU_BUFFER_BYTES: usize = 16 * 1024 * 1024;
+pub const MAX_GPU_TOTAL_BUFFER_BYTES: usize = 64 * 1024 * 1024;
+pub const MAX_GPU_TEXTURES: usize = 512;
+pub const MAX_GPU_TOTAL_TEXTURE_BYTES: usize = 256 * 1024 * 1024;
+pub const MAX_GPU_TEXTURE_DIMENSION_2D: u32 = 4_096;
+pub const MAX_GPU_TEXTURE_SAMPLE_COUNT: u32 = 1;
+pub const MAX_GPU_TEXTURE_MIP_LEVELS: u32 = 13;
+pub const MAX_GPU_TEXTURE_VIEWS: usize = 1_024;
+pub const MAX_GPU_SAMPLERS: usize = 128;
+pub const MAX_GPU_SHADER_MODULES: usize = 128;
+pub const MAX_GPU_WGSL_BYTES: usize = 1024 * 1024;
+pub const MAX_GPU_COMPILATIONS: usize = 8;
+pub const MAX_GPU_BIND_GROUP_LAYOUTS: usize = 128;
+pub const MAX_GPU_PIPELINE_LAYOUTS: usize = 64;
+pub const MAX_GPU_BIND_GROUPS: usize = 512;
+pub const MAX_GPU_RENDER_PIPELINES: usize = 256;
+pub const MAX_GPU_BIND_GROUPS_PER_PIPELINE: usize = 4;
+pub const MAX_GPU_BINDINGS_PER_GROUP: usize = 16;
+pub const MAX_GPU_VERTEX_BUFFERS: usize = 8;
+pub const MAX_GPU_VERTEX_ATTRIBUTES: usize = 16;
+pub const MAX_GPU_COLOR_ATTACHMENTS: usize = 4;
+pub const MAX_GPU_RENDER_PASSES_PER_BATCH: usize = 16;
+pub const MAX_GPU_DRAWS_PER_BATCH: usize = 8_192;
+
+pub const GPU_SUBMIT_ACCEPTED: i32 = 0;
+pub const GPU_SUBMIT_BUSY: i32 = 1;
+pub const GPU_ERROR_INVALID_GUEST_RANGE: i32 = -1;
+pub const GPU_ERROR_MALFORMED_BATCH: i32 = -2;
+pub const GPU_ERROR_QUOTA_EXCEEDED: i32 = -3;
+pub const GPU_ERROR_INVALID_HANDLE: i32 = -4;
+pub const GPU_ERROR_INVALID_STATE: i32 = -5;
+pub const GPU_ERROR_STOPPED: i32 = -6;
+
+pub const GPU_BATCH_ERROR_STALE_SURFACE: u32 = 4;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u16)]
+pub enum GpuCapabilityKey {
+    MaxTextureDimension2d = 1,
+    MaxBufferSize = 2,
+    MaxBindingsPerBindGroup = 3,
+    MaxBindGroups = 4,
+    MaxVertexBuffers = 5,
+    MaxVertexAttributes = 6,
+    MaxColorAttachments = 7,
+    MaxTextureBytes = 8,
+    MaxBufferBytes = 9,
+    MaxDrawsPerBatch = 10,
+    MaxBatchBytes = 11,
+    MaxUploadBytesPerTick = 12,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u16)]
+pub enum GpuEventType {
+    BatchRejected = 1,
+    ShaderDiagnostic = 2,
+    ResourceFailed = 3,
+    UncapturedError = 4,
+    SubmissionComplete = 5,
+    SurfaceChanged = 6,
+    DeviceLost = 7,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u16)]
+pub enum GpuOpcode {
+    CreateBuffer = 1,
+    WriteBuffer = 2,
+    CreateTexture = 3,
+    WriteTexture = 4,
+    CreateSampler = 5,
+    CreateShaderWgsl = 6,
+    CreateBindGroupLayout = 7,
+    CreatePipelineLayout = 8,
+    CreateBindGroup = 9,
+    CreateRenderPipeline = 10,
+    DestroyResource = 11,
+    BeginRenderPass = 12,
+    SetPipeline = 13,
+    SetVertexBuffer = 14,
+    SetIndexBuffer = 15,
+    SetBindGroup = 16,
+    SetViewport = 17,
+    SetScissorRect = 18,
+    Draw = 19,
+    DrawIndexed = 20,
+    EndRenderPass = 21,
+    CopyBufferToBuffer = 22,
+    CreateTextureView = 23,
+}
+
+impl TryFrom<u16> for GpuOpcode {
+    type Error = ();
+
+    fn try_from(value: u16) -> Result<Self, Self::Error> {
+        match value {
+            1 => Ok(Self::CreateBuffer),
+            2 => Ok(Self::WriteBuffer),
+            3 => Ok(Self::CreateTexture),
+            4 => Ok(Self::WriteTexture),
+            5 => Ok(Self::CreateSampler),
+            6 => Ok(Self::CreateShaderWgsl),
+            7 => Ok(Self::CreateBindGroupLayout),
+            8 => Ok(Self::CreatePipelineLayout),
+            9 => Ok(Self::CreateBindGroup),
+            10 => Ok(Self::CreateRenderPipeline),
+            11 => Ok(Self::DestroyResource),
+            12 => Ok(Self::BeginRenderPass),
+            13 => Ok(Self::SetPipeline),
+            14 => Ok(Self::SetVertexBuffer),
+            15 => Ok(Self::SetIndexBuffer),
+            16 => Ok(Self::SetBindGroup),
+            17 => Ok(Self::SetViewport),
+            18 => Ok(Self::SetScissorRect),
+            19 => Ok(Self::Draw),
+            20 => Ok(Self::DrawIndexed),
+            21 => Ok(Self::EndRenderPass),
+            22 => Ok(Self::CopyBufferToBuffer),
+            23 => Ok(Self::CreateTextureView),
+            _ => Err(()),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u16)]
+pub enum GpuTextureFormat {
+    Rgba8Unorm = 1,
+    Rgba8UnormSrgb = 2,
+    Bgra8Unorm = 3,
+    Bgra8UnormSrgb = 4,
+    Depth24Plus = 5,
+    Depth32Float = 6,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u16)]
+pub enum GpuVertexFormat {
+    Float32 = 1,
+    Float32x2 = 2,
+    Float32x3 = 3,
+    Float32x4 = 4,
+    Uint32 = 5,
+    Uint32x2 = 6,
+    Uint32x4 = 7,
+    Unorm8x2 = 8,
+    Unorm8x4 = 9,
+    Snorm8x2 = 10,
+    Snorm8x4 = 11,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuIndexFormat {
+    Uint16 = 1,
+    Uint32 = 2,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuAddressMode {
+    ClampToEdge = 1,
+    Repeat = 2,
+    MirrorRepeat = 3,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuFilterMode {
+    Nearest = 1,
+    Linear = 2,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuCompareFunction {
+    Never = 1,
+    Less = 2,
+    Equal = 3,
+    LessEqual = 4,
+    Greater = 5,
+    NotEqual = 6,
+    GreaterEqual = 7,
+    Always = 8,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuBlendOperation {
+    Add = 1,
+    Subtract = 2,
+    ReverseSubtract = 3,
+    Min = 4,
+    Max = 5,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuBlendFactor {
+    Zero = 1,
+    One = 2,
+    Src = 3,
+    OneMinusSrc = 4,
+    SrcAlpha = 5,
+    OneMinusSrcAlpha = 6,
+    Dst = 7,
+    OneMinusDst = 8,
+    DstAlpha = 9,
+    OneMinusDstAlpha = 10,
+    SrcAlphaSaturated = 11,
+    Constant = 12,
+    OneMinusConstant = 13,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuPrimitiveTopology {
+    PointList = 1,
+    LineList = 2,
+    LineStrip = 3,
+    TriangleList = 4,
+    TriangleStrip = 5,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuFrontFace {
+    Ccw = 1,
+    Cw = 2,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuCullMode {
+    Front = 1,
+    Back = 2,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u16)]
+pub enum GpuBindingKind {
+    UniformBuffer = 1,
+    Sampler = 2,
+    Texture = 3,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u32)]
+pub enum GpuSamplerBindingType {
+    Filtering = 1,
+    NonFiltering = 2,
+    Comparison = 3,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u32)]
+pub enum GpuTextureSampleType {
+    FloatFilterable = 1,
+    FloatUnfilterable = 2,
+    Depth = 3,
+    Sint = 4,
+    Uint = 5,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuVertexStepMode {
+    Vertex = 1,
+    Instance = 2,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuTextureDimension {
+    D2 = 1,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u32)]
+pub enum GpuTextureViewDimension {
+    D2 = 1,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum GpuTextureAspect {
+    All = 1,
+    DepthOnly = 2,
+}
+
+pub const GPU_BUFFER_USAGE_COPY_SRC: u32 = 4;
+pub const GPU_BUFFER_USAGE_COPY_DST: u32 = 8;
+pub const GPU_BUFFER_USAGE_INDEX: u32 = 16;
+pub const GPU_BUFFER_USAGE_VERTEX: u32 = 32;
+pub const GPU_BUFFER_USAGE_UNIFORM: u32 = 64;
+pub const GPU_TEXTURE_USAGE_COPY_SRC: u32 = 1;
+pub const GPU_TEXTURE_USAGE_COPY_DST: u32 = 2;
+pub const GPU_TEXTURE_USAGE_TEXTURE_BINDING: u32 = 4;
+pub const GPU_TEXTURE_USAGE_RENDER_ATTACHMENT: u32 = 16;
+pub const GPU_SHADER_STAGE_VERTEX: u32 = 1;
+pub const GPU_SHADER_STAGE_FRAGMENT: u32 = 2;
+pub const GPU_COLOR_WRITE_RED: u16 = 1;
+pub const GPU_COLOR_WRITE_GREEN: u16 = 2;
+pub const GPU_COLOR_WRITE_BLUE: u16 = 4;
+pub const GPU_COLOR_WRITE_ALPHA: u16 = 8;
+pub const GPU_RENDER_PASS_COLOR_LOAD: u32 = 1;
+pub const GPU_RENDER_PASS_COLOR_STORE: u32 = 2;
+pub const GPU_RENDER_PASS_DEPTH_LOAD: u32 = 4;
+pub const GPU_RENDER_PASS_DEPTH_STORE: u32 = 8;
+pub const GPU_BINDING_HAS_DYNAMIC_OFFSET: u16 = 1;
+pub const GPU_PIPELINE_DEPTH_WRITE: u16 = 1;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum GpuWireError {
+    BatchTooLarge {
+        actual: usize,
+    },
+    TruncatedBatchHeader {
+        actual: usize,
+    },
+    InvalidMagic,
+    UnsupportedVersion {
+        version: u16,
+    },
+    ReservedBatchFlags {
+        flags: u16,
+    },
+    BatchLengthMismatch {
+        declared: usize,
+        actual: usize,
+    },
+    EmptySequence,
+    TooManyCommands {
+        count: u32,
+    },
+    TruncatedCommandHeader {
+        index: u32,
+    },
+    InvalidCommandLength {
+        index: u32,
+        length: usize,
+    },
+    ReservedCommandFlags {
+        index: u32,
+        flags: u16,
+    },
+    UnknownOpcode {
+        index: u32,
+        opcode: u16,
+    },
+    InvalidPayloadLength {
+        index: u32,
+        opcode: GpuOpcode,
+        expected: usize,
+        actual: usize,
+    },
+    InvalidWgslUtf8 {
+        index: u32,
+    },
+    NonZeroPadding {
+        index: u32,
+    },
+    TrailingCommandBytes {
+        actual: usize,
+    },
+    IntegerOverflow {
+        index: u32,
+    },
+}
+
+impl fmt::Display for GpuWireError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Self::BatchTooLarge { actual } => {
+                write!(formatter, "GPU batch is {actual} bytes; maximum is {MAX_GPU_BATCH_BYTES}")
+            }
+            Self::TruncatedBatchHeader { actual } => write!(
+                formatter,
+                "GPU batch header is truncated: got {actual} bytes, need {GPU_BATCH_HEADER_BYTES}"
+            ),
+            Self::InvalidMagic => formatter.write_str("GPU batch has invalid magic"),
+            Self::UnsupportedVersion { version } => {
+                write!(formatter, "unsupported GPU wire version {version}")
+            }
+            Self::ReservedBatchFlags { flags } => {
+                write!(formatter, "GPU batch has reserved flags 0x{flags:04x}")
+            }
+            Self::BatchLengthMismatch { declared, actual } => write!(
+                formatter,
+                "GPU batch declares {declared} bytes but contains {actual}"
+            ),
+            Self::EmptySequence => formatter.write_str("GPU batch sequence must be nonzero"),
+            Self::TooManyCommands { count } => write!(
+                formatter,
+                "GPU batch declares {count} commands; maximum is {MAX_GPU_COMMANDS}"
+            ),
+            Self::TruncatedCommandHeader { index } => {
+                write!(formatter, "GPU command {index} header is truncated")
+            }
+            Self::InvalidCommandLength { index, length } => write!(
+                formatter,
+                "GPU command {index} has invalid aligned length {length}"
+            ),
+            Self::ReservedCommandFlags { index, flags } => write!(
+                formatter,
+                "GPU command {index} has reserved flags 0x{flags:04x}"
+            ),
+            Self::UnknownOpcode { index, opcode } => {
+                write!(formatter, "GPU command {index} uses unknown opcode {opcode}")
+            }
+            Self::InvalidPayloadLength {
+                index,
+                opcode,
+                expected,
+                actual,
+            } => write!(
+                formatter,
+                "GPU command {index} ({opcode:?}) needs {expected} payload bytes but contains {actual}"
+            ),
+            Self::InvalidWgslUtf8 { index } => {
+                write!(formatter, "GPU command {index} contains non-UTF-8 WGSL")
+            }
+            Self::NonZeroPadding { index } => {
+                write!(formatter, "GPU command {index} has nonzero padding")
+            }
+            Self::TrailingCommandBytes { actual } => {
+                write!(formatter, "GPU batch has {actual} trailing command bytes")
+            }
+            Self::IntegerOverflow { index } => {
+                write!(formatter, "GPU command {index} payload length overflows")
+            }
+        }
+    }
+}
+
+impl core::error::Error for GpuWireError {}
+
+#[derive(Clone, Copy, Debug)]
+pub struct GpuBatch<'a> {
+    sequence: u64,
+    command_count: u32,
+    command_bytes: &'a [u8],
+}
+
+impl<'a> GpuBatch<'a> {
+    pub fn sequence(self) -> u64 {
+        self.sequence
+    }
+
+    pub fn command_count(self) -> u32 {
+        self.command_count
+    }
+
+    pub fn commands(self) -> GpuCommands<'a> {
+        GpuCommands {
+            bytes: self.command_bytes,
+            remaining: self.command_count,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct GpuCommand<'a> {
+    pub opcode: GpuOpcode,
+    pub payload: &'a [u8],
+}
+
+pub struct GpuCommands<'a> {
+    bytes: &'a [u8],
+    remaining: u32,
+}
+
+impl<'a> Iterator for GpuCommands<'a> {
+    type Item = GpuCommand<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.remaining == 0 {
+            return None;
+        }
+        let opcode = GpuOpcode::try_from(u16_at(self.bytes, 0)).ok()?;
+        let command_bytes = u32_at(self.bytes, 4) as usize;
+        let payload = &self.bytes[GPU_COMMAND_HEADER_BYTES..command_bytes];
+        self.bytes = &self.bytes[command_bytes..];
+        self.remaining -= 1;
+        Some(GpuCommand { opcode, payload })
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.remaining as usize;
+        (remaining, Some(remaining))
+    }
+}
+
+impl ExactSizeIterator for GpuCommands<'_> {}
+
+pub fn decode_gpu_batch(bytes: &[u8]) -> Result<GpuBatch<'_>, GpuWireError> {
+    if bytes.len() > MAX_GPU_BATCH_BYTES {
+        return Err(GpuWireError::BatchTooLarge {
+            actual: bytes.len(),
+        });
+    }
+    if bytes.len() < GPU_BATCH_HEADER_BYTES {
+        return Err(GpuWireError::TruncatedBatchHeader {
+            actual: bytes.len(),
+        });
+    }
+    if bytes[..4] != GPU_WIRE_MAGIC {
+        return Err(GpuWireError::InvalidMagic);
+    }
+    let version = u16_at(bytes, 4);
+    if version != GPU_WIRE_VERSION {
+        return Err(GpuWireError::UnsupportedVersion { version });
+    }
+    let flags = u16_at(bytes, 6);
+    if flags != 0 {
+        return Err(GpuWireError::ReservedBatchFlags { flags });
+    }
+    let declared_length = u32_at(bytes, 8) as usize;
+    if declared_length != bytes.len() {
+        return Err(GpuWireError::BatchLengthMismatch {
+            declared: declared_length,
+            actual: bytes.len(),
+        });
+    }
+    let command_count = u32_at(bytes, 12);
+    if command_count > MAX_GPU_COMMANDS {
+        return Err(GpuWireError::TooManyCommands {
+            count: command_count,
+        });
+    }
+    let sequence = u64_at(bytes, 16);
+    if sequence == 0 {
+        return Err(GpuWireError::EmptySequence);
+    }
+
+    let mut command_bytes = &bytes[GPU_BATCH_HEADER_BYTES..];
+    for index in 0..command_count {
+        if command_bytes.len() < GPU_COMMAND_HEADER_BYTES {
+            return Err(GpuWireError::TruncatedCommandHeader { index });
+        }
+        let opcode_value = u16_at(command_bytes, 0);
+        let command_flags = u16_at(command_bytes, 2);
+        if command_flags != 0 {
+            return Err(GpuWireError::ReservedCommandFlags {
+                index,
+                flags: command_flags,
+            });
+        }
+        let command_length = u32_at(command_bytes, 4) as usize;
+        if command_length < GPU_COMMAND_HEADER_BYTES
+            || !command_length.is_multiple_of(4)
+            || command_length > command_bytes.len()
+        {
+            return Err(GpuWireError::InvalidCommandLength {
+                index,
+                length: command_length,
+            });
+        }
+        let opcode =
+            GpuOpcode::try_from(opcode_value).map_err(|()| GpuWireError::UnknownOpcode {
+                index,
+                opcode: opcode_value,
+            })?;
+        validate_payload(
+            index,
+            opcode,
+            &command_bytes[GPU_COMMAND_HEADER_BYTES..command_length],
+        )?;
+        command_bytes = &command_bytes[command_length..];
+    }
+    if !command_bytes.is_empty() {
+        return Err(GpuWireError::TrailingCommandBytes {
+            actual: command_bytes.len(),
+        });
+    }
+
+    Ok(GpuBatch {
+        sequence,
+        command_count,
+        command_bytes: &bytes[GPU_BATCH_HEADER_BYTES..],
+    })
+}
+
+fn validate_payload(index: u32, opcode: GpuOpcode, payload: &[u8]) -> Result<(), GpuWireError> {
+    match opcode {
+        GpuOpcode::CreateBuffer => exact_payload(index, opcode, payload, 16),
+        GpuOpcode::WriteBuffer => inline_payload(index, opcode, payload, 24, 16, false),
+        GpuOpcode::CreateTexture => exact_payload(index, opcode, payload, 24),
+        GpuOpcode::WriteTexture => inline_payload(index, opcode, payload, 44, 40, false),
+        GpuOpcode::CreateSampler => exact_payload(index, opcode, payload, 24),
+        GpuOpcode::CreateShaderWgsl => inline_payload(index, opcode, payload, 8, 4, true),
+        GpuOpcode::CreateBindGroupLayout => counted_payload(index, opcode, payload, 8, 4, 32),
+        GpuOpcode::CreatePipelineLayout => counted_payload(index, opcode, payload, 8, 4, 4),
+        GpuOpcode::CreateBindGroup => counted_payload(index, opcode, payload, 12, 8, 32),
+        GpuOpcode::CreateRenderPipeline => pipeline_payload(index, opcode, payload),
+        GpuOpcode::DestroyResource | GpuOpcode::SetPipeline => {
+            exact_payload(index, opcode, payload, 4)
+        }
+        GpuOpcode::BeginRenderPass => exact_payload(index, opcode, payload, 36),
+        GpuOpcode::CopyBufferToBuffer => exact_payload(index, opcode, payload, 32),
+        GpuOpcode::SetVertexBuffer | GpuOpcode::SetIndexBuffer | GpuOpcode::SetViewport => {
+            exact_payload(index, opcode, payload, 24)
+        }
+        GpuOpcode::SetBindGroup => counted_payload(index, opcode, payload, 12, 8, 4),
+        GpuOpcode::SetScissorRect | GpuOpcode::Draw => exact_payload(index, opcode, payload, 16),
+        GpuOpcode::DrawIndexed => exact_payload(index, opcode, payload, 20),
+        GpuOpcode::EndRenderPass => exact_payload(index, opcode, payload, 0),
+        GpuOpcode::CreateTextureView => exact_payload(index, opcode, payload, 20),
+    }
+}
+
+fn exact_payload(
+    index: u32,
+    opcode: GpuOpcode,
+    payload: &[u8],
+    expected: usize,
+) -> Result<(), GpuWireError> {
+    if payload.len() != expected {
+        return Err(GpuWireError::InvalidPayloadLength {
+            index,
+            opcode,
+            expected,
+            actual: payload.len(),
+        });
+    }
+    Ok(())
+}
+
+fn inline_payload(
+    index: u32,
+    opcode: GpuOpcode,
+    payload: &[u8],
+    header_bytes: usize,
+    length_offset: usize,
+    utf8: bool,
+) -> Result<(), GpuWireError> {
+    if payload.len() < header_bytes {
+        return Err(GpuWireError::InvalidPayloadLength {
+            index,
+            opcode,
+            expected: header_bytes,
+            actual: payload.len(),
+        });
+    }
+    let inline_bytes = u32_at(payload, length_offset) as usize;
+    let unpadded = header_bytes
+        .checked_add(inline_bytes)
+        .ok_or(GpuWireError::IntegerOverflow { index })?;
+    let expected = align4(unpadded).ok_or(GpuWireError::IntegerOverflow { index })?;
+    if payload.len() != expected {
+        return Err(GpuWireError::InvalidPayloadLength {
+            index,
+            opcode,
+            expected,
+            actual: payload.len(),
+        });
+    }
+    if utf8 && core::str::from_utf8(&payload[header_bytes..unpadded]).is_err() {
+        return Err(GpuWireError::InvalidWgslUtf8 { index });
+    }
+    if payload[unpadded..].iter().any(|byte| *byte != 0) {
+        return Err(GpuWireError::NonZeroPadding { index });
+    }
+    Ok(())
+}
+
+fn counted_payload(
+    index: u32,
+    opcode: GpuOpcode,
+    payload: &[u8],
+    header_bytes: usize,
+    count_offset: usize,
+    stride: usize,
+) -> Result<(), GpuWireError> {
+    if payload.len() < header_bytes {
+        return Err(GpuWireError::InvalidPayloadLength {
+            index,
+            opcode,
+            expected: header_bytes,
+            actual: payload.len(),
+        });
+    }
+    let count = u32_at(payload, count_offset) as usize;
+    let expected = count
+        .checked_mul(stride)
+        .and_then(|entries| header_bytes.checked_add(entries))
+        .ok_or(GpuWireError::IntegerOverflow { index })?;
+    exact_payload(index, opcode, payload, expected)
+}
+
+fn pipeline_payload(index: u32, opcode: GpuOpcode, payload: &[u8]) -> Result<(), GpuWireError> {
+    const HEADER_BYTES: usize = 40;
+    if payload.len() < HEADER_BYTES {
+        return Err(GpuWireError::InvalidPayloadLength {
+            index,
+            opcode,
+            expected: HEADER_BYTES,
+            actual: payload.len(),
+        });
+    }
+    let vertex_layouts = u16_at(payload, 12) as usize;
+    let vertex_attributes = u16_at(payload, 14) as usize;
+    let color_targets = u16_at(payload, 16) as usize;
+    let expected = vertex_layouts
+        .checked_mul(16)
+        .and_then(|value| {
+            vertex_attributes
+                .checked_mul(16)
+                .and_then(|next| value.checked_add(next))
+        })
+        .and_then(|value| {
+            color_targets
+                .checked_mul(16)
+                .and_then(|next| value.checked_add(next))
+        })
+        .and_then(|arrays| HEADER_BYTES.checked_add(arrays))
+        .ok_or(GpuWireError::IntegerOverflow { index })?;
+    exact_payload(index, opcode, payload, expected)
+}
+
+fn align4(value: usize) -> Option<usize> {
+    value.checked_add(3).map(|value| value & !3)
+}
+
+fn u16_at(bytes: &[u8], offset: usize) -> u16 {
+    u16::from_le_bytes(
+        bytes[offset..offset + 2]
+            .try_into()
+            .expect("validated field offset"),
+    )
+}
+
+fn u32_at(bytes: &[u8], offset: usize) -> u32 {
+    u32::from_le_bytes(
+        bytes[offset..offset + 4]
+            .try_into()
+            .expect("validated field offset"),
+    )
+}
+
+fn u64_at(bytes: &[u8], offset: usize) -> u64 {
+    u64::from_le_bytes(
+        bytes[offset..offset + 8]
+            .try_into()
+            .expect("validated field offset"),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    extern crate std;
+
+    use std::vec;
+    use std::vec::Vec;
+
+    const DESTROY_FIXTURE: [u8; 36] = [
+        0x45, 0x50, 0x47, 0x31, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+        0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0c, 0x00,
+        0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
+    ];
+
+    #[test]
+    fn decodes_golden_destroy_fixture_without_allocating() {
+        let batch = decode_gpu_batch(&DESTROY_FIXTURE).expect("valid fixture");
+        assert_eq!(batch.sequence(), 7);
+        assert_eq!(batch.command_count(), 1);
+        let commands = batch.commands().collect::<Vec<_>>();
+        assert_eq!(commands.len(), 1);
+        assert_eq!(commands[0].opcode, GpuOpcode::DestroyResource);
+        assert_eq!(commands[0].payload, 42u32.to_le_bytes());
+    }
+
+    #[test]
+    fn accepts_padded_utf8_shader_source() {
+        let mut payload = Vec::new();
+        payload.extend_from_slice(&9u32.to_le_bytes());
+        payload.extend_from_slice(&3u32.to_le_bytes());
+        payload.extend_from_slice(b"abc");
+        payload.push(0);
+        let batch = single_command(GpuOpcode::CreateShaderWgsl, &payload);
+        assert!(decode_gpu_batch(&batch).is_ok());
+    }
+
+    #[test]
+    fn rejects_unknown_opcode() {
+        let mut batch = DESTROY_FIXTURE;
+        batch[24..26].copy_from_slice(&99u16.to_le_bytes());
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::UnknownOpcode {
+                index: 0,
+                opcode: 99,
+            }
+        );
+    }
+
+    #[test]
+    fn rejects_declared_batch_length_mismatch() {
+        let mut batch = DESTROY_FIXTURE;
+        batch[8..12].copy_from_slice(&35u32.to_le_bytes());
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::BatchLengthMismatch {
+                declared: 35,
+                actual: 36,
+            }
+        );
+    }
+
+    #[test]
+    fn rejects_extra_well_formed_command() {
+        let mut batch = DESTROY_FIXTURE.to_vec();
+        batch.extend_from_slice(&DESTROY_FIXTURE[24..]);
+        let batch_length = batch.len() as u32;
+        batch[8..12].copy_from_slice(&batch_length.to_le_bytes());
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::TrailingCommandBytes { actual: 12 }
+        );
+    }
+
+    #[test]
+    fn rejects_nonzero_inline_padding() {
+        let mut payload = Vec::new();
+        payload.extend_from_slice(&9u32.to_le_bytes());
+        payload.extend_from_slice(&1u32.to_le_bytes());
+        payload.extend_from_slice(b"x");
+        payload.extend_from_slice(&[0, 1, 0]);
+        let batch = single_command(GpuOpcode::CreateShaderWgsl, &payload);
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::NonZeroPadding { index: 0 }
+        );
+    }
+
+    #[test]
+    fn rejects_non_utf8_shader_source() {
+        let mut payload = Vec::new();
+        payload.extend_from_slice(&9u32.to_le_bytes());
+        payload.extend_from_slice(&1u32.to_le_bytes());
+        payload.extend_from_slice(&[0xff, 0, 0, 0]);
+        let batch = single_command(GpuOpcode::CreateShaderWgsl, &payload);
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::InvalidWgslUtf8 { index: 0 }
+        );
+    }
+
+    #[test]
+    fn rejects_variable_payload_count_mismatch() {
+        let mut payload = Vec::new();
+        payload.extend_from_slice(&1u32.to_le_bytes());
+        payload.extend_from_slice(&2u32.to_le_bytes());
+        payload.extend_from_slice(&7u32.to_le_bytes());
+        let batch = single_command(GpuOpcode::CreatePipelineLayout, &payload);
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::InvalidPayloadLength {
+                index: 0,
+                opcode: GpuOpcode::CreatePipelineLayout,
+                expected: 16,
+                actual: 12,
+            }
+        );
+    }
+
+    #[test]
+    fn accepts_every_v1_opcode_payload_shape() {
+        let payloads = [
+            (GpuOpcode::CreateBuffer, 16),
+            (GpuOpcode::WriteBuffer, 24),
+            (GpuOpcode::CreateTexture, 24),
+            (GpuOpcode::WriteTexture, 44),
+            (GpuOpcode::CreateSampler, 24),
+            (GpuOpcode::CreateShaderWgsl, 8),
+            (GpuOpcode::CreateBindGroupLayout, 8),
+            (GpuOpcode::CreatePipelineLayout, 8),
+            (GpuOpcode::CreateBindGroup, 12),
+            (GpuOpcode::CreateRenderPipeline, 40),
+            (GpuOpcode::DestroyResource, 4),
+            (GpuOpcode::BeginRenderPass, 36),
+            (GpuOpcode::SetPipeline, 4),
+            (GpuOpcode::SetVertexBuffer, 24),
+            (GpuOpcode::SetIndexBuffer, 24),
+            (GpuOpcode::SetBindGroup, 12),
+            (GpuOpcode::SetViewport, 24),
+            (GpuOpcode::SetScissorRect, 16),
+            (GpuOpcode::Draw, 16),
+            (GpuOpcode::DrawIndexed, 20),
+            (GpuOpcode::EndRenderPass, 0),
+            (GpuOpcode::CopyBufferToBuffer, 32),
+            (GpuOpcode::CreateTextureView, 20),
+        ];
+        for (opcode, payload_bytes) in payloads {
+            let batch = single_command(opcode, &vec![0; payload_bytes]);
+            decode_gpu_batch(&batch)
+                .unwrap_or_else(|error| panic!("{opcode:?} fixture failed: {error}"));
+        }
+    }
+
+    #[test]
+    fn rejects_unaligned_command_length() {
+        let mut batch = DESTROY_FIXTURE;
+        batch[28..32].copy_from_slice(&10u32.to_le_bytes());
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::InvalidCommandLength {
+                index: 0,
+                length: 10,
+            }
+        );
+    }
+
+    #[test]
+    fn rejects_reserved_batch_flags() {
+        let mut batch = DESTROY_FIXTURE;
+        batch[6..8].copy_from_slice(&1u16.to_le_bytes());
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::ReservedBatchFlags { flags: 1 }
+        );
+    }
+
+    #[test]
+    fn rejects_zero_sequence() {
+        let mut batch = DESTROY_FIXTURE;
+        batch[16..24].fill(0);
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::EmptySequence
+        );
+    }
+
+    #[test]
+    fn rejects_trailing_partial_command() {
+        let mut batch = DESTROY_FIXTURE.to_vec();
+        batch.push(0);
+        let batch_length = batch.len() as u32;
+        batch[8..12].copy_from_slice(&batch_length.to_le_bytes());
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::TrailingCommandBytes { actual: 1 }
+        );
+    }
+
+    #[test]
+    fn rejects_batches_above_the_byte_ceiling_before_decoding() {
+        let batch = vec![0; MAX_GPU_BATCH_BYTES + 1];
+        assert_eq!(
+            decode_gpu_batch(&batch).unwrap_err(),
+            GpuWireError::BatchTooLarge {
+                actual: MAX_GPU_BATCH_BYTES + 1,
+            }
+        );
+    }
+
+    fn single_command(opcode: GpuOpcode, payload: &[u8]) -> Vec<u8> {
+        assert_eq!(payload.len() % 4, 0);
+        let command_length = GPU_COMMAND_HEADER_BYTES + payload.len();
+        let batch_length = GPU_BATCH_HEADER_BYTES + command_length;
+        let mut bytes = Vec::with_capacity(batch_length);
+        bytes.extend_from_slice(&GPU_WIRE_MAGIC);
+        bytes.extend_from_slice(&GPU_WIRE_VERSION.to_le_bytes());
+        bytes.extend_from_slice(&0u16.to_le_bytes());
+        bytes.extend_from_slice(&(batch_length as u32).to_le_bytes());
+        bytes.extend_from_slice(&1u32.to_le_bytes());
+        bytes.extend_from_slice(&1u64.to_le_bytes());
+        bytes.extend_from_slice(&(opcode as u16).to_le_bytes());
+        bytes.extend_from_slice(&0u16.to_le_bytes());
+        bytes.extend_from_slice(&(command_length as u32).to_le_bytes());
+        bytes.extend_from_slice(payload);
+        bytes
+    }
+}
diff --git a/rust/crates/pvm-runtime/Cargo.toml b/rust/crates/pvm-runtime/Cargo.toml
new file mode 100644
index 000000000..bf20c43d2
--- /dev/null
+++ b/rust/crates/pvm-runtime/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "pvm-runtime"
+version = "0.1.0"
+edition = "2021"
+description = "Host-neutral App manifest v2 PolkaVM runtime and browser execution wrapper"
+license = "MPL-2.0"
+publish = false
+
+[lib]
+crate-type = ["rlib", "cdylib", "staticlib"]
+
+[features]
+ffi = ["dep:thiserror", "dep:uniffi"]
+
+[dependencies]
+anyhow = "1"
+log = "0.4"
+pvm-gpu-wire = { path = "../pvm-gpu-wire" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+wasm-encoder = "0.240"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+polkavm = { git = "https://github.com/paritytech/polkavm.git", rev = "8cc3c5601aa614b0f6dfac2ae3ee271942b3c997", version = "=0.37.0", features = ["generic-sandbox"] }
+thiserror = { version = "1", optional = true }
+uniffi = { workspace = true, optional = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+polkavm-wasm = { package = "polkavm", git = "https://github.com/paritytech/polkavm.git", rev = "3df1d0309c4c81a1aad0a755d83570d203bba1d9", version = "=0.37.0", features = ["generic-sandbox"] }
+
+[dev-dependencies]
+wasmi = "0.40"
+wasmparser = "0.240"
diff --git a/rust/crates/pvm-runtime/src/application.rs b/rust/crates/pvm-runtime/src/application.rs
new file mode 100644
index 000000000..1faa4849d
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/application.rs
@@ -0,0 +1,346 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::corevm::{Interruption, Vm};
+use crate::{
+    AudioChunk, Frame, GpuBatch, InputEvent, InputEventType, PresentationProfile, Runtime,
+    Tri2dFrame, MAX_FRAME_BYTES, MAX_GUEST_RW_DATA_BYTES, MAX_GUEST_STACK_BYTES,
+};
+use anyhow::{anyhow, Context, Result};
+use polkavm::ProgramBlob;
+use std::collections::{HashMap, VecDeque};
+
+const MAX_INTERRUPTS_PER_UPDATE: usize = 8_192;
+const MAX_QUEUED_AUDIO_CHUNKS: usize = 64;
+
+// Both variants are large, long-lived runtime state machines. Boxing either
+// adds allocation and indirection to every host call to save 576 enum bytes.
+#[allow(clippy::large_enum_variant)]
+pub enum ApplicationRuntime {
+    Cooperative(Runtime),
+    CoreVm(CoreVmRuntime),
+}
+
+pub struct CoreVmRuntime {
+    vm: Vm,
+    frame: Option<Frame>,
+    audio: VecDeque<AudioChunk>,
+    palette: [[u8; 3]; 256],
+    sample_rate: u32,
+    channels: u32,
+    pointer: Option<(u16, u16)>,
+    audio_enabled: bool,
+    max_gas_per_update: u64,
+    exited: bool,
+}
+
+impl ApplicationRuntime {
+    pub fn new(
+        program: &[u8],
+        assets: HashMap<String, Vec<u8>>,
+        presentation: PresentationProfile,
+        audio_enabled: bool,
+        max_gas_per_update: u64,
+    ) -> Result<Self> {
+        Self::new_with_backend(
+            program,
+            assets,
+            presentation,
+            audio_enabled,
+            max_gas_per_update,
+            crate::preferred_backend(),
+        )
+    }
+
+    pub fn new_with_backend(
+        program: &[u8],
+        assets: HashMap<String, Vec<u8>>,
+        presentation: PresentationProfile,
+        audio_enabled: bool,
+        max_gas_per_update: u64,
+        backend: polkavm::BackendKind,
+    ) -> Result<Self> {
+        let blob = ProgramBlob::parse(program.into()).context("parse PolkaVM program")?;
+        if blob.rw_data_size() > MAX_GUEST_RW_DATA_BYTES {
+            return Err(anyhow!(
+                "guest read-write data exceeds {MAX_GUEST_RW_DATA_BYTES} bytes"
+            ));
+        }
+        if blob.stack_size() > MAX_GUEST_STACK_BYTES {
+            return Err(anyhow!("guest stack exceeds {MAX_GUEST_STACK_BYTES} bytes"));
+        }
+        let is_corevm = blob.exports().any(|export| export.symbol() == "_pvm_start");
+        if !is_corevm {
+            return Runtime::new_with_backend(
+                program,
+                assets,
+                presentation,
+                audio_enabled,
+                max_gas_per_update,
+                backend,
+            )
+            .map(Self::Cooperative);
+        }
+        if presentation != PresentationProfile::Framebuffer {
+            return Err(anyhow!(
+                "CoreVM guests require the framebuffer presentation profile"
+            ));
+        }
+
+        let mut vm = Vm::from_blob(blob, backend).context("create CoreVM guest")?;
+        for (path, bytes) in assets {
+            vm.register_file(&path, bytes);
+        }
+        vm.setup(["./quake"]).map_err(|error| anyhow!(error))?;
+        Ok(Self::CoreVm(CoreVmRuntime {
+            vm,
+            frame: None,
+            audio: VecDeque::new(),
+            palette: [[255; 3]; 256],
+            sample_rate: 0,
+            channels: 0,
+            audio_enabled,
+            pointer: None,
+            max_gas_per_update,
+            exited: false,
+        }))
+    }
+
+    pub fn init(&mut self) -> Result<()> {
+        match self {
+            Self::Cooperative(runtime) => runtime.init(),
+            Self::CoreVm(_) => Ok(()),
+        }
+    }
+
+    pub fn update(&mut self) -> Result<()> {
+        match self {
+            Self::Cooperative(runtime) => runtime.update(),
+            Self::CoreVm(runtime) => runtime.update(),
+        }
+    }
+
+    pub fn backend(&self) -> polkavm::BackendKind {
+        match self {
+            Self::Cooperative(runtime) => runtime.backend(),
+            Self::CoreVm(runtime) => runtime.vm.backend(),
+        }
+    }
+    pub fn last_gas_used(&self) -> u64 {
+        match self {
+            Self::Cooperative(runtime) => runtime.last_gas_used(),
+            Self::CoreVm(runtime) => runtime
+                .max_gas_per_update
+                .saturating_sub(runtime.vm.gas_remaining()),
+        }
+    }
+
+    pub fn send_input(&mut self, event: InputEvent) {
+        match self {
+            Self::Cooperative(runtime) => runtime.send_input(event),
+            Self::CoreVm(runtime) => runtime.send_input(event),
+        }
+    }
+
+    pub fn gpu_ready(&self) -> bool {
+        match self {
+            Self::Cooperative(runtime) => runtime.gpu_ready(),
+            Self::CoreVm(_) => true,
+        }
+    }
+
+    pub fn set_gpu_capabilities(&mut self, bytes: Vec<u8>) -> Result<()> {
+        match self {
+            Self::Cooperative(runtime) => runtime.set_gpu_capabilities(bytes),
+            Self::CoreVm(_) => Err(anyhow!("CoreVM does not support GPU capabilities")),
+        }
+    }
+
+    pub fn send_gpu_event(&mut self, bytes: Vec<u8>) -> Result<()> {
+        match self {
+            Self::Cooperative(runtime) => runtime.send_gpu_event(bytes),
+            Self::CoreVm(_) => Err(anyhow!("CoreVM does not support GPU events")),
+        }
+    }
+
+    pub fn take_gpu_batch(&mut self) -> Option<GpuBatch> {
+        match self {
+            Self::Cooperative(runtime) => runtime.take_gpu_batch(),
+            Self::CoreVm(_) => None,
+        }
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn set_time_ms(&mut self, time_ms: u64) {
+        if let Self::Cooperative(runtime) = self {
+            runtime.set_time_ms(time_ms);
+        }
+    }
+
+    pub fn take_frame(&mut self) -> Option<Frame> {
+        match self {
+            Self::Cooperative(runtime) => runtime.take_frame(),
+            Self::CoreVm(runtime) => runtime.frame.take(),
+        }
+    }
+    pub fn take_tri2d(&mut self) -> Option<Tri2dFrame> {
+        match self {
+            Self::Cooperative(runtime) => runtime.take_tri2d(),
+            Self::CoreVm(_) => None,
+        }
+    }
+
+    pub fn take_audio(&mut self) -> Option<AudioChunk> {
+        match self {
+            Self::Cooperative(runtime) => runtime.take_audio(),
+            Self::CoreVm(runtime) => runtime.audio.pop_front(),
+        }
+    }
+
+    pub fn take_log(&mut self) -> Option<String> {
+        match self {
+            Self::Cooperative(runtime) => runtime.take_log(),
+            Self::CoreVm(_) => None,
+        }
+    }
+
+    pub fn is_exited(&self) -> bool {
+        matches!(self, Self::CoreVm(runtime) if runtime.exited)
+    }
+
+    pub fn take_save(&mut self) -> Option<Vec<u8>> {
+        match self {
+            Self::Cooperative(runtime) => runtime.take_save(),
+            Self::CoreVm(_) => None,
+        }
+    }
+}
+
+impl CoreVmRuntime {
+    fn update(&mut self) -> Result<()> {
+        if self.exited {
+            return Ok(());
+        }
+        self.vm.set_gas(self.max_gas_per_update);
+        for _ in 0..MAX_INTERRUPTS_PER_UPDATE {
+            match self.vm.run().map_err(|error| anyhow!(error))? {
+                Interruption::Exit => {
+                    self.exited = true;
+                    return Ok(());
+                }
+                Interruption::Yield => return Ok(()),
+                Interruption::SetPalette { palette } => {
+                    if palette.len() != 256 * 3 {
+                        return Err(anyhow!("guest supplied an invalid Quake palette"));
+                    }
+                    for (target, source) in self.palette.iter_mut().zip(palette.as_chunks::<3>().0)
+                    {
+                        target.copy_from_slice(source);
+                    }
+                }
+                Interruption::Display {
+                    width,
+                    height,
+                    framebuffer,
+                } => {
+                    let width = u32::try_from(width).context("Quake frame width overflow")?;
+                    let height = u32::try_from(height).context("Quake frame height overflow")?;
+                    let pixels = width
+                        .checked_mul(height)
+                        .ok_or_else(|| anyhow!("Quake frame dimensions overflow"))?
+                        as usize;
+                    if pixels == 0 || pixels > MAX_FRAME_BYTES / 4 || framebuffer.len() != pixels {
+                        return Err(anyhow!("guest supplied an invalid Quake frame"));
+                    }
+                    let mut argb = Vec::with_capacity(pixels * 4);
+                    for index in framebuffer {
+                        let [red, green, blue] = self.palette[index as usize];
+                        argb.extend_from_slice(&[blue, green, red, 255]);
+                    }
+                    self.frame = Some(Frame {
+                        width,
+                        height,
+                        argb,
+                    });
+                    return Ok(());
+                }
+                Interruption::AudioInit {
+                    channels,
+                    sample_rate,
+                } => {
+                    if !self.audio_enabled {
+                        self.channels = 0;
+                        self.sample_rate = 0;
+                        continue;
+                    }
+                    if !(1..=2).contains(&channels) || !(8_000..=96_000).contains(&sample_rate) {
+                        return Err(anyhow!("guest requested an unsupported audio format"));
+                    }
+                    self.channels = channels;
+                    self.sample_rate = sample_rate;
+                }
+                Interruption::AudioFrame { buffer } => {
+                    if !self.audio_enabled {
+                        continue;
+                    }
+                    if self.channels == 0 {
+                        self.channels = crate::AUDIO_CHANNELS;
+                        self.sample_rate = crate::AUDIO_SAMPLE_RATE;
+                    }
+                    if buffer.is_empty() || buffer.len() % self.channels as usize != 0 {
+                        continue;
+                    }
+                    if self.audio.len() == MAX_QUEUED_AUDIO_CHUNKS {
+                        self.audio.pop_front();
+                    }
+                    self.audio.push_back(AudioChunk {
+                        samples: buffer,
+                        sample_rate: self.sample_rate,
+                        channels: self.channels,
+                    });
+                }
+            }
+        }
+        Err(anyhow!("guest exceeded interruption budget"))
+    }
+
+    fn send_input(&mut self, event: InputEvent) {
+        if self.vm.uses_epoca_inputs() {
+            self.vm.send_epoca_input(event);
+            return;
+        }
+        match event.event_type {
+            InputEventType::KeyDown | InputEventType::KeyUp => {
+                if let Some(key) = crate::quake_keys::from_hid(event.code) {
+                    self.vm
+                        .send_key(key, event.event_type == InputEventType::KeyDown);
+                }
+            }
+            InputEventType::ButtonDown | InputEventType::ButtonUp => {
+                if let Some(key) = crate::quake_keys::from_button(event.code) {
+                    self.vm
+                        .send_key(key, event.event_type == InputEventType::ButtonDown);
+                }
+            }
+            InputEventType::PointerMove => {
+                if let Some((previous_x, previous_y)) = self.pointer {
+                    self.vm.send_mouse_move(
+                        signed_delta(event.x, previous_x),
+                        signed_delta(event.y, previous_y),
+                    );
+                }
+                self.pointer = Some((event.x, event.y));
+            }
+            InputEventType::PointerDelta => self.vm.send_mouse_move(
+                (event.x as i16).clamp(i8::MIN as i16, i8::MAX as i16) as i8,
+                (event.y as i16).clamp(i8::MIN as i16, i8::MAX as i16) as i8,
+            ),
+            InputEventType::SurfaceMetrics => {}
+        }
+    }
+}
+
+fn signed_delta(current: u16, previous: u16) -> i8 {
+    (i32::from(current) - i32::from(previous)).clamp(i8::MIN as i32, i8::MAX as i32) as i8
+}
diff --git a/rust/crates/pvm-runtime/src/corevm.rs b/rust/crates/pvm-runtime/src/corevm.rs
new file mode 100644
index 000000000..492ba8511
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/corevm.rs
@@ -0,0 +1,851 @@
+/* SPDX-License-Identifier: Apache-2.0 OR MIT
+ * Vendored from paritytech/polkavm examples/quake/src/vm.rs at
+ * 3df1d0309c4c81a1aad0a755d83570d203bba1d9 and adapted for Epoca.
+ */
+
+#![allow(non_upper_case_globals)]
+
+use polkavm::{
+    Config, Engine, GasMeteringKind, InterruptKind, MemoryAccessError, Module, ModuleConfig,
+    ProgramBlob, ProgramCounter, RawInstance, Reg,
+};
+use std::collections::{BTreeMap, VecDeque};
+use std::mem::MaybeUninit;
+use std::sync::Arc;
+use std::time::Instant;
+
+struct File {
+    blob: Vec<u8>,
+}
+
+struct Fd {
+    file: Arc<File>,
+    position: u64,
+}
+
+struct OpenFiles {
+    descriptors: BTreeMap<u64, Fd>,
+    next: u64,
+}
+
+impl OpenFiles {
+    fn new() -> Self {
+        Self {
+            descriptors: BTreeMap::new(),
+            next: 3,
+        }
+    }
+
+    fn open(&mut self, file: Arc<File>) -> Result<u64, u64> {
+        if self.descriptors.len() >= MAX_OPEN_FILES {
+            return Err(EMFILE);
+        }
+        let fd = self.next;
+        self.next = self.next.checked_add(1).ok_or(EMFILE)?;
+        self.descriptors.insert(fd, Fd { file, position: 0 });
+        Ok(fd)
+    }
+
+    fn get_mut(&mut self, fd: u64) -> Option<&mut Fd> {
+        self.descriptors.get_mut(&fd)
+    }
+
+    fn remove(&mut self, fd: u64) -> Option<Fd> {
+        self.descriptors.remove(&fd)
+    }
+}
+
+pub struct Vm {
+    start: ProgramCounter,
+    instance: RawInstance,
+    backend: polkavm::BackendKind,
+    filesystem: BTreeMap<Vec<u8>, Arc<File>>,
+    open_files: OpenFiles,
+    input_events: VecDeque<InputEvent>,
+    audio_channels: u32,
+    epoca_input_events: VecDeque<[u8; crate::INPUT_EVENT_BYTES]>,
+    started: Instant,
+
+    import_syscall: Option<u32>,
+    import_set_palette: Option<u32>,
+    import_display: Option<u32>,
+    import_fetch_inputs: Option<u32>,
+    import_init_audio: Option<u32>,
+    import_output_audio: Option<u32>,
+    import_epoca_inputs: Option<u32>,
+    import_epoca_audio: Option<u32>,
+    import_asset_read: Option<u32>,
+    import_time_ms: Option<u32>,
+    import_log: Option<u32>,
+    import_yield: Option<u32>,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+struct InputEvent {
+    key: u8,
+    value: u8,
+}
+
+const SYS_read: u64 = 63;
+const SYS_readv: u64 = 65;
+const SYS_writev: u64 = 66;
+const SYS_exit: u64 = 93;
+const SYS_openat: u64 = 56;
+const SYS_lseek: u64 = 62;
+const SYS_close: u64 = 57;
+const SEEK_SET: u64 = 0;
+const SEEK_CUR: u64 = 1;
+const SEEK_END: u64 = 2;
+const FILENO_STDOUT: u64 = 1;
+const FILENO_STDERR: u64 = 2;
+const ENOSYS: u64 = 38;
+const EFAULT: u64 = 14;
+const ENOENT: u64 = 2;
+const EBADF: u64 = 9;
+const EACCES: u64 = 13;
+const EINVAL: u64 = 22;
+const EMFILE: u64 = 24;
+const AT_FDCWD: u64 = (-100_i64) as u64;
+const IOV_MAX: u64 = 1024;
+const MAX_QUEUED_INPUT_EVENTS: usize = 256;
+const MAX_GUEST_WRITE_BYTES: u64 = 4 * 1024;
+const MAX_OPEN_FILES: usize = 256;
+const O_WRONLY: u64 = 1;
+const O_RDWR: u64 = 2;
+const AT_PAGESZ: u64 = 6;
+
+fn errno(error: u64) -> u64 {
+    (-(error as i64)) as u64
+}
+
+fn normalize_path(path: &str) -> String {
+    path.trim_start_matches("./")
+        .trim_start_matches('/')
+        .to_owned()
+}
+
+fn seek_position(current: u64, length: u64, offset: i64, whence: u64) -> Result<u64, u64> {
+    let base = match whence {
+        SEEK_SET => 0,
+        SEEK_CUR => current,
+        SEEK_END => length,
+        _ => return Err(EINVAL),
+    };
+    u64::try_from(i128::from(base) + i128::from(offset)).map_err(|_| EINVAL)
+}
+
+fn queued_input_chunks(
+    events: &VecDeque<InputEvent>,
+    limit: usize,
+) -> (&[InputEvent], &[InputEvent]) {
+    let remaining = limit.min(events.len());
+    let (first, second) = events.as_slices();
+    let first = &first[..first.len().min(remaining)];
+    let second = &second[..second.len().min(remaining - first.len())];
+    (first, second)
+}
+
+fn input_destination(address: u64, event_offset: usize) -> Result<u32, String> {
+    let byte_offset = event_offset
+        .checked_mul(core::mem::size_of::<InputEvent>())
+        .and_then(|offset| u64::try_from(offset).ok())
+        .ok_or_else(|| "input address overflow".to_owned())?;
+    address
+        .checked_add(byte_offset)
+        .and_then(|address| u32::try_from(address).ok())
+        .ok_or_else(|| "input address is out of range".to_owned())
+}
+
+pub enum Interruption {
+    Exit,
+    Yield,
+    SetPalette {
+        palette: Vec<u8>,
+    },
+    Display {
+        width: u64,
+        height: u64,
+        framebuffer: Vec<u8>,
+    },
+    AudioInit {
+        channels: u32,
+        sample_rate: u32,
+    },
+    AudioFrame {
+        buffer: Vec<i16>,
+    },
+}
+
+impl Vm {
+    pub fn from_blob(
+        blob: ProgramBlob,
+        backend: polkavm::BackendKind,
+    ) -> Result<Self, polkavm::Error> {
+        let mut config = Config::new();
+        config.set_backend(Some(backend));
+        config.set_sandboxing_enabled(true);
+        #[cfg(target_os = "macos")]
+        {
+            config.set_sandbox(Some(polkavm::SandboxKind::Generic));
+            config.set_allow_experimental(true);
+        }
+        let engine = Engine::new(&config)?;
+        let backend = engine.backend();
+        let mut module_config = ModuleConfig::new();
+        module_config.set_gas_metering(Some(GasMeteringKind::Sync));
+        #[cfg(not(target_arch = "wasm32"))]
+        module_config.set_max_heap_size(Some(crate::MAX_GUEST_HEAP_BYTES));
+        #[cfg(target_os = "macos")]
+        module_config.set_page_size(16_384);
+        let module = Module::from_blob(&engine, &module_config, blob)?;
+
+        let start = module
+            .exports()
+            .find(|export| export.symbol() == "_pvm_start")
+            .ok_or_else(|| "'_pvm_start' export not found".to_string())?
+            .program_counter();
+
+        let mut import_syscall = None;
+        let mut import_set_palette = None;
+        let mut import_display = None;
+        let mut import_fetch_inputs = None;
+        let mut import_init_audio = None;
+        let mut import_output_audio = None;
+        let mut import_epoca_inputs = None;
+        let mut import_epoca_audio = None;
+        let mut import_asset_read = None;
+        let mut import_time_ms = None;
+        let mut import_log = None;
+        let mut import_yield = None;
+
+        for (import_index, import) in module.imports().into_iter().enumerate() {
+            let Some(import) = import else {
+                continue;
+            };
+
+            let import_index = import_index as u32;
+            match import.as_bytes() {
+                b"pvm_syscall" => import_syscall = Some(import_index),
+                b"pvm_set_palette" => import_set_palette = Some(import_index),
+                b"pvm_display" => import_display = Some(import_index),
+                b"pvm_fetch_inputs" => import_fetch_inputs = Some(import_index),
+                b"pvm_init_audio" => import_init_audio = Some(import_index),
+                b"pvm_output_audio" => import_output_audio = Some(import_index),
+                b"pvm_fetch_epoca_inputs" => import_epoca_inputs = Some(import_index),
+                b"host_audio_submit" => import_epoca_audio = Some(import_index),
+                b"pvm_asset_read" => import_asset_read = Some(import_index),
+                b"pvm_time_ms" => import_time_ms = Some(import_index),
+                b"host_log" => import_log = Some(import_index),
+                b"pvm_yield" => import_yield = Some(import_index),
+                _ => return Err(format!("unsupported import: {}", import).into()),
+            }
+        }
+
+        let mut instance = module.instantiate()?;
+        instance.set_interpreter_guest_memory_limit(Some(crate::MAX_GUEST_HEAP_BYTES as usize));
+        Ok(Self {
+            start,
+            instance,
+            backend,
+            filesystem: BTreeMap::new(),
+            open_files: OpenFiles::new(),
+            input_events: VecDeque::with_capacity(MAX_QUEUED_INPUT_EVENTS),
+            audio_channels: 0,
+            epoca_input_events: VecDeque::with_capacity(MAX_QUEUED_INPUT_EVENTS),
+            started: Instant::now(),
+            import_syscall,
+            import_set_palette,
+            import_display,
+            import_fetch_inputs,
+            import_init_audio,
+            import_output_audio,
+            import_epoca_inputs,
+            import_epoca_audio,
+            import_asset_read,
+            import_time_ms,
+            import_log,
+            import_yield,
+        })
+    }
+
+    pub fn backend(&self) -> polkavm::BackendKind {
+        self.backend
+    }
+
+    pub fn set_gas(&mut self, gas: u64) {
+        self.instance.set_gas(gas.min(i64::MAX as u64) as i64);
+    }
+    pub fn gas_remaining(&self) -> u64 {
+        self.instance.gas().max(0) as u64
+    }
+
+    fn send_input_event(&mut self, key: u8, value: u8) {
+        if key == crate::quake_keys::MOUSE_X || key == crate::quake_keys::MOUSE_Y {
+            if let Some(event) = self.input_events.iter_mut().find(|event| event.key == key) {
+                event.value = (event.value as i8).saturating_add(value as i8) as u8;
+                return;
+            }
+        }
+
+        if self.input_events.len() == MAX_QUEUED_INPUT_EVENTS {
+            self.input_events.pop_front();
+        }
+        self.input_events.push_back(InputEvent { key, value });
+    }
+
+    pub fn send_key(&mut self, key: u8, is_pressed: bool) {
+        self.send_input_event(key, if is_pressed { 1 } else { 0 });
+    }
+
+    pub fn send_mouse_move(&mut self, delta_x: i8, delta_y: i8) {
+        if delta_x != 0 {
+            self.send_input_event(crate::quake_keys::MOUSE_X, delta_x as u8);
+        }
+
+        if delta_y != 0 {
+            self.send_input_event(crate::quake_keys::MOUSE_Y, delta_y as u8);
+        }
+    }
+    pub fn uses_epoca_inputs(&self) -> bool {
+        self.import_epoca_inputs.is_some()
+    }
+
+    pub fn send_epoca_input(&mut self, event: crate::InputEvent) {
+        if self.epoca_input_events.len() == MAX_QUEUED_INPUT_EVENTS {
+            self.epoca_input_events.pop_front();
+        }
+        self.epoca_input_events.push_back(event.encode());
+    }
+
+    fn read_cstr(&mut self, address: u64) -> Result<Option<Vec<u8>>, String> {
+        // FIXME: This is slow.
+        let mut buffer = Vec::new();
+        for offset in 0..255 {
+            let Some(address) = address
+                .checked_add(offset)
+                .and_then(|address| u32::try_from(address).ok())
+            else {
+                return Ok(None);
+            };
+            match self.instance.read_u8(address) {
+                Ok(byte) => {
+                    if byte == 0 {
+                        return Ok(Some(buffer));
+                    }
+
+                    buffer.push(byte)
+                }
+                Err(MemoryAccessError::Error(error)) => return Err(error.into()),
+                Err(MemoryAccessError::OutOfRangeAccess { .. }) => return Ok(None),
+                Err(MemoryAccessError::MemoryLimitReached) => return Ok(None),
+            }
+        }
+
+        Ok(None)
+    }
+
+    pub fn register_file(&mut self, path: &str, blob: Vec<u8>) {
+        let normalized = normalize_path(path);
+        self.filesystem
+            .insert(normalized.into_bytes(), Arc::new(File { blob }));
+    }
+
+    fn handle_open(&mut self, path: &[u8], flags: u64) -> u64 {
+        let path = normalize_path(&String::from_utf8_lossy(path));
+        log::debug!("Open: path={path:?}, flags=0x{flags:x}");
+
+        if let Some(file) = self.filesystem.get(path.as_bytes()) {
+            if (flags & (O_WRONLY | O_RDWR)) != 0 {
+                return errno(EACCES);
+            }
+
+            return match self.open_files.open(Arc::clone(file)) {
+                Ok(fd) => fd,
+                Err(error) => errno(error),
+            };
+        }
+
+        errno(ENOENT)
+    }
+
+    fn handle_lseek(&mut self, fd: u64, offset: i64, whence: u64) -> u64 {
+        log::trace!("Seek: fd={fd}, offset={offset}, whence={whence}");
+
+        let Some(fd) = self.open_files.get_mut(fd) else {
+            log::trace!("  -> BADF");
+            return errno(EBADF);
+        };
+
+        let Ok(position) = seek_position(fd.position, fd.file.blob.len() as u64, offset, whence)
+        else {
+            log::trace!("  -> EINVAL");
+            return errno(EINVAL);
+        };
+        fd.position = position;
+
+        log::trace!("  -> offset={}", fd.position);
+        fd.position
+    }
+
+    fn handle_read(&mut self, fd: u64, address: u64, length: u64) -> Result<u64, String> {
+        log::trace!("Read: fd={fd}, address=0x{address:x}, length={length}");
+
+        let Some(fd) = self.open_files.get_mut(fd) else {
+            log::trace!("  -> EBADF");
+            return Ok(errno(EBADF));
+        };
+
+        if address.checked_add(length).is_none() || u32::try_from(address + length).is_err() {
+            log::trace!("  -> EFAULT");
+            return Ok(errno(EFAULT));
+        }
+
+        let Ok(address) = u32::try_from(address) else {
+            log::trace!("  -> EFAULT");
+            return Ok(errno(EFAULT));
+        };
+
+        let end = core::cmp::min(fd.position.wrapping_add(length), fd.file.blob.len() as u64);
+        if fd.position >= end || fd.position >= fd.file.blob.len() as u64 {
+            log::trace!("  -> offset={}, length=0", fd.position);
+            return Ok(0);
+        }
+
+        let blob = &fd.file.blob[fd.position as usize..end as usize];
+        match self.instance.write_memory(address, blob) {
+            Ok(()) => {}
+            Err(MemoryAccessError::Error(error)) => return Err(error.into()),
+            Err(MemoryAccessError::OutOfRangeAccess { .. }) => {
+                log::trace!("  -> EFAULT");
+                return Ok(errno(EFAULT));
+            }
+            Err(MemoryAccessError::MemoryLimitReached) => return Ok(errno(EFAULT)),
+        }
+
+        let length_out = blob.len() as u64;
+        log::trace!(
+            "  -> offset={}, length={}, new offset={}",
+            fd.position,
+            length_out,
+            fd.position + length_out
+        );
+
+        fd.position += length_out;
+        Ok(length_out)
+    }
+
+    fn handle_write(&mut self, fd: u64, address: u64, length: u64) -> Result<u64, String> {
+        if fd != FILENO_STDOUT && fd != FILENO_STDERR {
+            return Ok(errno(EBADF));
+        }
+
+        let length = length.min(MAX_GUEST_WRITE_BYTES);
+        if address.checked_add(length).is_none() || u32::try_from(address + length).is_err() {
+            return Ok(errno(EFAULT));
+        }
+
+        let Ok(address) = u32::try_from(address) else {
+            return Ok(errno(EFAULT));
+        };
+
+        let data = match self.instance.read_memory(address, length as u32) {
+            Ok(data) => data,
+            Err(MemoryAccessError::Error(error)) => return Err(error.into()),
+            Err(MemoryAccessError::OutOfRangeAccess { .. })
+            | Err(MemoryAccessError::MemoryLimitReached) => return Ok(errno(EFAULT)),
+        };
+        eprint!("{}", String::from_utf8_lossy(&data));
+        Ok(length)
+    }
+
+    fn handle_close(&mut self, fd: u64) -> u64 {
+        log::debug!("Close: fd = {fd}");
+        let Some(_fd) = self.open_files.remove(fd) else {
+            log::trace!("  -> EBADF");
+            return errno(EBADF);
+        };
+
+        0
+    }
+
+    #[allow(non_upper_case_globals)]
+    pub fn setup<'a, I>(&mut self, argv: I) -> Result<(), String>
+    where
+        I: IntoIterator<Item = &'a str>,
+        <I as IntoIterator>::IntoIter: ExactSizeIterator,
+    {
+        let argv = argv.into_iter();
+        let argc = argv.len() as u64;
+        let envp: &[&str] = &[];
+        let envp_len = envp.len() as u64;
+        let auxv: &[(u64, u64)] = &[(AT_PAGESZ, 4096)];
+        let auxv_len = auxv.len() as u64;
+
+        let mut sp = self.instance.module().default_sp();
+
+        sp -= (1 + argc + 1 + envp_len + 1 + (auxv_len + 1) * 2) * 8;
+        let address_init = sp;
+
+        let mut p = sp;
+        self.instance.write_u64(p as u32, argc)?;
+        p += 8;
+
+        for arg in argv {
+            sp -= arg.len() as u64 + 1;
+            self.instance.write_memory(sp as u32, arg.as_bytes())?;
+            self.instance.write_u64(p as u32, sp)?;
+            p += 8;
+        }
+        p += 8; // Null pointer.
+
+        for arg in envp {
+            sp -= arg.len() as u64 + 1;
+            self.instance.write_memory(sp as u32, arg.as_bytes())?;
+            self.instance.write_u64(p as u32, sp)?;
+            p += 8;
+        }
+        p += 8; // Null pointer.
+
+        for &(key, value) in auxv {
+            self.instance.write_u64(p as u32, key)?;
+            p += 8;
+            self.instance.write_u64(p as u32, value)?;
+            p += 8;
+        }
+
+        self.instance.set_reg(Reg::SP, sp);
+        self.instance.set_reg(Reg::A0, address_init);
+        self.instance.set_reg(Reg::RA, polkavm::RETURN_TO_HOST);
+        self.instance.set_next_program_counter(self.start);
+        Ok(())
+    }
+
+    pub fn run(&mut self) -> Result<Interruption, String> {
+        'outer_loop: loop {
+            #[allow(clippy::redundant_guards)] // Disable buggy lint.
+            match self.instance.run()? {
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_set_palette => {
+                    let address = self.instance.reg(Reg::A0);
+                    log::debug!("Set palette called: 0x{:x}", address);
+                    let palette = self.instance.read_memory(address as u32, 256 * 3)?;
+                    return Ok(Interruption::SetPalette { palette });
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_display => {
+                    let width = self.instance.reg(Reg::A0);
+                    let height = self.instance.reg(Reg::A1);
+                    let address = self.instance.reg(Reg::A2);
+                    log::trace!("Display called: {}x{}, 0x{:x}", width, height, address);
+                    let pixels = width
+                        .checked_mul(height)
+                        .ok_or_else(|| "frame dimensions overflow".to_owned())?;
+                    if pixels == 0 || pixels > (crate::MAX_FRAME_BYTES / 4) as u64 {
+                        return Err("frame dimensions exceed the host limit".into());
+                    }
+                    let address = u32::try_from(address)
+                        .map_err(|_| "frame address is out of range".to_owned())?;
+                    let framebuffer = self.instance.read_memory(address, pixels as u32)?;
+                    return Ok(Interruption::Display {
+                        width,
+                        height,
+                        framebuffer,
+                    });
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_epoca_inputs => {
+                    let address = u32::try_from(self.instance.reg(Reg::A0))
+                        .map_err(|_| "input address is out of range".to_owned())?;
+                    let capacity =
+                        usize::try_from(self.instance.reg(Reg::A1)).unwrap_or(usize::MAX);
+                    let event_count =
+                        (capacity / crate::INPUT_EVENT_BYTES).min(self.epoca_input_events.len());
+                    let mut written = 0usize;
+                    for _ in 0..event_count {
+                        let Some(event) = self.epoca_input_events.pop_front() else {
+                            break;
+                        };
+                        let destination = address
+                            .checked_add(written as u32)
+                            .ok_or_else(|| "input destination overflow".to_owned())?;
+                        self.instance.write_memory(destination, &event)?;
+                        written += event.len();
+                    }
+                    self.instance.set_reg(Reg::A0, written as u64);
+                    continue;
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_asset_read => {
+                    let name_address = u32::try_from(self.instance.reg(Reg::A0))
+                        .map_err(|_| "asset name address is out of range".to_owned())?;
+                    let name_length = usize::try_from(self.instance.reg(Reg::A1))
+                        .unwrap_or(usize::MAX)
+                        .min(crate::MAX_ASSET_NAME_BYTES);
+                    let offset = usize::try_from(self.instance.reg(Reg::A2)).unwrap_or(usize::MAX);
+                    let destination = u32::try_from(self.instance.reg(Reg::A3))
+                        .map_err(|_| "asset destination is out of range".to_owned())?;
+                    let capacity = usize::try_from(self.instance.reg(Reg::A4))
+                        .unwrap_or(usize::MAX)
+                        .min(crate::MAX_ASSET_READ_BYTES);
+                    let name = self
+                        .instance
+                        .read_memory(name_address, name_length as u32)?;
+                    let Some(file) = self.filesystem.get(&name) else {
+                        self.instance.set_reg(Reg::A0, 0);
+                        continue;
+                    };
+                    let length = capacity.min(file.blob.len().saturating_sub(offset));
+                    if length == 0 {
+                        self.instance.set_reg(Reg::A0, 0);
+                        continue;
+                    }
+                    self.instance
+                        .write_memory(destination, &file.blob[offset..offset + length])?;
+                    self.instance.set_reg(Reg::A0, length as u64);
+                    continue;
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_time_ms => {
+                    self.instance
+                        .set_reg(Reg::A0, self.started.elapsed().as_millis() as u64);
+                    continue;
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_log => {
+                    let address = u32::try_from(self.instance.reg(Reg::A0))
+                        .map_err(|_| "log address is out of range".to_owned())?;
+                    let length =
+                        u32::try_from(self.instance.reg(Reg::A1).min(crate::MAX_LOG_BYTES as u64))
+                            .map_err(|_| "log length is out of range".to_owned())?;
+                    let message = self.instance.read_memory(address, length)?;
+                    log::info!(target: "epoca_pvm_guest", "{}", String::from_utf8_lossy(&message));
+                    continue;
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_yield => {
+                    return Ok(Interruption::Yield);
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_epoca_audio => {
+                    let address = u32::try_from(self.instance.reg(Reg::A0))
+                        .map_err(|_| "audio address is out of range".to_owned())?;
+                    let sample_count =
+                        usize::try_from(self.instance.reg(Reg::A1)).unwrap_or(usize::MAX);
+                    if sample_count == 0
+                        || sample_count % crate::AUDIO_CHANNELS as usize != 0
+                        || sample_count > crate::MAX_AUDIO_SAMPLES_PER_CALL
+                    {
+                        self.instance.set_reg(Reg::A0, 1);
+                        continue;
+                    }
+                    let mut buffer = vec![0i16; sample_count];
+                    self.instance.read_memory_into(address, unsafe {
+                        core::slice::from_raw_parts_mut(
+                            buffer.as_mut_ptr().cast::<u8>(),
+                            sample_count * core::mem::size_of::<i16>(),
+                        )
+                    })?;
+                    self.instance.set_reg(Reg::A0, 0);
+                    return Ok(Interruption::AudioFrame { buffer });
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_fetch_inputs => {
+                    let address = self.instance.reg(Reg::A0);
+                    let requested =
+                        usize::try_from(self.instance.reg(Reg::A1)).unwrap_or(usize::MAX);
+                    let (first, second) = queued_input_chunks(&self.input_events, requested);
+                    let mut written = 0usize;
+
+                    for events in [first, second] {
+                        if events.is_empty() {
+                            continue;
+                        }
+                        let address = input_destination(address, written)?;
+                        self.instance.write_memory(address, unsafe {
+                            core::slice::from_raw_parts(
+                                events.as_ptr().cast::<u8>(),
+                                core::mem::size_of_val(events),
+                            )
+                        })?;
+                        written += events.len();
+                    }
+
+                    for _ in 0..written {
+                        self.input_events.pop_front();
+                    }
+                    self.instance.set_reg(Reg::A0, written as u64);
+                    continue;
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_init_audio => {
+                    let channels = self.instance.reg(Reg::A0) as u32;
+                    let bits_per_sample = self.instance.reg(Reg::A1);
+                    let sample_rate = self.instance.reg(Reg::A2) as u32;
+                    if bits_per_sample != 16 {
+                        self.instance.set_reg(Reg::A0, 0);
+                        continue;
+                    }
+
+                    self.audio_channels = channels;
+                    self.instance.set_reg(Reg::A0, 1);
+                    return Ok(Interruption::AudioInit {
+                        channels,
+                        sample_rate,
+                    });
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_output_audio => {
+                    let address = self.instance.reg(Reg::A0);
+                    let samples = self.instance.reg(Reg::A1) as usize;
+                    let channels = self.audio_channels as usize;
+                    let length = samples.saturating_mul(channels).min(1024 * 64);
+                    let address = u32::try_from(address)
+                        .map_err(|_| "audio address is out of range".to_owned())?;
+                    let mut buffer: Vec<i16> = Vec::with_capacity(length);
+                    unsafe {
+                        self.instance.read_memory_into(
+                            address,
+                            core::slice::from_raw_parts_mut(
+                                buffer
+                                    .spare_capacity_mut()
+                                    .as_mut_ptr()
+                                    .cast::<MaybeUninit<u8>>(),
+                                length * core::mem::size_of::<i16>(),
+                            ),
+                        )?;
+                        buffer.set_len(length);
+                    }
+
+                    return Ok(Interruption::AudioFrame { buffer });
+                }
+                InterruptKind::Ecalli(hostcall) if Some(hostcall) == self.import_syscall => {
+                    let syscall = self.instance.reg(Reg::A0);
+                    let a1 = self.instance.reg(Reg::A1);
+                    let a2 = self.instance.reg(Reg::A2);
+                    let a3 = self.instance.reg(Reg::A3);
+                    let a4 = self.instance.reg(Reg::A4);
+                    let a5 = self.instance.reg(Reg::A5);
+                    let pc = self.instance.program_counter();
+                    log::trace!(
+                        "Syscall at pc={pc:?}: {syscall:>3}, args = [0x{a1:>016x}, 0x{a2:>016x}, 0x{a3:>016x}, 0x{a4:>016x}, 0x{a5:>016x}]"
+                    );
+
+                    match syscall {
+                        SYS_read => {
+                            let result = self.handle_read(a1, a2, a3)?;
+                            self.instance.set_reg(Reg::A0, result);
+                            continue;
+                        }
+                        SYS_readv => {
+                            if a3 == 0 || a3 > IOV_MAX {
+                                self.instance.set_reg(Reg::A0, errno(EINVAL));
+                                continue;
+                            }
+
+                            let mut total_length = 0u64;
+                            for n in 0..a3 {
+                                let address =
+                                    self.instance.read_u64(a2.wrapping_add(n * 16) as u32)?;
+                                let length = self
+                                    .instance
+                                    .read_u64(a2.wrapping_add(n * 16).wrapping_add(8) as u32)?;
+                                let bytes_read = self.handle_read(a1, address, length)?;
+                                if (bytes_read as i64) < 0 {
+                                    self.instance.set_reg(Reg::A0, bytes_read);
+                                    continue 'outer_loop;
+                                }
+
+                                total_length = total_length
+                                    .checked_add(bytes_read)
+                                    .ok_or_else(|| "readv byte count overflow".to_owned())?;
+                                if bytes_read < length {
+                                    break;
+                                }
+                            }
+
+                            self.instance.set_reg(Reg::A0, total_length);
+                            continue;
+                        }
+                        SYS_writev => {
+                            if a3 == 0 || a3 > IOV_MAX {
+                                self.instance.set_reg(Reg::A0, errno(EINVAL));
+                                continue;
+                            }
+
+                            let mut total_length = 0u64;
+                            for n in 0..a3 {
+                                let address =
+                                    self.instance.read_u64(a2.wrapping_add(n * 16) as u32)?;
+                                let length = self
+                                    .instance
+                                    .read_u64(a2.wrapping_add(n * 16).wrapping_add(8) as u32)?;
+                                let bytes_written = self.handle_write(a1, address, length)?;
+                                if (bytes_written as i64) < 0 {
+                                    self.instance.set_reg(Reg::A0, bytes_written);
+                                    continue 'outer_loop;
+                                }
+
+                                total_length = total_length
+                                    .checked_add(bytes_written)
+                                    .ok_or_else(|| "writev byte count overflow".to_owned())?;
+                                if bytes_written < length {
+                                    break;
+                                }
+                            }
+
+                            self.instance.set_reg(Reg::A0, total_length);
+                            continue;
+                        }
+                        SYS_exit => {
+                            log::info!("Exit called: status={}", a1);
+                            if a1 == 0 {
+                                return Ok(Interruption::Exit);
+                            } else {
+                                return Err(format!("exit called with status: {a1}"));
+                            }
+                        }
+                        SYS_openat => {
+                            if a1 == AT_FDCWD {
+                                let Some(path) = self.read_cstr(a2)? else {
+                                    self.instance.set_reg(Reg::A0, errno(EFAULT));
+                                    continue;
+                                };
+
+                                let result = self.handle_open(&path, a3);
+                                self.instance.set_reg(Reg::A0, result);
+                                continue;
+                            }
+                        }
+                        SYS_lseek => {
+                            let result = self.handle_lseek(a1, a2 as i64, a3);
+                            self.instance.set_reg(Reg::A0, result);
+                            continue;
+                        }
+                        SYS_close => {
+                            let result = self.handle_close(a1);
+                            self.instance.set_reg(Reg::A0, result);
+                            continue;
+                        }
+                        _ => {
+                            log::debug!("Unimplemented syscall at pc={pc:?}: {syscall:>3}, args = [0x{a1:>016x}, 0x{a2:>016x}, 0x{a3:>016x}, 0x{a4:>016x}, 0x{a5:>016x}]");
+                        }
+                    }
+
+                    self.instance.set_reg(Reg::A0, errno(ENOSYS));
+                }
+                InterruptKind::Finished => {
+                    return Ok(Interruption::Exit);
+                }
+                InterruptKind::Ecalli(hostcall) => {
+                    return Err(format!("unsupported host call: {hostcall}"));
+                }
+                InterruptKind::Trap => {
+                    return Err(format!(
+                        "execution trapped at {:?}",
+                        self.instance.program_counter()
+                    ));
+                }
+                InterruptKind::NotEnoughGas => {
+                    return Err("ran out of gas".into());
+                }
+                InterruptKind::Segfault(address) => {
+                    return Err(format!("guest segfault at {address:?}"));
+                }
+                InterruptKind::Step => return Err("unexpected guest step".into()),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/rust/crates/pvm-runtime/src/corevm/tests.rs b/rust/crates/pvm-runtime/src/corevm/tests.rs
new file mode 100644
index 000000000..ad59c7ab9
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/corevm/tests.rs
@@ -0,0 +1,62 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use super::*;
+
+#[test]
+fn open_files_enforce_the_descriptor_limit() {
+    let file = Arc::new(File { blob: Vec::new() });
+    let mut open_files = OpenFiles::new();
+    for expected in 3..3 + MAX_OPEN_FILES as u64 {
+        assert_eq!(open_files.open(Arc::clone(&file)), Ok(expected));
+    }
+    assert_eq!(open_files.open(Arc::clone(&file)), Err(EMFILE));
+    assert_eq!(open_files.descriptors.len(), MAX_OPEN_FILES);
+
+    assert!(open_files.remove(3).is_some());
+    assert_eq!(
+        open_files.open(file),
+        Ok(3 + MAX_OPEN_FILES as u64),
+        "closing a descriptor should restore capacity"
+    );
+}
+
+#[test]
+fn seeks_reject_negative_offsets_without_clamping_valid_offsets() {
+    assert_eq!(seek_position(5, 10, -6, SEEK_CUR), Err(EINVAL));
+    assert_eq!(seek_position(0, 10, -11, SEEK_END), Err(EINVAL));
+    assert_eq!(seek_position(0, 10, 12, SEEK_SET), Ok(12));
+    assert_eq!(seek_position(5, 10, 3, SEEK_CUR), Ok(8));
+    assert_eq!(seek_position(0, 10, -3, SEEK_END), Ok(7));
+}
+
+#[test]
+fn wrapped_input_chunks_preserve_order_and_destination() {
+    let mut events = VecDeque::with_capacity(4);
+    for key in 1..=4 {
+        events.push_back(InputEvent { key, value: 1 });
+    }
+    events.pop_front();
+    events.pop_front();
+    events.push_back(InputEvent { key: 5, value: 1 });
+    events.push_back(InputEvent { key: 6, value: 1 });
+
+    let (first, second) = queued_input_chunks(&events, events.len());
+    assert!(
+        !second.is_empty(),
+        "test queue should cross its ring boundary"
+    );
+    let keys: Vec<_> = first.iter().chain(second).map(|event| event.key).collect();
+    assert_eq!(keys, [3, 4, 5, 6]);
+    assert_eq!(
+        input_destination(100, first.len()).unwrap(),
+        100 + u32::try_from(core::mem::size_of_val(first)).unwrap()
+    );
+
+    let written = first.len() + second.len();
+    for _ in 0..written {
+        events.pop_front();
+    }
+    assert!(events.is_empty(), "every reported event should be consumed");
+}
diff --git a/rust/crates/pvm-runtime/src/lib.rs b/rust/crates/pvm-runtime/src/lib.rs
new file mode 100644
index 000000000..5397ffcaa
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/lib.rs
@@ -0,0 +1,1183 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#[cfg(target_arch = "wasm32")]
+extern crate polkavm_wasm as polkavm;
+
+mod application;
+mod corevm;
+pub use pvm_gpu_wire as gpu_wire;
+mod manifest;
+#[cfg(all(not(target_arch = "wasm32"), feature = "ffi"))]
+mod native_ffi;
+mod quake_keys;
+mod tri2d;
+#[cfg(target_arch = "wasm32")]
+mod wasm;
+#[cfg(any(target_arch = "wasm32", test))]
+mod wasm_codegen;
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "ffi"))]
+pub use native_ffi::*;
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "ffi"))]
+uniffi::setup_scaffolding!();
+
+pub use application::ApplicationRuntime;
+pub use manifest::AppDescriptor;
+
+use anyhow::{anyhow, Context, Result};
+pub use polkavm::BackendKind;
+use polkavm::{CallError, Config, Engine, Instance, Linker, Module, ProgramBlob};
+use std::collections::{HashMap, VecDeque};
+use std::mem::size_of;
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::{Duration, Instant};
+pub use tri2d::{
+    Tri2dFrame, MAX_TRI2D_BYTES, MAX_TRI2D_COMMANDS, MAX_TRI2D_DRAWS, MAX_TRI2D_INDICES,
+    MAX_TRI2D_SURFACE_SIZE, MAX_TRI2D_TEXTURES, MAX_TRI2D_TEXTURE_BYTES, MAX_TRI2D_TEXTURE_SIZE,
+    MAX_TRI2D_VERTICES, TRI2D_HEADER_BYTES, TRI2D_MAGIC, TRI2D_VERSION,
+};
+
+pub const ABI_VERSION: u32 = 1;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PresentationProfile {
+    Framebuffer,
+    Tri2d,
+    WebGpuRaster,
+}
+
+impl PresentationProfile {
+    pub fn parse(value: &str) -> Result<Self> {
+        match value {
+            "framebuffer" => Ok(Self::Framebuffer),
+            "tri2d" => Ok(Self::Tri2d),
+            "webgpu-raster" => Ok(Self::WebGpuRaster),
+            _ => Err(anyhow!("unsupported presentation profile {value}")),
+        }
+    }
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Framebuffer => "framebuffer",
+            Self::Tri2d => "tri2d",
+            Self::WebGpuRaster => "webgpu-raster",
+        }
+    }
+}
+pub const BYTES_PER_PIXEL: usize = 4;
+pub const MAX_PROGRAM_BYTES: usize = 16 * 1024 * 1024;
+pub const MAX_FRAME_BYTES: usize = 16 * 1024 * 1024;
+pub const MAX_GUEST_READ: usize = MAX_FRAME_BYTES;
+pub const MAX_GUEST_RW_DATA_BYTES: u32 = 64 * 1024 * 1024;
+pub const MAX_GUEST_STACK_BYTES: u32 = 16 * 1024 * 1024;
+pub const MAX_GUEST_HEAP_BYTES: u32 = 128 * 1024 * 1024;
+pub const MAX_ASSET_FILES: usize = 2_048;
+pub const MAX_ASSET_FILE_BYTES: usize = 64 * 1024 * 1024;
+pub const MAX_ASSET_BYTES: usize = 128 * 1024 * 1024;
+pub const INPUT_EVENT_BYTES: usize = 8;
+pub const AUDIO_SAMPLE_RATE: u32 = 48_000;
+pub const AUDIO_CHANNELS: u32 = 2;
+pub const MAX_AUDIO_SAMPLES_PER_CALL: usize = AUDIO_SAMPLE_RATE as usize * AUDIO_CHANNELS as usize;
+const MAX_ASSET_NAME_BYTES: usize = 1_024;
+const MAX_ASSET_READ_BYTES: usize = 16 * 1024 * 1024;
+const MAX_HOSTCALL_BYTES_PER_TICK: usize = 32 * 1024 * 1024;
+const MAX_HOSTCALLS_PER_INIT: u32 = 131_072;
+const MAX_HOSTCALLS_PER_UPDATE: u32 = 8_192;
+const MAX_SLEEP_MS_PER_INIT: u32 = 100;
+const MAX_SLEEP_MS_PER_UPDATE: u32 = 50;
+const MAX_QUEUED_AUDIO_SAMPLES: usize = AUDIO_SAMPLE_RATE as usize * AUDIO_CHANNELS as usize * 2;
+const MAX_QUEUED_INPUT_EVENTS: usize = 4_096;
+const MAX_SAVE_BYTES: usize = 1024 * 1024;
+const MAX_LOG_BYTES: usize = 4 * 1024;
+const MAX_QUEUED_LOGS: usize = 64;
+const MAX_QUEUED_GPU_BATCHES: usize = 4;
+const MAX_QUEUED_GPU_EVENTS: usize = 256;
+const MAX_GPU_SUBMITS_PER_TICK: u32 = 8;
+const MAX_GPU_UPLOAD_BYTES_PER_TICK: usize = 16 * 1024 * 1024;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum InputEventType {
+    KeyDown = 1,
+    KeyUp = 2,
+    ButtonDown = 3,
+    ButtonUp = 4,
+    PointerMove = 5,
+    PointerDelta = 6,
+    SurfaceMetrics = 7,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct InputEvent {
+    pub event_type: InputEventType,
+    pub code: u8,
+    pub x: u16,
+    pub y: u16,
+}
+
+impl InputEvent {
+    fn encode(self) -> [u8; INPUT_EVENT_BYTES] {
+        let x = self.x.to_le_bytes();
+        let y = self.y.to_le_bytes();
+        [
+            self.event_type as u8,
+            self.code,
+            x[0],
+            x[1],
+            y[0],
+            y[1],
+            0,
+            0,
+        ]
+    }
+}
+
+#[derive(Debug)]
+pub struct Frame {
+    pub width: u32,
+    pub height: u32,
+    /// Packed 0xAARRGGBB pixels. On little-endian guests these bytes are BGRA.
+    pub argb: Vec<u8>,
+}
+
+#[derive(Debug)]
+pub struct AudioChunk {
+    /// Interleaved little-endian signed 16-bit samples.
+    pub samples: Vec<i16>,
+    pub sample_rate: u32,
+    pub channels: u32,
+}
+
+#[derive(Debug)]
+pub struct GpuBatch {
+    pub bytes: Vec<u8>,
+}
+
+struct HostClock {
+    #[cfg(not(target_arch = "wasm32"))]
+    started: Instant,
+    #[cfg(target_arch = "wasm32")]
+    now_ms: u64,
+}
+
+impl HostClock {
+    fn new() -> Self {
+        Self {
+            #[cfg(not(target_arch = "wasm32"))]
+            started: Instant::now(),
+            #[cfg(target_arch = "wasm32")]
+            now_ms: 0,
+        }
+    }
+
+    fn elapsed_ms(&self) -> u64 {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            self.started.elapsed().as_millis() as u64
+        }
+        #[cfg(target_arch = "wasm32")]
+        {
+            self.now_ms
+        }
+    }
+
+    fn sleep_ms(&mut self, duration_ms: u32) {
+        #[cfg(not(target_arch = "wasm32"))]
+        std::thread::sleep(Duration::from_millis(duration_ms.into()));
+        #[cfg(target_arch = "wasm32")]
+        {
+            self.now_ms = self.now_ms.saturating_add(duration_ms.into());
+        }
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    fn set_time_ms(&mut self, time_ms: u64) {
+        self.now_ms = self.now_ms.max(time_ms);
+    }
+}
+
+pub(crate) fn preferred_backend() -> BackendKind {
+    #[cfg(any(target_arch = "wasm32", target_os = "ios", target_os = "android"))]
+    {
+        BackendKind::Interpreter
+    }
+    #[cfg(not(any(target_arch = "wasm32", target_os = "ios", target_os = "android")))]
+    {
+        BackendKind::Compiler
+    }
+}
+
+struct HostState {
+    frame: Option<Frame>,
+    tri2d: Option<Tri2dFrame>,
+    tri2d_state: tri2d::Tri2dState,
+    audio_enabled: bool,
+    presentation: PresentationProfile,
+    tri2d_submitted: bool,
+    audio: VecDeque<AudioChunk>,
+    audio_samples: usize,
+    input: VecDeque<InputEvent>,
+    assets: HashMap<String, Vec<u8>>,
+    clock: HostClock,
+    logs: VecDeque<String>,
+    save: Option<Vec<u8>>,
+    hostcall_bytes_remaining: usize,
+    hostcalls_remaining: u32,
+    sleep_ms_remaining: u32,
+    gpu_capabilities: Option<Vec<u8>>,
+    gpu_batches: VecDeque<GpuBatch>,
+    gpu_events: VecDeque<Vec<u8>>,
+    gpu_last_sequence: u64,
+    gpu_submits_remaining: u32,
+    gpu_upload_bytes_remaining: usize,
+}
+
+impl HostState {
+    fn new(
+        assets: HashMap<String, Vec<u8>>,
+        presentation: PresentationProfile,
+        audio_enabled: bool,
+    ) -> Self {
+        Self {
+            frame: None,
+            tri2d: None,
+            presentation,
+            audio_enabled,
+            tri2d_state: tri2d::Tri2dState::default(),
+            tri2d_submitted: false,
+            audio: VecDeque::new(),
+            audio_samples: 0,
+            input: VecDeque::new(),
+            assets,
+            clock: HostClock::new(),
+            logs: VecDeque::new(),
+            save: None,
+            hostcall_bytes_remaining: 0,
+            hostcalls_remaining: 0,
+            sleep_ms_remaining: 0,
+            gpu_capabilities: None,
+            gpu_batches: VecDeque::new(),
+            gpu_events: VecDeque::new(),
+            gpu_last_sequence: 0,
+            gpu_submits_remaining: 0,
+            gpu_upload_bytes_remaining: 0,
+        }
+    }
+
+    fn reset_hostcall_budget(&mut self, max_hostcalls: u32, max_sleep_ms: u32) {
+        self.hostcall_bytes_remaining = MAX_HOSTCALL_BYTES_PER_TICK;
+        self.hostcalls_remaining = max_hostcalls;
+        self.sleep_ms_remaining = max_sleep_ms;
+        self.tri2d_submitted = false;
+        self.gpu_submits_remaining = MAX_GPU_SUBMITS_PER_TICK;
+        self.gpu_upload_bytes_remaining = MAX_GPU_UPLOAD_BYTES_PER_TICK;
+    }
+
+    fn charge_hostcall(&mut self, bytes: usize) -> Result<()> {
+        if self.hostcalls_remaining == 0 {
+            return Err(anyhow!("guest exceeded host-call count budget"));
+        }
+        self.hostcalls_remaining -= 1;
+        self.charge_hostcall_bytes(bytes)
+    }
+
+    fn charge_hostcall_bytes(&mut self, bytes: usize) -> Result<()> {
+        if bytes > self.hostcall_bytes_remaining {
+            return Err(anyhow!("guest exceeded host-call byte budget"));
+        }
+        self.hostcall_bytes_remaining -= bytes;
+        Ok(())
+    }
+
+    fn queue_input(&mut self, event: InputEvent) {
+        if event.event_type == InputEventType::SurfaceMetrics {
+            if let Some(position) = self
+                .input
+                .iter()
+                .rposition(|queued| queued.event_type == InputEventType::SurfaceMetrics)
+            {
+                self.input.remove(position);
+            }
+        } else if event.event_type == InputEventType::PointerMove
+            && self
+                .input
+                .back()
+                .is_some_and(|queued| queued.event_type == InputEventType::PointerMove)
+        {
+            self.input.pop_back();
+        }
+        if self.input.len() == MAX_QUEUED_INPUT_EVENTS {
+            let discardable = self
+                .input
+                .iter()
+                .position(|queued| queued.event_type == InputEventType::PointerMove)
+                .or_else(|| {
+                    self.input
+                        .iter()
+                        .position(|queued| queued.event_type != InputEventType::SurfaceMetrics)
+                });
+            if let Some(position) = discardable {
+                self.input.remove(position);
+            } else {
+                self.input.pop_front();
+            }
+        }
+        self.input.push_back(event);
+    }
+}
+
+pub struct Runtime {
+    instance: Instance<HostState, anyhow::Error>,
+    state: HostState,
+    max_gas_per_update: u64,
+    last_gas_used: u64,
+    backend: polkavm::BackendKind,
+}
+
+impl Runtime {
+    pub fn new(
+        program: &[u8],
+        assets: HashMap<String, Vec<u8>>,
+        presentation: PresentationProfile,
+        audio_enabled: bool,
+        max_gas_per_update: u64,
+    ) -> Result<Self> {
+        Self::new_with_backend(
+            program,
+            assets,
+            presentation,
+            audio_enabled,
+            max_gas_per_update,
+            preferred_backend(),
+        )
+    }
+
+    pub fn new_with_backend(
+        program: &[u8],
+        assets: HashMap<String, Vec<u8>>,
+        presentation: PresentationProfile,
+        audio_enabled: bool,
+        max_gas_per_update: u64,
+        backend: BackendKind,
+    ) -> Result<Self> {
+        let blob = ProgramBlob::parse(program.into()).context("parse PolkaVM program")?;
+        if blob.rw_data_size() > MAX_GUEST_RW_DATA_BYTES {
+            return Err(anyhow!(
+                "guest read-write data exceeds {MAX_GUEST_RW_DATA_BYTES} bytes"
+            ));
+        }
+        if blob.stack_size() > MAX_GUEST_STACK_BYTES {
+            return Err(anyhow!("guest stack exceeds {MAX_GUEST_STACK_BYTES} bytes"));
+        }
+        let mut engine_config = Config::new();
+        // macOS requires PolkaVM's experimental generic sandbox for native
+        // recompilation. Keep sandboxing enabled while opting into that boundary.
+        engine_config.set_backend(Some(backend));
+        engine_config.set_sandboxing_enabled(true);
+        #[cfg(target_os = "macos")]
+        {
+            engine_config.set_sandbox(Some(polkavm::SandboxKind::Generic));
+            engine_config.set_allow_experimental(true);
+        }
+        let engine = Engine::new(&engine_config).context("create PolkaVM engine")?;
+        let backend = engine.backend();
+
+        let mut module_config = polkavm::ModuleConfig::default();
+        module_config.set_gas_metering(Some(polkavm::GasMeteringKind::Sync));
+        #[cfg(not(target_arch = "wasm32"))]
+        module_config.set_max_heap_size(Some(MAX_GUEST_HEAP_BYTES));
+        #[cfg(target_os = "macos")]
+        module_config.set_page_size(16_384);
+
+        let module =
+            Module::from_blob(&engine, &module_config, blob).context("compile PolkaVM module")?;
+        let mut linker: Linker<HostState, anyhow::Error> = Linker::new();
+
+        linker
+            .define_typed(
+                "host_present_frame",
+                |caller: polkavm::Caller<'_, HostState>,
+                 pointer: u32,
+                 width: u32,
+                 height: u32,
+                 stride: u32|
+                 -> Result<u32> {
+                    let row_bytes = width
+                        .checked_mul(BYTES_PER_PIXEL as u32)
+                        .ok_or_else(|| anyhow!("frame row size overflow"))?;
+                    if stride != row_bytes {
+                        return Ok(1);
+                    }
+                    let byte_len = row_bytes
+                        .checked_mul(height)
+                        .ok_or_else(|| anyhow!("frame size overflow"))?
+                        as usize;
+                    if byte_len == 0 || byte_len > MAX_FRAME_BYTES {
+                        return Ok(1);
+                    }
+                    caller.user_data.charge_hostcall(byte_len)?;
+                    if caller.user_data.presentation != PresentationProfile::Framebuffer {
+                        return Ok(3);
+                    }
+                    let argb = read_guest_memory(caller.instance, pointer, byte_len)?;
+                    caller.user_data.frame = Some(Frame {
+                        width,
+                        height,
+                        argb,
+                    });
+                    Ok(0)
+                },
+            )
+            .context("define host_present_frame")?;
+
+        linker
+            .define_typed(
+                "host_tri2d_submit",
+                |caller: polkavm::Caller<'_, HostState>,
+                 pointer: u32,
+                 length: u32|
+                 -> Result<u32> {
+                    let length = length as usize;
+                    if length == 0 || length > MAX_TRI2D_BYTES {
+                        return Ok(1);
+                    }
+                    caller.user_data.charge_hostcall(length)?;
+                    if caller.user_data.presentation != PresentationProfile::Tri2d {
+                        return Ok(3);
+                    }
+                    if caller.user_data.tri2d_submitted {
+                        return Ok(2);
+                    }
+                    let bytes = read_guest_memory(caller.instance, pointer, length)?;
+                    let Ok((next_state, metadata)) =
+                        tri2d::validate_tri2d(&bytes, &caller.user_data.tri2d_state)
+                    else {
+                        return Ok(1);
+                    };
+                    caller.user_data.tri2d_state = next_state;
+                    caller.user_data.tri2d_submitted = true;
+                    caller.user_data.tri2d = Some(Tri2dFrame {
+                        width: metadata.width,
+                        height: metadata.height,
+                        draw_count: metadata.draw_count,
+                        vertex_count: metadata.vertex_count,
+                        index_count: metadata.index_count,
+                        bytes,
+                    });
+                    Ok(0)
+                },
+            )
+            .context("define host_tri2d_submit")?;
+
+        linker
+            .define_typed(
+                "epoca_gpu_capabilities",
+                |caller: polkavm::Caller<'_, HostState>,
+                 pointer: u32,
+                 capacity: u32|
+                 -> Result<i32> {
+                    caller.user_data.charge_hostcall(0)?;
+                    if caller.user_data.presentation != PresentationProfile::WebGpuRaster {
+                        return Ok(gpu_wire::GPU_ERROR_INVALID_STATE);
+                    }
+                    let Some(required_len) =
+                        caller.user_data.gpu_capabilities.as_ref().map(Vec::len)
+                    else {
+                        return Ok(0);
+                    };
+                    let required = i32::try_from(required_len)
+                        .map_err(|_| anyhow!("GPU capabilities length overflow"))?;
+                    if (capacity as usize) < required_len {
+                        return Ok(-required);
+                    }
+                    caller.user_data.charge_hostcall_bytes(required_len)?;
+                    let capabilities = caller.user_data.gpu_capabilities.as_ref().unwrap();
+                    if caller.instance.write_memory(pointer, capabilities).is_err() {
+                        return Ok(gpu_wire::GPU_ERROR_INVALID_GUEST_RANGE);
+                    }
+                    Ok(required)
+                },
+            )
+            .context("define epoca_gpu_capabilities")?;
+
+        linker
+            .define_typed(
+                "epoca_gpu_submit",
+                |caller: polkavm::Caller<'_, HostState>,
+                 pointer: u32,
+                 length: u32|
+                 -> Result<i32> {
+                    let length = length as usize;
+                    caller.user_data.charge_hostcall(length)?;
+                    if caller.user_data.presentation != PresentationProfile::WebGpuRaster {
+                        return Ok(gpu_wire::GPU_ERROR_INVALID_STATE);
+                    }
+                    if length == 0 || length > gpu_wire::MAX_GPU_BATCH_BYTES {
+                        return Ok(gpu_wire::GPU_ERROR_MALFORMED_BATCH);
+                    }
+                    if caller.user_data.gpu_capabilities.is_none() {
+                        return Ok(gpu_wire::GPU_ERROR_INVALID_STATE);
+                    }
+                    if caller.user_data.gpu_batches.len() == MAX_QUEUED_GPU_BATCHES {
+                        return Ok(gpu_wire::GPU_SUBMIT_BUSY);
+                    }
+                    if caller.user_data.gpu_submits_remaining == 0 {
+                        return Ok(gpu_wire::GPU_ERROR_QUOTA_EXCEEDED);
+                    }
+                    let Ok(bytes) = read_guest_memory(caller.instance, pointer, length) else {
+                        return Ok(gpu_wire::GPU_ERROR_INVALID_GUEST_RANGE);
+                    };
+                    let Ok(batch) = gpu_wire::decode_gpu_batch(&bytes) else {
+                        return Ok(gpu_wire::GPU_ERROR_MALFORMED_BATCH);
+                    };
+                    if batch.sequence() <= caller.user_data.gpu_last_sequence {
+                        return Ok(gpu_wire::GPU_ERROR_INVALID_STATE);
+                    }
+                    let Some(upload_bytes) = gpu_inline_upload_bytes(&batch) else {
+                        return Ok(gpu_wire::GPU_ERROR_MALFORMED_BATCH);
+                    };
+                    if upload_bytes > caller.user_data.gpu_upload_bytes_remaining {
+                        return Ok(gpu_wire::GPU_ERROR_QUOTA_EXCEEDED);
+                    }
+                    caller.user_data.gpu_submits_remaining -= 1;
+                    caller.user_data.gpu_upload_bytes_remaining -= upload_bytes;
+                    caller.user_data.gpu_last_sequence = batch.sequence();
+                    caller.user_data.gpu_batches.push_back(GpuBatch { bytes });
+                    Ok(gpu_wire::GPU_SUBMIT_ACCEPTED)
+                },
+            )
+            .context("define epoca_gpu_submit")?;
+
+        linker
+            .define_typed(
+                "epoca_gpu_receive",
+                |caller: polkavm::Caller<'_, HostState>,
+                 pointer: u32,
+                 capacity: u32|
+                 -> Result<i32> {
+                    caller.user_data.charge_hostcall(0)?;
+                    if caller.user_data.presentation != PresentationProfile::WebGpuRaster {
+                        return Ok(gpu_wire::GPU_ERROR_INVALID_STATE);
+                    }
+                    let Some(required_len) = caller.user_data.gpu_events.front().map(Vec::len)
+                    else {
+                        return Ok(0);
+                    };
+                    let required = i32::try_from(required_len)
+                        .map_err(|_| anyhow!("GPU event length overflow"))?;
+                    if (capacity as usize) < required_len {
+                        return Ok(-required);
+                    }
+                    caller.user_data.charge_hostcall_bytes(required_len)?;
+                    let event = caller.user_data.gpu_events.front().unwrap();
+                    if caller.instance.write_memory(pointer, event).is_err() {
+                        return Ok(gpu_wire::GPU_ERROR_INVALID_GUEST_RANGE);
+                    }
+                    caller.user_data.gpu_events.pop_front();
+                    Ok(required)
+                },
+            )
+            .context("define epoca_gpu_receive")?;
+
+        linker
+            .define_typed(
+                "host_poll_input",
+                |caller: polkavm::Caller<'_, HostState>,
+                 pointer: u32,
+                 capacity: u32|
+                 -> Result<u32> {
+                    let event_count =
+                        (capacity as usize / INPUT_EVENT_BYTES).min(caller.user_data.input.len());
+                    let byte_count = event_count
+                        .checked_mul(INPUT_EVENT_BYTES)
+                        .ok_or_else(|| anyhow!("input byte count overflow"))?;
+                    caller.user_data.charge_hostcall(byte_count)?;
+                    let mut written = 0u32;
+                    for _ in 0..event_count {
+                        let Some(event) = caller.user_data.input.pop_front() else {
+                            break;
+                        };
+                        let destination = pointer
+                            .checked_add(written)
+                            .ok_or_else(|| anyhow!("guest input destination overflow"))?;
+                        caller
+                            .instance
+                            .write_memory(destination, &event.encode())
+                            .map_err(|error| anyhow!("write guest input: {error:?}"))?;
+                        written += INPUT_EVENT_BYTES as u32;
+                    }
+                    Ok(written)
+                },
+            )
+            .context("define host_poll_input")?;
+
+        linker
+            .define_typed(
+                "host_time_ms",
+                |caller: polkavm::Caller<'_, HostState>| -> Result<u64> {
+                    caller.user_data.charge_hostcall(0)?;
+                    Ok(caller.user_data.clock.elapsed_ms())
+                },
+            )
+            .context("define host_time_ms")?;
+
+        linker
+            .define_typed(
+                "host_sleep_ms",
+                |caller: polkavm::Caller<'_, HostState>, duration_ms: u32| -> Result<()> {
+                    caller.user_data.charge_hostcall(0)?;
+                    let duration_ms = duration_ms.min(caller.user_data.sleep_ms_remaining);
+                    caller.user_data.sleep_ms_remaining -= duration_ms;
+                    caller.user_data.clock.sleep_ms(duration_ms);
+                    Ok(())
+                },
+            )
+            .context("define host_sleep_ms")?;
+
+        linker
+            .define_typed(
+                "host_audio_submit",
+                |caller: polkavm::Caller<'_, HostState>,
+                 pointer: u32,
+                 sample_count: u32|
+                 -> Result<u32> {
+                    let sample_count = sample_count as usize;
+                    if sample_count == 0
+                        || !sample_count.is_multiple_of(AUDIO_CHANNELS as usize)
+                        || sample_count > MAX_AUDIO_SAMPLES_PER_CALL
+                        || caller.user_data.audio_samples + sample_count > MAX_QUEUED_AUDIO_SAMPLES
+                    {
+                        return Ok(1);
+                    }
+                    let byte_count = sample_count
+                        .checked_mul(size_of::<i16>())
+                        .ok_or_else(|| anyhow!("audio byte count overflow"))?;
+                    caller.user_data.charge_hostcall(byte_count)?;
+                    if !caller.user_data.audio_enabled {
+                        return Ok(3);
+                    }
+                    let bytes = read_guest_memory(caller.instance, pointer, byte_count)?;
+                    let samples = bytes
+                        .as_chunks::<2>()
+                        .0
+                        .iter()
+                        .map(|sample| i16::from_le_bytes(*sample))
+                        .collect();
+                    caller.user_data.audio_samples += sample_count;
+                    caller.user_data.audio.push_back(AudioChunk {
+                        samples,
+                        sample_rate: AUDIO_SAMPLE_RATE,
+                        channels: AUDIO_CHANNELS,
+                    });
+                    Ok(0)
+                },
+            )
+            .context("define host_audio_submit")?;
+
+        linker
+            .define_typed(
+                "host_asset_read",
+                |caller: polkavm::Caller<'_, HostState>,
+                 name_pointer: u32,
+                 name_length: u32,
+                 offset: u32,
+                 destination: u32,
+                 capacity: u32|
+                 -> Result<u32> {
+                    let name_length = name_length as usize;
+                    caller.user_data.charge_hostcall(name_length)?;
+                    if name_length == 0 || name_length > MAX_ASSET_NAME_BYTES {
+                        return Ok(0);
+                    }
+                    let name = read_guest_memory(caller.instance, name_pointer, name_length)?;
+                    let Ok(name) = std::str::from_utf8(&name) else {
+                        return Ok(0);
+                    };
+                    let Some(asset_length) = caller.user_data.assets.get(name).map(Vec::len) else {
+                        return Ok(0);
+                    };
+                    let offset = offset as usize;
+                    if offset >= asset_length {
+                        return Ok(0);
+                    }
+                    let length = (capacity as usize)
+                        .min(asset_length - offset)
+                        .min(MAX_ASSET_READ_BYTES);
+                    caller.user_data.charge_hostcall_bytes(length)?;
+                    let asset = &caller.user_data.assets[name];
+                    caller
+                        .instance
+                        .write_memory(destination, &asset[offset..offset + length])
+                        .map_err(|error| anyhow!("write guest asset: {error:?}"))?;
+                    Ok(length as u32)
+                },
+            )
+            .context("define host_asset_read")?;
+
+        linker
+            .define_typed(
+                "host_save_submit",
+                |caller: polkavm::Caller<'_, HostState>,
+                 pointer: u32,
+                 length: u32|
+                 -> Result<u32> {
+                    let length = length as usize;
+                    if length == 0 || length > MAX_SAVE_BYTES {
+                        return Ok(1);
+                    }
+                    caller.user_data.charge_hostcall(length)?;
+                    caller.user_data.save =
+                        Some(read_guest_memory(caller.instance, pointer, length)?);
+                    Ok(0)
+                },
+            )
+            .context("define host_save_submit")?;
+
+        linker
+            .define_typed(
+                "host_log",
+                |caller: polkavm::Caller<'_, HostState>, pointer: u32, length: u32| -> Result<()> {
+                    let length = (length as usize).min(MAX_LOG_BYTES);
+                    caller.user_data.charge_hostcall(length)?;
+                    let bytes = read_guest_memory(caller.instance, pointer, length)?;
+                    if caller.user_data.logs.len() == MAX_QUEUED_LOGS {
+                        caller.user_data.logs.pop_front();
+                    }
+                    caller
+                        .user_data
+                        .logs
+                        .push_back(String::from_utf8_lossy(&bytes).into_owned());
+                    Ok(())
+                },
+            )
+            .context("define host_log")?;
+
+        let instance = linker
+            .instantiate_pre(&module)
+            .context("pre-instantiate PolkaVM module")?
+            .instantiate()
+            .context("instantiate PolkaVM module")?;
+
+        Ok(Self {
+            instance,
+            state: HostState::new(assets, presentation, audio_enabled),
+            max_gas_per_update,
+            last_gas_used: 0,
+            backend,
+        })
+    }
+
+    pub fn init(&mut self) -> Result<()> {
+        let gas = self.max_gas_per_update.min(i64::MAX as u64) as i64;
+        self.instance.set_gas(gas);
+        self.state
+            .reset_hostcall_budget(MAX_HOSTCALLS_PER_INIT, MAX_SLEEP_MS_PER_INIT);
+        let result = self
+            .instance
+            .call_typed_and_get_result::<(), ()>(&mut self.state, "init", ());
+        self.record_gas_used(gas);
+        let program_counter = self.instance.program_counter();
+        map_call_result(result, "init").map_err(|error| {
+            let error = if let Some(log) = self.state.logs.back() {
+                error.context(format!("last guest log: {log}"))
+            } else {
+                error
+            };
+            if let Some(program_counter) = program_counter {
+                error.context(format!("guest program counter: {program_counter}"))
+            } else {
+                error
+            }
+        })
+    }
+
+    pub fn update(&mut self) -> Result<()> {
+        let gas = self.max_gas_per_update.min(i64::MAX as u64) as i64;
+        self.instance.set_gas(gas);
+        self.state
+            .reset_hostcall_budget(MAX_HOSTCALLS_PER_UPDATE, MAX_SLEEP_MS_PER_UPDATE);
+        let result =
+            self.instance
+                .call_typed_and_get_result::<(), ()>(&mut self.state, "update", ());
+        self.record_gas_used(gas);
+        let program_counter = self.instance.program_counter();
+        map_call_result(result, "update").map_err(|error| {
+            let error = if let Some(log) = self.state.logs.back() {
+                error.context(format!("last guest log: {log}"))
+            } else {
+                error
+            };
+            if let Some(program_counter) = program_counter {
+                error.context(format!("guest program counter: {program_counter}"))
+            } else {
+                error
+            }
+        })
+    }
+    fn record_gas_used(&mut self, budget: i64) {
+        let remaining = self.instance.gas().max(0);
+        self.last_gas_used = (budget - remaining.min(budget)) as u64;
+    }
+
+    pub fn last_gas_used(&self) -> u64 {
+        self.last_gas_used
+    }
+
+    pub fn backend(&self) -> polkavm::BackendKind {
+        self.backend
+    }
+
+    pub fn send_input(&mut self, event: InputEvent) {
+        self.state.queue_input(event);
+    }
+
+    pub fn gpu_ready(&self) -> bool {
+        self.state.presentation != PresentationProfile::WebGpuRaster
+            || self.state.gpu_capabilities.is_some()
+    }
+
+    pub fn set_gpu_capabilities(&mut self, bytes: Vec<u8>) -> Result<()> {
+        if self.state.presentation != PresentationProfile::WebGpuRaster {
+            return Err(anyhow!("GPU capabilities sent to a non-GPU application"));
+        }
+        validate_gpu_capabilities(&bytes)?;
+        self.state.gpu_capabilities = Some(bytes);
+        Ok(())
+    }
+
+    pub fn send_gpu_event(&mut self, bytes: Vec<u8>) -> Result<()> {
+        if self.state.presentation != PresentationProfile::WebGpuRaster {
+            return Err(anyhow!("GPU event sent to a non-GPU application"));
+        }
+        validate_gpu_event(&bytes)?;
+        if self.state.gpu_events.len() == MAX_QUEUED_GPU_EVENTS {
+            return Err(anyhow!("GPU event queue overflow"));
+        }
+        self.state.gpu_events.push_back(bytes);
+        Ok(())
+    }
+
+    pub fn take_gpu_batch(&mut self) -> Option<GpuBatch> {
+        self.state.gpu_batches.pop_front()
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn set_time_ms(&mut self, time_ms: u64) {
+        self.state.clock.set_time_ms(time_ms);
+    }
+
+    pub fn take_frame(&mut self) -> Option<Frame> {
+        self.state.frame.take()
+    }
+
+    pub fn take_tri2d(&mut self) -> Option<Tri2dFrame> {
+        self.state.tri2d.take()
+    }
+
+    pub fn take_audio(&mut self) -> Option<AudioChunk> {
+        let chunk = self.state.audio.pop_front()?;
+        self.state.audio_samples -= chunk.samples.len();
+        Some(chunk)
+    }
+
+    pub fn take_log(&mut self) -> Option<String> {
+        self.state.logs.pop_front()
+    }
+
+    pub fn take_save(&mut self) -> Option<Vec<u8>> {
+        self.state.save.take()
+    }
+}
+
+fn gpu_inline_upload_bytes(batch: &gpu_wire::GpuBatch<'_>) -> Option<usize> {
+    batch.commands().try_fold(0usize, |total, command| {
+        let bytes = match command.opcode {
+            gpu_wire::GpuOpcode::WriteBuffer => gpu_u32(command.payload, 16)? as usize,
+            gpu_wire::GpuOpcode::WriteTexture => gpu_u32(command.payload, 40)? as usize,
+            _ => 0,
+        };
+        total.checked_add(bytes)
+    })
+}
+
+fn validate_gpu_capabilities(bytes: &[u8]) -> Result<()> {
+    const HEADER_BYTES: usize = 56;
+    const ENTRY_BYTES: usize = 16;
+    if bytes.len() < HEADER_BYTES
+        || bytes[..4] != gpu_wire::GPU_CAPABILITIES_MAGIC
+        || gpu_u16(bytes, 4) != Some(gpu_wire::GPU_WIRE_VERSION)
+        || gpu_u16(bytes, 6) != Some(0)
+        || gpu_u32(bytes, 8) != Some(bytes.len() as u32)
+        || !matches!(gpu_u16(bytes, 12), Some(1..=4))
+        || gpu_u16(bytes, 14) != Some(0)
+        || gpu_u32(bytes, 16) == Some(0)
+        || gpu_u32(bytes, 20) == Some(0)
+        || gpu_u32(bytes, 24) == Some(0)
+        || gpu_u32(bytes, 28) == Some(0)
+        || gpu_u32(bytes, 36) == Some(0)
+        || gpu_u32(bytes, 40) == Some(0)
+        || gpu_u32(bytes, 48) != Some(0)
+        || gpu_u32(bytes, 52) != Some(0)
+    {
+        return Err(anyhow!("invalid GPU capabilities record"));
+    }
+    let scale = f32::from_bits(gpu_u32(bytes, 32).unwrap());
+    if !scale.is_finite() || scale <= 0.0 {
+        return Err(anyhow!("invalid GPU capabilities scale"));
+    }
+    let count = gpu_u32(bytes, 44).unwrap() as usize;
+    if count > 12 || bytes.len() != HEADER_BYTES + count * ENTRY_BYTES {
+        return Err(anyhow!("invalid GPU capabilities limit table"));
+    }
+    let mut previous = 0;
+    for entry in bytes[HEADER_BYTES..].as_chunks::<ENTRY_BYTES>().0 {
+        let key = gpu_u16(entry, 0).unwrap();
+        if key <= previous
+            || key > 12
+            || gpu_u16(entry, 2) != Some(0)
+            || gpu_u64(entry, 4) == Some(0)
+            || gpu_u32(entry, 12) != Some(0)
+        {
+            return Err(anyhow!("invalid GPU capability limit entry"));
+        }
+        previous = key;
+    }
+    Ok(())
+}
+
+fn validate_gpu_event(bytes: &[u8]) -> Result<()> {
+    if bytes.len() < gpu_wire::GPU_EVENT_HEADER_BYTES
+        || bytes.len() > gpu_wire::MAX_GPU_EVENT_BYTES
+        || bytes[..4] != gpu_wire::GPU_EVENT_MAGIC
+        || gpu_u16(bytes, 4) != Some(gpu_wire::GPU_WIRE_VERSION)
+        || !matches!(gpu_u16(bytes, 6), Some(1..=7))
+        || gpu_u32(bytes, 8) != Some(bytes.len() as u32)
+        || gpu_u32(bytes, 12) != Some(0)
+    {
+        return Err(anyhow!("invalid GPU event envelope"));
+    }
+    let event_type = gpu_u16(bytes, 6).unwrap();
+    let payload = &bytes[gpu_wire::GPU_EVENT_HEADER_BYTES..];
+    match event_type {
+        1 | 3 => validate_gpu_text(payload, 8, 12, 16),
+        2 => {
+            if payload.len() < 32
+                || gpu_u16(payload, 6).is_none_or(|flags| flags > 1)
+                || gpu_u32(payload, 28) != Some(0)
+            {
+                return Err(anyhow!("invalid GPU shader diagnostic"));
+            }
+            validate_gpu_text(payload, 24, 6, 32)
+        }
+        4 | 7 => validate_gpu_text(payload, 4, 8, 12),
+        5 if payload.is_empty() => Ok(()),
+        6 => {
+            if payload.len() != 28
+                || gpu_u32(payload, 0) == Some(0)
+                || gpu_u32(payload, 4) == Some(0)
+                || gpu_u32(payload, 8) == Some(0)
+                || gpu_u32(payload, 12) == Some(0)
+                || gpu_u32(payload, 16) == Some(0)
+                || !f32::from_bits(gpu_u32(payload, 20).unwrap()).is_finite()
+                || f32::from_bits(gpu_u32(payload, 20).unwrap()) <= 0.0
+                || !matches!(gpu_u16(payload, 24), Some(1..=4))
+                || gpu_u16(payload, 26) != Some(0)
+            {
+                return Err(anyhow!("invalid GPU surface-change event"));
+            }
+            Ok(())
+        }
+        _ => Err(anyhow!("invalid GPU event payload")),
+    }
+}
+
+fn validate_gpu_text(
+    payload: &[u8],
+    length_offset: usize,
+    flags_offset: usize,
+    text_offset: usize,
+) -> Result<()> {
+    let Some(text_bytes) = gpu_u32(payload, length_offset).map(|value| value as usize) else {
+        return Err(anyhow!("truncated GPU text event"));
+    };
+    let flags = if flags_offset == 6 {
+        gpu_u16(payload, flags_offset).map(u32::from)
+    } else {
+        gpu_u32(payload, flags_offset)
+    };
+    let padded = text_bytes
+        .checked_add(3)
+        .map(|value| value & !3)
+        .and_then(|value| text_offset.checked_add(value))
+        .ok_or_else(|| anyhow!("GPU event text length overflow"))?;
+    if text_bytes > gpu_wire::MAX_GPU_DIAGNOSTIC_BYTES
+        || flags.is_none_or(|value| value > 1)
+        || payload.len() != padded
+        || core::str::from_utf8(&payload[text_offset..text_offset + text_bytes]).is_err()
+        || payload[text_offset + text_bytes..]
+            .iter()
+            .any(|byte| *byte != 0)
+    {
+        return Err(anyhow!("invalid GPU text event"));
+    }
+    Ok(())
+}
+
+fn gpu_u16(bytes: &[u8], offset: usize) -> Option<u16> {
+    Some(u16::from_le_bytes(
+        bytes.get(offset..offset + 2)?.try_into().ok()?,
+    ))
+}
+
+fn gpu_u32(bytes: &[u8], offset: usize) -> Option<u32> {
+    Some(u32::from_le_bytes(
+        bytes.get(offset..offset + 4)?.try_into().ok()?,
+    ))
+}
+
+fn gpu_u64(bytes: &[u8], offset: usize) -> Option<u64> {
+    Some(u64::from_le_bytes(
+        bytes.get(offset..offset + 8)?.try_into().ok()?,
+    ))
+}
+
+fn read_guest_memory(
+    instance: &mut polkavm::RawInstance,
+    pointer: u32,
+    length: usize,
+) -> Result<Vec<u8>> {
+    if length > MAX_GUEST_READ {
+        return Err(anyhow!("guest read exceeds {MAX_GUEST_READ} bytes"));
+    }
+    let mut bytes = vec![0; length];
+    instance
+        .read_memory_into(pointer, &mut bytes[..])
+        .map_err(|error| anyhow!("read guest memory: {error:?}"))?;
+    Ok(bytes)
+}
+
+fn map_call_result(result: Result<(), CallError<anyhow::Error>>, phase: &str) -> Result<()> {
+    match result {
+        Ok(()) => Ok(()),
+        Err(CallError::Trap) => Err(anyhow!("guest trapped during {phase}")),
+        Err(CallError::NotEnoughGas) => Err(anyhow!("guest exhausted gas during {phase}")),
+        Err(CallError::Error(error)) => Err(error).context(format!("guest error during {phase}")),
+        Err(CallError::User(error)) => Err(error).context(format!("host error during {phase}")),
+        Err(error) => Err(anyhow!(
+            "unexpected PolkaVM error during {phase}: {error:?}"
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn presentation_profile_uses_tri2d_without_legacy_alias() {
+        assert_eq!(
+            PresentationProfile::parse("tri2d").expect("tri2d profile should parse"),
+            PresentationProfile::Tri2d
+        );
+        assert!(
+            PresentationProfile::parse("ui-mesh").is_err(),
+            "the provisional profile name must not remain an alias"
+        );
+    }
+
+    #[test]
+    fn input_queue_coalesces_pointer_motion_and_stays_bounded() {
+        let mut state = HostState::new(HashMap::new(), PresentationProfile::Framebuffer, false);
+        for coordinate in 0..10_000u16 {
+            state.queue_input(InputEvent {
+                event_type: InputEventType::PointerMove,
+                code: 0,
+                x: coordinate,
+                y: coordinate,
+            });
+        }
+        assert_eq!(state.input.len(), 1);
+        assert_eq!(state.input.back().unwrap().x, 9_999);
+
+        state.queue_input(InputEvent {
+            event_type: InputEventType::SurfaceMetrics,
+            code: 32,
+            x: 1_280,
+            y: 800,
+        });
+        state.queue_input(InputEvent {
+            event_type: InputEventType::SurfaceMetrics,
+            code: 64,
+            x: 2_560,
+            y: 1_600,
+        });
+        assert_eq!(
+            state
+                .input
+                .iter()
+                .filter(|event| event.event_type == InputEventType::SurfaceMetrics)
+                .count(),
+            1
+        );
+        assert_eq!(state.input.back().unwrap().x, 2_560);
+
+        for index in 0..(MAX_QUEUED_INPUT_EVENTS + 100) {
+            state.queue_input(InputEvent {
+                event_type: InputEventType::KeyDown,
+                code: index as u8,
+                x: 0,
+                y: 0,
+            });
+        }
+        assert_eq!(state.input.len(), MAX_QUEUED_INPUT_EVENTS);
+        assert_eq!(
+            state
+                .input
+                .iter()
+                .filter(|event| event.event_type == InputEventType::SurfaceMetrics)
+                .count(),
+            1
+        );
+        state.queue_input(InputEvent {
+            event_type: InputEventType::SurfaceMetrics,
+            code: 64,
+            x: 3_000,
+            y: 2_000,
+        });
+        assert_eq!(state.input.len(), MAX_QUEUED_INPUT_EVENTS);
+        assert_eq!(
+            state.input.back().unwrap().event_type,
+            InputEventType::SurfaceMetrics
+        );
+    }
+
+    #[test]
+    fn surface_change_rejects_non_positive_and_non_finite_scale() {
+        let mut event = vec![0; gpu_wire::GPU_EVENT_HEADER_BYTES + 28];
+        event[..4].copy_from_slice(&gpu_wire::GPU_EVENT_MAGIC);
+        event[4..6].copy_from_slice(&gpu_wire::GPU_WIRE_VERSION.to_le_bytes());
+        event[6..8].copy_from_slice(&(gpu_wire::GpuEventType::SurfaceChanged as u16).to_le_bytes());
+        let event_len = event.len() as u32;
+        event[8..12].copy_from_slice(&event_len.to_le_bytes());
+        let payload = &mut event[gpu_wire::GPU_EVENT_HEADER_BYTES..];
+        for offset in [0, 4, 8, 12, 16] {
+            payload[offset..offset + 4].copy_from_slice(&1u32.to_le_bytes());
+        }
+        payload[24..26]
+            .copy_from_slice(&(gpu_wire::GpuTextureFormat::Rgba8Unorm as u16).to_le_bytes());
+
+        payload[20..24].copy_from_slice(&1.0f32.to_le_bytes());
+        validate_gpu_event(&event).expect("positive finite scale should be valid");
+        for scale in [0.0f32, -1.0, f32::NAN, f32::INFINITY] {
+            event[gpu_wire::GPU_EVENT_HEADER_BYTES + 20..gpu_wire::GPU_EVENT_HEADER_BYTES + 24]
+                .copy_from_slice(&scale.to_le_bytes());
+            assert!(
+                validate_gpu_event(&event).is_err(),
+                "invalid scale {scale:?} must fail closed"
+            );
+        }
+    }
+}
diff --git a/rust/crates/pvm-runtime/src/manifest.rs b/rust/crates/pvm-runtime/src/manifest.rs
new file mode 100644
index 000000000..e5a0d66c8
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/manifest.rs
@@ -0,0 +1,220 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::PresentationProfile;
+use anyhow::{anyhow, bail, Context, Result};
+use serde::Deserialize;
+use std::collections::BTreeMap;
+
+/// Validated host-facing description of a strict App manifest v2 executable.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AppDescriptor {
+    /// Semantic application version.
+    pub app_version: Vec<u32>,
+    /// PolkaVM entrypoint within the verified application archive.
+    pub program_path: String,
+    /// Selected presentation profile.
+    pub presentation: PresentationProfile,
+    /// Whether the application may submit audio.
+    pub audio_enabled: bool,
+    /// Required device-input features.
+    pub input_features: Vec<String>,
+    /// Required WebGPU limits, empty for other profiles.
+    pub gpu_limits: BTreeMap<String, u64>,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Manifest {
+    #[serde(rename = "$v")]
+    version: u32,
+    kind: String,
+    #[serde(rename = "appVersion")]
+    app_version: Vec<u32>,
+    runtime: Runtime,
+    capabilities: Capabilities,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Runtime {
+    kind: String,
+    #[serde(rename = "abiVersion")]
+    abi_version: u32,
+    entrypoint: String,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Capabilities {
+    graphics: Graphics,
+    #[serde(rename = "deviceInput")]
+    device_input: Option<DeviceInput>,
+    audio: Option<Audio>,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Graphics {
+    #[serde(rename = "abiVersion")]
+    abi_version: u32,
+    profile: String,
+    #[serde(rename = "requiredFeatures")]
+    required_features: Vec<String>,
+    #[serde(rename = "requiredLimits", default)]
+    required_limits: BTreeMap<String, u64>,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct DeviceInput {
+    #[serde(rename = "abiVersion")]
+    abi_version: u32,
+    #[serde(rename = "requiredFeatures")]
+    required_features: Vec<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Audio {
+    #[serde(rename = "abiVersion")]
+    abi_version: u32,
+    #[serde(rename = "requiredFeatures")]
+    required_features: Vec<String>,
+}
+
+const GPU_LIMITS: &[&str] = &[
+    "maxTextureDimension2D",
+    "maxBufferSize",
+    "maxBindingsPerBindGroup",
+    "maxBindGroups",
+    "maxVertexBuffers",
+    "maxVertexAttributes",
+    "maxColorAttachments",
+];
+
+impl AppDescriptor {
+    /// Parses and validates an embedded App v2 manifest after proving it is
+    /// byte-identical to the executable record resolved from DotNS.
+    pub fn parse_exact(embedded: &[u8], executable_record: &[u8]) -> Result<Self> {
+        if embedded != executable_record {
+            bail!("embedded App manifest differs from executable record");
+        }
+        let manifest: Manifest =
+            serde_json::from_slice(embedded).context("parse strict App manifest v2")?;
+        if manifest.version != 2 || manifest.kind != "app" {
+            bail!("manifest must be $v 2 kind app");
+        }
+        if !(manifest.app_version.len() == 3 || manifest.app_version.len() == 4) {
+            bail!("App version must contain three or four components");
+        }
+        if manifest.runtime.kind != "polkavm" || manifest.runtime.abi_version != 1 {
+            bail!("App runtime must be PolkaVM ABI version 1");
+        }
+        validate_path(&manifest.runtime.entrypoint)?;
+        if !manifest.runtime.entrypoint.ends_with(".polkavm") {
+            bail!("PolkaVM entrypoint must end in .polkavm");
+        }
+        if manifest.capabilities.graphics.abi_version != 1 {
+            bail!("graphics capability must use ABI version 1");
+        }
+        if !manifest.capabilities.graphics.required_features.is_empty() {
+            bail!("graphics profile requests unsupported optional features");
+        }
+        let presentation = PresentationProfile::parse(&manifest.capabilities.graphics.profile)?;
+        let gpu_limits = manifest.capabilities.graphics.required_limits;
+        if presentation == PresentationProfile::WebGpuRaster {
+            for (name, value) in &gpu_limits {
+                if !GPU_LIMITS.contains(&name.as_str()) || *value == 0 {
+                    return Err(anyhow!("unsupported WebGPU required limit {name}"));
+                }
+            }
+        } else if !gpu_limits.is_empty() {
+            bail!("non-WebGPU graphics profile declares required limits");
+        }
+        let input_features = if let Some(input) = manifest.capabilities.device_input {
+            if input.abi_version != 1 {
+                bail!("device input capability must use ABI version 1");
+            }
+            for feature in &input.required_features {
+                if feature != "pointer" && feature != "keyboard" {
+                    bail!("unsupported device input feature {feature}");
+                }
+            }
+            input.required_features
+        } else {
+            Vec::new()
+        };
+        let audio_enabled = if let Some(audio) = manifest.capabilities.audio {
+            if audio.abi_version != 1 || !audio.required_features.is_empty() {
+                bail!("audio capability requires unsupported features or ABI");
+            }
+            true
+        } else {
+            false
+        };
+        Ok(Self {
+            app_version: manifest.app_version,
+            program_path: manifest.runtime.entrypoint,
+            presentation,
+            audio_enabled,
+            input_features,
+            gpu_limits,
+        })
+    }
+}
+
+fn validate_path(path: &str) -> Result<()> {
+    if path.is_empty()
+        || path.starts_with('/')
+        || path.contains('\\')
+        || path
+            .split('/')
+            .any(|component| component.is_empty() || component == "." || component == "..")
+    {
+        bail!("invalid application asset path {path}");
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::AppDescriptor;
+    use crate::PresentationProfile;
+
+    const FRAMEBUFFER: &[u8] = br#"{"$v":2,"kind":"app","appVersion":[1,2,3],"runtime":{"kind":"polkavm","abiVersion":1,"entrypoint":"app.polkavm"},"capabilities":{"graphics":{"abiVersion":1,"profile":"framebuffer","requiredFeatures":[]},"deviceInput":{"abiVersion":1,"requiredFeatures":["pointer","keyboard"]},"audio":{"abiVersion":1,"requiredFeatures":[]}}}"#;
+
+    #[test]
+    fn parses_exact_strict_manifest() {
+        let descriptor = AppDescriptor::parse_exact(FRAMEBUFFER, FRAMEBUFFER).unwrap();
+        assert_eq!(descriptor.presentation, PresentationProfile::Framebuffer);
+        assert_eq!(descriptor.program_path, "app.polkavm");
+        assert!(descriptor.audio_enabled);
+    }
+
+    #[test]
+    fn rejects_external_byte_mismatch() {
+        let mut changed = FRAMEBUFFER.to_vec();
+        changed.push(b'\n');
+        assert!(AppDescriptor::parse_exact(FRAMEBUFFER, &changed).is_err());
+    }
+
+    #[test]
+    fn rejects_legacy_and_unknown_fields() {
+        let legacy = FRAMEBUFFER
+            .windows(6)
+            .position(|window| window == b"\"$v\":2")
+            .map(|offset| {
+                let mut bytes = FRAMEBUFFER.to_vec();
+                bytes[offset + 5] = b'1';
+                bytes
+            })
+            .unwrap();
+        assert!(AppDescriptor::parse_exact(&legacy, &legacy).is_err());
+        let unknown = String::from_utf8(FRAMEBUFFER.to_vec())
+            .unwrap()
+            .replace("\"kind\":\"app\"", "\"kind\":\"app\",\"modalities\":{}");
+        assert!(AppDescriptor::parse_exact(unknown.as_bytes(), unknown.as_bytes()).is_err());
+    }
+}
diff --git a/rust/crates/pvm-runtime/src/native_ffi.rs b/rust/crates/pvm-runtime/src/native_ffi.rs
new file mode 100644
index 000000000..24b4068a3
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/native_ffi.rs
@@ -0,0 +1,290 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::{
+    ApplicationRuntime, AudioChunk, Frame, GpuBatch, InputEvent, InputEventType,
+    PresentationProfile, Tri2dFrame,
+};
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex, MutexGuard};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, uniffi::Enum)]
+pub enum NativePvmPresentationProfile {
+    Framebuffer,
+    Tri2d,
+    WebGpuRaster,
+}
+
+impl From<NativePvmPresentationProfile> for PresentationProfile {
+    fn from(value: NativePvmPresentationProfile) -> Self {
+        match value {
+            NativePvmPresentationProfile::Framebuffer => Self::Framebuffer,
+            NativePvmPresentationProfile::Tri2d => Self::Tri2d,
+            NativePvmPresentationProfile::WebGpuRaster => Self::WebGpuRaster,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, uniffi::Enum)]
+pub enum NativePvmInputEventType {
+    KeyDown,
+    KeyUp,
+    ButtonDown,
+    ButtonUp,
+    PointerMove,
+    PointerDelta,
+    SurfaceMetrics,
+}
+
+impl From<NativePvmInputEventType> for InputEventType {
+    fn from(value: NativePvmInputEventType) -> Self {
+        match value {
+            NativePvmInputEventType::KeyDown => Self::KeyDown,
+            NativePvmInputEventType::KeyUp => Self::KeyUp,
+            NativePvmInputEventType::ButtonDown => Self::ButtonDown,
+            NativePvmInputEventType::ButtonUp => Self::ButtonUp,
+            NativePvmInputEventType::PointerMove => Self::PointerMove,
+            NativePvmInputEventType::PointerDelta => Self::PointerDelta,
+            NativePvmInputEventType::SurfaceMetrics => Self::SurfaceMetrics,
+        }
+    }
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct NativePvmAsset {
+    pub path: String,
+    pub bytes: Vec<u8>,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct NativePvmFrame {
+    pub width: u32,
+    pub height: u32,
+    pub argb: Vec<u8>,
+}
+
+impl From<Frame> for NativePvmFrame {
+    fn from(frame: Frame) -> Self {
+        Self {
+            width: frame.width,
+            height: frame.height,
+            argb: frame.argb,
+        }
+    }
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct NativePvmTri2dFrame {
+    pub width: u32,
+    pub height: u32,
+    pub draw_count: u32,
+    pub vertex_count: u32,
+    pub index_count: u32,
+    pub bytes: Vec<u8>,
+}
+
+impl From<Tri2dFrame> for NativePvmTri2dFrame {
+    fn from(frame: Tri2dFrame) -> Self {
+        Self {
+            width: frame.width,
+            height: frame.height,
+            draw_count: frame.draw_count,
+            vertex_count: frame.vertex_count,
+            index_count: frame.index_count,
+            bytes: frame.bytes,
+        }
+    }
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct NativePvmAudioChunk {
+    pub samples: Vec<i16>,
+    pub sample_rate: u32,
+    pub channels: u32,
+}
+
+impl From<AudioChunk> for NativePvmAudioChunk {
+    fn from(chunk: AudioChunk) -> Self {
+        Self {
+            samples: chunk.samples,
+            sample_rate: chunk.sample_rate,
+            channels: chunk.channels,
+        }
+    }
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct NativePvmGpuBatch {
+    pub bytes: Vec<u8>,
+}
+
+impl From<GpuBatch> for NativePvmGpuBatch {
+    fn from(batch: GpuBatch) -> Self {
+        Self { bytes: batch.bytes }
+    }
+}
+
+#[derive(Clone, Debug, thiserror::Error, uniffi::Error)]
+pub enum NativePvmError {
+    #[error("{detail}")]
+    Runtime { detail: String },
+    #[error("asset path appears more than once: {path}")]
+    DuplicateAsset { path: String },
+    #[error("PVM runtime mutex was poisoned")]
+    RuntimePoisoned,
+}
+
+impl NativePvmError {
+    fn runtime(error: impl std::fmt::Display) -> Self {
+        Self::Runtime {
+            detail: error.to_string(),
+        }
+    }
+}
+
+#[derive(uniffi::Object)]
+pub struct NativePvmRuntime {
+    runtime: Mutex<ApplicationRuntime>,
+}
+
+impl NativePvmRuntime {
+    fn lock(&self) -> Result<MutexGuard<'_, ApplicationRuntime>, NativePvmError> {
+        self.runtime
+            .lock()
+            .map_err(|_| NativePvmError::RuntimePoisoned)
+    }
+}
+
+#[uniffi::export]
+impl NativePvmRuntime {
+    #[uniffi::constructor]
+    pub fn new(
+        program: Vec<u8>,
+        assets: Vec<NativePvmAsset>,
+        presentation: NativePvmPresentationProfile,
+        audio_enabled: bool,
+        max_gas_per_update: u64,
+    ) -> Result<Arc<Self>, NativePvmError> {
+        let mut asset_map = HashMap::with_capacity(assets.len());
+        for asset in assets {
+            let path = asset.path;
+            if asset_map.insert(path.clone(), asset.bytes).is_some() {
+                return Err(NativePvmError::DuplicateAsset { path });
+            }
+        }
+        let runtime = ApplicationRuntime::new(
+            &program,
+            asset_map,
+            presentation.into(),
+            audio_enabled,
+            max_gas_per_update,
+        )
+        .map_err(NativePvmError::runtime)?;
+        Ok(Arc::new(Self {
+            runtime: Mutex::new(runtime),
+        }))
+    }
+
+    pub fn init(&self) -> Result<(), NativePvmError> {
+        self.lock()?.init().map_err(NativePvmError::runtime)
+    }
+
+    pub fn update(&self) -> Result<(), NativePvmError> {
+        self.lock()?.update().map_err(NativePvmError::runtime)
+    }
+
+    pub fn backend(&self) -> Result<String, NativePvmError> {
+        Ok(format!("{:?}", self.lock()?.backend()).to_ascii_lowercase())
+    }
+
+    pub fn last_gas_used(&self) -> Result<u64, NativePvmError> {
+        Ok(self.lock()?.last_gas_used())
+    }
+
+    pub fn send_input(
+        &self,
+        event_type: NativePvmInputEventType,
+        code: u8,
+        x: u16,
+        y: u16,
+    ) -> Result<(), NativePvmError> {
+        self.lock()?.send_input(InputEvent {
+            event_type: event_type.into(),
+            code,
+            x,
+            y,
+        });
+        Ok(())
+    }
+
+    pub fn gpu_ready(&self) -> Result<bool, NativePvmError> {
+        Ok(self.lock()?.gpu_ready())
+    }
+
+    pub fn set_gpu_capabilities(&self, bytes: Vec<u8>) -> Result<(), NativePvmError> {
+        self.lock()?
+            .set_gpu_capabilities(bytes)
+            .map_err(NativePvmError::runtime)
+    }
+
+    pub fn send_gpu_event(&self, bytes: Vec<u8>) -> Result<(), NativePvmError> {
+        self.lock()?
+            .send_gpu_event(bytes)
+            .map_err(NativePvmError::runtime)
+    }
+
+    pub fn take_frame(&self) -> Result<Option<NativePvmFrame>, NativePvmError> {
+        Ok(self.lock()?.take_frame().map(Into::into))
+    }
+
+    pub fn take_tri2d(&self) -> Result<Option<NativePvmTri2dFrame>, NativePvmError> {
+        Ok(self.lock()?.take_tri2d().map(Into::into))
+    }
+
+    pub fn take_audio(&self) -> Result<Option<NativePvmAudioChunk>, NativePvmError> {
+        Ok(self.lock()?.take_audio().map(Into::into))
+    }
+
+    pub fn take_gpu_batch(&self) -> Result<Option<NativePvmGpuBatch>, NativePvmError> {
+        Ok(self.lock()?.take_gpu_batch().map(Into::into))
+    }
+
+    pub fn take_log(&self) -> Result<Option<String>, NativePvmError> {
+        Ok(self.lock()?.take_log())
+    }
+
+    pub fn is_exited(&self) -> Result<bool, NativePvmError> {
+        Ok(self.lock()?.is_exited())
+    }
+
+    pub fn take_save(&self) -> Result<Option<Vec<u8>>, NativePvmError> {
+        Ok(self.lock()?.take_save())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn duplicate_assets_are_rejected_before_program_parsing() {
+        let result = NativePvmRuntime::new(
+            Vec::new(),
+            vec![
+                NativePvmAsset {
+                    path: "data.bin".into(),
+                    bytes: vec![1],
+                },
+                NativePvmAsset {
+                    path: "data.bin".into(),
+                    bytes: vec![2],
+                },
+            ],
+            NativePvmPresentationProfile::Framebuffer,
+            false,
+            1,
+        );
+        assert!(matches!(result, Err(NativePvmError::DuplicateAsset { .. })));
+    }
+}
diff --git a/rust/crates/pvm-runtime/src/quake_keys.rs b/rust/crates/pvm-runtime/src/quake_keys.rs
new file mode 100644
index 000000000..edb26539e
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/quake_keys.rs
@@ -0,0 +1,86 @@
+/* SPDX-License-Identifier: Apache-2.0 OR MIT
+ * Derived from paritytech/polkavm examples/quake/src/keys.rs at
+ * 3df1d0309c4c81a1aad0a755d83570d203bba1d9.
+ */
+
+pub const UPARROW: u8 = 0x80;
+pub const DOWNARROW: u8 = 0x81;
+pub const RIGHTARROW: u8 = 0x82;
+pub const LEFTARROW: u8 = 0x83;
+pub const LSHIFT: u8 = 0x9a;
+pub const RSHIFT: u8 = 0x9b;
+pub const LCTRL: u8 = 0x9c;
+pub const RCTRL: u8 = 0x9d;
+pub const LALT: u8 = 0x9e;
+pub const RALT: u8 = 0x9f;
+pub const MOUSE_1: u8 = 0xa0;
+pub const MOUSE_2: u8 = 0xa1;
+pub const MOUSE_3: u8 = 0xa2;
+pub const MOUSE_X: u8 = 0xa3;
+pub const MOUSE_Y: u8 = 0xa4;
+
+pub fn from_hid(code: u8) -> Option<u8> {
+    Some(match code {
+        0x04..=0x1d => b'a' + (code - 0x04),
+        0x1e..=0x26 => b'1' + (code - 0x1e),
+        0x27 => b'0',
+        0x28 | 0x58 => b'\n',
+        0x29 => 0x1b,
+        0x2a => 0x08,
+        0x2b => b'\t',
+        0x2c => b' ',
+        0x2d | 0x56 => b'-',
+        0x2e => b'=',
+        0x2f => b'[',
+        0x30 => b']',
+        0x31 => b'\\',
+        0x33 => b';',
+        0x34 => b'\'',
+        0x35 => b'`',
+        0x36 => b',',
+        0x37 | 0x63 => b'.',
+        0x38 | 0x54 => b'/',
+        0x3a..=0x45 => 0x84 + (code - 0x3a),
+        0x46 => 0x91,
+        0x47 => 0x92,
+        0x48 => 0x93,
+        0x49 => 0x94,
+        0x4a => 0x96,
+        0x4b => 0x98,
+        0x4c => 0x95,
+        0x4d => 0x97,
+        0x4e => 0x99,
+        0x4f => RIGHTARROW,
+        0x50 => LEFTARROW,
+        0x51 => DOWNARROW,
+        0x52 => UPARROW,
+        0x55 => b'*',
+        0x57 => b'+',
+        0x59 => 0x97,
+        0x5a => DOWNARROW,
+        0x5b => 0x99,
+        0x5c => LEFTARROW,
+        0x5d => b'5',
+        0x5e => RIGHTARROW,
+        0x5f => 0x96,
+        0x60 => UPARROW,
+        0x61 => 0x98,
+        0x62 => b'.',
+        0xe0 => LCTRL,
+        0xe1 => LSHIFT,
+        0xe2 => LALT,
+        0xe4 => RCTRL,
+        0xe5 => RSHIFT,
+        0xe6 => RALT,
+        _ => return None,
+    })
+}
+
+pub fn from_button(code: u8) -> Option<u8> {
+    Some(match code {
+        1 => MOUSE_1,
+        2 => MOUSE_2,
+        3 => MOUSE_3,
+        _ => return None,
+    })
+}
diff --git a/rust/crates/pvm-runtime/src/tri2d.rs b/rust/crates/pvm-runtime/src/tri2d.rs
new file mode 100644
index 000000000..bef6bf9ed
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/tri2d.rs
@@ -0,0 +1,435 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use anyhow::{anyhow, bail, Result};
+use std::collections::HashMap;
+
+pub const TRI2D_MAGIC: &[u8; 4] = b"ETD1";
+pub const TRI2D_VERSION: u16 = 1;
+pub const TRI2D_HEADER_BYTES: usize = 24;
+pub const MAX_TRI2D_BYTES: usize = 8 * 1024 * 1024;
+pub const MAX_TRI2D_COMMANDS: u32 = 8_192;
+pub const MAX_TRI2D_SURFACE_SIZE: u32 = 4_096;
+pub const MAX_TRI2D_TEXTURE_SIZE: u32 = 4_096;
+pub const MAX_TRI2D_TEXTURES: usize = 256;
+pub const MAX_TRI2D_TEXTURE_BYTES: usize = 64 * 1024 * 1024;
+pub const MAX_TRI2D_DRAWS: u32 = 4_096;
+pub const MAX_TRI2D_VERTICES: u32 = 262_144;
+pub const MAX_TRI2D_INDICES: u32 = 786_432;
+
+const VERTEX_BYTES: usize = 20;
+const OPCODE_TEXTURE_CREATE: u8 = 1;
+const OPCODE_TEXTURE_UPDATE: u8 = 2;
+const OPCODE_TEXTURE_DESTROY: u8 = 3;
+const OPCODE_DRAW: u8 = 4;
+const OPCODE_PRESENT: u8 = 5;
+
+#[derive(Clone, Copy, Debug)]
+struct Texture {
+    width: u32,
+    height: u32,
+    bytes: usize,
+}
+
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Tri2dState {
+    textures: HashMap<u32, Texture>,
+    texture_bytes: usize,
+}
+
+#[derive(Debug)]
+pub struct Tri2dFrame {
+    pub width: u32,
+    pub height: u32,
+    pub draw_count: u32,
+    pub vertex_count: u32,
+    pub index_count: u32,
+    pub bytes: Vec<u8>,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Tri2dMetadata {
+    pub width: u32,
+    pub height: u32,
+    pub draw_count: u32,
+    pub vertex_count: u32,
+    pub index_count: u32,
+}
+
+pub(crate) fn validate_tri2d(
+    bytes: &[u8],
+    current: &Tri2dState,
+) -> Result<(Tri2dState, Tri2dMetadata)> {
+    if bytes.len() < TRI2D_HEADER_BYTES || bytes.len() > MAX_TRI2D_BYTES {
+        bail!("tri2d stream has invalid byte length");
+    }
+    if &bytes[..4] != TRI2D_MAGIC {
+        bail!("tri2d stream has invalid magic");
+    }
+
+    let mut reader = Reader::new(bytes);
+    reader.skip(4)?;
+    if reader.u16()? != TRI2D_VERSION {
+        bail!("tri2d stream has unsupported version");
+    }
+    if reader.u16()? as usize != TRI2D_HEADER_BYTES {
+        bail!("tri2d stream has invalid header length");
+    }
+    let width = reader.u32()?;
+    let height = reader.u32()?;
+    if width == 0
+        || height == 0
+        || width > MAX_TRI2D_SURFACE_SIZE
+        || height > MAX_TRI2D_SURFACE_SIZE
+    {
+        bail!("tri2d stream has invalid surface dimensions");
+    }
+    let command_count = reader.u32()?;
+    if command_count == 0 || command_count > MAX_TRI2D_COMMANDS {
+        bail!("tri2d stream has invalid command count");
+    }
+    let _clear_rgba = reader.u32()?;
+
+    let mut state = current.clone();
+    let mut draw_count = 0u32;
+    let mut vertex_count = 0u32;
+    let mut index_count = 0u32;
+    let mut presented = false;
+
+    for command_index in 0..command_count {
+        let opcode = reader.u8()?;
+        if reader.u8()? != 0 || reader.u16()? != 0 {
+            bail!("tri2d command has unsupported flags");
+        }
+        let payload_length = reader.u32()? as usize;
+        let payload = reader.bytes(payload_length)?;
+        let mut payload = Reader::new(payload);
+
+        if presented {
+            bail!("tri2d command follows present");
+        }
+        match opcode {
+            OPCODE_TEXTURE_CREATE => {
+                let handle = nonzero_handle(payload.u32()?)?;
+                let texture_width = payload.u32()?;
+                let texture_height = payload.u32()?;
+                let filter = payload.u32()?;
+                let byte_length = payload.u32()? as usize;
+                if texture_width == 0
+                    || texture_height == 0
+                    || texture_width > MAX_TRI2D_TEXTURE_SIZE
+                    || texture_height > MAX_TRI2D_TEXTURE_SIZE
+                    || filter > 1
+                {
+                    bail!("tri2d texture create has invalid properties");
+                }
+                let expected = pixel_bytes(texture_width, texture_height)?;
+                if byte_length != expected || payload.remaining() != byte_length {
+                    bail!("tri2d texture create has invalid pixel length");
+                }
+                payload.skip(byte_length)?;
+                if state.textures.contains_key(&handle) {
+                    bail!("tri2d texture handle already exists");
+                }
+                if state.textures.len() == MAX_TRI2D_TEXTURES
+                    || state.texture_bytes.saturating_add(byte_length) > MAX_TRI2D_TEXTURE_BYTES
+                {
+                    bail!("tri2d texture limits exceeded");
+                }
+                state.textures.insert(
+                    handle,
+                    Texture {
+                        width: texture_width,
+                        height: texture_height,
+                        bytes: byte_length,
+                    },
+                );
+                state.texture_bytes += byte_length;
+            }
+            OPCODE_TEXTURE_UPDATE => {
+                let handle = nonzero_handle(payload.u32()?)?;
+                let x = payload.u32()?;
+                let y = payload.u32()?;
+                let update_width = payload.u32()?;
+                let update_height = payload.u32()?;
+                let byte_length = payload.u32()? as usize;
+                let texture = state
+                    .textures
+                    .get(&handle)
+                    .ok_or_else(|| anyhow!("tri2d texture update uses an unknown handle"))?;
+                if update_width == 0
+                    || update_height == 0
+                    || x.checked_add(update_width)
+                        .is_none_or(|right| right > texture.width)
+                    || y.checked_add(update_height)
+                        .is_none_or(|bottom| bottom > texture.height)
+                {
+                    bail!("tri2d texture update exceeds texture bounds");
+                }
+                let expected = pixel_bytes(update_width, update_height)?;
+                if byte_length != expected || payload.remaining() != byte_length {
+                    bail!("tri2d texture update has invalid pixel length");
+                }
+                payload.skip(byte_length)?;
+            }
+            OPCODE_TEXTURE_DESTROY => {
+                let handle = nonzero_handle(payload.u32()?)?;
+                let texture = state
+                    .textures
+                    .remove(&handle)
+                    .ok_or_else(|| anyhow!("tri2d texture destroy uses an unknown handle"))?;
+                state.texture_bytes -= texture.bytes;
+            }
+            OPCODE_DRAW => {
+                let handle = nonzero_handle(payload.u32()?)?;
+                if !state.textures.contains_key(&handle) {
+                    bail!("tri2d draw uses an unknown texture handle");
+                }
+                let clip_x = payload.u32()?;
+                let clip_y = payload.u32()?;
+                let clip_width = payload.u32()?;
+                let clip_height = payload.u32()?;
+                if clip_width == 0
+                    || clip_height == 0
+                    || clip_x
+                        .checked_add(clip_width)
+                        .is_none_or(|right| right > width)
+                    || clip_y
+                        .checked_add(clip_height)
+                        .is_none_or(|bottom| bottom > height)
+                {
+                    bail!("tri2d draw has an invalid clip rectangle");
+                }
+                let vertices = payload.u32()?;
+                let indices = payload.u32()?;
+                if vertices == 0 || indices == 0 || indices % 3 != 0 {
+                    bail!("tri2d draw has invalid element counts");
+                }
+                draw_count = draw_count
+                    .checked_add(1)
+                    .ok_or_else(|| anyhow!("tri2d draw count overflow"))?;
+                vertex_count = vertex_count
+                    .checked_add(vertices)
+                    .ok_or_else(|| anyhow!("tri2d vertex count overflow"))?;
+                index_count = index_count
+                    .checked_add(indices)
+                    .ok_or_else(|| anyhow!("tri2d index count overflow"))?;
+                if draw_count > MAX_TRI2D_DRAWS
+                    || vertex_count > MAX_TRI2D_VERTICES
+                    || index_count > MAX_TRI2D_INDICES
+                {
+                    bail!("tri2d draw limits exceeded");
+                }
+                let vertex_bytes = (vertices as usize)
+                    .checked_mul(VERTEX_BYTES)
+                    .ok_or_else(|| anyhow!("tri2d vertex byte length overflow"))?;
+                let index_bytes = (indices as usize)
+                    .checked_mul(4)
+                    .ok_or_else(|| anyhow!("tri2d index byte length overflow"))?;
+                if payload.remaining() != vertex_bytes.saturating_add(index_bytes) {
+                    bail!("tri2d draw has invalid payload length");
+                }
+                payload.skip(vertex_bytes)?;
+                for _ in 0..indices {
+                    if payload.u32()? >= vertices {
+                        bail!("tri2d draw index exceeds vertex count");
+                    }
+                }
+            }
+            OPCODE_PRESENT => {
+                if payload_length != 0 || command_index + 1 != command_count {
+                    bail!("tri2d present must be the final empty command");
+                }
+                presented = true;
+            }
+            _ => bail!("tri2d stream has unknown opcode {opcode}"),
+        }
+        if payload.remaining() != 0 {
+            bail!("tri2d command has trailing payload bytes");
+        }
+    }
+
+    if !presented || reader.remaining() != 0 {
+        bail!("tri2d stream has invalid presentation boundary");
+    }
+
+    Ok((
+        state,
+        Tri2dMetadata {
+            width,
+            height,
+            draw_count,
+            vertex_count,
+            index_count,
+        },
+    ))
+}
+
+fn nonzero_handle(handle: u32) -> Result<u32> {
+    if handle == 0 {
+        bail!("tri2d texture handle must be nonzero");
+    }
+    Ok(handle)
+}
+
+fn pixel_bytes(width: u32, height: u32) -> Result<usize> {
+    (width as usize)
+        .checked_mul(height as usize)
+        .and_then(|pixels| pixels.checked_mul(4))
+        .ok_or_else(|| anyhow!("tri2d texture byte length overflow"))
+}
+
+struct Reader<'a> {
+    bytes: &'a [u8],
+    offset: usize,
+}
+
+impl<'a> Reader<'a> {
+    fn new(bytes: &'a [u8]) -> Self {
+        Self { bytes, offset: 0 }
+    }
+
+    fn remaining(&self) -> usize {
+        self.bytes.len() - self.offset
+    }
+
+    fn bytes(&mut self, length: usize) -> Result<&'a [u8]> {
+        let end = self
+            .offset
+            .checked_add(length)
+            .filter(|end| *end <= self.bytes.len())
+            .ok_or_else(|| anyhow!("truncated tri2d stream"))?;
+        let bytes = &self.bytes[self.offset..end];
+        self.offset = end;
+        Ok(bytes)
+    }
+
+    fn skip(&mut self, length: usize) -> Result<()> {
+        self.bytes(length).map(|_| ())
+    }
+
+    fn u8(&mut self) -> Result<u8> {
+        Ok(self.bytes(1)?[0])
+    }
+
+    fn u16(&mut self) -> Result<u16> {
+        let bytes: [u8; 2] = self
+            .bytes(2)?
+            .try_into()
+            .expect("reader returns the requested byte length");
+        Ok(u16::from_le_bytes(bytes))
+    }
+
+    fn u32(&mut self) -> Result<u32> {
+        let bytes: [u8; 4] = self
+            .bytes(4)?
+            .try_into()
+            .expect("reader returns the requested byte length");
+        Ok(u32::from_le_bytes(bytes))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn command(opcode: u8, payload: &[u8]) -> Vec<u8> {
+        let mut bytes = vec![opcode, 0, 0, 0];
+        bytes.extend_from_slice(&(payload.len() as u32).to_le_bytes());
+        bytes.extend_from_slice(payload);
+        bytes
+    }
+
+    fn stream(commands: &[Vec<u8>]) -> Vec<u8> {
+        let mut bytes = Vec::new();
+        bytes.extend_from_slice(TRI2D_MAGIC);
+        bytes.extend_from_slice(&TRI2D_VERSION.to_le_bytes());
+        bytes.extend_from_slice(&(TRI2D_HEADER_BYTES as u16).to_le_bytes());
+        bytes.extend_from_slice(&64u32.to_le_bytes());
+        bytes.extend_from_slice(&48u32.to_le_bytes());
+        bytes.extend_from_slice(&(commands.len() as u32).to_le_bytes());
+        bytes.extend_from_slice(&0xff000000u32.to_le_bytes());
+        for command in commands {
+            bytes.extend_from_slice(command);
+        }
+        bytes
+    }
+
+    fn create(handle: u32) -> Vec<u8> {
+        let mut payload = Vec::new();
+        payload.extend_from_slice(&handle.to_le_bytes());
+        payload.extend_from_slice(&1u32.to_le_bytes());
+        payload.extend_from_slice(&1u32.to_le_bytes());
+        payload.extend_from_slice(&0u32.to_le_bytes());
+        payload.extend_from_slice(&4u32.to_le_bytes());
+        payload.extend_from_slice(&[255, 255, 255, 255]);
+        command(OPCODE_TEXTURE_CREATE, &payload)
+    }
+
+    fn draw(handle: u32, last_index: u32) -> Vec<u8> {
+        let mut payload = Vec::new();
+        for value in [handle, 0, 0, 64, 48, 3, 3] {
+            payload.extend_from_slice(&value.to_le_bytes());
+        }
+        payload.extend_from_slice(&[0; VERTEX_BYTES * 3]);
+        for index in [0u32, 1, last_index] {
+            payload.extend_from_slice(&index.to_le_bytes());
+        }
+        command(OPCODE_DRAW, &payload)
+    }
+
+    fn present() -> Vec<u8> {
+        command(OPCODE_PRESENT, &[])
+    }
+
+    #[test]
+    fn accepts_a_stateful_texture_and_draw_sequence() {
+        let state = Tri2dState::default();
+        let first = stream(&[create(7), draw(7, 2), present()]);
+        let (state, metadata) =
+            validate_tri2d(&first, &state).expect("initial tri2d should validate");
+        assert_eq!((metadata.width, metadata.height), (64, 48));
+        assert_eq!(metadata.draw_count, 1);
+        assert_eq!(metadata.vertex_count, 3);
+        assert_eq!(metadata.index_count, 3);
+        assert_eq!(state.textures.len(), 1);
+
+        let second = stream(&[draw(7, 2), present()]);
+        let (_, metadata) =
+            validate_tri2d(&second, &state).expect("retained texture should be reusable");
+        assert_eq!(metadata.draw_count, 1);
+    }
+
+    #[test]
+    fn rejects_malformed_and_out_of_bounds_streams() {
+        let state = Tri2dState::default();
+        let mut invalid_magic = stream(&[present()]);
+        invalid_magic[0] = b'X';
+        assert!(validate_tri2d(&invalid_magic, &state).is_err());
+
+        let truncated = &stream(&[create(1), present()])[..31];
+        assert!(validate_tri2d(truncated, &state).is_err());
+
+        let unknown_texture = stream(&[draw(9, 2), present()]);
+        assert!(validate_tri2d(&unknown_texture, &state).is_err());
+
+        let invalid_index = stream(&[create(1), draw(1, 3), present()]);
+        assert!(validate_tri2d(&invalid_index, &state).is_err());
+
+        let command_after_present = stream(&[present(), present()]);
+        assert!(validate_tri2d(&command_after_present, &state).is_err());
+    }
+
+    #[test]
+    fn failed_submission_does_not_mutate_retained_texture_state() {
+        let state = Tri2dState::default();
+        let missing_present = stream(&[create(11)]);
+        assert!(validate_tri2d(&missing_present, &state).is_err());
+
+        let valid = stream(&[create(11), present()]);
+        let (state, _) =
+            validate_tri2d(&valid, &state).expect("failed validation must not retain textures");
+        assert!(state.textures.contains_key(&11));
+    }
+}
diff --git a/rust/crates/pvm-runtime/src/wasm.rs b/rust/crates/pvm-runtime/src/wasm.rs
new file mode 100644
index 000000000..e553572ba
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/wasm.rs
@@ -0,0 +1,538 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::{
+    ApplicationRuntime, AudioChunk, Frame, GpuBatch, InputEvent, InputEventType,
+    PresentationProfile, Tri2dFrame, MAX_ASSET_BYTES, MAX_ASSET_FILES, MAX_ASSET_FILE_BYTES,
+    MAX_PROGRAM_BYTES,
+};
+use anyhow::{anyhow, Result};
+use polkavm::BackendKind;
+use std::cell::RefCell;
+use std::collections::HashMap;
+
+const MAX_ASSET_NAME_BYTES: usize = 1_024;
+const MAX_STAGING_BYTES: usize = MAX_ASSET_FILE_BYTES + MAX_ASSET_NAME_BYTES;
+
+struct Launch {
+    program: Vec<u8>,
+    assets: HashMap<String, Vec<u8>>,
+    asset_bytes: usize,
+    max_gas_per_update: u64,
+    audio_enabled: bool,
+    presentation: PresentationProfile,
+}
+
+enum Phase {
+    Empty,
+    Building(Launch),
+    Running(ApplicationRuntime),
+}
+
+struct BrowserHost {
+    phase: Phase,
+    staging: Vec<u8>,
+    frame: Option<Frame>,
+    tri2d: Option<Tri2dFrame>,
+    gpu_batch: Option<GpuBatch>,
+    audio: Option<AudioChunk>,
+    log: Option<String>,
+    save: Option<Vec<u8>>,
+    translation: Vec<u8>,
+    error: String,
+}
+
+impl BrowserHost {
+    fn new() -> Self {
+        Self {
+            phase: Phase::Empty,
+            staging: Vec::new(),
+            frame: None,
+            tri2d: None,
+            gpu_batch: None,
+            audio: None,
+            log: None,
+            save: None,
+            translation: Vec::new(),
+            error: String::new(),
+        }
+    }
+
+    fn running(&mut self) -> Result<&mut ApplicationRuntime> {
+        match &mut self.phase {
+            Phase::Running(runtime) => Ok(runtime),
+            _ => Err(anyhow!("PolkaVM browser runtime is not running")),
+        }
+    }
+
+    fn clear_outputs(&mut self) {
+        self.frame = None;
+        self.tri2d = None;
+        self.gpu_batch = None;
+        self.audio = None;
+        self.log = None;
+        self.save = None;
+    }
+}
+
+thread_local! {
+    static HOST: RefCell<BrowserHost> = RefCell::new(BrowserHost::new());
+}
+
+fn status(operation: impl FnOnce(&mut BrowserHost) -> Result<()>) -> u32 {
+    HOST.with(|host| {
+        let mut host = host.borrow_mut();
+        host.error.clear();
+        match operation(&mut host) {
+            Ok(()) => 0,
+            Err(error) => {
+                host.error = format!("{error:#}");
+                1
+            }
+        }
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_abi_version() -> u32 {
+    1
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_reset() {
+    HOST.with(|host| *host.borrow_mut() = BrowserHost::new());
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_staging_reserve(length: u32) -> u32 {
+    HOST.with(|host| {
+        let mut host = host.borrow_mut();
+        host.error.clear();
+        let length = length as usize;
+        if length == 0 || length > MAX_STAGING_BYTES {
+            host.error = format!("invalid PolkaVM browser staging length {length}");
+            host.staging.clear();
+            return 0;
+        }
+        host.staging = vec![0; length];
+        host.staging.as_mut_ptr() as usize as u32
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_translate_staged() -> u32 {
+    status(|host| {
+        host.translation = crate::wasm_codegen::translate(&host.staging)?;
+        Ok(())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_translation_pointer() -> u32 {
+    HOST.with(|host| host.borrow().translation.as_ptr() as usize as u32)
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_translation_length() -> u32 {
+    HOST.with(|host| host.borrow().translation.len() as u32)
+}
+
+fn launch_begin(max_gas_per_update: u32, audio_enabled: u32, presentation: u32) -> u32 {
+    status(|host| {
+        if !matches!(host.phase, Phase::Empty) {
+            return Err(anyhow!("PolkaVM browser launch is already active"));
+        }
+        let program = std::mem::take(&mut host.staging);
+        if program.is_empty() || program.len() > MAX_PROGRAM_BYTES {
+            return Err(anyhow!(
+                "PolkaVM browser program must contain 1..={MAX_PROGRAM_BYTES} bytes"
+            ));
+        }
+        if max_gas_per_update == 0 {
+            return Err(anyhow!("PolkaVM browser gas budget must be nonzero"));
+        }
+        if audio_enabled > 1 {
+            return Err(anyhow!("invalid PolkaVM browser audio capability"));
+        }
+        let presentation = match presentation {
+            0 => PresentationProfile::Framebuffer,
+            1 => PresentationProfile::Tri2d,
+            2 => PresentationProfile::WebGpuRaster,
+            _ => return Err(anyhow!("invalid PolkaVM browser presentation profile")),
+        };
+        host.phase = Phase::Building(Launch {
+            program,
+            assets: HashMap::new(),
+            asset_bytes: 0,
+            max_gas_per_update: max_gas_per_update.into(),
+            audio_enabled: audio_enabled == 1,
+            presentation,
+        });
+        Ok(())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_launch_begin(max_gas_per_update: u32, audio_enabled: u32) -> u32 {
+    launch_begin(max_gas_per_update, audio_enabled, 0)
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_launch_begin_v2(
+    max_gas_per_update: u32,
+    audio_enabled: u32,
+    presentation: u32,
+) -> u32 {
+    launch_begin(max_gas_per_update, audio_enabled, presentation)
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_launch_add_asset(path_length: u32) -> u32 {
+    status(|host| {
+        let bytes = std::mem::take(&mut host.staging);
+        let path_length = path_length as usize;
+        if path_length == 0 || path_length > MAX_ASSET_NAME_BYTES || path_length >= bytes.len() {
+            return Err(anyhow!("invalid PolkaVM browser asset path length"));
+        }
+        let path = std::str::from_utf8(&bytes[..path_length])
+            .map_err(|_| anyhow!("PolkaVM browser asset path is not UTF-8"))?;
+        if path.contains('\0') || path.contains('\\') {
+            return Err(anyhow!("invalid PolkaVM browser asset path"));
+        }
+        let data = &bytes[path_length..];
+        if data.len() > MAX_ASSET_FILE_BYTES {
+            return Err(anyhow!("PolkaVM browser asset exceeds size limit"));
+        }
+        let Phase::Building(launch) = &mut host.phase else {
+            return Err(anyhow!("PolkaVM browser launch is not accepting assets"));
+        };
+        if launch.assets.len() == MAX_ASSET_FILES {
+            return Err(anyhow!("PolkaVM browser launch exceeds asset count limit"));
+        }
+        let asset_bytes = launch
+            .asset_bytes
+            .checked_add(data.len())
+            .ok_or_else(|| anyhow!("PolkaVM browser asset size overflow"))?;
+        if asset_bytes > MAX_ASSET_BYTES {
+            return Err(anyhow!("PolkaVM browser launch exceeds asset byte limit"));
+        }
+        if launch.assets.contains_key(path) {
+            return Err(anyhow!("duplicate PolkaVM browser asset {path}"));
+        }
+        launch.assets.insert(path.to_owned(), data.to_vec());
+        launch.asset_bytes = asset_bytes;
+        Ok(())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_launch_start() -> u32 {
+    status(|host| {
+        let phase = std::mem::replace(&mut host.phase, Phase::Empty);
+        let Phase::Building(launch) = phase else {
+            host.phase = phase;
+            return Err(anyhow!("PolkaVM browser launch is not ready"));
+        };
+        let runtime = ApplicationRuntime::new_with_backend(
+            &launch.program,
+            launch.assets,
+            launch.presentation,
+            launch.audio_enabled,
+            launch.max_gas_per_update,
+            BackendKind::Interpreter,
+        )?;
+        host.phase = Phase::Running(runtime);
+        Ok(())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_set_gpu_capabilities() -> u32 {
+    status(|host| {
+        let bytes = std::mem::take(&mut host.staging);
+        host.running()?.set_gpu_capabilities(bytes)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_send_gpu_event() -> u32 {
+    status(|host| {
+        let bytes = std::mem::take(&mut host.staging);
+        host.running()?.send_gpu_event(bytes)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_init() -> u32 {
+    status(|host| host.running()?.init())
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_update(time_ms: f64) -> u32 {
+    status(|host| {
+        if !time_ms.is_finite() || time_ms < 0.0 {
+            return Err(anyhow!("invalid PolkaVM browser timestamp"));
+        }
+        let runtime = host.running()?;
+        runtime.set_time_ms(time_ms.min(u64::MAX as f64) as u64);
+        runtime.update()
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_send_input(event_type: u32, code: u32, x: u32, y: u32) -> u32 {
+    status(|host| {
+        let event_type = match event_type {
+            1 => InputEventType::KeyDown,
+            2 => InputEventType::KeyUp,
+            3 => InputEventType::ButtonDown,
+            4 => InputEventType::ButtonUp,
+            5 => InputEventType::PointerMove,
+            6 => InputEventType::PointerDelta,
+            7 => InputEventType::SurfaceMetrics,
+            _ => return Err(anyhow!("invalid PolkaVM browser input event type")),
+        };
+        let code = u8::try_from(code).map_err(|_| anyhow!("input code exceeds u8"))?;
+        let x = u16::try_from(x).map_err(|_| anyhow!("input x exceeds u16"))?;
+        let y = u16::try_from(y).map_err(|_| anyhow!("input y exceeds u16"))?;
+        host.running()?.send_input(InputEvent {
+            event_type,
+            code,
+            x,
+            y,
+        });
+        Ok(())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_take_frame() -> u32 {
+    HOST.with(|host| {
+        let mut host = host.borrow_mut();
+        host.frame = match &mut host.phase {
+            Phase::Running(runtime) => runtime.take_frame(),
+            _ => None,
+        };
+        u32::from(host.frame.is_some())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_frame_width() -> u32 {
+    HOST.with(|host| host.borrow().frame.as_ref().map_or(0, |frame| frame.width))
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_frame_height() -> u32 {
+    HOST.with(|host| host.borrow().frame.as_ref().map_or(0, |frame| frame.height))
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_frame_pointer() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .frame
+            .as_ref()
+            .map_or(0, |frame| frame.argb.as_ptr() as usize as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_frame_length() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .frame
+            .as_ref()
+            .map_or(0, |frame| frame.argb.len() as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_take_tri2d() -> u32 {
+    HOST.with(|host| {
+        let mut host = host.borrow_mut();
+        host.tri2d = match &mut host.phase {
+            Phase::Running(runtime) => runtime.take_tri2d(),
+            _ => None,
+        };
+        u32::from(host.tri2d.is_some())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_tri2d_pointer() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .tri2d
+            .as_ref()
+            .map_or(0, |frame| frame.bytes.as_ptr() as usize as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_tri2d_length() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .tri2d
+            .as_ref()
+            .map_or(0, |frame| frame.bytes.len() as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_take_gpu_batch() -> u32 {
+    HOST.with(|host| {
+        let mut host = host.borrow_mut();
+        host.gpu_batch = match &mut host.phase {
+            Phase::Running(runtime) => runtime.take_gpu_batch(),
+            _ => None,
+        };
+        u32::from(host.gpu_batch.is_some())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_gpu_batch_pointer() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .gpu_batch
+            .as_ref()
+            .map_or(0, |batch| batch.bytes.as_ptr() as usize as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_gpu_batch_length() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .gpu_batch
+            .as_ref()
+            .map_or(0, |batch| batch.bytes.len() as u32)
+    })
+}
+#[no_mangle]
+pub extern "C" fn pvm_browser_take_audio() -> u32 {
+    HOST.with(|host| {
+        let mut host = host.borrow_mut();
+        host.audio = match &mut host.phase {
+            Phase::Running(runtime) => runtime.take_audio(),
+            _ => None,
+        };
+        u32::from(host.audio.is_some())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_audio_pointer() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .audio
+            .as_ref()
+            .map_or(0, |audio| audio.samples.as_ptr() as usize as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_audio_length() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .audio
+            .as_ref()
+            .map_or(0, |audio| audio.samples.len() as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_audio_sample_rate() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .audio
+            .as_ref()
+            .map_or(0, |audio| audio.sample_rate)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_audio_channels() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .audio
+            .as_ref()
+            .map_or(0, |audio| audio.channels)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_take_log() -> u32 {
+    HOST.with(|host| {
+        let mut host = host.borrow_mut();
+        host.log = match &mut host.phase {
+            Phase::Running(runtime) => runtime.take_log(),
+            _ => None,
+        };
+        u32::from(host.log.is_some())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_log_pointer() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .log
+            .as_ref()
+            .map_or(0, |log| log.as_ptr() as usize as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_log_length() -> u32 {
+    HOST.with(|host| host.borrow().log.as_ref().map_or(0, |log| log.len() as u32))
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_take_save() -> u32 {
+    HOST.with(|host| {
+        let mut host = host.borrow_mut();
+        host.save = match &mut host.phase {
+            Phase::Running(runtime) => runtime.take_save(),
+            _ => None,
+        };
+        u32::from(host.save.is_some())
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_save_pointer() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .save
+            .as_ref()
+            .map_or(0, |save| save.as_ptr() as usize as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_save_length() -> u32 {
+    HOST.with(|host| {
+        host.borrow()
+            .save
+            .as_ref()
+            .map_or(0, |save| save.len() as u32)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_error_pointer() -> u32 {
+    HOST.with(|host| host.borrow().error.as_ptr() as usize as u32)
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_error_length() -> u32 {
+    HOST.with(|host| host.borrow().error.len() as u32)
+}
+
+#[no_mangle]
+pub extern "C" fn pvm_browser_clear_outputs() {
+    HOST.with(|host| host.borrow_mut().clear_outputs());
+}
diff --git a/rust/crates/pvm-runtime/src/wasm_codegen.rs b/rust/crates/pvm-runtime/src/wasm_codegen.rs
new file mode 100644
index 000000000..0dba722a1
--- /dev/null
+++ b/rust/crates/pvm-runtime/src/wasm_codegen.rs
@@ -0,0 +1,2233 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::{
+    MAX_GUEST_HEAP_BYTES, MAX_GUEST_RW_DATA_BYTES, MAX_GUEST_STACK_BYTES, MAX_PROGRAM_BYTES,
+};
+use anyhow::{anyhow, bail, Context, Result};
+use polkavm::program::{Instruction as PvmInstruction, ParsedInstruction, RawReg};
+use polkavm::{MemoryMapBuilder, ProgramBlob, Reg, RETURN_TO_HOST};
+use std::borrow::Cow;
+use std::collections::{BTreeMap, BTreeSet};
+use wasm_encoder::{
+    BlockType, CodeSection, ConstExpr, CustomSection, DataSection, ElementSection, Elements,
+    ExportKind, ExportSection, Function, FunctionSection, GlobalSection, GlobalType,
+    Instruction as W, MemArg, MemorySection, MemoryType, Module, RefType, TableSection, TableType,
+    TypeSection, ValType,
+};
+
+const PAGE_SIZE: u32 = 65_536;
+const STATUS_FINISHED: i32 = -1;
+const STATUS_ECALL: i32 = -2;
+const STATUS_TRAP: i32 = -3;
+const STATUS_OUT_OF_GAS: i32 = -4;
+const REGISTER_COUNT: u32 = 13;
+
+const TYPE_BLOCK: u32 = 0;
+const TYPE_BINARY_I64: u32 = 1;
+const TYPE_BEGIN: u32 = 2;
+const TYPE_SET_GAS: u32 = 3;
+const TYPE_UNARY_I64: u32 = 4;
+
+const GLOBAL_PC: u32 = REGISTER_COUNT;
+const GLOBAL_GAS: u32 = GLOBAL_PC + 1;
+const GLOBAL_HEAP_SIZE: u32 = GLOBAL_GAS + 1;
+const GLOBAL_ECALL: u32 = GLOBAL_HEAP_SIZE + 1;
+const GLOBAL_TRAP_PC: u32 = GLOBAL_ECALL + 1;
+
+const LOCAL_ADDR: u32 = 0;
+const LOCAL_PHYS: u32 = 1;
+const LOCAL_I64_0: u32 = 2;
+const LOCAL_I64_1: u32 = 3;
+
+#[derive(Clone, Copy)]
+struct Layout {
+    ro_address: u32,
+    ro_size: u32,
+    ro_phys: u32,
+    rw_address: u32,
+    rw_size: u32,
+    rw_phys: u32,
+    heap_base: u32,
+    heap_limit: u32,
+    stack_low: u32,
+    stack_high: u32,
+    stack_phys: u32,
+    ro_pages: u64,
+    rw_pages: u64,
+    rw_max_pages: u64,
+    stack_pages: u64,
+}
+
+#[derive(Clone, Copy)]
+enum LoadKind {
+    U8,
+    I8,
+    U16,
+    I16,
+    U32,
+    I32,
+    U64,
+}
+
+#[derive(Clone, Copy)]
+enum StoreKind {
+    U8,
+    U16,
+    U32,
+    U64,
+}
+
+pub fn translate(program: &[u8]) -> Result<Vec<u8>> {
+    if program.is_empty() || program.len() > MAX_PROGRAM_BYTES {
+        bail!("guest program exceeds browser limit");
+    }
+    let blob =
+        ProgramBlob::parse(program.into()).context("parse PolkaVM program for Wasm translation")?;
+    blob.validate_code_with_isa(blob.isa())
+        .map_err(|pc| anyhow!("invalid PolkaVM instruction at {pc}"))?;
+    if blob.stack_size() > MAX_GUEST_STACK_BYTES {
+        bail!("guest stack exceeds browser limit");
+    }
+    if blob.rw_data_size() > MAX_GUEST_RW_DATA_BYTES {
+        bail!("guest read-write data exceeds browser limit");
+    }
+
+    let instructions: Vec<_> = blob.instructions().collect();
+    if instructions.is_empty() {
+        bail!("PolkaVM program contains no instructions");
+    }
+    let metered_targets = collect_metered_targets(&instructions);
+
+    let layout = build_layout(&blob)?;
+    let targets = collect_block_targets(&blob, &instructions)?;
+    let (blocks, block_by_pc) = build_blocks(&instructions, &targets)?;
+    let jump_targets: Vec<_> = blob.jump_table().into_iter().collect();
+
+    let mut module = Module::new();
+    let mut types = TypeSection::new();
+    types.ty().function([], [ValType::I32]);
+    types
+        .ty()
+        .function([ValType::I64, ValType::I64], [ValType::I64]);
+    types
+        .ty()
+        .function([ValType::I32, ValType::I64], [ValType::I32]);
+    types.ty().function([ValType::I64], []);
+    types.ty().function([ValType::I64], [ValType::I64]);
+    module.section(&types);
+
+    let helper_count = 3u32;
+    let block_base = helper_count;
+    let resolver_base = block_base + blocks.len() as u32;
+    let dispatcher_index = resolver_base + jump_targets.len() as u32;
+    let begin_index = dispatcher_index + 1;
+    let set_gas_index = begin_index + 1;
+
+    let mut functions = FunctionSection::new();
+    functions.function(TYPE_BINARY_I64);
+    functions.function(TYPE_UNARY_I64);
+    functions.function(TYPE_UNARY_I64);
+    for _ in &blocks {
+        functions.function(TYPE_BLOCK);
+    }
+    for _ in &jump_targets {
+        functions.function(TYPE_BLOCK);
+    }
+    functions.function(TYPE_BLOCK);
+    functions.function(TYPE_BEGIN);
+    functions.function(TYPE_SET_GAS);
+    module.section(&functions);
+
+    let mut table = TableSection::new();
+    table.table(TableType {
+        element_type: RefType::FUNCREF,
+        minimum: (blocks.len() + jump_targets.len()) as u64,
+        maximum: Some((blocks.len() + jump_targets.len()) as u64),
+        table64: false,
+        shared: false,
+    });
+    module.section(&table);
+
+    let mut memory = MemorySection::new();
+    for (minimum, maximum) in [
+        (layout.ro_pages, layout.ro_pages),
+        (layout.rw_pages, layout.rw_max_pages),
+        (layout.stack_pages, layout.stack_pages),
+    ] {
+        memory.memory(MemoryType {
+            minimum,
+            maximum: Some(maximum),
+            memory64: false,
+            shared: false,
+            page_size_log2: None,
+        });
+    }
+    module.section(&memory);
+
+    let mut globals = GlobalSection::new();
+    for index in 0..REGISTER_COUNT {
+        globals.global(
+            GlobalType {
+                val_type: ValType::I64,
+                mutable: true,
+                shared: false,
+            },
+            &ConstExpr::i64_const(if index == Reg::SP.to_u32() {
+                layout.stack_high as i64
+            } else {
+                0
+            }),
+        );
+    }
+    for _ in 0..5 {
+        let index = globals.len();
+        if index == GLOBAL_GAS || index == GLOBAL_HEAP_SIZE {
+            globals.global(
+                GlobalType {
+                    val_type: ValType::I64,
+                    mutable: true,
+                    shared: false,
+                },
+                &ConstExpr::i64_const(0),
+            );
+        } else {
+            globals.global(
+                GlobalType {
+                    val_type: ValType::I32,
+                    mutable: true,
+                    shared: false,
+                },
+                &ConstExpr::i32_const(0),
+            );
+        }
+    }
+    module.section(&globals);
+
+    let mut exports = ExportSection::new();
+    exports.export("memory_ro", ExportKind::Memory, 0);
+    exports.export("memory_rw", ExportKind::Memory, 1);
+    exports.export("memory_stack", ExportKind::Memory, 2);
+    exports.export("pvm_begin", ExportKind::Func, begin_index);
+    exports.export("pvm_resume", ExportKind::Func, dispatcher_index);
+    exports.export("pvm_set_gas", ExportKind::Func, set_gas_index);
+    for reg in Reg::ALL {
+        exports.export(reg.name_non_abi(), ExportKind::Global, reg.to_u32());
+    }
+    exports.export("pc", ExportKind::Global, GLOBAL_PC);
+    exports.export("gas", ExportKind::Global, GLOBAL_GAS);
+    exports.export("heap_size", ExportKind::Global, GLOBAL_HEAP_SIZE);
+    exports.export("ecall", ExportKind::Global, GLOBAL_ECALL);
+    exports.export("trap_pc", ExportKind::Global, GLOBAL_TRAP_PC);
+    module.section(&exports);
+
+    let table_functions: Vec<u32> =
+        (block_base..resolver_base + jump_targets.len() as u32).collect();
+    let mut elements = ElementSection::new();
+    elements.active(
+        Some(0),
+        &ConstExpr::i32_const(0),
+        Elements::Functions(Cow::Owned(table_functions)),
+    );
+    module.section(&elements);
+
+    let mut code = CodeSection::new();
+    code.function(&emit_mulhu());
+    code.function(&emit_bswap32());
+    code.function(&emit_bswap64());
+
+    let context = EmitContext {
+        layout,
+        block_by_pc: &block_by_pc,
+        jump_table_len: jump_targets.len() as u32,
+        resolver_table_base: blocks.len() as u32,
+        block_function_base: block_base,
+        mulhu_function: 0,
+        bswap32_function: 1,
+        metered_targets: &metered_targets,
+        bswap64_function: 2,
+        is_64_bit: blob.is_64_bit(),
+    };
+    for block in &blocks {
+        code.function(&emit_block(&context, block)?);
+    }
+    for target in &jump_targets {
+        let mut function = Function::new([]);
+        function.instruction(&W::I32Const(
+            block_by_pc
+                .get(&target.0)
+                .copied()
+                .map(|index| index as i32)
+                .unwrap_or(STATUS_TRAP),
+        ));
+        function.instruction(&W::End);
+        code.function(&function);
+    }
+    code.function(&emit_dispatcher());
+    code.function(&emit_begin());
+    code.function(&emit_set_gas());
+    module.section(&code);
+
+    let mut data = DataSection::new();
+    if !blob.ro_data().is_empty() {
+        data.active(
+            0,
+            &ConstExpr::i32_const(layout.ro_phys as i32),
+            blob.ro_data().iter().copied(),
+        );
+    }
+    if !blob.rw_data().is_empty() {
+        data.active(
+            1,
+            &ConstExpr::i32_const(layout.rw_phys as i32),
+            blob.rw_data().iter().copied(),
+        );
+    }
+    module.section(&data);
+
+    let metadata = encode_metadata(&blob, &block_by_pc, layout)?;
+    module.section(&CustomSection {
+        name: Cow::Borrowed("epoca.pvm.meta"),
+        data: Cow::Owned(metadata),
+    });
+    Ok(module.finish())
+}
+
+fn align(value: u32, alignment: u32) -> Result<u32> {
+    value
+        .checked_add(alignment - 1)
+        .map(|value| value & !(alignment - 1))
+        .ok_or_else(|| anyhow!("translated memory layout overflow"))
+}
+
+fn build_layout(blob: &ProgramBlob) -> Result<Layout> {
+    let map = MemoryMapBuilder::new(PAGE_SIZE)
+        .ro_data_size(blob.ro_data_size())
+        .rw_data_size(blob.rw_data_size())
+        .stack_size(blob.stack_size())
+        .build()
+        .map_err(|error| anyhow!(error))?;
+    let heap_limit = MAX_GUEST_HEAP_BYTES.min(map.max_heap_size());
+    let rw_max_bytes = map
+        .heap_base()
+        .wrapping_sub(map.rw_data_address())
+        .checked_add(heap_limit)
+        .ok_or_else(|| anyhow!("translated heap layout overflow"))?;
+    let pages = |bytes: u32| align(bytes, PAGE_SIZE).map(|bytes| u64::from(bytes / PAGE_SIZE));
+    Ok(Layout {
+        ro_address: map.ro_data_address(),
+        ro_size: map.ro_data_size(),
+        ro_phys: 0,
+        rw_address: map.rw_data_address(),
+        rw_size: map.rw_data_size(),
+        rw_phys: 0,
+        heap_base: map.heap_base(),
+        heap_limit,
+        stack_low: map.stack_address_low(),
+        stack_high: map.stack_address_high(),
+        stack_phys: 0,
+        ro_pages: pages(map.ro_data_size())?,
+        rw_pages: pages(map.rw_data_size())?,
+        rw_max_pages: pages(rw_max_bytes)?,
+        stack_pages: pages(map.stack_size())?,
+    })
+}
+
+fn is_terminator(kind: PvmInstruction) -> bool {
+    matches!(
+        kind,
+        PvmInstruction::trap
+            | PvmInstruction::jump(..)
+            | PvmInstruction::jump_indirect(..)
+            | PvmInstruction::load_imm_and_jump(..)
+            | PvmInstruction::load_imm_and_jump_indirect(..)
+            | PvmInstruction::branch_eq(..)
+            | PvmInstruction::branch_not_eq(..)
+            | PvmInstruction::branch_less_unsigned(..)
+            | PvmInstruction::branch_less_signed(..)
+            | PvmInstruction::branch_greater_or_equal_unsigned(..)
+            | PvmInstruction::branch_greater_or_equal_signed(..)
+            | PvmInstruction::branch_eq_imm(..)
+            | PvmInstruction::branch_not_eq_imm(..)
+            | PvmInstruction::branch_less_unsigned_imm(..)
+            | PvmInstruction::branch_less_signed_imm(..)
+            | PvmInstruction::branch_greater_or_equal_unsigned_imm(..)
+            | PvmInstruction::branch_greater_or_equal_signed_imm(..)
+            | PvmInstruction::branch_less_or_equal_signed_imm(..)
+            | PvmInstruction::branch_less_or_equal_unsigned_imm(..)
+            | PvmInstruction::branch_greater_signed_imm(..)
+            | PvmInstruction::branch_greater_unsigned_imm(..)
+            | PvmInstruction::ecalli(..)
+    )
+}
+
+fn direct_target(kind: PvmInstruction) -> Option<u32> {
+    match kind {
+        PvmInstruction::jump(target) | PvmInstruction::load_imm_and_jump(_, _, target) => {
+            Some(target)
+        }
+        PvmInstruction::branch_eq(_, _, target)
+        | PvmInstruction::branch_not_eq(_, _, target)
+        | PvmInstruction::branch_less_unsigned(_, _, target)
+        | PvmInstruction::branch_less_signed(_, _, target)
+        | PvmInstruction::branch_greater_or_equal_unsigned(_, _, target)
+        | PvmInstruction::branch_greater_or_equal_signed(_, _, target)
+        | PvmInstruction::branch_eq_imm(_, _, target)
+        | PvmInstruction::branch_not_eq_imm(_, _, target)
+        | PvmInstruction::branch_less_unsigned_imm(_, _, target)
+        | PvmInstruction::branch_less_signed_imm(_, _, target)
+        | PvmInstruction::branch_greater_or_equal_unsigned_imm(_, _, target)
+        | PvmInstruction::branch_greater_or_equal_signed_imm(_, _, target)
+        | PvmInstruction::branch_less_or_equal_signed_imm(_, _, target)
+        | PvmInstruction::branch_less_or_equal_unsigned_imm(_, _, target)
+        | PvmInstruction::branch_greater_signed_imm(_, _, target)
+        | PvmInstruction::branch_greater_unsigned_imm(_, _, target) => Some(target),
+        _ => None,
+    }
+}
+
+fn collect_block_targets(
+    blob: &ProgramBlob,
+    instructions: &[ParsedInstruction],
+) -> Result<BTreeSet<u32>> {
+    let valid: BTreeSet<_> = instructions
+        .iter()
+        .map(|instruction| instruction.offset.0)
+        .collect();
+    let mut targets = BTreeSet::from([instructions[0].offset.0]);
+    for export in blob.exports() {
+        targets.insert(export.program_counter().0);
+    }
+    for target in blob.jump_table() {
+        targets.insert(target.0);
+    }
+    for instruction in instructions {
+        if let Some(target) = direct_target(instruction.kind) {
+            targets.insert(target);
+        }
+        if is_terminator(instruction.kind) && valid.contains(&instruction.next_offset.0) {
+            targets.insert(instruction.next_offset.0);
+        }
+    }
+    if let Some(invalid) = targets.iter().find(|target| !valid.contains(target)) {
+        bail!("PolkaVM control-flow target {invalid} is not an instruction");
+    }
+    Ok(targets)
+}
+
+type BlockLayout = (Vec<Vec<ParsedInstruction>>, BTreeMap<u32, u32>);
+
+fn build_blocks(
+    instructions: &[ParsedInstruction],
+    targets: &BTreeSet<u32>,
+) -> Result<BlockLayout> {
+    let mut blocks = Vec::new();
+    let mut current = Vec::new();
+    for instruction in instructions {
+        if targets.contains(&instruction.offset.0) && !current.is_empty() {
+            blocks.push(std::mem::take(&mut current));
+        }
+        current.push(*instruction);
+    }
+    if !current.is_empty() {
+        blocks.push(current);
+    }
+    let mut block_by_pc = BTreeMap::new();
+    for (index, block) in blocks.iter().enumerate() {
+        block_by_pc.insert(block[0].offset.0, index as u32);
+    }
+    Ok((blocks, block_by_pc))
+}
+
+fn collect_metered_targets(instructions: &[ParsedInstruction]) -> BTreeSet<u32> {
+    let mut targets = BTreeSet::new();
+    for instruction in instructions {
+        if let Some(target) = direct_target(instruction.kind) {
+            if target <= instruction.offset.0 {
+                targets.insert(target);
+            }
+        }
+    }
+    targets
+}
+
+struct EmitContext<'a> {
+    layout: Layout,
+    block_by_pc: &'a BTreeMap<u32, u32>,
+    jump_table_len: u32,
+    resolver_table_base: u32,
+    block_function_base: u32,
+    mulhu_function: u32,
+    bswap32_function: u32,
+    metered_targets: &'a BTreeSet<u32>,
+    bswap64_function: u32,
+    is_64_bit: bool,
+}
+
+fn reg_index(reg: RawReg) -> u32 {
+    reg.get().to_u32()
+}
+
+fn memarg(bytes: u32, memory_index: u32) -> MemArg {
+    MemArg {
+        offset: 0,
+        align: bytes.trailing_zeros(),
+        memory_index,
+    }
+}
+
+fn emit_mulhu() -> Function {
+    let mut f = Function::new([(4, ValType::I64)]);
+    // Hacker's Delight 32-bit limb multiplication.
+    f.instruction(&W::LocalGet(0));
+    f.instruction(&W::I64Const(0xffff_ffff));
+    f.instruction(&W::I64And);
+    f.instruction(&W::LocalSet(2));
+    f.instruction(&W::LocalGet(1));
+    f.instruction(&W::I64Const(0xffff_ffff));
+    f.instruction(&W::I64And);
+    f.instruction(&W::LocalSet(3));
+    f.instruction(&W::LocalGet(2));
+    f.instruction(&W::LocalGet(3));
+    f.instruction(&W::I64Mul);
+    f.instruction(&W::I64Const(32));
+    f.instruction(&W::I64ShrU);
+    f.instruction(&W::LocalGet(0));
+    f.instruction(&W::I64Const(32));
+    f.instruction(&W::I64ShrU);
+    f.instruction(&W::LocalGet(3));
+    f.instruction(&W::I64Mul);
+    f.instruction(&W::I64Add);
+    f.instruction(&W::LocalTee(4));
+    f.instruction(&W::I64Const(32));
+    f.instruction(&W::I64ShrU);
+    f.instruction(&W::LocalSet(5));
+    f.instruction(&W::LocalGet(4));
+    f.instruction(&W::I64Const(0xffff_ffff));
+    f.instruction(&W::I64And);
+    f.instruction(&W::LocalGet(2));
+    f.instruction(&W::LocalGet(1));
+    f.instruction(&W::I64Const(32));
+    f.instruction(&W::I64ShrU);
+    f.instruction(&W::I64Mul);
+    f.instruction(&W::I64Add);
+    f.instruction(&W::I64Const(32));
+    f.instruction(&W::I64ShrU);
+    f.instruction(&W::LocalGet(5));
+    f.instruction(&W::I64Add);
+    f.instruction(&W::LocalGet(0));
+    f.instruction(&W::I64Const(32));
+    f.instruction(&W::I64ShrU);
+    f.instruction(&W::LocalGet(1));
+    f.instruction(&W::I64Const(32));
+    f.instruction(&W::I64ShrU);
+    f.instruction(&W::I64Mul);
+    f.instruction(&W::I64Add);
+    f.instruction(&W::End);
+    f
+}
+
+fn emit_bswap32() -> Function {
+    let mut f = Function::new([]);
+    for (mask, shift, left) in [
+        (0x0000_00ffu32, 24, true),
+        (0x0000_ff00u32, 8, true),
+        (0x00ff_0000u32, 8, false),
+        (0xff00_0000u32, 24, false),
+    ] {
+        f.instruction(&W::LocalGet(0));
+        f.instruction(&W::I32WrapI64);
+        f.instruction(&W::I32Const(mask as i32));
+        f.instruction(&W::I32And);
+        f.instruction(&W::I32Const(shift));
+        f.instruction(if left { &W::I32Shl } else { &W::I32ShrU });
+        if mask != 0x0000_00ff {
+            f.instruction(&W::I32Or);
+        }
+    }
+    f.instruction(&W::I64ExtendI32U);
+    f.instruction(&W::End);
+    f
+}
+
+fn emit_bswap64() -> Function {
+    let mut f = Function::new([]);
+    for (mask, left, right) in [
+        (0x00ff_00ff_00ff_00ffu64, 8, 8),
+        (0x0000_ffff_0000_ffffu64, 16, 16),
+        (0x0000_0000_ffff_ffffu64, 32, 32),
+    ] {
+        f.instruction(&W::LocalGet(0));
+        f.instruction(&W::I64Const(mask as i64));
+        f.instruction(&W::I64And);
+        f.instruction(&W::I64Const(left));
+        f.instruction(&W::I64Shl);
+        f.instruction(&W::LocalGet(0));
+        f.instruction(&W::I64Const(!mask as i64));
+        f.instruction(&W::I64And);
+        f.instruction(&W::I64Const(right));
+        f.instruction(&W::I64ShrU);
+        f.instruction(&W::I64Or);
+        if left != 32 {
+            f.instruction(&W::LocalSet(0));
+        }
+    }
+    f.instruction(&W::End);
+    f
+}
+
+fn emit_dispatcher() -> Function {
+    let mut f = Function::new([]);
+    f.instruction(&W::GlobalGet(GLOBAL_PC));
+    f.instruction(&W::ReturnCallIndirect {
+        type_index: TYPE_BLOCK,
+        table_index: 0,
+    });
+    f.instruction(&W::End);
+    f
+}
+
+fn emit_begin() -> Function {
+    let mut f = Function::new([]);
+    f.instruction(&W::I64Const(RETURN_TO_HOST as i64));
+    f.instruction(&W::GlobalSet(Reg::RA.to_u32()));
+    f.instruction(&W::LocalGet(0));
+    f.instruction(&W::GlobalSet(GLOBAL_PC));
+    f.instruction(&W::LocalGet(1));
+    f.instruction(&W::GlobalSet(GLOBAL_GAS));
+    f.instruction(&W::LocalGet(0));
+    f.instruction(&W::ReturnCallIndirect {
+        type_index: TYPE_BLOCK,
+        table_index: 0,
+    });
+    f.instruction(&W::End);
+    f
+}
+
+fn emit_set_gas() -> Function {
+    let mut f = Function::new([]);
+    f.instruction(&W::LocalGet(0));
+    f.instruction(&W::GlobalSet(GLOBAL_GAS));
+    f.instruction(&W::End);
+    f
+}
+
+fn encode_metadata(
+    blob: &ProgramBlob,
+    block_by_pc: &BTreeMap<u32, u32>,
+    layout: Layout,
+) -> Result<Vec<u8>> {
+    let mut bytes = b"EPM2".to_vec();
+    bytes.extend_from_slice(&u32::from(blob.is_64_bit()).to_le_bytes());
+    for value in [
+        layout.ro_address,
+        layout.ro_size,
+        layout.ro_phys,
+        layout.rw_address,
+        layout.rw_size,
+        layout.rw_phys,
+        layout.heap_base,
+        layout.heap_limit,
+        layout.stack_low,
+        layout.stack_high,
+        layout.stack_phys,
+    ] {
+        bytes.extend_from_slice(&value.to_le_bytes());
+    }
+    let imports: Vec<_> = blob.imports().into_iter().collect();
+    bytes.extend_from_slice(&(imports.len() as u32).to_le_bytes());
+    for import in imports {
+        match import {
+            Some(symbol) => {
+                let name = symbol.as_bytes();
+                let length =
+                    u16::try_from(name.len()).context("PolkaVM import name is too long")?;
+                bytes.extend_from_slice(&length.to_le_bytes());
+                bytes.extend_from_slice(name);
+            }
+            None => bytes.extend_from_slice(&0u16.to_le_bytes()),
+        }
+    }
+    let exports: Vec<_> = blob.exports().collect();
+    bytes.extend_from_slice(&(exports.len() as u32).to_le_bytes());
+    for export in exports {
+        let name = export.symbol().as_bytes();
+        let length = u16::try_from(name.len()).context("PolkaVM export name is too long")?;
+        bytes.extend_from_slice(&length.to_le_bytes());
+        bytes.extend_from_slice(name);
+        let block = block_by_pc
+            .get(&export.program_counter().0)
+            .copied()
+            .ok_or_else(|| anyhow!("export target is not a translated block"))?;
+        bytes.extend_from_slice(&block.to_le_bytes());
+    }
+    Ok(bytes)
+}
+
+fn emit_gas_charge(f: &mut Function) {
+    f.instruction(&W::GlobalGet(GLOBAL_GAS));
+    f.instruction(&W::I64Const(1));
+    f.instruction(&W::I64Sub);
+    f.instruction(&W::LocalTee(LOCAL_I64_0));
+    f.instruction(&W::GlobalSet(GLOBAL_GAS));
+    f.instruction(&W::LocalGet(LOCAL_I64_0));
+    f.instruction(&W::I64Const(0));
+    f.instruction(&W::I64LeS);
+    f.instruction(&W::If(BlockType::Empty));
+    f.instruction(&W::I32Const(STATUS_OUT_OF_GAS));
+    f.instruction(&W::Return);
+    f.instruction(&W::End);
+}
+
+fn emit_block(context: &EmitContext<'_>, block: &[ParsedInstruction]) -> Result<Function> {
+    let mut f = Function::new([(2, ValType::I32), (2, ValType::I64)]);
+    if context.metered_targets.contains(&block[0].offset.0) {
+        emit_gas_charge(&mut f);
+    }
+
+    for instruction in block {
+        if emit_instruction(context, &mut f, instruction)? {
+            f.instruction(&W::End);
+            return Ok(f);
+        }
+    }
+    let next = block.last().unwrap().next_offset.0;
+    emit_block_target(context, &mut f, next)?;
+    f.instruction(&W::End);
+    Ok(f)
+}
+
+fn emit_block_target(context: &EmitContext<'_>, f: &mut Function, pc: u32) -> Result<()> {
+    let target = context
+        .block_by_pc
+        .get(&pc)
+        .copied()
+        .ok_or_else(|| anyhow!("translated fallthrough target {pc} is missing"))?;
+    f.instruction(&W::ReturnCall(context.block_function_base + target));
+    Ok(())
+}
+
+fn emit_return_target(context: &EmitContext<'_>, f: &mut Function, pc: u32) -> Result<()> {
+    emit_block_target(context, f, pc)
+}
+
+fn emit_trap(f: &mut Function, pc: u32) {
+    f.instruction(&W::I32Const(pc as i32));
+    f.instruction(&W::GlobalSet(GLOBAL_TRAP_PC));
+    f.instruction(&W::I32Const(STATUS_TRAP));
+    f.instruction(&W::Return);
+}
+
+fn emit_reg(f: &mut Function, reg: RawReg) {
+    f.instruction(&W::GlobalGet(reg_index(reg)));
+}
+
+fn emit_set_reg(f: &mut Function, reg: RawReg) {
+    f.instruction(&W::GlobalSet(reg_index(reg)));
+}
+
+fn emit_i32_result(f: &mut Function, reg: RawReg, operation: W<'_>) {
+    f.instruction(&operation);
+    f.instruction(&W::I64ExtendI32S);
+    emit_set_reg(f, reg);
+}
+
+fn emit_address(f: &mut Function, base: Option<RawReg>, offset: i32) {
+    if let Some(base) = base {
+        emit_reg(f, base);
+        f.instruction(&W::I64Const(offset as i64));
+        f.instruction(&W::I64Add);
+        f.instruction(&W::I32WrapI64);
+    } else {
+        f.instruction(&W::I32Const(offset));
+    }
+}
+
+fn static_target(layout: Layout, address: u32, bytes: u32, write: bool) -> Option<(u32, u32)> {
+    let end = u64::from(address).checked_add(u64::from(bytes))?;
+    let (memory, base) = if !write
+        && address >= layout.ro_address
+        && end <= u64::from(layout.ro_address) + u64::from(layout.ro_size)
+    {
+        (0, layout.ro_address)
+    } else if address >= layout.rw_address
+        && end <= u64::from(layout.rw_address) + u64::from(layout.rw_size)
+    {
+        (1, layout.rw_address)
+    } else if address >= layout.stack_low && end <= u64::from(layout.stack_high) {
+        (2, layout.stack_low)
+    } else {
+        return None;
+    };
+    Some((memory, address.checked_sub(base)?))
+}
+
+fn emit_load_at(f: &mut Function, kind: LoadKind, memory: u32) {
+    let bytes = match kind {
+        LoadKind::U8 | LoadKind::I8 => 1,
+        LoadKind::U16 | LoadKind::I16 => 2,
+        LoadKind::U32 | LoadKind::I32 => 4,
+        LoadKind::U64 => 8,
+    };
+    f.instruction(&match kind {
+        LoadKind::U8 => W::I64Load8U(memarg(bytes, memory)),
+        LoadKind::I8 => W::I64Load8S(memarg(bytes, memory)),
+        LoadKind::U16 => W::I64Load16U(memarg(bytes, memory)),
+        LoadKind::I16 => W::I64Load16S(memarg(bytes, memory)),
+        LoadKind::U32 => W::I64Load32U(memarg(bytes, memory)),
+        LoadKind::I32 => W::I64Load32S(memarg(bytes, memory)),
+        LoadKind::U64 => W::I64Load(memarg(bytes, memory)),
+    });
+}
+
+fn emit_load(
+    context: &EmitContext<'_>,
+    f: &mut Function,
+    pc: u32,
+    dst: RawReg,
+    base: Option<RawReg>,
+    offset: i32,
+    kind: LoadKind,
+) {
+    let bytes = match kind {
+        LoadKind::U8 | LoadKind::I8 => 1,
+        LoadKind::U16 | LoadKind::I16 => 2,
+        LoadKind::U32 | LoadKind::I32 => 4,
+        LoadKind::U64 => 8,
+    };
+    if base.is_none() {
+        if let Some((memory, physical)) = static_target(context.layout, offset as u32, bytes, false)
+        {
+            f.instruction(&W::I32Const(physical as i32));
+            emit_load_at(f, kind, memory);
+        } else {
+            emit_trap(f, pc);
+        }
+        emit_set_reg(f, dst);
+        return;
+    }
+    if base == Some(Reg::SP.raw()) {
+        emit_address(f, base, offset);
+        f.instruction(&W::I32Const(context.layout.stack_low as i32));
+        f.instruction(&W::I32Sub);
+        emit_load_at(f, kind, 2);
+        emit_set_reg(f, dst);
+        return;
+    }
+    emit_address(f, base, offset);
+    f.instruction(&W::LocalTee(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.stack_low as i32));
+    f.instruction(&W::I32GeU);
+    f.instruction(&W::If(BlockType::Result(ValType::I64)));
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.stack_low as i32));
+    f.instruction(&W::I32Sub);
+    emit_load_at(f, kind, 2);
+    f.instruction(&W::Else);
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.rw_address as i32));
+    f.instruction(&W::I32GeU);
+    f.instruction(&W::If(BlockType::Result(ValType::I64)));
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.rw_address as i32));
+    f.instruction(&W::I32Sub);
+    emit_load_at(f, kind, 1);
+    f.instruction(&W::Else);
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.ro_address as i32));
+    f.instruction(&W::I32Sub);
+    emit_load_at(f, kind, 0);
+    f.instruction(&W::End);
+    f.instruction(&W::End);
+    emit_set_reg(f, dst);
+}
+
+fn emit_store_value(
+    f: &mut Function,
+    kind: StoreKind,
+    source: Option<RawReg>,
+    immediate: i32,
+    memory: u32,
+) {
+    if let Some(source) = source {
+        emit_reg(f, source);
+    } else {
+        f.instruction(&W::I64Const(immediate as i64));
+    }
+    f.instruction(&match kind {
+        StoreKind::U8 => W::I64Store8(memarg(1, memory)),
+        StoreKind::U16 => W::I64Store16(memarg(2, memory)),
+        StoreKind::U32 => W::I64Store32(memarg(4, memory)),
+        StoreKind::U64 => W::I64Store(memarg(8, memory)),
+    });
+}
+
+// The decoded store operands map directly to the PolkaVM instruction fields;
+// grouping them would only move this argument list into a transient struct.
+#[allow(clippy::too_many_arguments)]
+fn emit_store(
+    context: &EmitContext<'_>,
+    f: &mut Function,
+    pc: u32,
+    source: Option<RawReg>,
+    base: Option<RawReg>,
+    offset: i32,
+    immediate: i32,
+    kind: StoreKind,
+) {
+    let bytes = match kind {
+        StoreKind::U8 => 1,
+        StoreKind::U16 => 2,
+        StoreKind::U32 => 4,
+        StoreKind::U64 => 8,
+    };
+    if base.is_none() {
+        if let Some((memory, physical)) = static_target(context.layout, offset as u32, bytes, true)
+        {
+            f.instruction(&W::I32Const(physical as i32));
+            emit_store_value(f, kind, source, immediate, memory);
+        } else {
+            emit_trap(f, pc);
+        }
+        return;
+    }
+    if base == Some(Reg::SP.raw()) {
+        emit_address(f, base, offset);
+        f.instruction(&W::I32Const(context.layout.stack_low as i32));
+        f.instruction(&W::I32Sub);
+        emit_store_value(f, kind, source, immediate, 2);
+        return;
+    }
+    emit_address(f, base, offset);
+    f.instruction(&W::LocalTee(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.stack_low as i32));
+    f.instruction(&W::I32GeU);
+    f.instruction(&W::If(BlockType::Empty));
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.stack_low as i32));
+    f.instruction(&W::I32Sub);
+    emit_store_value(f, kind, source, immediate, 2);
+    f.instruction(&W::Else);
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.rw_address as i32));
+    f.instruction(&W::I32GeU);
+    f.instruction(&W::If(BlockType::Empty));
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.rw_address as i32));
+    f.instruction(&W::I32Sub);
+    emit_store_value(f, kind, source, immediate, 1);
+    f.instruction(&W::Else);
+    emit_trap(f, pc);
+    f.instruction(&W::End);
+    f.instruction(&W::End);
+}
+
+fn emit_binary_i64(f: &mut Function, dst: RawReg, lhs: RawReg, rhs: RawReg, operation: W<'_>) {
+    emit_reg(f, lhs);
+    emit_reg(f, rhs);
+    f.instruction(&operation);
+    emit_set_reg(f, dst);
+}
+
+fn emit_binary_i32(f: &mut Function, dst: RawReg, lhs: RawReg, rhs: RawReg, operation: W<'_>) {
+    emit_reg(f, lhs);
+    f.instruction(&W::I32WrapI64);
+    emit_reg(f, rhs);
+    f.instruction(&W::I32WrapI64);
+    emit_i32_result(f, dst, operation);
+}
+
+fn emit_binary_imm_i64(f: &mut Function, dst: RawReg, lhs: RawReg, imm: i32, operation: W<'_>) {
+    emit_reg(f, lhs);
+    f.instruction(&W::I64Const(imm as i64));
+    f.instruction(&operation);
+    emit_set_reg(f, dst);
+}
+
+fn emit_binary_imm_i32(f: &mut Function, dst: RawReg, lhs: RawReg, imm: i32, operation: W<'_>) {
+    emit_reg(f, lhs);
+    f.instruction(&W::I32WrapI64);
+    f.instruction(&W::I32Const(imm));
+    emit_i32_result(f, dst, operation);
+}
+
+#[derive(Clone, Copy)]
+enum CompareOp {
+    Eq,
+    Ne,
+    LtU,
+    LtS,
+    LeU,
+    LeS,
+    GtU,
+    GtS,
+    GeU,
+    GeS,
+}
+
+fn emit_compare_regs(
+    context: &EmitContext<'_>,
+    f: &mut Function,
+    lhs: RawReg,
+    rhs: RawReg,
+    operation: CompareOp,
+) {
+    emit_reg(f, lhs);
+    if !context.is_64_bit {
+        f.instruction(&W::I32WrapI64);
+    }
+    emit_reg(f, rhs);
+    if !context.is_64_bit {
+        f.instruction(&W::I32WrapI64);
+    }
+    emit_compare_operation(context, f, operation);
+}
+
+fn emit_compare_imm(
+    context: &EmitContext<'_>,
+    f: &mut Function,
+    lhs: RawReg,
+    rhs: i32,
+    operation: CompareOp,
+) {
+    emit_reg(f, lhs);
+    if context.is_64_bit {
+        f.instruction(&W::I64Const(rhs as i64));
+    } else {
+        f.instruction(&W::I32WrapI64);
+        f.instruction(&W::I32Const(rhs));
+    }
+    emit_compare_operation(context, f, operation);
+}
+
+fn emit_compare_operation(context: &EmitContext<'_>, f: &mut Function, operation: CompareOp) {
+    f.instruction(&match (context.is_64_bit, operation) {
+        (true, CompareOp::Eq) => W::I64Eq,
+        (true, CompareOp::Ne) => W::I64Ne,
+        (true, CompareOp::LtU) => W::I64LtU,
+        (true, CompareOp::LtS) => W::I64LtS,
+        (true, CompareOp::LeU) => W::I64LeU,
+        (true, CompareOp::LeS) => W::I64LeS,
+        (true, CompareOp::GtU) => W::I64GtU,
+        (true, CompareOp::GtS) => W::I64GtS,
+        (true, CompareOp::GeU) => W::I64GeU,
+        (true, CompareOp::GeS) => W::I64GeS,
+        (false, CompareOp::Eq) => W::I32Eq,
+        (false, CompareOp::Ne) => W::I32Ne,
+        (false, CompareOp::LtU) => W::I32LtU,
+        (false, CompareOp::LtS) => W::I32LtS,
+        (false, CompareOp::LeU) => W::I32LeU,
+        (false, CompareOp::LeS) => W::I32LeS,
+        (false, CompareOp::GtU) => W::I32GtU,
+        (false, CompareOp::GtS) => W::I32GtS,
+        (false, CompareOp::GeU) => W::I32GeU,
+        (false, CompareOp::GeS) => W::I32GeS,
+    });
+}
+
+fn emit_compare_branch(
+    context: &EmitContext<'_>,
+    f: &mut Function,
+    instruction: &ParsedInstruction,
+    target: u32,
+) -> Result<()> {
+    f.instruction(&W::If(BlockType::Empty));
+    emit_block_target(context, f, target)?;
+    f.instruction(&W::Else);
+    emit_block_target(context, f, instruction.next_offset.0)?;
+    f.instruction(&W::End);
+    f.instruction(&W::Unreachable);
+    Ok(())
+}
+
+fn emit_indirect(context: &EmitContext<'_>, f: &mut Function, pc: u32, base: RawReg, offset: i32) {
+    emit_reg(f, base);
+    f.instruction(&W::I64Const(offset as i64));
+    f.instruction(&W::I64Add);
+    f.instruction(&W::I32WrapI64);
+    f.instruction(&W::LocalSet(LOCAL_ADDR));
+    emit_indirect_from_local(context, f, pc, base != Reg::RA.raw() || offset != 0);
+}
+
+fn emit_indirect_from_local(context: &EmitContext<'_>, f: &mut Function, pc: u32, meter: bool) {
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(RETURN_TO_HOST as i32));
+    f.instruction(&W::I32Eq);
+    f.instruction(&W::If(BlockType::Empty));
+    f.instruction(&W::I32Const(STATUS_FINISHED));
+    f.instruction(&W::Return);
+    f.instruction(&W::End);
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(1));
+    f.instruction(&W::I32And);
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Eqz);
+    f.instruction(&W::I32Or);
+    f.instruction(&W::If(BlockType::Empty));
+    emit_trap(f, pc);
+    f.instruction(&W::End);
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(2));
+    f.instruction(&W::I32DivU);
+    f.instruction(&W::I32Const(1));
+    f.instruction(&W::I32Sub);
+    f.instruction(&W::LocalTee(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.jump_table_len as i32));
+    f.instruction(&W::I32GeU);
+    f.instruction(&W::If(BlockType::Empty));
+    emit_trap(f, pc);
+    f.instruction(&W::End);
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.resolver_table_base as i32));
+    f.instruction(&W::I32Add);
+    f.instruction(&W::CallIndirect {
+        type_index: TYPE_BLOCK,
+        table_index: 0,
+    });
+    f.instruction(&W::LocalSet(LOCAL_ADDR));
+    if meter {
+        let current_block = context
+            .block_by_pc
+            .range(..=pc)
+            .next_back()
+            .map(|(_, index)| *index)
+            .unwrap_or(0);
+        f.instruction(&W::LocalGet(LOCAL_ADDR));
+        f.instruction(&W::I32Const(current_block as i32));
+        f.instruction(&W::I32LeU);
+        f.instruction(&W::If(BlockType::Empty));
+        emit_gas_charge(f);
+        f.instruction(&W::End);
+    } else {
+        let current_block = context
+            .block_by_pc
+            .range(..=pc)
+            .next_back()
+            .map(|(_, index)| *index)
+            .unwrap_or(0);
+        f.instruction(&W::LocalGet(LOCAL_ADDR));
+        f.instruction(&W::I32Const(current_block as i32));
+        f.instruction(&W::I32Eq);
+        f.instruction(&W::If(BlockType::Empty));
+        emit_gas_charge(f);
+        f.instruction(&W::End);
+    }
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::ReturnCallIndirect {
+        type_index: TYPE_BLOCK,
+        table_index: 0,
+    });
+}
+
+fn written_register(kind: PvmInstruction) -> Option<RawReg> {
+    use PvmInstruction::*;
+    Some(match kind {
+        load_imm(dst, _)
+        | load_imm64(dst, _)
+        | move_reg(dst, _)
+        | load_u8(dst, _)
+        | load_i8(dst, _)
+        | load_u16(dst, _)
+        | load_i16(dst, _)
+        | load_u32(dst, _)
+        | load_i32(dst, _)
+        | load_u64(dst, _)
+        | load_indirect_u8(dst, _, _)
+        | load_indirect_i8(dst, _, _)
+        | load_indirect_u16(dst, _, _)
+        | load_indirect_i16(dst, _, _)
+        | load_indirect_u32(dst, _, _)
+        | load_indirect_i32(dst, _, _)
+        | load_indirect_u64(dst, _, _)
+        | add_32(dst, _, _)
+        | add_64(dst, _, _)
+        | sub_32(dst, _, _)
+        | sub_64(dst, _, _)
+        | and(dst, _, _)
+        | xor(dst, _, _)
+        | or(dst, _, _)
+        | and_inverted(dst, _, _)
+        | or_inverted(dst, _, _)
+        | xnor(dst, _, _)
+        | mul_32(dst, _, _)
+        | mul_64(dst, _, _)
+        | mul_upper_unsigned_unsigned(dst, _, _)
+        | mul_upper_signed_signed(dst, _, _)
+        | mul_upper_signed_unsigned(dst, _, _)
+        | add_imm_32(dst, _, _)
+        | add_imm_64(dst, _, _)
+        | and_imm(dst, _, _)
+        | xor_imm(dst, _, _)
+        | or_imm(dst, _, _)
+        | mul_imm_32(dst, _, _)
+        | mul_imm_64(dst, _, _)
+        | negate_and_add_imm_32(dst, _, _)
+        | negate_and_add_imm_64(dst, _, _)
+        | set_less_than_unsigned(dst, _, _)
+        | set_less_than_signed(dst, _, _)
+        | set_less_than_unsigned_imm(dst, _, _)
+        | set_less_than_signed_imm(dst, _, _)
+        | set_greater_than_unsigned_imm(dst, _, _)
+        | set_greater_than_signed_imm(dst, _, _)
+        | shift_logical_left_32(dst, _, _)
+        | shift_logical_left_64(dst, _, _)
+        | shift_logical_right_32(dst, _, _)
+        | shift_logical_right_64(dst, _, _)
+        | shift_arithmetic_right_32(dst, _, _)
+        | shift_arithmetic_right_64(dst, _, _)
+        | shift_logical_left_imm_32(dst, _, _)
+        | shift_logical_left_imm_64(dst, _, _)
+        | shift_logical_right_imm_32(dst, _, _)
+        | shift_logical_right_imm_64(dst, _, _)
+        | shift_arithmetic_right_imm_32(dst, _, _)
+        | shift_arithmetic_right_imm_64(dst, _, _)
+        | shift_logical_right_imm_alt_32(dst, _, _)
+        | shift_logical_right_imm_alt_64(dst, _, _)
+        | shift_arithmetic_right_imm_alt_32(dst, _, _)
+        | shift_arithmetic_right_imm_alt_64(dst, _, _)
+        | shift_logical_left_imm_alt_32(dst, _, _)
+        | shift_logical_left_imm_alt_64(dst, _, _)
+        | rotate_left_32(dst, _, _)
+        | rotate_left_64(dst, _, _)
+        | rotate_right_32(dst, _, _)
+        | rotate_right_64(dst, _, _)
+        | rotate_right_imm_32(dst, _, _)
+        | rotate_right_imm_64(dst, _, _)
+        | rotate_right_imm_alt_32(dst, _, _)
+        | rotate_right_imm_alt_64(dst, _, _)
+        | div_unsigned_32(dst, _, _)
+        | div_unsigned_64(dst, _, _)
+        | div_signed_32(dst, _, _)
+        | div_signed_64(dst, _, _)
+        | rem_unsigned_32(dst, _, _)
+        | rem_unsigned_64(dst, _, _)
+        | rem_signed_32(dst, _, _)
+        | rem_signed_64(dst, _, _)
+        | count_leading_zero_bits_32(dst, _)
+        | count_leading_zero_bits_64(dst, _)
+        | count_trailing_zero_bits_32(dst, _)
+        | count_trailing_zero_bits_64(dst, _)
+        | count_set_bits_32(dst, _)
+        | count_set_bits_64(dst, _)
+        | sign_extend_8(dst, _)
+        | sign_extend_16(dst, _)
+        | zero_extend_16(dst, _)
+        | reverse_byte(dst, _)
+        | maximum(dst, _, _)
+        | maximum_unsigned(dst, _, _)
+        | minimum(dst, _, _)
+        | minimum_unsigned(dst, _, _)
+        | cmov_if_zero(dst, _, _)
+        | cmov_if_not_zero(dst, _, _)
+        | cmov_if_zero_imm(dst, _, _)
+        | cmov_if_not_zero_imm(dst, _, _)
+        | sbrk(dst, _) => dst,
+        _ => return None,
+    })
+}
+
+fn normalize_32(f: &mut Function, reg: RawReg) {
+    emit_reg(f, reg);
+    f.instruction(&W::I32WrapI64);
+    f.instruction(&W::I64ExtendI32U);
+    emit_set_reg(f, reg);
+}
+
+fn emit_instruction(
+    context: &EmitContext<'_>,
+    f: &mut Function,
+    instruction: &ParsedInstruction,
+) -> Result<bool> {
+    use PvmInstruction::*;
+    let pc = instruction.offset.0;
+    match instruction.kind {
+        trap | invalid => {
+            emit_trap(f, pc);
+            return Ok(true);
+        }
+        fallthrough | unlikely => {}
+        memset => emit_memset(context, f, pc),
+        jump(target) => {
+            emit_return_target(context, f, target)?;
+            return Ok(true);
+        }
+        jump_indirect(base, offset) => {
+            emit_indirect(context, f, pc, base, offset);
+            return Ok(true);
+        }
+        load_imm_and_jump(dst, value, target) => {
+            f.instruction(&W::I64Const(if context.is_64_bit {
+                value as i64
+            } else {
+                value as u32 as i64
+            }));
+            emit_set_reg(f, dst);
+            emit_return_target(context, f, target)?;
+            return Ok(true);
+        }
+        load_imm_and_jump_indirect(dst, base, value, offset) => {
+            // The target address uses the old base value when dst aliases base.
+            emit_reg(f, base);
+            f.instruction(&W::I64Const(offset as i64));
+            f.instruction(&W::I64Add);
+            f.instruction(&W::I32WrapI64);
+            f.instruction(&W::LocalSet(LOCAL_ADDR));
+            f.instruction(&W::I64Const(if context.is_64_bit {
+                value as i64
+            } else {
+                value as u32 as i64
+            }));
+            emit_set_reg(f, dst);
+            emit_indirect_from_local(context, f, pc, true);
+            return Ok(true);
+        }
+        ecalli(index) => {
+            f.instruction(&W::I32Const(index));
+            f.instruction(&W::GlobalSet(GLOBAL_ECALL));
+            let next = context
+                .block_by_pc
+                .get(&instruction.next_offset.0)
+                .copied()
+                .ok_or_else(|| anyhow!("ecall continuation is not a block"))?;
+            f.instruction(&W::I32Const(next as i32));
+            f.instruction(&W::GlobalSet(GLOBAL_PC));
+            f.instruction(&W::I32Const(STATUS_ECALL));
+            f.instruction(&W::Return);
+            return Ok(true);
+        }
+        load_imm(dst, value) => {
+            f.instruction(&W::I64Const(value as i64));
+            emit_set_reg(f, dst);
+        }
+        load_imm64(dst, value) => {
+            f.instruction(&W::I64Const(value as i64));
+            emit_set_reg(f, dst);
+        }
+        move_reg(dst, src) => {
+            emit_reg(f, src);
+            emit_set_reg(f, dst);
+        }
+        load_u8(dst, offset) => emit_load(context, f, pc, dst, None, offset, LoadKind::U8),
+        load_i8(dst, offset) => emit_load(context, f, pc, dst, None, offset, LoadKind::I8),
+        load_u16(dst, offset) => emit_load(context, f, pc, dst, None, offset, LoadKind::U16),
+        load_i16(dst, offset) => emit_load(context, f, pc, dst, None, offset, LoadKind::I16),
+        load_u32(dst, offset) => emit_load(context, f, pc, dst, None, offset, LoadKind::U32),
+        load_i32(dst, offset) => emit_load(context, f, pc, dst, None, offset, LoadKind::I32),
+        load_u64(dst, offset) => emit_load(context, f, pc, dst, None, offset, LoadKind::U64),
+        load_indirect_u8(dst, base, offset) => {
+            emit_load(context, f, pc, dst, Some(base), offset, LoadKind::U8)
+        }
+        load_indirect_i8(dst, base, offset) => {
+            emit_load(context, f, pc, dst, Some(base), offset, LoadKind::I8)
+        }
+        load_indirect_u16(dst, base, offset) => {
+            emit_load(context, f, pc, dst, Some(base), offset, LoadKind::U16)
+        }
+        load_indirect_i16(dst, base, offset) => {
+            emit_load(context, f, pc, dst, Some(base), offset, LoadKind::I16)
+        }
+        load_indirect_u32(dst, base, offset) => {
+            emit_load(context, f, pc, dst, Some(base), offset, LoadKind::U32)
+        }
+        load_indirect_i32(dst, base, offset) => {
+            emit_load(context, f, pc, dst, Some(base), offset, LoadKind::I32)
+        }
+        load_indirect_u64(dst, base, offset) => {
+            emit_load(context, f, pc, dst, Some(base), offset, LoadKind::U64)
+        }
+        store_u8(src, offset) => {
+            emit_store(context, f, pc, Some(src), None, offset, 0, StoreKind::U8)
+        }
+        store_u16(src, offset) => {
+            emit_store(context, f, pc, Some(src), None, offset, 0, StoreKind::U16)
+        }
+        store_u32(src, offset) => {
+            emit_store(context, f, pc, Some(src), None, offset, 0, StoreKind::U32)
+        }
+        store_u64(src, offset) => {
+            emit_store(context, f, pc, Some(src), None, offset, 0, StoreKind::U64)
+        }
+        store_indirect_u8(src, base, offset) => emit_store(
+            context,
+            f,
+            pc,
+            Some(src),
+            Some(base),
+            offset,
+            0,
+            StoreKind::U8,
+        ),
+        store_indirect_u16(src, base, offset) => emit_store(
+            context,
+            f,
+            pc,
+            Some(src),
+            Some(base),
+            offset,
+            0,
+            StoreKind::U16,
+        ),
+        store_indirect_u32(src, base, offset) => emit_store(
+            context,
+            f,
+            pc,
+            Some(src),
+            Some(base),
+            offset,
+            0,
+            StoreKind::U32,
+        ),
+        store_indirect_u64(src, base, offset) => emit_store(
+            context,
+            f,
+            pc,
+            Some(src),
+            Some(base),
+            offset,
+            0,
+            StoreKind::U64,
+        ),
+        store_imm_u8(offset, value) => {
+            emit_store(context, f, pc, None, None, offset, value, StoreKind::U8)
+        }
+        store_imm_u16(offset, value) => {
+            emit_store(context, f, pc, None, None, offset, value, StoreKind::U16)
+        }
+        store_imm_u32(offset, value) => {
+            emit_store(context, f, pc, None, None, offset, value, StoreKind::U32)
+        }
+        store_imm_u64(offset, value) => {
+            emit_store(context, f, pc, None, None, offset, value, StoreKind::U64)
+        }
+        store_imm_indirect_u8(base, offset, value) => emit_store(
+            context,
+            f,
+            pc,
+            None,
+            Some(base),
+            offset,
+            value,
+            StoreKind::U8,
+        ),
+        store_imm_indirect_u16(base, offset, value) => emit_store(
+            context,
+            f,
+            pc,
+            None,
+            Some(base),
+            offset,
+            value,
+            StoreKind::U16,
+        ),
+        store_imm_indirect_u32(base, offset, value) => emit_store(
+            context,
+            f,
+            pc,
+            None,
+            Some(base),
+            offset,
+            value,
+            StoreKind::U32,
+        ),
+        store_imm_indirect_u64(base, offset, value) => emit_store(
+            context,
+            f,
+            pc,
+            None,
+            Some(base),
+            offset,
+            value,
+            StoreKind::U64,
+        ),
+        add_32(dst, a, b) => emit_binary_i32(f, dst, a, b, W::I32Add),
+        add_64(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64Add),
+        sub_32(dst, a, b) => emit_binary_i32(f, dst, a, b, W::I32Sub),
+        sub_64(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64Sub),
+        and(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64And),
+        xor(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64Xor),
+        or(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64Or),
+        and_inverted(dst, a, b) => {
+            emit_reg(f, a);
+            emit_reg(f, b);
+            f.instruction(&W::I64Const(-1));
+            f.instruction(&W::I64Xor);
+            f.instruction(&W::I64And);
+            emit_set_reg(f, dst);
+        }
+        or_inverted(dst, a, b) => {
+            emit_reg(f, a);
+            emit_reg(f, b);
+            f.instruction(&W::I64Const(-1));
+            f.instruction(&W::I64Xor);
+            f.instruction(&W::I64Or);
+            emit_set_reg(f, dst);
+        }
+        xnor(dst, a, b) => {
+            emit_reg(f, a);
+            emit_reg(f, b);
+            f.instruction(&W::I64Xor);
+            f.instruction(&W::I64Const(-1));
+            f.instruction(&W::I64Xor);
+            emit_set_reg(f, dst);
+        }
+        mul_32(dst, a, b) => emit_binary_i32(f, dst, a, b, W::I32Mul),
+        mul_64(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64Mul),
+        mul_upper_unsigned_unsigned(dst, a, b) => {
+            emit_mul_high(context, f, dst, a, b, false, false);
+        }
+        mul_upper_signed_signed(dst, a, b) => emit_mul_high(context, f, dst, a, b, true, true),
+        mul_upper_signed_unsigned(dst, a, b) => emit_mul_high(context, f, dst, a, b, true, false),
+        add_imm_32(dst, a, imm) => emit_binary_imm_i32(f, dst, a, imm, W::I32Add),
+        add_imm_64(dst, a, imm) => emit_binary_imm_i64(f, dst, a, imm, W::I64Add),
+        and_imm(dst, a, imm) => emit_binary_imm_i64(f, dst, a, imm, W::I64And),
+        xor_imm(dst, a, imm) => emit_binary_imm_i64(f, dst, a, imm, W::I64Xor),
+        or_imm(dst, a, imm) => emit_binary_imm_i64(f, dst, a, imm, W::I64Or),
+        mul_imm_32(dst, a, imm) => emit_binary_imm_i32(f, dst, a, imm, W::I32Mul),
+        mul_imm_64(dst, a, imm) => emit_binary_imm_i64(f, dst, a, imm, W::I64Mul),
+        negate_and_add_imm_32(dst, a, imm) => {
+            f.instruction(&W::I32Const(imm));
+            emit_reg(f, a);
+            f.instruction(&W::I32WrapI64);
+            emit_i32_result(f, dst, W::I32Sub);
+        }
+        negate_and_add_imm_64(dst, a, imm) => {
+            f.instruction(&W::I64Const(imm as i64));
+            emit_reg(f, a);
+            f.instruction(&W::I64Sub);
+            emit_set_reg(f, dst);
+        }
+        set_less_than_unsigned(dst, a, b) => emit_comparison(context, f, dst, a, b, CompareOp::LtU),
+        set_less_than_signed(dst, a, b) => emit_comparison(context, f, dst, a, b, CompareOp::LtS),
+        set_less_than_unsigned_imm(dst, a, imm) => {
+            emit_comparison_imm(context, f, dst, a, imm, CompareOp::LtU)
+        }
+        set_less_than_signed_imm(dst, a, imm) => {
+            emit_comparison_imm(context, f, dst, a, imm, CompareOp::LtS)
+        }
+        set_greater_than_unsigned_imm(dst, a, imm) => {
+            emit_comparison_imm(context, f, dst, a, imm, CompareOp::GtU)
+        }
+        set_greater_than_signed_imm(dst, a, imm) => {
+            emit_comparison_imm(context, f, dst, a, imm, CompareOp::GtS)
+        }
+        shift_logical_left_32(dst, a, b) => emit_binary_i32(f, dst, a, b, W::I32Shl),
+        shift_logical_left_64(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64Shl),
+        shift_logical_right_32(dst, a, b) => emit_binary_i32(f, dst, a, b, W::I32ShrU),
+        shift_logical_right_64(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64ShrU),
+        shift_arithmetic_right_32(dst, a, b) => emit_binary_i32(f, dst, a, b, W::I32ShrS),
+        shift_arithmetic_right_64(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64ShrS),
+        shift_logical_left_imm_32(dst, a, imm) => emit_binary_imm_i32(f, dst, a, imm, W::I32Shl),
+        shift_logical_left_imm_64(dst, a, imm) => emit_binary_imm_i64(f, dst, a, imm, W::I64Shl),
+        shift_logical_right_imm_32(dst, a, imm) => emit_binary_imm_i32(f, dst, a, imm, W::I32ShrU),
+        shift_logical_right_imm_64(dst, a, imm) => emit_binary_imm_i64(f, dst, a, imm, W::I64ShrU),
+        shift_arithmetic_right_imm_32(dst, a, imm) => {
+            emit_binary_imm_i32(f, dst, a, imm, W::I32ShrS)
+        }
+        shift_arithmetic_right_imm_64(dst, a, imm) => {
+            emit_binary_imm_i64(f, dst, a, imm, W::I64ShrS)
+        }
+        shift_logical_right_imm_alt_32(dst, a, imm) => {
+            emit_alt_shift_i32(f, dst, a, imm, W::I32ShrU)
+        }
+        shift_logical_right_imm_alt_64(dst, a, imm) => {
+            emit_alt_shift_i64(f, dst, a, imm, W::I64ShrU)
+        }
+        shift_arithmetic_right_imm_alt_32(dst, a, imm) => {
+            emit_alt_shift_i32(f, dst, a, imm, W::I32ShrS)
+        }
+        shift_arithmetic_right_imm_alt_64(dst, a, imm) => {
+            emit_alt_shift_i64(f, dst, a, imm, W::I64ShrS)
+        }
+        shift_logical_left_imm_alt_32(dst, a, imm) => emit_alt_shift_i32(f, dst, a, imm, W::I32Shl),
+        shift_logical_left_imm_alt_64(dst, a, imm) => emit_alt_shift_i64(f, dst, a, imm, W::I64Shl),
+        rotate_left_32(dst, a, b) => emit_binary_i32(f, dst, a, b, W::I32Rotl),
+        rotate_left_64(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64Rotl),
+        rotate_right_32(dst, a, b) => emit_binary_i32(f, dst, a, b, W::I32Rotr),
+        rotate_right_64(dst, a, b) => emit_binary_i64(f, dst, a, b, W::I64Rotr),
+        rotate_right_imm_32(dst, a, imm) => emit_binary_imm_i32(f, dst, a, imm, W::I32Rotr),
+        rotate_right_imm_64(dst, a, imm) => emit_binary_imm_i64(f, dst, a, imm, W::I64Rotr),
+        rotate_right_imm_alt_32(dst, a, imm) => emit_alt_shift_i32(f, dst, a, imm, W::I32Rotr),
+        rotate_right_imm_alt_64(dst, a, imm) => emit_alt_shift_i64(f, dst, a, imm, W::I64Rotr),
+        div_unsigned_32(dst, a, b) => emit_divrem(f, dst, a, b, false, false, true),
+        div_unsigned_64(dst, a, b) => emit_divrem(f, dst, a, b, false, false, false),
+        div_signed_32(dst, a, b) => emit_divrem(f, dst, a, b, true, false, true),
+        div_signed_64(dst, a, b) => emit_divrem(f, dst, a, b, true, false, false),
+        rem_unsigned_32(dst, a, b) => emit_divrem(f, dst, a, b, false, true, true),
+        rem_unsigned_64(dst, a, b) => emit_divrem(f, dst, a, b, false, true, false),
+        rem_signed_32(dst, a, b) => emit_divrem(f, dst, a, b, true, true, true),
+        rem_signed_64(dst, a, b) => emit_divrem(f, dst, a, b, true, true, false),
+        count_leading_zero_bits_32(dst, src) => emit_unary_i32(f, dst, src, W::I32Clz),
+        count_leading_zero_bits_64(dst, src) => emit_unary_i64(f, dst, src, W::I64Clz),
+        count_trailing_zero_bits_32(dst, src) => emit_unary_i32(f, dst, src, W::I32Ctz),
+        count_trailing_zero_bits_64(dst, src) => emit_unary_i64(f, dst, src, W::I64Ctz),
+        count_set_bits_32(dst, src) => emit_unary_i32(f, dst, src, W::I32Popcnt),
+        count_set_bits_64(dst, src) => emit_unary_i64(f, dst, src, W::I64Popcnt),
+        sign_extend_8(dst, src) => {
+            emit_reg(f, src);
+            f.instruction(&W::I64Extend8S);
+            emit_set_reg(f, dst);
+        }
+        sign_extend_16(dst, src) => {
+            emit_reg(f, src);
+            f.instruction(&W::I64Extend16S);
+            emit_set_reg(f, dst);
+        }
+        zero_extend_16(dst, src) => {
+            emit_reg(f, src);
+            f.instruction(&W::I64Const(0xffff));
+            f.instruction(&W::I64And);
+            emit_set_reg(f, dst);
+        }
+        reverse_byte(dst, src) => {
+            emit_reg(f, src);
+            f.instruction(&W::Call(if context.is_64_bit {
+                context.bswap64_function
+            } else {
+                context.bswap32_function
+            }));
+            emit_set_reg(f, dst);
+        }
+        maximum(dst, a, b) => emit_minmax(f, dst, a, b, true, false, context.is_64_bit),
+        maximum_unsigned(dst, a, b) => emit_minmax(f, dst, a, b, true, true, context.is_64_bit),
+        minimum(dst, a, b) => emit_minmax(f, dst, a, b, false, false, context.is_64_bit),
+        minimum_unsigned(dst, a, b) => emit_minmax(f, dst, a, b, false, true, context.is_64_bit),
+        cmov_if_zero(dst, src, condition) => emit_cmov(f, dst, src, condition, true),
+        cmov_if_not_zero(dst, src, condition) => emit_cmov(f, dst, src, condition, false),
+        cmov_if_zero_imm(dst, condition, value) => emit_cmov_imm(f, dst, condition, value, true),
+        cmov_if_not_zero_imm(dst, condition, value) => {
+            emit_cmov_imm(f, dst, condition, value, false)
+        }
+        sbrk(dst, size) => emit_sbrk(context, f, dst, size),
+        branch_eq(a, b, target) => {
+            emit_compare_regs(context, f, a, b, CompareOp::Eq);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_not_eq(a, b, target) => {
+            emit_compare_regs(context, f, a, b, CompareOp::Ne);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_less_unsigned(a, b, target) => {
+            emit_compare_regs(context, f, a, b, CompareOp::LtU);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_less_signed(a, b, target) => {
+            emit_compare_regs(context, f, a, b, CompareOp::LtS);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_greater_or_equal_unsigned(a, b, target) => {
+            emit_compare_regs(context, f, a, b, CompareOp::GeU);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_greater_or_equal_signed(a, b, target) => {
+            emit_compare_regs(context, f, a, b, CompareOp::GeS);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_eq_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::Eq);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_not_eq_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::Ne);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_less_unsigned_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::LtU);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_less_signed_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::LtS);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_greater_or_equal_unsigned_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::GeU);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_greater_or_equal_signed_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::GeS);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_less_or_equal_unsigned_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::LeU);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_less_or_equal_signed_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::LeS);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_greater_unsigned_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::GtU);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+        branch_greater_signed_imm(a, imm, target) => {
+            emit_compare_imm(context, f, a, imm, CompareOp::GtS);
+            emit_compare_branch(context, f, instruction, target)?;
+            return Ok(true);
+        }
+    }
+    if !context.is_64_bit {
+        if instruction.kind == PvmInstruction::memset {
+            normalize_32(f, Reg::A0.raw());
+            normalize_32(f, Reg::A2.raw());
+        } else if let Some(reg) = written_register(instruction.kind) {
+            normalize_32(f, reg);
+        }
+    }
+    Ok(false)
+}
+
+fn emit_memset(context: &EmitContext<'_>, f: &mut Function, pc: u32) {
+    emit_reg(f, Reg::A0.raw());
+    f.instruction(&W::I32WrapI64);
+    f.instruction(&W::LocalSet(LOCAL_ADDR));
+    emit_reg(f, Reg::A2.raw());
+    f.instruction(&W::I32WrapI64);
+    f.instruction(&W::LocalSet(LOCAL_PHYS));
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.stack_low as i32));
+    f.instruction(&W::I32GeU);
+    f.instruction(&W::If(BlockType::Empty));
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.stack_low as i32));
+    f.instruction(&W::I32Sub);
+    emit_reg(f, Reg::A1.raw());
+    f.instruction(&W::I32WrapI64);
+    f.instruction(&W::LocalGet(LOCAL_PHYS));
+    f.instruction(&W::MemoryFill(2));
+    f.instruction(&W::Else);
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.rw_address as i32));
+    f.instruction(&W::I32GeU);
+    f.instruction(&W::If(BlockType::Empty));
+    f.instruction(&W::LocalGet(LOCAL_ADDR));
+    f.instruction(&W::I32Const(context.layout.rw_address as i32));
+    f.instruction(&W::I32Sub);
+    emit_reg(f, Reg::A1.raw());
+    f.instruction(&W::I32WrapI64);
+    f.instruction(&W::LocalGet(LOCAL_PHYS));
+    f.instruction(&W::MemoryFill(1));
+    f.instruction(&W::Else);
+    emit_trap(f, pc);
+    f.instruction(&W::End);
+    f.instruction(&W::End);
+    emit_reg(f, Reg::A0.raw());
+    emit_reg(f, Reg::A2.raw());
+    f.instruction(&W::I64Add);
+    emit_set_reg(f, Reg::A0.raw());
+    f.instruction(&W::I64Const(0));
+    emit_set_reg(f, Reg::A2.raw());
+}
+
+fn emit_mul_high(
+    context: &EmitContext<'_>,
+    f: &mut Function,
+    dst: RawReg,
+    a: RawReg,
+    b: RawReg,
+    signed_a: bool,
+    signed_b: bool,
+) {
+    if !context.is_64_bit {
+        emit_reg(f, a);
+        f.instruction(&W::I32WrapI64);
+        f.instruction(&if signed_a {
+            W::I64ExtendI32S
+        } else {
+            W::I64ExtendI32U
+        });
+        emit_reg(f, b);
+        f.instruction(&W::I32WrapI64);
+        f.instruction(&if signed_b {
+            W::I64ExtendI32S
+        } else {
+            W::I64ExtendI32U
+        });
+        f.instruction(&W::I64Mul);
+        f.instruction(&W::I64Const(32));
+        f.instruction(&W::I64ShrU);
+        emit_set_reg(f, dst);
+        return;
+    }
+    emit_reg(f, a);
+    f.instruction(&W::LocalSet(LOCAL_I64_0));
+    emit_reg(f, b);
+    f.instruction(&W::LocalSet(LOCAL_I64_1));
+    f.instruction(&W::LocalGet(LOCAL_I64_0));
+    f.instruction(&W::LocalGet(LOCAL_I64_1));
+    f.instruction(&W::Call(context.mulhu_function));
+    if signed_a {
+        f.instruction(&W::LocalGet(LOCAL_I64_0));
+        f.instruction(&W::I64Const(0));
+        f.instruction(&W::I64LtS);
+        f.instruction(&W::If(BlockType::Result(ValType::I64)));
+        f.instruction(&W::LocalGet(LOCAL_I64_1));
+        f.instruction(&W::Else);
+        f.instruction(&W::I64Const(0));
+        f.instruction(&W::End);
+        f.instruction(&W::I64Sub);
+    }
+    if signed_b {
+        f.instruction(&W::LocalGet(LOCAL_I64_1));
+        f.instruction(&W::I64Const(0));
+        f.instruction(&W::I64LtS);
+        f.instruction(&W::If(BlockType::Result(ValType::I64)));
+        f.instruction(&W::LocalGet(LOCAL_I64_0));
+        f.instruction(&W::Else);
+        f.instruction(&W::I64Const(0));
+        f.instruction(&W::End);
+        f.instruction(&W::I64Sub);
+    }
+    emit_set_reg(f, dst);
+}
+
+fn emit_comparison(
+    context: &EmitContext<'_>,
+    f: &mut Function,
+    dst: RawReg,
+    a: RawReg,
+    b: RawReg,
+    operation: CompareOp,
+) {
+    emit_compare_regs(context, f, a, b, operation);
+    f.instruction(&W::I64ExtendI32U);
+    emit_set_reg(f, dst);
+}
+
+fn emit_comparison_imm(
+    context: &EmitContext<'_>,
+    f: &mut Function,
+    dst: RawReg,
+    a: RawReg,
+    imm: i32,
+    operation: CompareOp,
+) {
+    emit_compare_imm(context, f, a, imm, operation);
+    f.instruction(&W::I64ExtendI32U);
+    emit_set_reg(f, dst);
+}
+fn emit_alt_shift_i32(f: &mut Function, dst: RawReg, a: RawReg, imm: i32, operation: W<'_>) {
+    f.instruction(&W::I32Const(imm));
+    emit_reg(f, a);
+    f.instruction(&W::I32WrapI64);
+    emit_i32_result(f, dst, operation);
+}
+fn emit_alt_shift_i64(f: &mut Function, dst: RawReg, a: RawReg, imm: i32, operation: W<'_>) {
+    f.instruction(&W::I64Const(imm as i64));
+    emit_reg(f, a);
+    f.instruction(&operation);
+    emit_set_reg(f, dst);
+}
+fn emit_unary_i32(f: &mut Function, dst: RawReg, src: RawReg, operation: W<'_>) {
+    emit_reg(f, src);
+    f.instruction(&W::I32WrapI64);
+    emit_i32_result(f, dst, operation);
+}
+fn emit_unary_i64(f: &mut Function, dst: RawReg, src: RawReg, operation: W<'_>) {
+    emit_reg(f, src);
+    f.instruction(&operation);
+    emit_set_reg(f, dst);
+}
+
+fn emit_divrem(
+    f: &mut Function,
+    dst: RawReg,
+    a: RawReg,
+    b: RawReg,
+    signed: bool,
+    remainder: bool,
+    bits32: bool,
+) {
+    emit_reg(f, a);
+    f.instruction(&W::LocalSet(LOCAL_I64_0));
+    emit_reg(f, b);
+    f.instruction(&W::LocalSet(LOCAL_I64_1));
+    f.instruction(&W::LocalGet(LOCAL_I64_1));
+    if bits32 {
+        f.instruction(&W::I32WrapI64);
+        f.instruction(&W::I32Eqz);
+    } else {
+        f.instruction(&W::I64Eqz);
+    }
+    f.instruction(&W::If(BlockType::Result(ValType::I64)));
+    if remainder {
+        f.instruction(&W::LocalGet(LOCAL_I64_0));
+        if bits32 {
+            f.instruction(&W::I32WrapI64);
+            f.instruction(&W::I64ExtendI32S);
+        }
+    } else {
+        f.instruction(&W::I64Const(-1));
+    }
+    f.instruction(&W::Else);
+    if signed {
+        f.instruction(&W::LocalGet(LOCAL_I64_0));
+        if bits32 {
+            f.instruction(&W::I32WrapI64);
+            f.instruction(&W::I32Const(i32::MIN));
+            f.instruction(&W::I32Eq);
+            f.instruction(&W::LocalGet(LOCAL_I64_1));
+            f.instruction(&W::I32WrapI64);
+            f.instruction(&W::I32Const(-1));
+            f.instruction(&W::I32Eq);
+        } else {
+            f.instruction(&W::I64Const(i64::MIN));
+            f.instruction(&W::I64Eq);
+            f.instruction(&W::LocalGet(LOCAL_I64_1));
+            f.instruction(&W::I64Const(-1));
+            f.instruction(&W::I64Eq);
+        }
+        f.instruction(&W::I32And);
+        f.instruction(&W::If(BlockType::Result(ValType::I64)));
+        f.instruction(&W::I64Const(if remainder {
+            0
+        } else if bits32 {
+            i32::MIN as i64
+        } else {
+            i64::MIN
+        }));
+        f.instruction(&W::Else);
+        emit_divrem_operation(f, signed, remainder, bits32);
+        f.instruction(&W::End);
+    } else {
+        emit_divrem_operation(f, signed, remainder, bits32);
+    }
+    f.instruction(&W::End);
+    emit_set_reg(f, dst);
+}
+
+fn emit_divrem_operation(f: &mut Function, signed: bool, remainder: bool, bits32: bool) {
+    f.instruction(&W::LocalGet(LOCAL_I64_0));
+    if bits32 {
+        f.instruction(&W::I32WrapI64);
+    }
+    f.instruction(&W::LocalGet(LOCAL_I64_1));
+    if bits32 {
+        f.instruction(&W::I32WrapI64);
+        f.instruction(&match (signed, remainder) {
+            (true, true) => W::I32RemS,
+            (true, false) => W::I32DivS,
+            (false, true) => W::I32RemU,
+            (false, false) => W::I32DivU,
+        });
+        f.instruction(&W::I64ExtendI32S);
+    } else {
+        f.instruction(&match (signed, remainder) {
+            (true, true) => W::I64RemS,
+            (true, false) => W::I64DivS,
+            (false, true) => W::I64RemU,
+            (false, false) => W::I64DivU,
+        });
+    }
+}
+
+fn emit_minmax(
+    f: &mut Function,
+    dst: RawReg,
+    a: RawReg,
+    b: RawReg,
+    maximum: bool,
+    unsigned: bool,
+    bits64: bool,
+) {
+    emit_reg(f, a);
+    f.instruction(&W::LocalSet(LOCAL_I64_0));
+    emit_reg(f, b);
+    f.instruction(&W::LocalSet(LOCAL_I64_1));
+    f.instruction(&W::LocalGet(LOCAL_I64_0));
+    if !bits64 {
+        f.instruction(&W::I32WrapI64);
+    }
+    f.instruction(&W::LocalGet(LOCAL_I64_1));
+    if !bits64 {
+        f.instruction(&W::I32WrapI64);
+    }
+    f.instruction(&match (maximum, unsigned, bits64) {
+        (true, true, true) => W::I64GtU,
+        (true, false, true) => W::I64GtS,
+        (false, true, true) => W::I64LtU,
+        (false, false, true) => W::I64LtS,
+        (true, true, false) => W::I32GtU,
+        (true, false, false) => W::I32GtS,
+        (false, true, false) => W::I32LtU,
+        (false, false, false) => W::I32LtS,
+    });
+    f.instruction(&W::If(BlockType::Result(ValType::I64)));
+    f.instruction(&W::LocalGet(LOCAL_I64_0));
+    f.instruction(&W::Else);
+    f.instruction(&W::LocalGet(LOCAL_I64_1));
+    f.instruction(&W::End);
+    if !bits64 {
+        f.instruction(&W::I32WrapI64);
+        f.instruction(&W::I64ExtendI32S);
+    }
+    emit_set_reg(f, dst);
+}
+
+fn emit_cmov(f: &mut Function, dst: RawReg, src: RawReg, condition: RawReg, zero: bool) {
+    emit_reg(f, condition);
+    f.instruction(&W::I64Eqz);
+    if !zero {
+        f.instruction(&W::I32Eqz);
+    }
+    f.instruction(&W::If(BlockType::Empty));
+    emit_reg(f, src);
+    emit_set_reg(f, dst);
+    f.instruction(&W::End);
+}
+fn emit_cmov_imm(f: &mut Function, dst: RawReg, condition: RawReg, value: i32, zero: bool) {
+    emit_reg(f, condition);
+    f.instruction(&W::I64Eqz);
+    if !zero {
+        f.instruction(&W::I32Eqz);
+    }
+    f.instruction(&W::If(BlockType::Empty));
+    f.instruction(&W::I64Const(value as i64));
+    emit_set_reg(f, dst);
+    f.instruction(&W::End);
+}
+
+fn emit_sbrk(context: &EmitContext<'_>, f: &mut Function, dst: RawReg, size: RawReg) {
+    emit_reg(f, size);
+    f.instruction(&W::LocalSet(LOCAL_I64_0));
+    if context.is_64_bit {
+        f.instruction(&W::LocalGet(LOCAL_I64_0));
+        f.instruction(&W::I64Const(u32::MAX as i64));
+        f.instruction(&W::I64GtU);
+        f.instruction(&W::If(BlockType::Empty));
+        f.instruction(&W::I64Const(0));
+        f.instruction(&W::LocalSet(LOCAL_I64_0));
+        f.instruction(&W::End);
+    }
+    f.instruction(&W::GlobalGet(GLOBAL_HEAP_SIZE));
+    f.instruction(&W::LocalGet(LOCAL_I64_0));
+    f.instruction(&W::I64Add);
+    f.instruction(&W::LocalTee(LOCAL_I64_1));
+    f.instruction(&W::I64Const(context.layout.heap_limit as i64));
+    f.instruction(&W::I64LeU);
+    f.instruction(&W::If(BlockType::Result(ValType::I64)));
+    f.instruction(&W::I64Const(
+        context
+            .layout
+            .heap_base
+            .wrapping_sub(context.layout.rw_address) as i64,
+    ));
+    f.instruction(&W::LocalGet(LOCAL_I64_1));
+    f.instruction(&W::I64Add);
+    f.instruction(&W::I64Const((PAGE_SIZE - 1) as i64));
+    f.instruction(&W::I64Add);
+    f.instruction(&W::I64Const(PAGE_SIZE.trailing_zeros() as i64));
+    f.instruction(&W::I64ShrU);
+    f.instruction(&W::I32WrapI64);
+    f.instruction(&W::MemorySize(1));
+    f.instruction(&W::I32Sub);
+    f.instruction(&W::MemoryGrow(1));
+    f.instruction(&W::I32Const(-1));
+    f.instruction(&W::I32Ne);
+    f.instruction(&W::If(BlockType::Result(ValType::I64)));
+    f.instruction(&W::LocalGet(LOCAL_I64_1));
+    f.instruction(&W::GlobalSet(GLOBAL_HEAP_SIZE));
+    f.instruction(&W::I64Const(context.layout.heap_base as i64));
+    f.instruction(&W::LocalGet(LOCAL_I64_1));
+    f.instruction(&W::I64Add);
+    f.instruction(&W::Else);
+    f.instruction(&W::I64Const(0));
+    f.instruction(&W::End);
+    f.instruction(&W::Else);
+    f.instruction(&W::I64Const(0));
+    f.instruction(&W::End);
+    emit_set_reg(f, dst);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{translate, STATUS_FINISHED};
+    use polkavm::program::{assemble, InstructionSetKind};
+    use polkavm::{
+        BackendKind, Config, Engine, InterruptKind, Module, ModuleConfig, ProgramBlob, Reg,
+        RETURN_TO_HOST,
+    };
+    use wasmi::{Engine as WasmEngine, Linker, Module as WasmModule, Store, Val};
+
+    fn interpreter_registers(program: &[u8]) -> [u64; 13] {
+        let blob = ProgramBlob::parse(program.into()).expect("parse differential fixture");
+        let entry = blob
+            .exports()
+            .find(|export| export.symbol() == "main")
+            .expect("main export")
+            .program_counter();
+        let mut config = Config::new();
+        config.set_backend(Some(BackendKind::Interpreter));
+        config.set_sandboxing_enabled(true);
+        let engine = Engine::new(&config).expect("create interpreter");
+        let module =
+            Module::from_blob(&engine, &ModuleConfig::new(), blob).expect("compile fixture");
+        let mut instance = module.instantiate().expect("instantiate fixture");
+        instance.set_reg(Reg::SP, module.default_sp());
+        instance.set_reg(Reg::RA, RETURN_TO_HOST);
+        instance.set_gas(i64::MAX);
+        instance.set_next_program_counter(entry);
+        assert_eq!(
+            instance.run().expect("run interpreter"),
+            InterruptKind::Finished
+        );
+        Reg::ALL.map(|reg| instance.reg(reg))
+    }
+
+    fn translated_registers(program: &[u8]) -> [u64; 13] {
+        let wasm = translate(program).expect("translate differential fixture");
+        let engine = WasmEngine::default();
+        let module = WasmModule::new(&engine, &wasm[..]).expect("compile translated fixture");
+        let mut store = Store::new(&engine, ());
+        let linker = Linker::new(&engine);
+        let instance = linker
+            .instantiate(&mut store, &module)
+            .expect("instantiate translated fixture")
+            .start(&mut store)
+            .expect("start translated fixture");
+        let begin = instance
+            .get_typed_func::<(i32, i64), i32>(&store, "pvm_begin")
+            .expect("translated begin export");
+        assert_eq!(
+            begin
+                .call(&mut store, (0, i64::MAX))
+                .expect("run translated fixture"),
+            STATUS_FINISHED
+        );
+        std::array::from_fn(|index| {
+            let value = instance
+                .get_global(&store, &format!("r{index}"))
+                .expect("translated register")
+                .get(&store);
+            let Val::I64(value) = value else {
+                panic!("translated register is not i64");
+            };
+            value as u64
+        })
+    }
+
+    fn assert_differential_isa(isa: InstructionSetKind, source: &str) {
+        let program = assemble(Some(isa), source).expect("assemble differential fixture");
+        assert_eq!(
+            translated_registers(&program),
+            interpreter_registers(&program)
+        );
+    }
+
+    fn assert_differential(source: &str) {
+        assert_differential_isa(InstructionSetKind::Latest64, source);
+    }
+
+    #[test]
+    fn framebuffer_fixture_translates_to_valid_wasm() {
+        let program = include_bytes!("../tests/fixtures/framebuffer-test.polkavm");
+        let wasm = translate(program).expect("translate framebuffer fixture");
+        wasmparser::Validator::new()
+            .validate_all(&wasm)
+            .expect("validate translated framebuffer fixture");
+    }
+
+    #[test]
+    fn arithmetic_matches_interpreter() {
+        assert_differential(
+            r#"
+                %stack_size = 4096
+                pub @main:
+                a0 = 1234
+                a1 = 100
+                a2 = a0 + a1
+                a3 = a2 * 7
+                a4 = a3 /u a1
+                a5 = a3 %u a1
+                ret
+            "#,
+        );
+    }
+
+    #[test]
+    fn reverse_bytes_match_interpreter() {
+        let source = r#"
+            %stack_size = 4096
+            pub @main:
+            a0 = 305419896
+            a1 = reverse a0
+            ret
+        "#;
+        assert_differential_isa(InstructionSetKind::Latest64, source);
+        assert_differential_isa(InstructionSetKind::Latest32, source);
+    }
+
+    #[test]
+    fn division_edges_match_interpreter() {
+        assert_differential(
+            r#"
+                %stack_size = 4096
+                pub @main:
+                a0 = -2147483648
+                a1 = -1
+                i32 a2 = a0 /s a1
+                i32 a3 = a0 %s a1
+                a4 = 0
+                a5 = a0 /u a4
+                ret
+            "#,
+        );
+    }
+
+    #[test]
+    fn memory_and_branches_match_interpreter() {
+        assert_differential(
+            r#"
+                %rw_data_size = 65536
+                %stack_size = 4096
+                pub @main:
+                a0 = 305419896
+                u64 [131072] = a0
+                a1 = u8 [131072]
+                a2 = u16 [131072]
+                a3 = i32 [131072]
+                a4 = u64 [131072]
+                jump @matched if a1 == 120
+                a5 = -1
+                ret
+                @matched:
+                a5 = a4
+                ret
+            "#,
+        );
+    }
+
+    #[test]
+    fn latest32_unsigned_control_flow_matches_interpreter() {
+        assert_differential_isa(
+            InstructionSetKind::Latest32,
+            r#"
+                %stack_size = 4096
+                pub @main:
+                a0 = -1
+                a1 = 1
+                i32 a2 = a0 + a1
+                jump @wrong if a0 <u a1
+                a3 = 7
+                ret
+                @wrong:
+                a3 = 9
+                ret
+            "#,
+        );
+    }
+}
diff --git a/rust/crates/pvm-runtime/tests/fixtures/framebuffer-test.polkavm b/rust/crates/pvm-runtime/tests/fixtures/framebuffer-test.polkavm
new file mode 100644
index 000000000..39d4a0647
Binary files /dev/null and b/rust/crates/pvm-runtime/tests/fixtures/framebuffer-test.polkavm differ
diff --git a/rust/crates/truapi-host-cli/src/frame_server.rs b/rust/crates/truapi-host-cli/src/frame_server.rs
index 564f9113e..25fce795d 100644
--- a/rust/crates/truapi-host-cli/src/frame_server.rs
+++ b/rust/crates/truapi-host-cli/src/frame_server.rs
@@ -108,6 +108,9 @@ pub trait ProductRuntimeFactory: Send + Sync + 'static {
     }
 }
 
+// async-trait's generated boxed Future is already must-use; newer Clippy
+// otherwise reports the macro's duplicate annotation on this private trait.
+#[allow(clippy::double_must_use)]
 #[async_trait::async_trait]
 trait ConnectionRuntime: Send + Sync + 'static {
     async fn receive_frame(&self, frame: Vec<u8>) -> Result<(), ProductRuntimeError>;
diff --git a/rust/crates/truapi-server/Cargo.toml b/rust/crates/truapi-server/Cargo.toml
index e941f6c27..f13050cfe 100644
--- a/rust/crates/truapi-server/Cargo.toml
+++ b/rust/crates/truapi-server/Cargo.toml
@@ -68,6 +68,7 @@ verifiable = { git = "https://github.com/paritytech/verifiable.git", rev = "19b0
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 truapi = { path = "../truapi", features = ["uniffi"] }
+pvm-runtime = { path = "../pvm-runtime", features = ["ffi"] }
 truapi-platform = { path = "../truapi-platform", features = ["uniffi"] }
 futures = { version = "0.3", features = ["thread-pool"] }
 rand = { version = "0.8", optional = true }
diff --git a/rust/crates/truapi-server/src/lib.rs b/rust/crates/truapi-server/src/lib.rs
index 8b9ef7f53..b0a599c55 100644
--- a/rust/crates/truapi-server/src/lib.rs
+++ b/rust/crates/truapi-server/src/lib.rs
@@ -94,3 +94,6 @@ truapi::uniffi_reexport_scaffolding!();
 
 #[cfg(not(target_arch = "wasm32"))]
 truapi_platform::uniffi_reexport_scaffolding!();
+
+#[cfg(not(target_arch = "wasm32"))]
+pvm_runtime::uniffi_reexport_scaffolding!();