diff --git a/.cspell-wordlist.txt b/.cspell-wordlist.txt
index 964521ab13..aba2c06f21 100644
--- a/.cspell-wordlist.txt
+++ b/.cspell-wordlist.txt
@@ -314,3 +314,20 @@ Partitioner
 denoised
 ttfa
 TTFA
+smaps
+xcrun
+simctl
+greppable
+denormal
+denormals
+formants
+stdev
+interquartile
+untimed
+colormapping
+inlines
+jetsam
+utsname
+phys
+benchprobe
+adb
diff --git a/apps/benchmarks/.gitignore b/apps/benchmarks/.gitignore
new file mode 100644
index 0000000000..257b2fe827
--- /dev/null
+++ b/apps/benchmarks/.gitignore
@@ -0,0 +1,3 @@
+# Raw output of individual runs. A run worth keeping gets copied into
+# `baselines/` by hand, so that the committed numbers are ones somebody chose.
+results/
diff --git a/apps/benchmarks/App.tsx b/apps/benchmarks/App.tsx
new file mode 100644
index 0000000000..2555b28576
--- /dev/null
+++ b/apps/benchmarks/App.tsx
@@ -0,0 +1,128 @@
+/**
+ * The harness UI.
+ *
+ * Deliberately thin. The app's product is the JSON on stdout and at the
+ * collector; this screen exists so a human watching a 20-minute run on a desk
+ * can see which case is executing and spot a failure without tailing a log.
+ */
+
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { ScrollView, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
+
+import { config } from './src/config';
+import { runSuite } from './src/runner';
+import type { CaseResult } from './src/report';
+import { selectCases } from './src/suite';
+
+type Phase = { readonly caseId: string; readonly phase: string } | null;
+
+export default function App() {
+  const [running, setRunning] = useState(false);
+  const [done, setDone] = useState(false);
+  const [phase, setPhase] = useState<Phase>(null);
+  const [results, setResults] = useState<CaseResult[]>([]);
+  const [fatal, setFatal] = useState<string | null>(null);
+  const started = useRef(false);
+
+  const planned = selectCases(config.suite, config.only);
+
+  const start = useCallback(async () => {
+    if (started.current) return;
+    started.current = true;
+    setRunning(true);
+    setFatal(null);
+    setResults([]);
+    setDone(false);
+
+    try {
+      await runSuite({
+        onPhase: (caseId, name) => setPhase({ caseId, phase: name }),
+        onCase: (result) => setResults((previous) => [...previous, result]),
+      });
+      setDone(true);
+    } catch (error) {
+      setFatal(String(error));
+    } finally {
+      setPhase(null);
+      setRunning(false);
+      started.current = false;
+    }
+  }, []);
+
+  useEffect(() => {
+    if (config.autostart) start();
+  }, [start]);
+
+  return (
+    <SafeAreaProvider>
+      <SafeAreaView style={styles.container}>
+        <Text style={styles.title}>ExecuTorch benchmarks</Text>
+        <Text style={styles.meta}>
+          {config.label} · {config.only.length > 0 ? 'custom' : config.suite} · {config.iterations}{' '}
+          iterations · {planned.length} cases
+        </Text>
+        <Text style={styles.meta}>sink: {config.sink ?? 'console only'}</Text>
+
+        <TouchableOpacity
+          style={[styles.button, running && styles.buttonDisabled]}
+          onPress={start}
+          disabled={running}
+        >
+          <Text style={styles.buttonText}>{running ? 'Running…' : 'Run suite'}</Text>
+        </TouchableOpacity>
+
+        {phase && (
+          <Text style={styles.phase}>
+            {phase.caseId} — {phase.phase}
+          </Text>
+        )}
+        {done && <Text style={styles.done}>Run complete.</Text>}
+        {fatal && <Text style={styles.error}>{fatal}</Text>}
+
+        <ScrollView style={styles.list} contentContainerStyle={styles.listContent}>
+          {planned.map((benchCase) => {
+            const result = results.find((entry) => entry.id === benchCase.id);
+            return (
+              <View key={benchCase.id} style={styles.row}>
+                <Text style={styles.rowId}>{benchCase.id}</Text>
+                {!result && <Text style={styles.rowPending}>pending</Text>}
+                {result?.status === 'error' && <Text style={styles.error}>{result.error}</Text>}
+                {result?.status === 'ok' && (
+                  <Text style={styles.rowStats}>
+                    pipeline {result.pipeline?.median ?? 0} ms · load {result.taskLoadMs} ms
+                    {result.memory ? ` · peak ${result.memory.peakMb} MB` : ''}
+                  </Text>
+                )}
+              </View>
+            );
+          })}
+        </ScrollView>
+      </SafeAreaView>
+    </SafeAreaProvider>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#fff', paddingHorizontal: 16 },
+  title: { fontSize: 20, fontWeight: '700', marginTop: 12 },
+  meta: { fontSize: 12, color: '#666', marginTop: 4 },
+  button: {
+    marginTop: 16,
+    backgroundColor: '#001a72',
+    borderRadius: 10,
+    paddingVertical: 12,
+    alignItems: 'center',
+  },
+  buttonDisabled: { backgroundColor: '#9aa0b4' },
+  buttonText: { color: '#fff', fontWeight: '600' },
+  phase: { marginTop: 12, fontSize: 13, color: '#001a72' },
+  done: { marginTop: 12, fontSize: 13, fontWeight: '600', color: '#2b8a3e' },
+  error: { marginTop: 4, fontSize: 12, color: '#c92a2a' },
+  list: { flex: 1, marginTop: 16 },
+  listContent: { paddingBottom: 24 },
+  row: { paddingVertical: 8, borderBottomWidth: 1, borderBottomColor: '#f1f3f5' },
+  rowId: { fontSize: 13, fontWeight: '600' },
+  rowPending: { fontSize: 12, color: '#adb5bd' },
+  rowStats: { fontSize: 12, color: '#495057' },
+});
diff --git a/apps/benchmarks/README.md b/apps/benchmarks/README.md
new file mode 100644
index 0000000000..702e1bbce0
--- /dev/null
+++ b/apps/benchmarks/README.md
@@ -0,0 +1,141 @@
+# Performance benchmarks
+
+An on-device harness that measures model load time, inference latency and peak
+memory for the task pipelines, and a comparator that diffs two runs and fails on
+regressions.
+
+Its first job is bracketing an ExecuTorch bump: run the suite on 1.3.1, bump,
+run it again on the same device, and compare.
+
+## Why on-device
+
+The numbers that matter come from the backends an ExecuTorch bump actually
+changes — CoreML on the Apple Neural Engine, XNNPACK on an ARM core, Vulkan on
+an Android GPU. A host-side benchmark on a CI runner exercises none of them: it
+links a separately built desktop ExecuTorch against x86 XNNPACK, on a shared
+runner whose noise floor is wider than most regressions. So the harness runs on
+a real device and is triggered by hand, rather than running on every pull
+request and being ignored.
+
+## Running a suite
+
+```bash
+# Android, quick tier, results tagged "et-1.3.1"
+yarn bench --platform android --label et-1.3.1
+
+# iOS, everything
+yarn bench --platform ios --suite full --label et-1.3.1
+
+# A single case, more iterations
+yarn bench --platform android --only classification/efficientnet-v2-s-xnnpack-int8 --iterations 50
+```
+
+`yarn bench` starts a collector on port 8099, sets the app's `EXPO_PUBLIC_BENCH_*`
+variables, builds and launches the app, and writes
+`results/<label>-<platform>-<device>.json` when the run ends. On Android it sets
+up `adb reverse` for you; on an iOS device it binds the collector to the host's
+LAN address (override with `--host`).
+
+To drive the app yourself, pass `--no-launch` and the script prints the
+environment to start it with.
+
+Options: `--suite quick|full`, `--only <ids>`, `--iterations N`, `--warmup N`,
+`--no-memory`, `--no-native`, `--port N`, `--out <path>`.
+
+## Comparing two runs
+
+```bash
+yarn bench:compare results/et-1.3.1-ios-iPhone17,1.json results/et-1.4.1-ios-iPhone17,1.json
+```
+
+Prints a per-metric table and exits 1 if anything regressed past tolerance
+(inference 10%, load 15%, memory 10% — override with `--inference N`, `--load N`,
+`--memory N`).
+
+Two guards keep the output honest:
+
+- **Device mismatch is fatal.** Comparing an iPhone run against a Pixel run is
+  meaningless; pass `--allow-device-mismatch` if you know what you are doing.
+- **A metric whose workload changed is reported as `INCOMPARABLE`, not as a
+  delta.** If a pipeline decoded 14 tokens in one run and 19 in the other, it did
+  different work, and the ratio of the two timings measures nothing.
+
+A delta inside the run's own interquartile range is reported but not failed —
+the two runs cannot distinguish it from scheduling jitter.
+
+Copy a run you want to keep into `baselines/`; `results/` is gitignored.
+
+## What gets measured
+
+Per case:
+
+| Metric | What it covers |
+| --- | --- |
+| `load.native` | `loadModel` on the `.pte` alone |
+| `load.task` | The pipeline's `create` — load, schema validation, tensor pre-allocation |
+| `execute.<method>` | Raw `model.execute`, per exported method, no pipeline around it |
+| `pipeline.median` | The task's synchronous entry point end to end: preprocessing, execute, post-processing |
+| `memory.loaded` | Process footprint once the pipeline is ready |
+| `memory.peak` | Peak footprint during inference |
+| `memory.disposed` | Footprint after `dispose` — a leak shows up as a case that never returns to baseline |
+
+The raw-execute pass is the one to watch for an ExecuTorch bump. A pipeline
+timing folds `model.execute` together with preprocessing and post-processing,
+which are TypeScript and did not change; `execute.<method>` is ExecuTorch and
+nothing else. Its input and output tensors are derived from `model.schema`, so
+it works for any `.pte` in the registry, including every method a multi-method
+program exports. Methods whose schema cannot be pinned to concrete shapes are
+reported as skipped, with the reason.
+
+**`execute.<method>` and `pipeline.median` are not comparable to each other.**
+Where a model declares a dynamic dimension, the raw pass takes it at the top of
+its declared domain, so it measures the worst case the model can be asked for.
+The pipeline feeds whatever the input actually needs. On all-MiniLM-L6-v2 that
+is the difference between a 254-token forward and a 20-token one, and the raw
+number comes out several times the pipeline's. Each is comparable against itself
+across runs, which is all the comparator asks of them. The resolved shapes are
+recorded per method in the report, so it is always visible what was run.
+
+Memory is sampled in a separate pass from the timings. Reading total PSS on
+Android walks `/proc/self/smaps` and costs milliseconds; polling that during a
+15 ms inference would land in the numbers.
+
+## Determinism
+
+Every input is synthetic and is a pure function of its parameters, so two runs
+feed byte-identical data to the models. That matters because post-processing
+cost is input-dependent — an NMS pass over 200 candidate boxes is not the work
+of one over 3 — and a harness that picked a photo from the gallery would move
+for reasons unrelated to the change under test. See `src/inputs.ts`.
+
+The exception is speech-to-text. The synthetic waveform is voice-shaped but is
+not speech, so Whisper's decoder emits far fewer tokens than a real clip would
+and the pipeline figure is dominated by the encoder. Compare its
+`execute.<method>` numbers rather than its pipeline number.
+
+## Tiers
+
+`quick` (the default) is the small models — classification, selfie segmentation,
+style transfer, BlazeFace, MiniLM embeddings, FSMN VAD. Roughly 150 MB of
+downloads, a couple of minutes on device. `full` adds SSDLite, YOLO26, CLIP, the
+privacy filter, Whisper tiny and Supertonic TTS.
+
+## Adding a case
+
+Add an entry to `CASES` in `src/suite.ts`. The runner derives everything else —
+what to download, which methods to benchmark, what to sample — from the config
+and the model's schema. A case needs an id, its registry config, the pipeline's
+`create`, and a `run` worklet that returns the iteration's workload size.
+
+Pipelines with no synchronous entry point (Supertonic streams through four
+sub-models with JS-thread orchestration between chunks) set `mode: 'async'` and
+provide `runAsync`. Those timings include a thread hop per call, so they are
+comparable across runs but not against worklet-timed cases.
+
+## The native probe
+
+`modules/bench-probe` is a local Expo module reading the process footprint:
+`task_vm_info.phys_footprint` on iOS (what jetsam measures an app against) and
+total PSS on Android. Both count the resident pages of a memory-mapped `.pte`,
+which the native-heap counters miss entirely — and that is most of a model's
+footprint.
diff --git a/apps/benchmarks/app.json b/apps/benchmarks/app.json
new file mode 100644
index 0000000000..cb66a30118
--- /dev/null
+++ b/apps/benchmarks/app.json
@@ -0,0 +1,45 @@
+{
+  "expo": {
+    "name": "benchmarks",
+    "slug": "benchmarks",
+    "version": "1.0.0",
+    "orientation": "portrait",
+    "icon": "./assets/icons/icon.png",
+    "userInterfaceStyle": "light",
+    "newArchEnabled": true,
+    "scheme": "rne-benchmarks",
+    "splash": {
+      "image": "./assets/icons/splash.png",
+      "resizeMode": "contain",
+      "backgroundColor": "#ffffff"
+    },
+    "ios": {
+      "supportsTablet": true,
+      "bundleIdentifier": "com.anonymous.benchmarks"
+    },
+    "android": {
+      "adaptiveIcon": {
+        "foregroundImage": "./assets/icons/adaptive-icon.png",
+        "backgroundColor": "#ffffff"
+      },
+      "package": "com.anonymous.benchmarks",
+      "usesCleartextTraffic": true
+    },
+    "web": {
+      "favicon": "./assets/icons/favicon.png"
+    },
+    "plugins": [
+      [
+        "expo-build-properties",
+        {
+          "android": {
+            "minSdkVersion": 26
+          },
+          "ios": {
+            "deploymentTarget": "17.0"
+          }
+        }
+      ]
+    ]
+  }
+}
diff --git a/apps/benchmarks/assets/icons/adaptive-icon.png b/apps/benchmarks/assets/icons/adaptive-icon.png
new file mode 100644
index 0000000000..03d6f6b6c6
Binary files /dev/null and b/apps/benchmarks/assets/icons/adaptive-icon.png differ
diff --git a/apps/benchmarks/assets/icons/favicon.png b/apps/benchmarks/assets/icons/favicon.png
new file mode 100644
index 0000000000..e75f697b18
Binary files /dev/null and b/apps/benchmarks/assets/icons/favicon.png differ
diff --git a/apps/benchmarks/assets/icons/icon.png b/apps/benchmarks/assets/icons/icon.png
new file mode 100644
index 0000000000..a0b1526fc7
Binary files /dev/null and b/apps/benchmarks/assets/icons/icon.png differ
diff --git a/apps/benchmarks/assets/icons/splash.png b/apps/benchmarks/assets/icons/splash.png
new file mode 100644
index 0000000000..0e89705a94
Binary files /dev/null and b/apps/benchmarks/assets/icons/splash.png differ
diff --git a/apps/benchmarks/babel.config.js b/apps/benchmarks/babel.config.js
new file mode 100644
index 0000000000..6b2006979c
--- /dev/null
+++ b/apps/benchmarks/babel.config.js
@@ -0,0 +1,7 @@
+module.exports = function (api) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo'],
+    plugins: ['react-native-worklets/plugin'],
+  };
+};
diff --git a/apps/benchmarks/index.ts b/apps/benchmarks/index.ts
new file mode 100644
index 0000000000..ce8f2073fb
--- /dev/null
+++ b/apps/benchmarks/index.ts
@@ -0,0 +1,5 @@
+import { registerRootComponent } from 'expo';
+
+import App from './App';
+
+registerRootComponent(App);
diff --git a/apps/benchmarks/metro.config.js b/apps/benchmarks/metro.config.js
new file mode 100644
index 0000000000..8fa66cc7c1
--- /dev/null
+++ b/apps/benchmarks/metro.config.js
@@ -0,0 +1,9 @@
+// Learn more https://docs.expo.io/guides/customizing-metro
+const { getDefaultConfig } = require('expo/metro-config');
+
+/** @type {import('expo/metro-config').MetroConfig} */
+const config = getDefaultConfig(__dirname);
+
+config.resolver.assetExts.push('pte');
+
+module.exports = config;
diff --git a/apps/benchmarks/modules/bench-probe/android/build.gradle b/apps/benchmarks/modules/bench-probe/android/build.gradle
new file mode 100644
index 0000000000..1e0fb2aeeb
--- /dev/null
+++ b/apps/benchmarks/modules/bench-probe/android/build.gradle
@@ -0,0 +1,25 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.benchprobe'
+version = '1.0.0'
+
+def expoModulesCorePlugin = new File(
+  project(":expo-modules-core").projectDir.absolutePath,
+  "ExpoModulesCorePlugin.gradle"
+)
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useDefaultAndroidSdkVersions()
+useExpoPublishing()
+
+android {
+  namespace "expo.modules.benchprobe"
+  defaultConfig {
+    versionCode 1
+    versionName "1.0.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
diff --git a/apps/benchmarks/modules/bench-probe/android/src/main/java/expo/modules/benchprobe/BenchProbeModule.kt b/apps/benchmarks/modules/bench-probe/android/src/main/java/expo/modules/benchprobe/BenchProbeModule.kt
new file mode 100644
index 0000000000..1258c03ee5
--- /dev/null
+++ b/apps/benchmarks/modules/bench-probe/android/src/main/java/expo/modules/benchprobe/BenchProbeModule.kt
@@ -0,0 +1,54 @@
+package expo.modules.benchprobe
+
+import android.app.ActivityManager
+import android.content.Context
+import android.os.Build
+import android.os.Debug
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class BenchProbeModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("BenchProbe")
+
+    // Synchronous by design: the sampler polls this from the JS thread while
+    // inference runs on the worklet thread, and a promise hop per sample would
+    // add more jitter than the read itself costs.
+    //
+    // Total PSS walks /proc/self/smaps, so it is the expensive one (single-digit
+    // milliseconds). It is also the only counter that sees the pages a
+    // memory-mapped .pte actually has resident, which is most of a model's
+    // footprint — hence the sampler's default 100 ms interval rather than
+    // something tighter.
+    Function("memoryFootprintBytes") {
+      val info = Debug.MemoryInfo()
+      Debug.getMemoryInfo(info)
+      info.totalPss.toDouble() * 1024.0
+    }
+
+    Function("nativeHeapBytes") {
+      Debug.getNativeHeapAllocatedSize().toDouble()
+    }
+
+    Function("deviceInfo") {
+      val activityManager =
+        appContext.reactContext?.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+      val memoryInfo = ActivityManager.MemoryInfo().also { activityManager?.getMemoryInfo(it) }
+
+      mapOf(
+        "model" to Build.MODEL,
+        "osVersion" to Build.VERSION.RELEASE,
+        "soc" to if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) Build.SOC_MODEL else "",
+        // Emulator images report a generic/google build fingerprint; the ABI
+        // check alone would miss an arm64 emulator on an Apple Silicon host.
+        "isEmulator" to (Build.FINGERPRINT.startsWith("generic") ||
+          Build.FINGERPRINT.contains("vbox") ||
+          Build.FINGERPRINT.contains("emulator") ||
+          Build.MODEL.contains("Emulator") ||
+          Build.MODEL.contains("Android SDK built for")),
+        "cpuCores" to Runtime.getRuntime().availableProcessors(),
+        "totalMemoryBytes" to memoryInfo.totalMem.toDouble()
+      )
+    }
+  }
+}
diff --git a/apps/benchmarks/modules/bench-probe/expo-module.config.json b/apps/benchmarks/modules/bench-probe/expo-module.config.json
new file mode 100644
index 0000000000..0ffc08031a
--- /dev/null
+++ b/apps/benchmarks/modules/bench-probe/expo-module.config.json
@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["BenchProbeModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.benchprobe.BenchProbeModule"]
+  }
+}
diff --git a/apps/benchmarks/modules/bench-probe/index.ts b/apps/benchmarks/modules/bench-probe/index.ts
new file mode 100644
index 0000000000..9f517b3b62
--- /dev/null
+++ b/apps/benchmarks/modules/bench-probe/index.ts
@@ -0,0 +1,42 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+/**
+ * Host metadata identifying the machine a benchmark run was produced on.
+ *
+ * Results are only comparable across runs that share these values, so the
+ * comparator refuses to diff two runs whose `model` or `osVersion` differ.
+ */
+export interface BenchDeviceInfo {
+  /** Raw hardware identifier: `iPhone17,1` on iOS, `Build.MODEL` on Android. */
+  readonly model: string;
+  /** Marketing OS version, e.g. `18.2` or `15`. */
+  readonly osVersion: string;
+  /** SoC name when the platform reports one, otherwise an empty string. */
+  readonly soc: string;
+  /** `true` when running on a simulator or emulator rather than real hardware. */
+  readonly isEmulator: boolean;
+  /** Number of CPU cores visible to the process. */
+  readonly cpuCores: number;
+  /** Total physical RAM in bytes. */
+  readonly totalMemoryBytes: number;
+}
+
+interface BenchProbeNativeModule {
+  /**
+   * Process memory footprint in bytes.
+   *
+   * iOS reports `task_vm_info.phys_footprint` — the figure jetsam evaluates
+   * against the per-app limit. Android reports total PSS. Both include the
+   * pages a memory-mapped `.pte` actually has resident, which the native heap
+   * counters miss entirely; that is why the sampler pays for the slower call.
+   */
+  memoryFootprintBytes(): number;
+  /**
+   * Native heap allocation in bytes. Cheap to read but blind to mapped model
+   * pages, so it is recorded alongside the footprint rather than instead of it.
+   */
+  nativeHeapBytes(): number;
+  deviceInfo(): BenchDeviceInfo;
+}
+
+export default requireNativeModule<BenchProbeNativeModule>('BenchProbe');
diff --git a/apps/benchmarks/modules/bench-probe/ios/BenchProbe.podspec b/apps/benchmarks/modules/bench-probe/ios/BenchProbe.podspec
new file mode 100644
index 0000000000..12a9f208d8
--- /dev/null
+++ b/apps/benchmarks/modules/bench-probe/ios/BenchProbe.podspec
@@ -0,0 +1,20 @@
+Pod::Spec.new do |s|
+  s.name           = 'BenchProbe'
+  s.version        = '1.0.0'
+  s.summary        = 'Process memory and host metadata probe for the benchmark harness'
+  s.description    = 'Reads task_vm_info.phys_footprint and device identifiers for react-native-executorch benchmarks.'
+  s.author         = 'Software Mansion'
+  s.homepage       = 'https://docs.swmansion.com/react-native-executorch'
+  s.platforms      = { :ios => '15.1' }
+  s.source         = { git: '' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end
diff --git a/apps/benchmarks/modules/bench-probe/ios/BenchProbeModule.swift b/apps/benchmarks/modules/bench-probe/ios/BenchProbeModule.swift
new file mode 100644
index 0000000000..106f102899
--- /dev/null
+++ b/apps/benchmarks/modules/bench-probe/ios/BenchProbeModule.swift
@@ -0,0 +1,64 @@
+import ExpoModulesCore
+import UIKit
+
+public class BenchProbeModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("BenchProbe")
+
+    // Synchronous by design: the sampler polls this from the JS thread while
+    // inference runs on the worklet thread, and a promise hop per sample would
+    // add more jitter than the read itself costs.
+    Function("memoryFootprintBytes") { () -> Double in
+      var info = task_vm_info_data_t()
+      var count = mach_msg_type_number_t(
+        MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<natural_t>.size)
+
+      let result = withUnsafeMutablePointer(to: &info) { pointer in
+        pointer.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { rebound in
+          task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), rebound, &count)
+        }
+      }
+
+      // phys_footprint is what jetsam measures an app against, so it is the
+      // number that decides whether a model fits on a device.
+      return result == KERN_SUCCESS ? Double(info.phys_footprint) : -1
+    }
+
+    // No public API exposes the malloc-zone total separately from the footprint
+    // on iOS, so the two agree here. Android is where they diverge.
+    Function("nativeHeapBytes") { () -> Double in
+      var info = mach_task_basic_info()
+      var count = mach_msg_type_number_t(
+        MemoryLayout<mach_task_basic_info>.size / MemoryLayout<natural_t>.size)
+
+      let result = withUnsafeMutablePointer(to: &info) { pointer in
+        pointer.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { rebound in
+          task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), rebound, &count)
+        }
+      }
+
+      return result == KERN_SUCCESS ? Double(info.resident_size) : -1
+    }
+
+    Function("deviceInfo") { () -> [String: Any] in
+      var systemInfo = utsname()
+      uname(&systemInfo)
+      let identifier = withUnsafePointer(to: &systemInfo.machine) { pointer in
+        pointer.withMemoryRebound(to: CChar.self, capacity: 1) { String(cString: $0) }
+      }
+
+      // On a simulator `utsname.machine` is the host Mac's architecture, so the
+      // real device identity comes from the environment instead.
+      let simulatorModel = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"]
+
+      return [
+        "model": simulatorModel ?? identifier,
+        "osVersion": UIDevice.current.systemVersion,
+        "soc": identifier,
+        "isEmulator": simulatorModel != nil,
+        "cpuCores": ProcessInfo.processInfo.processorCount,
+        "totalMemoryBytes": Double(ProcessInfo.processInfo.physicalMemory),
+      ]
+    }
+  }
+}
diff --git a/apps/benchmarks/package.json b/apps/benchmarks/package.json
new file mode 100644
index 0000000000..f991881110
--- /dev/null
+++ b/apps/benchmarks/package.json
@@ -0,0 +1,50 @@
+{
+  "name": "benchmarks",
+  "version": "1.0.0",
+  "main": "index.ts",
+  "react-native-executorch": {
+    "features": [
+      "classification",
+      "styleTransfer",
+      "semanticSegmentation",
+      "instanceSegmentation",
+      "objectDetection",
+      "keypointDetection",
+      "imageEmbeddings",
+      "textEmbeddings",
+      "privacyFilter",
+      "vad",
+      "speechToText",
+      "textToSpeech",
+      "tokenizer"
+    ]
+  },
+  "scripts": {
+    "start": "expo start",
+    "android": "expo run:android",
+    "ios": "expo run:ios",
+    "typecheck": "tsc",
+    "lint": "eslint . --ext .ts,.tsx --fix",
+    "bench": "node scripts/run-benchmarks.mjs",
+    "bench:compare": "node scripts/compare.mjs",
+    "postinstall": "yarn run -T patch-package --patch-dir ../../patches"
+  },
+  "dependencies": {
+    "expo": "~56.0.9",
+    "expo-build-properties": "~56.0.17",
+    "react": "19.2.3",
+    "react-native": "0.85.3",
+    "react-native-blob-util": "^0.24.0",
+    "react-native-executorch": "workspace:*",
+    "react-native-safe-area-context": "~5.7.0",
+    "react-native-worklets": "0.10.3"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@react-native/metro-config": "^0.86.0",
+    "@types/react": "~19.2.0",
+    "babel-preset-expo": "~56.0.14",
+    "react-refresh": "^0.14.0"
+  },
+  "private": true
+}
diff --git a/apps/benchmarks/scripts/compare.mjs b/apps/benchmarks/scripts/compare.mjs
new file mode 100644
index 0000000000..d57e32f65b
--- /dev/null
+++ b/apps/benchmarks/scripts/compare.mjs
@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+/**
+ * Diffs two benchmark reports and fails on regressions.
+ *
+ * Usage:
+ *   yarn bench:compare results/et-1.3.1-ios-iPhone17,1.json results/et-1.4.1-ios-iPhone17,1.json
+ *   yarn bench:compare baseline.json current.json --inference 8 --memory 5
+ *
+ * Exits 1 when any metric regresses past its tolerance, 0 otherwise.
+ *
+ * What the tolerances are for: on-device timings are not reproducible to the
+ * percent. Thermal state, the scheduler, and whatever else the OS decided to do
+ * during the run all move the numbers, which is why the comparator works off
+ * medians and treats a delta as real only once it clears both a fixed tolerance
+ * and the run's own noise floor (its interquartile range). The defaults are set
+ * where a regression is worth a human look rather than where it is certain.
+ */
+
+import { readFileSync } from 'node:fs';
+
+const DEFAULT_TOLERANCE = {
+  /** Percent regression in pipeline and raw-execute medians that trips a failure. */
+  inference: 10,
+  /** Percent regression in model load time. Loading is noisier than inference. */
+  load: 15,
+  /** Percent growth in peak footprint. */
+  memory: 10,
+};
+
+function parseArgs(argv) {
+  const files = [];
+  const tolerance = { ...DEFAULT_TOLERANCE };
+  let allowDeviceMismatch = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--allow-device-mismatch') allowDeviceMismatch = true;
+    else if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      if (!(key in tolerance)) throw new Error(`Unknown option ${arg}`);
+      tolerance[key] = Number(argv[++i]);
+      if (!Number.isFinite(tolerance[key])) throw new Error(`${arg} needs a number`);
+    } else files.push(arg);
+  }
+
+  if (files.length !== 2) {
+    throw new Error('Usage: compare.mjs <baseline.json> <current.json> [--inference N] ...');
+  }
+  return { files, tolerance, allowDeviceMismatch };
+}
+
+const load = (path) => JSON.parse(readFileSync(path, 'utf8'));
+
+const percentDelta = (baseline, current) =>
+  baseline === 0 ? 0 : ((current - baseline) / baseline) * 100;
+
+/**
+ * Classifies one metric's movement.
+ *
+ * `noise` is the larger of the two runs' interquartile ranges, expressed as a
+ * percentage of the baseline. A delta inside that band is reported but not
+ * failed: the runs simply cannot distinguish it from scheduling jitter.
+ */
+function classify(baseline, current, tolerancePercent, noisePercent = 0) {
+  const delta = percentDelta(baseline, current);
+  const threshold = Math.max(tolerancePercent, noisePercent);
+
+  if (delta > threshold) return { delta, verdict: 'REGRESSED' };
+  if (delta < -threshold) return { delta, verdict: 'improved' };
+  return { delta, verdict: 'same' };
+}
+
+const noiseFloor = (baselineStats, currentStats) => {
+  if (!baselineStats?.median) return 0;
+  const worst = Math.max(baselineStats.iqr ?? 0, currentStats?.iqr ?? 0);
+  return (worst / baselineStats.median) * 100;
+};
+
+/** Builds the comparison rows for a single case present in both reports. */
+function compareCase(baseline, current, tolerance) {
+  const rows = [];
+  const add = (metric, before, after, tolerancePercent, noise) => {
+    if (typeof before !== 'number' || typeof after !== 'number') return;
+    if (before <= 0 || after <= 0) return;
+    rows.push({ metric, before, after, ...classify(before, after, tolerancePercent, noise) });
+  };
+
+  if (baseline.status !== 'ok' || current.status !== 'ok') {
+    return [
+      {
+        metric: 'status',
+        before: baseline.status,
+        after: current.status,
+        delta: 0,
+        verdict: baseline.status === 'ok' && current.status !== 'ok' ? 'REGRESSED' : 'same',
+      },
+    ];
+  }
+
+  // Two runs that produced different amounts of work did not run the same
+  // benchmark, so their timings are not comparable at all — reporting a delta
+  // would be worse than reporting nothing.
+  if (baseline.units !== current.units) {
+    return [
+      {
+        metric: 'workload',
+        before: baseline.units,
+        after: current.units,
+        delta: 0,
+        verdict: 'INCOMPARABLE',
+      },
+    ];
+  }
+
+  add(
+    'pipeline.median',
+    baseline.pipeline?.median,
+    current.pipeline?.median,
+    tolerance.inference,
+    noiseFloor(baseline.pipeline, current.pipeline)
+  );
+  add('load.task', baseline.taskLoadMs, current.taskLoadMs, tolerance.load);
+  add('load.native', baseline.native?.loadMs, current.native?.loadMs, tolerance.load);
+  add('memory.peak', baseline.memory?.peakMb, current.memory?.peakMb, tolerance.memory);
+  add('memory.loaded', baseline.memory?.loadedMb, current.memory?.loadedMb, tolerance.memory);
+
+  for (const beforeMethod of baseline.native?.methods ?? []) {
+    const afterMethod = (current.native?.methods ?? []).find(
+      (entry) => entry.method === beforeMethod.method
+    );
+    add(
+      `execute.${beforeMethod.method}`,
+      beforeMethod.stats?.median,
+      afterMethod?.stats?.median,
+      tolerance.inference,
+      noiseFloor(beforeMethod.stats, afterMethod?.stats)
+    );
+  }
+
+  return rows;
+}
+
+const pad = (value, width) => String(value).padEnd(width);
+const padStart = (value, width) => String(value).padStart(width);
+
+function main() {
+  const { files, tolerance, allowDeviceMismatch } = parseArgs(process.argv.slice(2));
+  const [baseline, current] = files.map(load);
+
+  console.log(`baseline: ${baseline.label} (${files[0]})`);
+  console.log(`current:  ${current.label} (${files[1]})`);
+  console.log(
+    `device:   ${baseline.device?.model} / ${baseline.platform} ${baseline.device?.osVersion}`
+  );
+
+  const sameDevice =
+    baseline.device?.model === current.device?.model &&
+    baseline.device?.osVersion === current.device?.osVersion;
+
+  if (!sameDevice) {
+    const message =
+      `device mismatch: ${baseline.device?.model} ${baseline.device?.osVersion} vs ` +
+      `${current.device?.model} ${current.device?.osVersion}`;
+    if (!allowDeviceMismatch) {
+      console.error(`\nERROR: ${message}. Pass --allow-device-mismatch to compare anyway.`);
+      process.exit(2);
+    }
+    console.warn(`\nWARNING: ${message}`);
+  }
+
+  if (baseline.settings?.iterations !== current.settings?.iterations) {
+    console.warn(
+      `\nWARNING: iteration counts differ (${baseline.settings?.iterations} vs ` +
+        `${current.settings?.iterations}); medians are still comparable but noise is not.`
+    );
+  }
+
+  console.log(
+    `\ntolerances: inference ${tolerance.inference}%, load ${tolerance.load}%, ` +
+      `memory ${tolerance.memory}%\n`
+  );
+
+  const currentById = new Map(current.cases.map((entry) => [entry.id, entry]));
+  const regressions = [];
+  const incomparable = [];
+
+  for (const baselineCase of baseline.cases) {
+    const currentCase = currentById.get(baselineCase.id);
+    if (!currentCase) {
+      console.log(`${baselineCase.id}\n  missing from the current run\n`);
+      continue;
+    }
+
+    const rows = compareCase(baselineCase, currentCase, tolerance);
+    console.log(baselineCase.id);
+    for (const row of rows) {
+      const delta = row.verdict === 'INCOMPARABLE' ? '' : `${row.delta >= 0 ? '+' : ''}${row.delta.toFixed(1)}%`;
+      console.log(
+        `  ${pad(row.metric, 24)} ${padStart(row.before, 10)} -> ${padStart(row.after, 10)}` +
+          `  ${padStart(delta, 8)}  ${row.verdict}`
+      );
+      if (row.verdict === 'REGRESSED') regressions.push(`${baselineCase.id} ${row.metric}`);
+      if (row.verdict === 'INCOMPARABLE') incomparable.push(`${baselineCase.id} ${row.metric}`);
+    }
+    console.log('');
+  }
+
+  const added = current.cases.filter((entry) => !baseline.cases.some((e) => e.id === entry.id));
+  if (added.length > 0) console.log(`new cases: ${added.map((e) => e.id).join(', ')}\n`);
+
+  if (incomparable.length > 0) {
+    console.log(`${incomparable.length} metric(s) could not be compared:`);
+    for (const entry of incomparable) console.log(`  ${entry}`);
+    console.log('');
+  }
+
+  if (regressions.length > 0) {
+    console.log(`FAIL — ${regressions.length} regression(s):`);
+    for (const entry of regressions) console.log(`  ${entry}`);
+    process.exit(1);
+  }
+
+  console.log('PASS — no regressions past tolerance.');
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exit(2);
+}
diff --git a/apps/benchmarks/scripts/run-benchmarks.mjs b/apps/benchmarks/scripts/run-benchmarks.mjs
new file mode 100644
index 0000000000..63ded7e89d
--- /dev/null
+++ b/apps/benchmarks/scripts/run-benchmarks.mjs
@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * Drives a benchmark run and collects its results.
+ *
+ * Starts an HTTP collector, points the app at it through `EXPO_PUBLIC_BENCH_*`,
+ * builds and launches the app, and waits for the run to finish before writing
+ * the report to `results/`.
+ *
+ * The collector exists because getting structured data off a phone is otherwise
+ * platform-specific: `adb logcat` covers Android, `xcrun simctl` covers the iOS
+ * Simulator, and a physical iPhone has no equivalent short of Console.app. An
+ * HTTP POST works the same everywhere — over `adb reverse` on Android, and over
+ * the LAN on an iOS device.
+ *
+ * Usage:
+ *   yarn bench --platform android --label et-1.3.1
+ *   yarn bench --platform ios --suite full --label et-1.4.1
+ *   yarn bench --platform ios --no-launch          # app started by hand
+ */
+
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { networkInterfaces } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const APP_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+const DEFAULTS = {
+  platform: 'android',
+  suite: 'quick',
+  only: '',
+  label: 'local',
+  iterations: '20',
+  warmup: '3',
+  memoryIterations: '5',
+  port: '8099',
+  host: '',
+  out: '',
+};
+
+function parseArgs(argv) {
+  const options = { ...DEFAULTS, launch: true, memory: true, native: true };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--no-launch') options.launch = false;
+    else if (arg === '--no-memory') options.memory = false;
+    else if (arg === '--no-native') options.native = false;
+    else if (arg.startsWith('--')) {
+      const key = arg
+        .slice(2)
+        .replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+      if (!(key in DEFAULTS)) throw new Error(`Unknown option ${arg}`);
+      options[key] = argv[++i];
+    } else throw new Error(`Unexpected argument ${arg}`);
+  }
+
+  if (options.platform !== 'ios' && options.platform !== 'android') {
+    throw new Error(`--platform must be ios or android, got ${options.platform}`);
+  }
+  return options;
+}
+
+/** First non-internal IPv4 address, for an iOS device reaching the host over LAN. */
+function lanAddress() {
+  for (const addresses of Object.values(networkInterfaces())) {
+    for (const address of addresses ?? []) {
+      if (address.family === 'IPv4' && !address.internal) return address.address;
+    }
+  }
+  return null;
+}
+
+function readBody(request) {
+  return new Promise((resolveBody, rejectBody) => {
+    const chunks = [];
+    request.on('data', (chunk) => chunks.push(chunk));
+    request.on('end', () => {
+      try {
+        resolveBody(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+      } catch (error) {
+        rejectBody(error);
+      }
+    });
+    request.on('error', rejectBody);
+  });
+}
+
+function startCollector(port, onEnd) {
+  const server = createServer(async (request, response) => {
+    let body = null;
+    try {
+      body = await readBody(request);
+    } catch {
+      response.writeHead(400).end();
+      return;
+    }
+    response.writeHead(204).end();
+
+    if (request.url === '/begin') {
+      console.log(`\n[bench] run "${body.label}" started — ${body.cases.length} cases`);
+    } else if (request.url === '/case') {
+      const summary =
+        body.status === 'ok'
+          ? `${body.pipeline?.median ?? '-'} ms median` +
+            (body.memory ? `, peak ${body.memory.peakMb} MB` : '')
+          : `FAILED: ${body.error}`;
+      console.log(`[bench] ${body.id} — ${summary}`);
+    } else if (request.url === '/end') {
+      onEnd(body);
+    }
+  });
+
+  return new Promise((resolveServer, rejectServer) => {
+    server.on('error', (error) => {
+      rejectServer(
+        error.code === 'EADDRINUSE'
+          ? new Error(`port ${port} is in use — another run is still open. Pass --port to change it.`)
+          : error
+      );
+    });
+    // 0.0.0.0 so an iOS device on the LAN can reach the collector, not just
+    // adb-reversed localhost traffic from Android.
+    server.listen(port, '0.0.0.0', () => resolveServer(server));
+  });
+}
+
+function run(command, args, env) {
+  return spawn(command, args, { cwd: APP_ROOT, env, stdio: 'inherit', shell: false });
+}
+
+function adbReverse(port) {
+  const result = spawn('adb', ['reverse', `tcp:${port}`, `tcp:${port}`], { stdio: 'inherit' });
+  return new Promise((resolveReverse) => result.on('exit', resolveReverse));
+}
+
+function reportPath(options, report) {
+  if (options.out) return resolve(options.out);
+  const device = String(report.device?.model ?? 'unknown').replace(/[^\w.-]+/g, '-');
+  return join(APP_ROOT, 'results', `${options.label}-${report.platform}-${device}.json`);
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const port = Number(options.port);
+
+  // Android reaches the host through the adb reverse tunnel on localhost. An iOS
+  // device needs a routable address; the Simulator shares the host's loopback.
+  const host =
+    options.host ||
+    (options.platform === 'android' ? 'localhost' : (lanAddress() ?? 'localhost'));
+  const sink = `http://${host}:${port}`;
+
+  let settle;
+  const finished = new Promise((resolveFinished) => {
+    settle = resolveFinished;
+  });
+
+  const server = await startCollector(port, settle);
+  console.log(`[bench] collector listening on ${sink}`);
+
+  if (options.platform === 'android') await adbReverse(port);
+
+  const env = {
+    ...process.env,
+    EXPO_PUBLIC_BENCH_SUITE: options.suite,
+    EXPO_PUBLIC_BENCH_ONLY: options.only,
+    EXPO_PUBLIC_BENCH_LABEL: options.label,
+    EXPO_PUBLIC_BENCH_ITERATIONS: options.iterations,
+    EXPO_PUBLIC_BENCH_WARMUP: options.warmup,
+    EXPO_PUBLIC_BENCH_MEMORY_ITERATIONS: options.memoryIterations,
+    EXPO_PUBLIC_BENCH_MEMORY: options.memory ? '1' : '0',
+    EXPO_PUBLIC_BENCH_NATIVE: options.native ? '1' : '0',
+    EXPO_PUBLIC_BENCH_SINK: sink,
+    EXPO_PUBLIC_BENCH_AUTOSTART: '1',
+  };
+
+  let child = null;
+  if (options.launch) {
+    console.log(`[bench] launching the app on ${options.platform}`);
+    child = run('yarn', [options.platform], env);
+
+    // A failed build must not leave the collector waiting forever: it holds the
+    // port, so the next attempt cannot even start its own. `expo run:*` stays
+    // alive serving Metro after a successful launch, so only a non-zero exit is
+    // treated as fatal.
+    child.on('exit', (code) => {
+      if (code !== 0 && code !== null) {
+        console.error(`\n[bench] the app exited with code ${code} before reporting a run`);
+        server.close();
+        process.exit(2);
+      }
+    });
+  } else {
+    console.log('[bench] waiting for a run. Start the app with:');
+    for (const [key, value] of Object.entries(env)) {
+      if (key.startsWith('EXPO_PUBLIC_BENCH_')) console.log(`         ${key}=${value}`);
+    }
+  }
+
+  const report = await finished;
+  const destination = reportPath(options, report);
+  mkdirSync(dirname(destination), { recursive: true });
+  writeFileSync(destination, `${JSON.stringify(report, null, 2)}\n`);
+
+  const failures = report.cases.filter((entry) => entry.status !== 'ok');
+  console.log(`\n[bench] wrote ${destination}`);
+  console.log(`[bench] ${report.cases.length - failures.length} ok, ${failures.length} failed`);
+
+  child?.kill('SIGTERM');
+  server.close();
+  process.exit(failures.length > 0 ? 1 : 0);
+}
+
+main().catch((error) => {
+  console.error(`[bench] ${error.message}`);
+  process.exit(2);
+});
diff --git a/apps/benchmarks/src/config.ts b/apps/benchmarks/src/config.ts
new file mode 100644
index 0000000000..b569a0ea34
--- /dev/null
+++ b/apps/benchmarks/src/config.ts
@@ -0,0 +1,70 @@
+/**
+ * Run configuration, resolved once at startup from `EXPO_PUBLIC_BENCH_*`
+ * environment variables.
+ *
+ * Metro inlines `process.env.EXPO_PUBLIC_*` at bundle time, so every value here
+ * is fixed when the JS bundle is built. `scripts/run-benchmarks.mjs` sets them
+ * before starting Metro; a developer running the app by hand gets the defaults.
+ */
+
+const str = (value: string | undefined, fallback: string): string =>
+  value === undefined || value === '' ? fallback : value;
+
+const int = (value: string | undefined, fallback: number): number => {
+  const parsed = Number.parseInt(str(value, ''), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+
+const bool = (value: string | undefined, fallback: boolean): boolean => {
+  const normalized = str(value, '').toLowerCase();
+  if (normalized === '') return fallback;
+  return normalized === '1' || normalized === 'true' || normalized === 'yes';
+};
+
+const list = (value: string | undefined): string[] =>
+  str(value, '')
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+
+/** Named subsets of the case list. See `src/suite.ts` for the membership rules. */
+export type SuiteName = 'quick' | 'full';
+
+export interface BenchConfig {
+  /** Which named subset to run. Ignored when `only` is non-empty. */
+  readonly suite: SuiteName;
+  /** Explicit case ids to run, overriding `suite`. Empty means "use the suite". */
+  readonly only: readonly string[];
+  /** Timed iterations per measurement. */
+  readonly iterations: number;
+  /** Untimed iterations run before each measurement to warm caches and JIT. */
+  readonly warmup: number;
+  /** Iterations run during the separate, sampled memory pass. */
+  readonly memoryIterations: number;
+  /** Whether to run the memory pass at all. */
+  readonly measureMemory: boolean;
+  /** Whether to run the schema-driven raw `model.execute` pass. */
+  readonly measureNative: boolean;
+  /** Polling period of the memory sampler, in milliseconds. */
+  readonly sampleIntervalMs: number;
+  /** Base URL of the collector run by `scripts/run-benchmarks.mjs`, or null. */
+  readonly sink: string | null;
+  /** Whether to start the suite as soon as the app mounts. */
+  readonly autostart: boolean;
+  /** Free-form label identifying the build under test, e.g. `et-1.3.1`. */
+  readonly label: string;
+}
+
+export const config: BenchConfig = {
+  suite: str(process.env.EXPO_PUBLIC_BENCH_SUITE, 'quick') === 'full' ? 'full' : 'quick',
+  only: list(process.env.EXPO_PUBLIC_BENCH_ONLY),
+  iterations: int(process.env.EXPO_PUBLIC_BENCH_ITERATIONS, 20),
+  warmup: int(process.env.EXPO_PUBLIC_BENCH_WARMUP, 3),
+  memoryIterations: int(process.env.EXPO_PUBLIC_BENCH_MEMORY_ITERATIONS, 5),
+  measureMemory: bool(process.env.EXPO_PUBLIC_BENCH_MEMORY, true),
+  measureNative: bool(process.env.EXPO_PUBLIC_BENCH_NATIVE, true),
+  sampleIntervalMs: int(process.env.EXPO_PUBLIC_BENCH_SAMPLE_INTERVAL_MS, 100),
+  sink: process.env.EXPO_PUBLIC_BENCH_SINK || null,
+  autostart: bool(process.env.EXPO_PUBLIC_BENCH_AUTOSTART, true),
+  label: str(process.env.EXPO_PUBLIC_BENCH_LABEL, 'local'),
+};
diff --git a/apps/benchmarks/src/inputs.ts b/apps/benchmarks/src/inputs.ts
new file mode 100644
index 0000000000..10fb7674f8
--- /dev/null
+++ b/apps/benchmarks/src/inputs.ts
@@ -0,0 +1,184 @@
+/**
+ * Deterministic synthetic inputs.
+ *
+ * Every input here is a pure function of its arguments, so two runs on the same
+ * device feed byte-identical data to the models. That matters more than realism
+ * for a regression harness: post-processing cost is input-dependent (an NMS pass
+ * over 200 candidate boxes is not the same work as over 3), so a benchmark that
+ * picked an image from the gallery would move for reasons that have nothing to
+ * do with the change under test.
+ *
+ * The image is a structured scene rather than noise for the same reason. Pure
+ * noise drives detectors into pathological candidate counts that are unlike any
+ * real workload; a few solid blobs on a gradient produce a small, stable set of
+ * detections.
+ */
+
+import type { cv } from 'react-native-executorch';
+
+type ImageBuffer = cv.ImageBuffer;
+
+/* eslint-disable no-bitwise -- the hash below is defined in terms of them */
+
+/**
+ * mulberry32 — small, fast, and identical across every JS engine.
+ * @param seed The generator's starting state.
+ * @returns A function yielding successive values in `[0, 1)`.
+ */
+function prng(seed: number): () => number {
+  let state = seed >>> 0;
+  return () => {
+    state = (state + 0x6d2b79f5) >>> 0;
+    let t = state;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/* eslint-enable no-bitwise */
+
+interface Blob {
+  readonly cx: number;
+  readonly cy: number;
+  readonly rx: number;
+  readonly ry: number;
+  readonly rgb: readonly [number, number, number];
+}
+
+// Positions are fractions of the frame so the same scene renders at any size.
+const BLOBS: readonly Blob[] = [
+  { cx: 0.3, cy: 0.42, rx: 0.17, ry: 0.26, rgb: [210, 96, 72] },
+  { cx: 0.66, cy: 0.6, rx: 0.13, ry: 0.19, rgb: [72, 140, 200] },
+  { cx: 0.5, cy: 0.82, rx: 0.28, ry: 0.11, rgb: [96, 176, 108] },
+];
+
+/**
+ * Builds an RGBA/HWC image buffer holding a fixed synthetic scene: a vertical
+ * gradient, three solid ellipses, and a light deterministic dither so the image
+ * is not perfectly flat.
+ * @param width Frame width in pixels.
+ * @param height Frame height in pixels.
+ * @param seed Seed for the dither. Same seed and size means the same bytes.
+ * @returns The image buffer, ready to pass to any vision task.
+ */
+export function syntheticImage(width: number, height: number, seed = 0x5eed): ImageBuffer {
+  const data = new Uint8Array(width * height * 4);
+  const random = prng(seed);
+
+  for (let y = 0; y < height; y++) {
+    const v = y / height;
+    for (let x = 0; x < width; x++) {
+      const u = x / width;
+
+      let r = 40 + 150 * v;
+      let g = 60 + 120 * u;
+      let b = 150 - 80 * v;
+
+      for (const blob of BLOBS) {
+        const dx = (u - blob.cx) / blob.rx;
+        const dy = (v - blob.cy) / blob.ry;
+        if (dx * dx + dy * dy <= 1) {
+          [r, g, b] = blob.rgb;
+          break;
+        }
+      }
+
+      const dither = (random() - 0.5) * 12;
+      const i = (y * width + x) * 4;
+      data[i] = Math.max(0, Math.min(255, Math.round(r + dither)));
+      data[i + 1] = Math.max(0, Math.min(255, Math.round(g + dither)));
+      data[i + 2] = Math.max(0, Math.min(255, Math.round(b + dither)));
+      data[i + 3] = 255;
+    }
+  }
+
+  return { data, width, height, format: 'rgba', layout: 'hwc' };
+}
+
+/**
+ * Builds a mono waveform alternating voice-like bursts with silence.
+ *
+ * Each burst is a glottal-style pulse train swept through three formant
+ * resonances, with a band-limited noise component for the fricative energy a
+ * pure harmonic stack lacks, under a syllable-rate envelope. It is not speech,
+ * and no recognizer will transcribe meaning from it, but it carries enough of
+ * speech's spectral shape for a voice-activity detector to open segments on the
+ * bursts and close them on the gaps — which is what makes the VAD case exercise
+ * its segmentation path rather than returning nothing.
+ * @param seconds Waveform length in seconds.
+ * @param sampleRate Samples per second.
+ * @returns Float32 PCM samples normalized to `[-1, 1]`.
+ */
+export function syntheticWaveform(seconds: number, sampleRate: number): Float32Array {
+  const samples = new Float32Array(Math.round(seconds * sampleRate));
+  const random = prng(0xa11d10);
+
+  // 0.7 s of burst followed by 0.3 s of near-silence, repeating.
+  const periodSamples = sampleRate;
+  const burstSamples = Math.round(0.7 * sampleRate);
+
+  // Two-pole resonators, one per formant, driven by the pulse train and noise.
+  const formants = [
+    { hz: 700, bandwidth: 90, gain: 1.0 },
+    { hz: 1220, bandwidth: 110, gain: 0.6 },
+    { hz: 2600, bandwidth: 170, gain: 0.35 },
+  ].map((formant) => {
+    const r = Math.exp((-Math.PI * formant.bandwidth) / sampleRate);
+    return {
+      gain: formant.gain,
+      a1: 2 * r * Math.cos((2 * Math.PI * formant.hz) / sampleRate),
+      a2: -r * r,
+      y1: 0,
+      y2: 0,
+    };
+  });
+
+  const pitchHz = 130;
+  const samplesPerPulse = sampleRate / pitchHz;
+
+  for (let i = 0; i < samples.length; i++) {
+    const phaseInPeriod = i % periodSamples;
+
+    if (phaseInPeriod >= burstSamples) {
+      samples[i] = (random() - 0.5) * 0.002;
+      // Let the resonators ring down rather than snapping to zero.
+      for (const formant of formants) {
+        const y = formant.a1 * formant.y1 + formant.a2 * formant.y2;
+        formant.y2 = formant.y1;
+        formant.y1 = y;
+      }
+      continue;
+    }
+
+    // Impulse train (voicing) plus aspiration noise, shaped by the formants.
+    const sincePulse = phaseInPeriod % samplesPerPulse;
+    const excitation = (sincePulse < 1 ? 1 : 0) + (random() - 0.5) * 0.35;
+
+    let voiced = 0;
+    for (const formant of formants) {
+      const y = excitation + formant.a1 * formant.y1 + formant.a2 * formant.y2;
+      formant.y2 = formant.y1;
+      formant.y1 = y;
+      voiced += formant.gain * y;
+    }
+
+    const envelope = 0.5 - 0.5 * Math.cos((2 * Math.PI * phaseInPeriod) / burstSamples);
+    samples[i] = Math.max(-1, Math.min(1, 0.08 * envelope * voiced));
+  }
+
+  return samples;
+}
+
+/** Fixed prose used by the text pipelines. Long enough to fill a few chunks. */
+export const SAMPLE_TEXT =
+  'React Native ExecuTorch runs machine learning models directly on device, ' +
+  'without sending user data to a server. The runtime loads a compiled program, ' +
+  'resolves the delegates it was exported against, and executes it against ' +
+  'pre-allocated tensors so that inference costs no allocations per frame.';
+
+/** Fixed text seeded with the entity types a PII detector is expected to find. */
+export const SAMPLE_PII_TEXT =
+  'Please forward the signed contract to Dana Whitfield at dana.whitfield@example.com ' +
+  'or call 555-0142 before Friday. The office is at 118 Ellis Street, Portland, and ' +
+  'the account number on file is 4029 1183 5567 2210.';
diff --git a/apps/benchmarks/src/memory.ts b/apps/benchmarks/src/memory.ts
new file mode 100644
index 0000000000..44ee0b9f8b
--- /dev/null
+++ b/apps/benchmarks/src/memory.ts
@@ -0,0 +1,73 @@
+/**
+ * Process-memory instrumentation.
+ *
+ * Sampling is deliberately kept out of the timing passes. Reading total PSS on
+ * Android walks `/proc/self/smaps` and costs single-digit milliseconds; polling
+ * that while measuring a 15 ms inference would show up in the numbers. So the
+ * runner takes its timings first with the sampler off, then repeats a handful
+ * of iterations with it on. The cost is one extra pass, and the payoff is that
+ * neither metric is contaminated by the other.
+ */
+
+import BenchProbe from '../modules/bench-probe';
+import { config } from './config';
+
+const BYTES_PER_MB = 1024 * 1024;
+
+const toMb = (bytes: number): number =>
+  bytes < 0 ? -1 : Math.round((bytes / BYTES_PER_MB) * 100) / 100;
+
+/**
+ * Reads the current process footprint.
+ * @returns The footprint in MB, or -1 when the platform read failed.
+ */
+export const footprintMb = (): number => toMb(BenchProbe.memoryFootprintBytes());
+
+/**
+ * Reads the current native heap allocation.
+ * @returns The allocation in MB, or -1 when the platform read failed.
+ */
+export const nativeHeapMb = (): number => toMb(BenchProbe.nativeHeapBytes());
+
+export interface MemorySample {
+  /** Highest footprint observed across the sampling window, in MB. */
+  readonly peakMb: number;
+  /** Footprint at the moment sampling started, in MB. */
+  readonly startMb: number;
+  /** Footprint at the moment sampling stopped, in MB. */
+  readonly endMb: number;
+  /** Number of polls taken. A very low count means the window was short. */
+  readonly samples: number;
+}
+
+/**
+ * Polls the process footprint on the JS thread for the duration of `body`.
+ *
+ * Inference runs on the worklet runtime's own thread, so the JS thread is free
+ * to poll without blocking the work being measured.
+ * @typeParam T The result type of `body`.
+ * @param body The work to sample across.
+ * @returns The work's result alongside the sampled footprint window.
+ */
+export async function sampleDuring<T>(
+  body: () => Promise<T>
+): Promise<{ result: T; memory: MemorySample }> {
+  const startMb = footprintMb();
+  let peakMb = startMb;
+  let samples = 1;
+
+  const timer = setInterval(() => {
+    const current = footprintMb();
+    samples += 1;
+    if (current > peakMb) peakMb = current;
+  }, config.sampleIntervalMs);
+
+  try {
+    const result = await body();
+    const endMb = footprintMb();
+    if (endMb > peakMb) peakMb = endMb;
+    return { result, memory: { peakMb, startMb, endMb, samples } };
+  } finally {
+    clearInterval(timer);
+  }
+}
diff --git a/apps/benchmarks/src/nativeForward.ts b/apps/benchmarks/src/nativeForward.ts
new file mode 100644
index 0000000000..aa76796d2c
--- /dev/null
+++ b/apps/benchmarks/src/nativeForward.ts
@@ -0,0 +1,317 @@
+/**
+ * The schema-driven raw-execute pass.
+ *
+ * A task pipeline's timing folds together three things an ExecuTorch bump can
+ * move independently: preprocessing (image resize, tokenization, mel framing),
+ * `model.execute` itself, and post-processing (softmax, NMS, colormapping).
+ * Only the middle one is ExecuTorch's. This pass isolates it by loading the
+ * `.pte` through `loadModel` and calling `execute` directly, with input and
+ * output tensors derived from the model's own exported schema — no task code,
+ * no pre- or post-processing, no pipeline in between.
+ *
+ * Deriving the shapes from `model.schema` rather than hard-coding them per model
+ * means this works for any `.pte` the registry grows, including every method a
+ * multi-method program exports (a Whisper `encode` and `decode` get separate
+ * numbers). Where a schema cannot be pinned down to concrete shapes the method
+ * is reported as skipped, with the reason, rather than silently dropped.
+ */
+
+import { runOnRuntimeAsync } from 'react-native-worklets';
+import {
+  loadModel,
+  tensor,
+  defaultWorkletRuntime,
+  type ConcreteDim,
+  type DimRef,
+  type DType,
+  type MethodSpec,
+  type Model,
+  type ModelInput,
+  type ParamSpec,
+  type Tensor,
+  type TensorSpec,
+} from 'react-native-executorch';
+
+import { summarize, type Stats } from './stats';
+import { timeInWorklet } from './time';
+
+/** Companion method carrying the schema JSON; it runs no compute worth timing. */
+const SCHEMA_METHOD = 'get_model_schema';
+
+// Dynamic dimensions are resolved to the largest value their domain allows, so
+// the measurement covers the worst case a model can be asked for. These caps
+// stop that from turning into an out-of-memory crash on a model whose declared
+// maximum is far larger than anything a real caller would pass — an LLM logits
+// output at max sequence length is tens of gigabytes.
+const MAX_TENSOR_ELEMENTS = 32 * 1024 * 1024;
+const MAX_METHOD_ELEMENTS = 128 * 1024 * 1024;
+
+/** Outcome of benchmarking one exported method. */
+export interface NativeMethodResult {
+  readonly method: string;
+  readonly status: 'ok' | 'skipped' | 'error';
+  /** Why the method was skipped or how it failed. Absent when `status` is ok. */
+  readonly reason?: string;
+  /** Resolved input shapes, in slot order; `null` marks a primitive slot. */
+  readonly inputShapes?: (readonly number[] | null)[];
+  /** Resolved output tensor shapes, in order. */
+  readonly outputShapes?: (readonly number[])[];
+  /** Per-iteration `execute` timings in milliseconds. */
+  readonly stats?: Stats;
+}
+
+export interface NativeResult {
+  /** Time to `loadModel` the `.pte`, in milliseconds. */
+  readonly loadMs: number;
+  /** ExecuTorch backends the program resolved, keyed by method. */
+  readonly backends: Record<string, readonly string[]>;
+  readonly methods: NativeMethodResult[];
+}
+
+const isTensorSpec = <D extends ConcreteDim>(spec: ParamSpec<D>): spec is TensorSpec<D> =>
+  spec.kind === 'Tensor';
+
+/**
+ * Takes a dimension at the top of its domain.
+ * @param dim The exported dimension domain.
+ * @returns The largest value the domain permits.
+ */
+function resolveDim(dim: ConcreteDim): number {
+  switch (dim.kind) {
+    case 'constant':
+      return dim.value;
+    case 'range':
+      return dim.range.max;
+    case 'enum':
+      return dim.choices.reduce((max, choice) => Math.max(max, choice), 1);
+  }
+}
+
+interface ResolvedShapes {
+  readonly input: number[][];
+  readonly output: number[][];
+}
+
+const dimSlot = (shapes: ResolvedShapes, ref: DimRef): number[] | undefined =>
+  (ref.paramSide === 'input' ? shapes.input : shapes.output)[ref.tensorIdx];
+
+/**
+ * Resolves every tensor dimension of a method to a concrete size.
+ *
+ * Dimensions are first taken at their domain maximum, then reconciled against
+ * the method's declared runtime constraints — the runtime enforces those at
+ * execute time, so shapes that ignore them would simply be rejected. Equality
+ * groups collapse to their smallest member (the largest value that stays inside
+ * every member's own domain); linear constraints are solved for their left-hand
+ * side.
+ * @param spec The exported method spec.
+ * @returns The resolved input and output tensor shapes.
+ */
+function resolveShapes(spec: MethodSpec<ConcreteDim>): ResolvedShapes {
+  const shapes: ResolvedShapes = {
+    input: spec.inputs.filter(isTensorSpec).map((param) => param.shape.map(resolveDim)),
+    output: spec.outputs.filter(isTensorSpec).map((param) => param.shape.map(resolveDim)),
+  };
+
+  for (const constraint of spec.runtimeConstraints) {
+    if (constraint.kind !== 'equality') continue;
+
+    const refs = constraint.dims.filter((ref) => dimSlot(shapes, ref)?.[ref.dimIdx] !== undefined);
+    if (refs.length === 0) continue;
+
+    const agreed = refs.reduce(
+      (min, ref) => Math.min(min, dimSlot(shapes, ref)![ref.dimIdx]!),
+      Number.POSITIVE_INFINITY
+    );
+    for (const ref of refs) dimSlot(shapes, ref)![ref.dimIdx] = agreed;
+  }
+
+  for (const constraint of spec.runtimeConstraints) {
+    if (constraint.kind !== 'linear') continue;
+
+    const lhs = dimSlot(shapes, constraint.dimLhs);
+    const rhsValue = dimSlot(shapes, constraint.dimRhs)?.[constraint.dimRhs.dimIdx];
+    if (!lhs || rhsValue === undefined) continue;
+
+    const [scale, offset] = constraint.coefficients;
+    lhs[constraint.dimLhs.dimIdx] = scale * rhsValue + offset;
+  }
+
+  return shapes;
+}
+
+const numel = (shape: readonly number[]): number =>
+  shape.reduce((product, size) => product * size, 1);
+
+/**
+ * Decides whether a method can be driven from its schema alone.
+ * @param spec The exported method spec.
+ * @param shapes The shapes resolved for it.
+ * @returns The reason it cannot be benchmarked, or `null` when it can.
+ */
+function rejectMethod(spec: MethodSpec<ConcreteDim>, shapes: ResolvedShapes): string | null {
+  for (const param of spec.inputs) {
+    if (isTensorSpec(param)) continue;
+    // A primitive slot is filled with a neutral value below. Strings and lists
+    // have no neutral value guaranteed to be in-domain for the model.
+    if (param.kind !== 'Int' && param.kind !== 'Double' && param.kind !== 'Bool') {
+      return `unsupported input slot kind '${param.kind}'`;
+    }
+  }
+
+  const all = [...shapes.input, ...shapes.output];
+  if (all.some((shape) => shape.some((size) => !Number.isInteger(size) || size <= 0))) {
+    return 'schema resolved to a non-positive dimension';
+  }
+
+  const oversized = all.find((shape) => numel(shape) > MAX_TENSOR_ELEMENTS);
+  if (oversized) {
+    return `tensor [${oversized.join(', ')}] exceeds the ${MAX_TENSOR_ELEMENTS} element cap`;
+  }
+
+  const total = all.reduce((sum, shape) => sum + numel(shape), 0);
+  if (total > MAX_METHOD_ELEMENTS) {
+    return `method allocates ${total} elements, over the ${MAX_METHOD_ELEMENTS} cap`;
+  }
+
+  return null;
+}
+
+/**
+ * Picks a neutral value for a non-tensor input slot.
+ * @param kind The slot's ExecuTorch value tag.
+ * @returns `false` for a boolean slot, `0` for a numeric one.
+ */
+const primitiveFor = (kind: ParamSpec<ConcreteDim>['kind']): ModelInput =>
+  kind === 'Bool' ? false : 0;
+
+/**
+ * Zeroes a tensor's buffer.
+ *
+ * Freshly allocated native memory is uninitialized, and the bit patterns it
+ * happens to hold are frequently denormal floats — which some CPUs handle in
+ * microcode, at a slowdown large enough to swamp whatever the benchmark is
+ * trying to detect.
+ * @param target The tensor to clear.
+ * @param dtype Its element type, which decides the typed array used.
+ */
+function zero(target: Tensor, dtype: DType): void {
+  switch (dtype) {
+    case 'uint8':
+      target.setData(new Uint8Array(target.numel));
+      return;
+    case 'int32':
+      target.setData(new Int32Array(target.numel));
+      return;
+    case 'int64':
+      target.setData(new BigInt64Array(target.numel));
+      return;
+    case 'float32':
+      target.setData(new Float32Array(target.numel));
+  }
+}
+
+const loadOnRuntime = (modelPath: string): Promise<Model> =>
+  runOnRuntimeAsync(
+    defaultWorkletRuntime,
+    (path: string) => {
+      'worklet';
+      return loadModel(path);
+    },
+    modelPath
+  );
+
+/**
+ * Times `execute` on a single exported method.
+ * @param model The loaded program.
+ * @param name The method to run.
+ * @param spec The method's exported spec, used to size its tensors.
+ * @param iterations Timed iterations.
+ * @param warmup Untimed iterations run first.
+ * @returns The method's timings, or why it could not be run.
+ */
+async function benchmarkMethod(
+  model: Model,
+  name: string,
+  spec: MethodSpec<ConcreteDim>,
+  iterations: number,
+  warmup: number
+): Promise<NativeMethodResult> {
+  const shapes = resolveShapes(spec);
+  const rejection = rejectMethod(spec, shapes);
+  if (rejection) return { method: name, status: 'skipped', reason: rejection };
+
+  const allocated: Tensor[] = [];
+  try {
+    const inputSpecs = spec.inputs.filter(isTensorSpec);
+    const inputTensors = inputSpecs.map((param, index) => {
+      const allocation = tensor(param.dtype, shapes.input[index]!);
+      allocated.push(allocation);
+      zero(allocation, param.dtype);
+      return allocation;
+    });
+    const outputTensors = spec.outputs.filter(isTensorSpec).map((param, index) => {
+      const allocation = tensor(param.dtype, shapes.output[index]!);
+      allocated.push(allocation);
+      return allocation;
+    });
+
+    let tensorSlot = 0;
+    const inputShapes: (readonly number[] | null)[] = [];
+    const inputs: ModelInput[] = spec.inputs.map((param) => {
+      if (!isTensorSpec(param)) {
+        inputShapes.push(null);
+        return primitiveFor(param.kind);
+      }
+      inputShapes.push(shapes.input[tensorSlot]!);
+      return inputTensors[tensorSlot++]!;
+    });
+
+    const run = () => {
+      'worklet';
+      model.execute(name, inputs, outputTensors);
+      return 1;
+    };
+
+    const timed = await timeInWorklet(defaultWorkletRuntime, run, iterations, warmup);
+    return {
+      method: name,
+      status: 'ok',
+      inputShapes,
+      outputShapes: shapes.output,
+      stats: summarize(timed.durations),
+    };
+  } catch (error) {
+    return { method: name, status: 'error', reason: String(error) };
+  } finally {
+    allocated.forEach((allocation) => allocation.dispose());
+  }
+}
+
+/**
+ * Loads a `.pte` directly and times `execute` on every method it exports.
+ * @param modelPath Local path to the `.pte` file.
+ * @param iterations Timed iterations per method.
+ * @param warmup Untimed iterations per method.
+ * @returns Load timing, resolved backends, and one entry per exported method.
+ */
+export async function benchmarkNativeForward(
+  modelPath: string,
+  iterations: number,
+  warmup: number
+): Promise<NativeResult> {
+  const started = performance.now();
+  const model = await loadOnRuntime(modelPath);
+  const loadMs = Math.round((performance.now() - started) * 1000) / 1000;
+
+  try {
+    const methods: NativeMethodResult[] = [];
+    for (const [name, spec] of Object.entries(model.schema)) {
+      if (name === SCHEMA_METHOD) continue;
+      methods.push(await benchmarkMethod(model, name, spec, iterations, warmup));
+    }
+    return { loadMs, backends: model.backends, methods };
+  } finally {
+    model.dispose();
+  }
+}
diff --git a/apps/benchmarks/src/report.ts b/apps/benchmarks/src/report.ts
new file mode 100644
index 0000000000..67b55a2e79
--- /dev/null
+++ b/apps/benchmarks/src/report.ts
@@ -0,0 +1,112 @@
+/**
+ * Result shapes and the two channels results leave the device by.
+ *
+ * Getting numbers off a phone is the awkward part of on-device benchmarking:
+ * `adb logcat` works for Android, `xcrun simctl` only for the iOS Simulator, and
+ * a physical iPhone has no equivalent that does not involve Console.app. So the
+ * harness writes to both channels — a line-prefixed console log a human can read
+ * straight from Metro, and an HTTP POST to the collector in
+ * `scripts/run-benchmarks.mjs`, which works identically on a simulator, an
+ * emulator and real hardware over `adb reverse` or the LAN.
+ */
+
+import type { BenchDeviceInfo } from '../modules/bench-probe';
+import type { NativeResult } from './nativeForward';
+import type { Stats } from './stats';
+import { config } from './config';
+
+/** Prefix that makes result lines greppable in a log stream. */
+export const LOG_PREFIX = 'RNE_BENCH';
+
+export interface CaseResult {
+  readonly id: string;
+  readonly task: string;
+  readonly model: string;
+  readonly status: 'ok' | 'error';
+  /** Failure detail. Present only when `status` is `error`. */
+  readonly error?: string;
+  readonly note?: string;
+  /** Whether timings came from the worklet runtime or the RN thread. */
+  readonly mode: 'worklet' | 'async';
+  /** Milliseconds spent resolving remote model files. 0 when fully cached. */
+  readonly downloadMs: number;
+  /** Milliseconds for the task pipeline's `create` call, model load included. */
+  readonly taskLoadMs: number;
+  /** End-to-end pipeline timings: preprocessing, execute, and post-processing. */
+  readonly pipeline?: Stats;
+  /** Workload size the pipeline reported. See `TimedRun.units`. */
+  readonly units?: number;
+  /** Raw `model.execute` timings, per exported method. */
+  readonly native?: NativeResult;
+  readonly memory?: {
+    /** Footprint before the model was loaded, in MB. */
+    readonly baselineMb: number;
+    /** Footprint once the pipeline was ready, in MB. */
+    readonly loadedMb: number;
+    /** Peak footprint observed during the sampled inference pass, in MB. */
+    readonly peakMb: number;
+    /** Footprint after `dispose`, in MB. Should return near the baseline. */
+    readonly disposedMb: number;
+  };
+}
+
+export interface RunReport {
+  /** Report schema version. Bumped when a field's meaning changes. */
+  readonly schemaVersion: 1;
+  /** Label identifying the build under test, e.g. `et-1.3.1`. */
+  readonly label: string;
+  readonly startedAt: string;
+  readonly finishedAt: string;
+  readonly platform: string;
+  readonly device: BenchDeviceInfo;
+  readonly settings: {
+    readonly suite: string;
+    readonly iterations: number;
+    readonly warmup: number;
+    readonly memoryIterations: number;
+  };
+  readonly cases: readonly CaseResult[];
+}
+
+const post = async (path: string, body: unknown): Promise<void> => {
+  if (!config.sink) return;
+  try {
+    await fetch(`${config.sink}${path}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+  } catch (error) {
+    // The collector is optional: a developer running the app by hand has no
+    // sink at all. Losing it must not take the run down, since the console
+    // channel still carries every result.
+    console.warn(`${LOG_PREFIX}_SINK_ERROR ${String(error)}`);
+  }
+};
+
+/**
+ * Announces the case list before any work starts.
+ * @param ids The cases about to run, in order.
+ */
+export async function reportStart(ids: readonly string[]): Promise<void> {
+  console.log(`${LOG_PREFIX}_BEGIN ${JSON.stringify({ label: config.label, cases: ids })}`);
+  await post('/begin', { label: config.label, cases: ids });
+}
+
+/**
+ * Emits one case's result as soon as it is available.
+ * @param result The finished case.
+ */
+export async function reportCase(result: CaseResult): Promise<void> {
+  console.log(`${LOG_PREFIX}_CASE ${JSON.stringify(result)}`);
+  await post('/case', result);
+}
+
+/**
+ * Emits the complete report.
+ * @param report The finished run.
+ */
+export async function reportEnd(report: RunReport): Promise<void> {
+  console.log(`${LOG_PREFIX}_END ${JSON.stringify(report)}`);
+  await post('/end', report);
+}
diff --git a/apps/benchmarks/src/runner.ts b/apps/benchmarks/src/runner.ts
new file mode 100644
index 0000000000..e29869b0d2
--- /dev/null
+++ b/apps/benchmarks/src/runner.ts
@@ -0,0 +1,204 @@
+/**
+ * The benchmark engine.
+ *
+ * Each case runs through a fixed sequence of passes, in this order and for these
+ * reasons:
+ *
+ * 1. **Download.** Timed separately and reported, but never part of a metric —
+ *    it measures the network, not the build. Cached after the first run.
+ * 2. **Raw execute.** Loads the `.pte` on its own and times `model.execute` per
+ *    method. Runs before the pipeline pass so it holds the only model in memory
+ *    while it runs, and is disposed before the pipeline loads its own copy.
+ * 3. **Task load.** Times the pipeline's `create` call — model load, schema
+ *    validation and tensor pre-allocation, the thing a user waits through.
+ * 4. **Pipeline timing.** Warmup, then timed iterations, with the memory sampler
+ *    off so the sampler's cost stays out of the numbers.
+ * 5. **Memory.** A few more iterations with the sampler on, for the peak. Split
+ *    from pass 4 because reading total PSS on Android is milliseconds of work.
+ * 6. **Dispose.** Footprint is read once more, so a leak shows up as a case that
+ *    never returns to its baseline.
+ */
+
+import { download, defaultWorkletRuntime } from 'react-native-executorch';
+import { Platform } from 'react-native';
+
+import BenchProbe from '../modules/bench-probe';
+import { config } from './config';
+import { footprintMb, sampleDuring } from './memory';
+import { benchmarkNativeForward } from './nativeForward';
+import { reportCase, reportEnd, reportStart, type CaseResult, type RunReport } from './report';
+import { summarize } from './stats';
+import { timeAsync, timeInWorklet } from './time';
+import { selectCases, type BenchCase } from './suite';
+
+/** Progress callback so the on-device UI can show what is happening. */
+export interface RunnerEvents {
+  onPhase?: (caseId: string, phase: string) => void;
+  onCase?: (result: CaseResult) => void;
+}
+
+const round = (value: number): number => Math.round(value * 1000) / 1000;
+
+/**
+ * Gives the allocator and the OS a moment to settle before a footprint reading.
+ *
+ * Freed native memory is not returned to the kernel synchronously, so reading
+ * the footprint the instant after `dispose` mostly measures how far behind the
+ * allocator is rather than whether anything leaked.
+ * @returns A promise resolving once the pause has elapsed.
+ */
+const settle = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 250));
+
+async function runCase(benchCase: BenchCase, events: RunnerEvents): Promise<CaseResult> {
+  const base = {
+    id: benchCase.id,
+    task: benchCase.task,
+    model: benchCase.model,
+    note: benchCase.note,
+    mode: benchCase.mode ?? ('worklet' as const),
+  };
+
+  events.onPhase?.(benchCase.id, 'download');
+  const downloadStarted = performance.now();
+  const resolved = await download(benchCase.config);
+  const downloadMs = round(performance.now() - downloadStarted);
+
+  let native: CaseResult['native'];
+  if (config.measureNative && benchCase.modelPathKey) {
+    events.onPhase?.(benchCase.id, 'raw execute');
+    const modelPath = resolved[benchCase.modelPathKey];
+    if (typeof modelPath === 'string') {
+      native = await benchmarkNativeForward(modelPath, config.iterations, config.warmup);
+      await settle();
+    }
+  }
+
+  // Read after the raw-execute pass, not before it. That pass loads and disposes
+  // a model of its own, and the allocator does not hand every page back; a
+  // baseline taken ahead of it would charge whatever it retained to the pipeline.
+  const baselineMb = footprintMb();
+
+  events.onPhase?.(benchCase.id, 'load');
+  const loadStarted = performance.now();
+  const instance = await benchCase.create(resolved);
+  const taskLoadMs = round(performance.now() - loadStarted);
+  const loadedMb = footprintMb();
+
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    instance.dispose();
+  };
+
+  try {
+    events.onPhase?.(benchCase.id, 'inference');
+    const timed =
+      benchCase.mode === 'async'
+        ? await timeAsync(benchCase.runAsync(instance), config.iterations, config.warmup)
+        : await timeInWorklet(
+            defaultWorkletRuntime,
+            benchCase.run(instance),
+            config.iterations,
+            config.warmup
+          );
+
+    let memory: CaseResult['memory'];
+    if (config.measureMemory) {
+      events.onPhase?.(benchCase.id, 'memory');
+      const sampled = await sampleDuring(async () => {
+        if (benchCase.mode === 'async') {
+          return timeAsync(benchCase.runAsync(instance), config.memoryIterations, 0);
+        }
+        return timeInWorklet(
+          defaultWorkletRuntime,
+          benchCase.run(instance),
+          config.memoryIterations,
+          0
+        );
+      });
+
+      dispose();
+      await settle();
+      memory = {
+        baselineMb,
+        loadedMb,
+        peakMb: sampled.memory.peakMb,
+        disposedMb: footprintMb(),
+      };
+    } else {
+      dispose();
+    }
+
+    return {
+      ...base,
+      status: 'ok',
+      downloadMs,
+      taskLoadMs,
+      pipeline: summarize(timed.durations),
+      units: timed.units,
+      native,
+      memory,
+    };
+  } catch (error) {
+    dispose();
+    return { ...base, status: 'error', error: String(error), downloadMs, taskLoadMs, native };
+  }
+}
+
+/**
+ * Runs the configured suite and emits a report.
+ * @param events Progress callbacks for the on-device UI.
+ * @returns The completed report, also sent to the console and the collector.
+ */
+export async function runSuite(events: RunnerEvents = {}): Promise<RunReport> {
+  const cases = selectCases(config.suite, config.only);
+  const startedAt = new Date().toISOString();
+
+  await reportStart(cases.map((benchCase) => benchCase.id));
+
+  const results: CaseResult[] = [];
+  for (const benchCase of cases) {
+    let result: CaseResult;
+    try {
+      result = await runCase(benchCase, events);
+    } catch (error) {
+      // A case that fails outright — a download timeout, a backend the device
+      // does not have — must not strand the rest of the suite.
+      result = {
+        id: benchCase.id,
+        task: benchCase.task,
+        model: benchCase.model,
+        note: benchCase.note,
+        mode: benchCase.mode ?? 'worklet',
+        status: 'error',
+        error: String(error),
+        downloadMs: 0,
+        taskLoadMs: 0,
+      };
+    }
+
+    results.push(result);
+    events.onCase?.(result);
+    await reportCase(result);
+  }
+
+  const report: RunReport = {
+    schemaVersion: 1,
+    label: config.label,
+    startedAt,
+    finishedAt: new Date().toISOString(),
+    platform: Platform.OS,
+    device: BenchProbe.deviceInfo(),
+    settings: {
+      suite: config.only.length > 0 ? config.only.join(',') : config.suite,
+      iterations: config.iterations,
+      warmup: config.warmup,
+      memoryIterations: config.memoryIterations,
+    },
+    cases: results,
+  };
+
+  await reportEnd(report);
+  return report;
+}
diff --git a/apps/benchmarks/src/stats.ts b/apps/benchmarks/src/stats.ts
new file mode 100644
index 0000000000..75b3a7064f
--- /dev/null
+++ b/apps/benchmarks/src/stats.ts
@@ -0,0 +1,73 @@
+/**
+ * Summary statistics over a set of timing samples.
+ *
+ * The comparator compares medians rather than means: a single scheduling
+ * hiccup or a thermal throttle step moves the mean of a 20-sample run by more
+ * than a genuine 5% regression does, while the median shrugs it off. `iqr` is
+ * carried alongside so the comparator can tell a real shift from a noisy run.
+ */
+export interface Stats {
+  /** Number of samples. */
+  readonly count: number;
+  readonly min: number;
+  readonly max: number;
+  readonly mean: number;
+  readonly median: number;
+  /** 90th percentile, by nearest-rank. Surfaces tail latency. */
+  readonly p90: number;
+  /** Interquartile range — the run's own noise floor. */
+  readonly iqr: number;
+  readonly stdev: number;
+}
+
+const round = (value: number): number => Math.round(value * 1000) / 1000;
+
+/**
+ * Nearest-rank percentile over an already-sorted array.
+ * @param sorted The samples, ascending.
+ * @param fraction The percentile to take, in `[0, 1]`.
+ * @returns The sample at that rank, or 0 when there are none.
+ */
+const percentile = (sorted: readonly number[], fraction: number): number => {
+  if (sorted.length === 0) return 0;
+  const rank = Math.ceil(fraction * sorted.length);
+  return sorted[Math.min(Math.max(rank, 1), sorted.length) - 1]!;
+};
+
+/**
+ * Middle value of an already-sorted array, averaging the two middles on an
+ * even count.
+ * @param sorted The samples, ascending.
+ * @returns The median, or 0 when there are no samples.
+ */
+const median = (sorted: readonly number[]): number => {
+  if (sorted.length === 0) return 0;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[mid]! : (sorted[mid - 1]! + sorted[mid]!) / 2;
+};
+
+/**
+ * Reduces raw timing samples to the summary the report carries.
+ * @param samples Per-iteration durations, in any order.
+ * @returns The summary statistics, all rounded to three decimals.
+ */
+export function summarize(samples: readonly number[]): Stats {
+  if (samples.length === 0) {
+    return { count: 0, min: 0, max: 0, mean: 0, median: 0, p90: 0, iqr: 0, stdev: 0 };
+  }
+
+  const sorted = [...samples].sort((a, b) => a - b);
+  const mean = sorted.reduce((sum, value) => sum + value, 0) / sorted.length;
+  const variance = sorted.reduce((sum, value) => sum + (value - mean) ** 2, 0) / sorted.length;
+
+  return {
+    count: sorted.length,
+    min: round(sorted[0]!),
+    max: round(sorted[sorted.length - 1]!),
+    mean: round(mean),
+    median: round(median(sorted)),
+    p90: round(percentile(sorted, 0.9)),
+    iqr: round(percentile(sorted, 0.75) - percentile(sorted, 0.25)),
+    stdev: round(Math.sqrt(variance)),
+  };
+}
diff --git a/apps/benchmarks/src/suite.ts b/apps/benchmarks/src/suite.ts
new file mode 100644
index 0000000000..c9f0048ba1
--- /dev/null
+++ b/apps/benchmarks/src/suite.ts
@@ -0,0 +1,314 @@
+/**
+ * The benchmark case list.
+ *
+ * A case pairs a model from the registry with the task pipeline that drives it
+ * and a deterministic input. Cases are split into two tiers because the whole
+ * suite is gated on download size far more than on runtime: `quick` stays under
+ * roughly 150 MB of model files and finishes in a couple of minutes, which is
+ * what you want when bisecting. `full` adds the larger models and the pipelines
+ * whose downloads run to several hundred megabytes.
+ *
+ * Adding a case means adding an entry here and nothing else — the runner
+ * discovers what to measure from the task instance and the model schema.
+ */
+
+import {
+  createClassifier,
+  createFsmnVoiceActivityDetector,
+  createImageEmbedder,
+  createKeypointDetector,
+  createObjectDetector,
+  createPrivacyFilter,
+  createSemanticSegmenter,
+  createStyleTransfer,
+  createSupertonicTextToSpeech,
+  createTextEmbedder,
+  createWhisperSpeechToText,
+  constants,
+  models,
+  FSMN_VAD_SAMPLE_RATE_HZ,
+  WHISPER_SAMPLE_RATE_HZ,
+} from 'react-native-executorch';
+import { Platform } from 'react-native';
+
+import { SAMPLE_PII_TEXT, SAMPLE_TEXT, syntheticImage, syntheticWaveform } from './inputs';
+import type { SuiteName } from './config';
+
+interface CaseCommon<TInstance extends { dispose: () => void }> {
+  /** Stable identifier. Used by `EXPO_PUBLIC_BENCH_ONLY` and by the comparator. */
+  readonly id: string;
+  /** Registry category, e.g. `classification`. */
+  readonly task: string;
+  /** Registry path of the model variant, e.g. `EFFICIENTNET_V2_S.XNNPACK_INT8`. */
+  readonly model: string;
+  readonly tier: SuiteName;
+  /** Platforms the case can run on. Omit for both. */
+  readonly platforms?: readonly ('ios' | 'android')[];
+  /**
+   * Task config with the registry's remote URLs still in place. The runner
+   * resolves them to local paths with `download` before calling `create`.
+   */
+  readonly config: any;
+  /**
+   * Key within `config` holding the main `.pte`, for the raw-execute pass. Omit
+   * on pipelines built from several sub-models, which have no single program to
+   * benchmark in isolation.
+   */
+  readonly modelPathKey?: string;
+  readonly create: (config: any) => Promise<TInstance>;
+  /** Free-text caveat recorded with the result. */
+  readonly note?: string;
+}
+
+/**
+ * A case timed on the worklet runtime through the pipeline's synchronous entry
+ * point. This is the accurate path and the default.
+ */
+interface WorkletCase<TInstance extends { dispose: () => void }> extends CaseCommon<TInstance> {
+  readonly mode?: 'worklet';
+  /**
+   * Builds the worklet to time. It returns the iteration's workload size, so a
+   * pipeline whose cost depends on its own output (tokens decoded, boxes kept)
+   * can report it; constant-work pipelines return 1. The comparator refuses to
+   * diff two runs whose workload sizes differ.
+   */
+  readonly run: (instance: TInstance) => () => number;
+}
+
+/**
+ * A case timed from the React Native thread, for pipelines with no synchronous
+ * entry point to call.
+ */
+interface AsyncCase<TInstance extends { dispose: () => void }> extends CaseCommon<TInstance> {
+  readonly mode: 'async';
+  readonly runAsync: (instance: TInstance) => () => Promise<number>;
+}
+
+export type BenchCase<TInstance extends { dispose: () => void } = any> =
+  | WorkletCase<TInstance>
+  | AsyncCase<TInstance>;
+
+/**
+ * Type-checks one case against the pipeline it drives.
+ *
+ * The case list is heterogeneous, so the array itself can only be typed as
+ * `BenchCase<any>` — and `any` would let `instance.classifyWorklet` keep
+ * compiling after the pipeline renamed that method, which is exactly the rot a
+ * benchmark suite is prone to. Naming the pipeline's `create` as a separate
+ * leading parameter makes it its own inference site, resolved before the object
+ * literal is checked, so `run` sees the real instance type. Passing `create`
+ * inside the literal instead does not work: it is then inferred alongside `run`,
+ * and `TInstance` collapses to its constraint.
+ * @typeParam TInstance The task runner type, inferred from `create`.
+ * @param create The pipeline's factory.
+ * @param body The rest of the case.
+ * @returns The assembled case, widened for the array.
+ */
+const defineCase = <TInstance extends { dispose: () => void }>(
+  create: (config: any) => Promise<TInstance>,
+  body: Omit<WorkletCase<TInstance>, 'create'> | Omit<AsyncCase<TInstance>, 'create'>
+): BenchCase => ({ ...body, create }) as BenchCase;
+
+// Vision inputs are generated once and shared: they are pure data, and building
+// a 640x640 scene costs more than the inference being measured.
+const IMAGE_512 = syntheticImage(512, 512);
+const IMAGE_640 = syntheticImage(640, 640);
+const VAD_WAVEFORM = syntheticWaveform(10, FSMN_VAD_SAMPLE_RATE_HZ);
+const WHISPER_WAVEFORM = syntheticWaveform(10, WHISPER_SAMPLE_RATE_HZ);
+const SUPERTONIC_VOICE = constants.SUPERTONIC_DEFAULT_VOICE_NAMES[0]!;
+
+export const CASES: readonly BenchCase[] = [
+  defineCase(createClassifier, {
+    id: 'classification/efficientnet-v2-s-xnnpack-int8',
+    task: 'classification',
+    model: 'EFFICIENTNET_V2_S.XNNPACK_INT8',
+    tier: 'quick',
+    config: models.classification.EFFICIENTNET_V2_S.XNNPACK_INT8,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.classifyWorklet(IMAGE_512, { topk: 5 }).length;
+    },
+  }),
+  defineCase(createClassifier, {
+    id: 'classification/efficientnet-v2-s-coreml-fp16',
+    task: 'classification',
+    model: 'EFFICIENTNET_V2_S.COREML_FP16',
+    tier: 'quick',
+    platforms: ['ios'],
+    config: models.classification.EFFICIENTNET_V2_S.COREML_FP16,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.classifyWorklet(IMAGE_512, { topk: 5 }).length;
+    },
+    // CoreML programs fail to encode on the iOS Simulator, so this case only
+    // produces numbers on real hardware.
+    note: 'physical device only',
+  }),
+  defineCase(createSemanticSegmenter, {
+    id: 'semantic-segmentation/selfie-xnnpack-fp32',
+    task: 'semanticSegmentation',
+    model: 'SELFIE_SEGMENTATION.XNNPACK_FP32',
+    tier: 'quick',
+    config: models.semanticSegmentation.SELFIE_SEGMENTATION.XNNPACK_FP32,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.segmentWorklet(IMAGE_512).buffer.width;
+    },
+  }),
+  defineCase(createStyleTransfer, {
+    id: 'style-transfer/candy-xnnpack-int8',
+    task: 'styleTransfer',
+    model: 'CANDY.XNNPACK_INT8',
+    tier: 'quick',
+    config: models.styleTransfer.CANDY.XNNPACK_INT8,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.transferStyleWorklet(IMAGE_512).width;
+    },
+  }),
+  defineCase(createKeypointDetector, {
+    id: 'keypoint-detection/blazeface-xnnpack-fp32',
+    task: 'keypointDetection',
+    model: 'BLAZEFACE.XNNPACK_FP32',
+    tier: 'quick',
+    config: models.keypointDetection.BLAZEFACE.XNNPACK_FP32,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.detectKeypointsWorklet(IMAGE_512).length;
+    },
+  }),
+  defineCase(createTextEmbedder, {
+    id: 'text-embeddings/all-minilm-l6-v2-xnnpack-fp32',
+    task: 'textEmbeddings',
+    model: 'ALL_MINILM_L6_V2.XNNPACK_FP32',
+    tier: 'quick',
+    config: models.textEmbeddings.ALL_MINILM_L6_V2.XNNPACK_FP32,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.embedWorklet(SAMPLE_TEXT).length;
+    },
+  }),
+  defineCase(createFsmnVoiceActivityDetector, {
+    id: 'vad/fsmn-xnnpack-fp32',
+    task: 'voiceActivityDetection',
+    model: 'FSMN_VAD.XNNPACK_FP32',
+    tier: 'quick',
+    config: models.voiceActivityDetection.FSMN_VAD.XNNPACK_FP32,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.detectVoiceWorklet(VAD_WAVEFORM).length;
+    },
+  }),
+
+  defineCase(createObjectDetector, {
+    id: 'object-detection/ssdlite320-xnnpack-fp32',
+    task: 'objectDetection',
+    model: 'SSDLITE320_MOBILENET_V3_LARGE.XNNPACK_FP32',
+    tier: 'full',
+    config: models.objectDetection.SSDLITE320_MOBILENET_V3_LARGE.XNNPACK_FP32,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.detectObjectsWorklet(IMAGE_640).length;
+    },
+  }),
+  defineCase(createObjectDetector, {
+    id: 'object-detection/yolo26-nano-384-xnnpack-fp32',
+    task: 'objectDetection',
+    model: 'YOLO26.NANO.SIZE_384.XNNPACK_FP32',
+    tier: 'full',
+    config: models.objectDetection.YOLO26.NANO.SIZE_384.XNNPACK_FP32,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.detectObjectsWorklet(IMAGE_640).length;
+    },
+  }),
+  defineCase(createImageEmbedder, {
+    id: 'image-embeddings/clip-vit-base-patch32-xnnpack-fp32',
+    task: 'imageEmbeddings',
+    model: 'CLIP_VIT_BASE_PATCH32.XNNPACK_FP32',
+    tier: 'full',
+    config: models.imageEmbeddings.CLIP_VIT_BASE_PATCH32.XNNPACK_FP32,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.embedWorklet(IMAGE_512).length;
+    },
+  }),
+  defineCase(createPrivacyFilter, {
+    id: 'privacy-filter/openai-xnnpack-8da4w',
+    task: 'privacyFilter',
+    model: 'OPENAI.XNNPACK_8DA4W',
+    tier: 'full',
+    config: models.privacyFilter.OPENAI.XNNPACK_8DA4W,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.detectPiiWorklet(SAMPLE_PII_TEXT).length;
+    },
+  }),
+  defineCase(createWhisperSpeechToText, {
+    id: 'speech-to-text/whisper-tiny-en-xnnpack-fp32',
+    task: 'speechToText',
+    model: 'WHISPER.EN.TINY.XNNPACK_FP32',
+    tier: 'full',
+    config: models.speechToText.WHISPER.EN.TINY.XNNPACK_FP32,
+    modelPathKey: 'modelPath',
+    run: (instance) => () => {
+      'worklet';
+      return instance.transcribeWorklet(WHISPER_WAVEFORM, { language: 'en' }).length;
+    },
+    // The synthetic waveform is voice-shaped but is not speech, so the decoder
+    // emits far fewer tokens than a real clip would and the pipeline figure is
+    // dominated by the encoder. The per-method numbers from the raw-execute pass
+    // are the ones to trust here; the comparator invalidates the pipeline figure
+    // outright if the transcript length moves between runs.
+    note: 'decode length is input-dependent; compare the raw-execute methods',
+  }),
+  defineCase(createSupertonicTextToSpeech, {
+    id: 'text-to-speech/supertonic-xnnpack-fp32',
+    task: 'textToSpeech',
+    model: 'SUPERTONIC.XNNPACK_FP32',
+    tier: 'full',
+    config: models.textToSpeech.SUPERTONIC.XNNPACK_FP32,
+    mode: 'async',
+    runAsync: (instance) => async () => {
+      let samples = 0;
+      for await (const chunk of instance.synthesize(SAMPLE_TEXT, {
+        voiceStyle: SUPERTONIC_VOICE,
+      })) {
+        samples += chunk.audio.length;
+      }
+      return samples;
+    },
+    // Supertonic streams through four sub-models with JS-thread orchestration
+    // between chunks, so there is no synchronous entry point to time, and no
+    // single `.pte` for the raw-execute pass. These numbers include one thread
+    // hop per chunk.
+    note: 'timed on the RN thread; includes per-chunk thread hops',
+  }),
+];
+
+/**
+ * Selects the cases to run.
+ * @param suite The tier to run when `only` is empty.
+ * @param only Explicit case ids. Non-empty overrides `suite`.
+ * @returns The runnable cases for the current platform, in declaration order.
+ */
+export function selectCases(suite: SuiteName, only: readonly string[]): BenchCase[] {
+  const platform = Platform.OS === 'ios' ? 'ios' : 'android';
+
+  return CASES.filter((benchCase) => {
+    if (benchCase.platforms && !benchCase.platforms.includes(platform)) return false;
+    if (only.length > 0) return only.includes(benchCase.id);
+    return suite === 'full' || benchCase.tier === 'quick';
+  });
+}
diff --git a/apps/benchmarks/src/time.ts b/apps/benchmarks/src/time.ts
new file mode 100644
index 0000000000..e25bef7833
--- /dev/null
+++ b/apps/benchmarks/src/time.ts
@@ -0,0 +1,97 @@
+/**
+ * Timing primitives.
+ *
+ * The measurement loop runs *inside* the worklet runtime rather than driving it
+ * from the React Native thread one iteration at a time. Each `runOnRuntimeAsync`
+ * hop costs a serialization of the captured closure plus a thread handoff, which
+ * is the same order of magnitude as a small model's inference — measuring from
+ * outside would bury the signal under harness overhead. Keeping the loop inside
+ * means one hop per measurement instead of one per iteration.
+ *
+ * `performance.now()` is installed on worklet runtimes by react-native-worklets
+ * and is backed by `std::chrono::steady_clock`, so it is monotonic and has
+ * sub-millisecond resolution. `Date.now()`'s 1 ms granularity would quantize a
+ * 4 ms inference into three distinct values.
+ */
+
+import { runOnRuntimeAsync, type WorkletRuntime } from 'react-native-worklets';
+
+/**
+ * A single measurement's raw output.
+ */
+export interface TimedRun {
+  /** Per-iteration wall time in milliseconds, in execution order. */
+  readonly durations: number[];
+  /**
+   * Workload size reported by the measured function on its last iteration —
+   * tokens decoded, boxes kept, samples synthesized. Constant-work benchmarks
+   * report 1. The comparator refuses to diff two runs whose units differ, since
+   * that means the two did different amounts of work.
+   */
+  readonly units: number;
+}
+
+/**
+ * Runs `run` on `runtime`, timing each iteration.
+ * @param runtime The worklet runtime to execute on.
+ * @param run A worklet returning its workload size. Called `warmup + iterations`
+ * times; only the last `iterations` calls are timed.
+ * @param iterations Number of timed iterations.
+ * @param warmup Number of untimed iterations run first.
+ * @returns The per-iteration durations and the final workload size.
+ */
+export function timeInWorklet(
+  runtime: WorkletRuntime,
+  run: () => number,
+  iterations: number,
+  warmup: number
+): Promise<TimedRun> {
+  return runOnRuntimeAsync(
+    runtime,
+    (fn: () => number, timed: number, untimed: number) => {
+      'worklet';
+      for (let i = 0; i < untimed; i++) fn();
+
+      const durations: number[] = [];
+      let units = 1;
+      for (let i = 0; i < timed; i++) {
+        const started = performance.now();
+        units = fn();
+        durations.push(performance.now() - started);
+      }
+      return { durations, units };
+    },
+    run,
+    iterations,
+    warmup
+  );
+}
+
+/**
+ * Times an asynchronous call from the React Native thread.
+ *
+ * Only for pipelines with no synchronous worklet entry point — the Supertonic
+ * text-to-speech generator, for instance, interleaves worklet chunks with
+ * JS-thread orchestration. The numbers include one thread hop per call, so they
+ * are comparable across runs but not against `timeInWorklet` results.
+ * @param run An async function returning its workload size.
+ * @param iterations Number of timed iterations.
+ * @param warmup Number of untimed iterations run first.
+ * @returns The per-iteration durations and the final workload size.
+ */
+export async function timeAsync(
+  run: () => Promise<number>,
+  iterations: number,
+  warmup: number
+): Promise<TimedRun> {
+  for (let i = 0; i < warmup; i++) await run();
+
+  const durations: number[] = [];
+  let units = 1;
+  for (let i = 0; i < iterations; i++) {
+    const started = performance.now();
+    units = await run();
+    durations.push(performance.now() - started);
+  }
+  return { durations, units };
+}
diff --git a/apps/benchmarks/tsconfig.json b/apps/benchmarks/tsconfig.json
new file mode 100644
index 0000000000..c9cd78d7f5
--- /dev/null
+++ b/apps/benchmarks/tsconfig.json
@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "strict": true,
+    "allowJs": true,
+    "module": "preserve",
+    "moduleDetection": "force",
+    "moduleResolution": "bundler",
+    "customConditions": ["react-native"],
+    "noEmit": true,
+    "paths": {
+      "react-native-executorch": ["../../packages/react-native-executorch/src"]
+    }
+  },
+  // Repeats the root's exclusions because `exclude` replaces rather than merges,
+  // and adds the Node driver scripts — they are .mjs, and `allowJs` would
+  // otherwise pull them into the React Native program.
+  "exclude": ["node_modules", "babel.config.js", "metro.config.js", "scripts"]
+}
diff --git a/yarn.lock b/yarn.lock
index 875b8db572..b658074112 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5974,6 +5974,26 @@ __metadata:
   languageName: node
   linkType: hard
 
+"benchmarks@workspace:apps/benchmarks":
+  version: 0.0.0-use.local
+  resolution: "benchmarks@workspace:apps/benchmarks"
+  dependencies:
+    "@babel/core": "npm:^7.29.0"
+    "@react-native/metro-config": "npm:^0.86.0"
+    "@types/react": "npm:~19.2.0"
+    babel-preset-expo: "npm:~56.0.14"
+    expo: "npm:~56.0.9"
+    expo-build-properties: "npm:~56.0.17"
+    react: "npm:19.2.3"
+    react-native: "npm:0.85.3"
+    react-native-blob-util: "npm:^0.24.0"
+    react-native-executorch: "workspace:*"
+    react-native-safe-area-context: "npm:~5.7.0"
+    react-native-worklets: "npm:0.10.3"
+    react-refresh: "npm:^0.14.0"
+  languageName: unknown
+  linkType: soft
+
 "big-integer@npm:1.6.x":
   version: 1.6.52
   resolution: "big-integer@npm:1.6.52"