Skip to content
← All writing

01. Platform Runtime

Hyperion Core: Sandboxed In-Browser WebAssembly Compute Engine

Engineered a zero-copy memory pooled execution runtime utilizing WebAssembly SIMD and SharedArrayBuffer worker meshes. Enables users to compute vectorized financial forecasts and spatial graph transforms completely client-side at 12 million operations per second without freezing the UI thread.

TypeScriptJavaScript

Rendering a financial forecast or a spatial graph transform has always forced a choice: run the heavy math on the main thread and freeze the UI, or ship it to a server and accept the latency, the cost, and the offline story that comes with it. Hyperion Core is my exploration of a third path — a sandboxed WebAssembly runtime that keeps the entire workload in the browser.

Architecture at a glance

The runtime is a small mesh of cooperating layers. Each layer owns one responsibility, and the boundaries between them are where the performance comes from.

  • a worker mesh that executes batched instructions off the UI thread
  • a zero-copy linear-memory pool that the mesh and the UI agree on
  • vectorized SIMD kernels for the hot math
  • a control plane that schedules batches and hands results to native rendering

The zero-copy memory pool

The core idea is that bytes never move — ownership does. The pool is a single region of linear memory partitioned into arenas. Consumers ask for a view, the pool hands back the same memory the kernels wrote to, and nothing is copied along the way.

// Exiting the pool hands back a typed view — no intermediate allocation.
const arena = pool.acquire(size);
const forecast = pool.as<f32>(arena);

kernels.run(forecast);          // writes in place
render(forecast, arena);        // reads the same memory
Ownership moves between layers; the bytes never do.

Batching for SIMD

Kernels process work in fixed-size batches instead of per-item calls. Fixed batch shapes let the compiler emit vector instructions across lanes, which is what makes the numbers work out.

for (let i = 0; i < batch; i += LANES) {
  const v = simd.load(forecast, i);
  simd.store(forecast, i, simd.compute(v));
}

Sharing memory across a worker mesh

A SharedArrayBuffer backs the pool, so every worker in the mesh maps the same linear memory. Dispatching work means passing offsets into shared memory, not serializing payloads. That is what lets the mesh fan batches out to workers and collect results without a copy on either side.

Keeping the UI thread free

The control plane is the only piece the main thread talks to. It schedules batches against the mesh, tracks ownership of arenas, and hands finished results straight to native rendering. The main thread is never blocked because the main thread never touches the math — its whole job is deciding what to render next.

The performance envelope

On its target workloads — vectorized financial forecasts and spatial graph transforms — the engine sustains roughly 12 million operations per second, entirely client-side. The UI thread stays interactive throughout, because the pipeline produces no allocations, no copies, and no main-thread hops.

This project sits at the intersection of the things I keep returning to: memory layout, concurrency primitives, and what the platform gives you for free when you respect its grain.