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 memoryOwnership 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.