Future Vision / Zero Limits
Industrial Design Systems

System diagnostic / This browser

Measuring what this browser can do…

Full diagnostic

Control / Scene state

One set of values, shared live across pages and tabs. Each says what it changes on this page.

Here: phosphor colour of the screen

Presets

Here: screen clock and the key light

Here: signal trace and the terminal's sway

Appearance
All modules

Module 04 / RIVE

Rive, data-bound

The terminal's screen, alive

FVZL—FC01Module 04Live since 2026-10-11

Interactive graphics designed in a tool and driven by live data, with a small runtime and no hand-written animation code.

Why it matters
What you're looking at
The FC01's amber screen as a Rive file: the dial, the signal and the time of day are bound to its view model, and GPU Canvas wraps the screen onto 3D hardware.
Why it matters
Designers own the motion and the states; developers only feed data. Files are small, sharp at any size, and play on the web, iOS and Android from one source.
The trade-off
The 3D layer (GPU Canvas) is new and its scripts must be signed; text and layout are limited next to HTML, and debugging happens in the editor.
Fig. 04 / Live stage Open stage

Loading stage…

Module notes

The FC01 Personal Terminal's amber screen as a Rive file bound to live data: the dial, the signal and the time of day drive it. Rive's GPU Canvas wraps the 2D display onto 3D hardware.

This browser
checking…
Native path
Rive Renderer (WebGL 2) with GPU Canvas needs WebGL 2
Fallback
Canvas 2D renderer, no 3D layer needs nothing extra
Status
Live since 2026-10-11
Payload
  • Rive runtime (WebAssembly, the Rive Renderer) · 924 KB
  • The FC01 screen (fc01-screen.riv) · 267 KB
  • Screen still, until the file plays (WebP) · 83 KB
  • Rive's JavaScript · 65 KB
  • Stage code · 6 KB
Gzip over the wire · measured 2026-10-11
Budget
  • Payload 1.3 MB · budget ≤ 1.6 MB Within
  • First frame desktop 1.9 s · phone 1.5 s · budget ≤ 3.0 s Within
  • Frame rate desktop 60 fps · phone 60 fps · budget ≥ 55 fps desktop · ≥ 30 phone Within
First frame on throttled 4G (desktop) and on an iPhone · measured 2026-10-12, live, Fast 4G (tools/verify/perf.mjs); phone: Chad's iPhone, ?perf
Browser support
FeatureChromeSafariFirefox
WebGL 2 (Rive Renderer, GPU Canvas)561551
WebAssembly (the Rive runtime)571152
Canvas 2D (the fallback)43.12
First version with each feature · caniuse, 2026-10-10
Compared
Rive beside the other technologies
Tags
rendererdata-bindingmotion

Module 04 / Use it on your page

One JavaScript runtime and one .riv file. The animation, its state machine and its data bindings live in the file; your page sets values.

npm @rive-app/webgl2 2.44 (JS 65 KB + wasm 924 KB; @rive-app/canvas-lite for 2D only, about 425 KB) · one .riv (267 KB)

  1. Step 1

    Build the file

    Design in the Rive editor (here: as text, with the Rive CLI) and give everything the page will drive a view model. A file with scripting (Luau) must be exported signed, or web runtimes refuse it.

  2. Step 2

    Host the runtime yourself

    By default the runtime fetches its wasm from a CDN. Point it at your own copy; Vite's ?url import bundles the file.

    import { Rive, RuntimeLoader, Layout, Fit } from "@rive-app/webgl2";
    import wasmUrl from "@rive-app/webgl2/rive.wasm?url";
    
    RuntimeLoader.setWasmUrl(wasmUrl);
  3. Step 3

    Play it

    Give it a canvas, the file and the state machine. autoBind connects the artboard's default view model.

    const rive = new Rive({
      canvas,
      src: "fc01-screen.riv",
      stateMachines: "Screen",
      autoplay: true,
      autoBind: true,
      layout: new Layout({ fit: Fit.Contain }),
      onLoad: () => rive.resizeDrawingSurfaceToCanvas(),
    });
  4. Step 4

    Drive it with data

    Set view model properties by name. The file decides what each one does: here energy shapes the trace, the clock is text, and the colour tints the phosphor.

    const vm = rive.viewModelInstance;
    vm.number("energy").value = 0.8;
    vm.string("clock").value = "10:42";
    vm.color("phosphor").value = 0xffffb000;   // ARGB

Serving it

  • .riv is binary: serve it as application/octet-stream and gzip it (267 KB here, about half the file).
  • Call resizeDrawingSurfaceToCanvas whenever the canvas changes size (a ResizeObserver), with the pixel ratio capped.
  • Without WebGL 2, @rive-app/canvas draws the same file in 2D, without the 3D layer.
  • onLoad fires even when the view model is missing, so check rive.viewModelInstance first.

Documentation