Research Demo

Neural video,
in your browser.

The video below is a trained neural network running live on your GPU via WebGPU — no server, no codec, no runtime dependencies beyond a modern browser. Pick a video and it decodes in real time from a ~11 MB file.

750K–12M+ parameters 30–342× compression ~11 MB per video WebGPU, no server

Select a video — it loads and plays on your GPU (the first load fetches a ~11 MB file).

Research

What is NIKA?

NIKA (Neural Implicit Component Assembly) is a neural video architecture, not a fixed-size model — the paper reports configurations from ~750K to 12M+ parameters, and it scales further still. Instead of frames and codecs, the video lives as learned weights — a continuous function from time to pixels.

Most neural video methods improve quality by making the decoder larger and more expensive. NIKA takes the opposite approach: keep the decoder lightweight, and put all the video-specific capacity into a structured latent state built from complementary components — low-rank Tucker factorizations, Fourier-domain spectral features, and learned spatial grids.

The result: on UVG at ~3M parameters, NIKA achieves 33.33 dB PSNR at 462 decode FPS with only 4.5G MACs per frame — compared to 175–228G MACs for comparable NeRV-family baselines at similar quality. That's a 39–51× reduction in active compute while improving average reconstruction quality.

NIKA scales by segmentation: splitting a video into temporal segments, each with its own copy of the base architecture. More segments means more stored capacity, but the active per-frame decode path stays fixed. On Bunny, going from 1 to 4 segments (XXS → S scale) improves PSNR from 35.92 to 39.61 dB while decode speed stays at 1010 FPS.

Read the preprint

Ablation study (Bunny, ~3M params)

Variant	PSNR	Δ
Full NIKA	39.61 dB	—
Single segment	38.54 dB	−1.07
No temporal operators	38.49 dB	−1.12
Real/spatial only	37.51 dB	−2.10
Complex/spectral only	37.36 dB	−2.25
Grid components only	34.76 dB	−4.85
Tucker components only	33.61 dB	−6.00

Each latent component type contributes. The full mixed representation outperforms any single-domain variant by 2–6 dB.

Infrastructure

How the demo works

Running a PyTorch model in a browser requires more than exporting weights. Kuma is the compiler–runtime pipeline that makes it possible.

PyTorch → `.iph`

The Python compiler captures the model with torch.export, packs weights into a flat float32 blob, and bundles everything — computation graph, weights, and WGSL compute shaders — into a self-contained zip archive.

Browser loads `.iph`

Kuma, our WebGPU runtime, unzips the package, uploads weights to GPU buffers, and walks the computation graph — dispatching one WebGPU compute pass per node per inference call.

Time → pixels

A <kuma-player> web component scrubs a normalized t ∈ [0, 1] time input across the model, rendering each decoded frame directly to a canvas with no CPU round-trip.

The models above were exported with the NIKA architecture and are running entirely client-side. No inference server. No Python.

Neural video,in your browser.