Render — code-defined video
Render turns a declarative Scene — HTML, CSS, audio, and captions — into a voiced, captioned, alpha-capable video. The open reference renderer runs locally today; the hosted, agent-callable pipeline is in preview behind the same gateway that meters everything else on WAVE.
Most "video as code" stacks ask you to operate a renderer. You pick a framework, you stand up the compute, you wire the audio yourself, and when you need a transparent overlay you find out the format won't carry alpha. The hard part was never drawing a frame — it was carrying a whole production through one consistent surface, and paying for it the same way every time.
Render is WAVE's answer. You describe a Scene — plain HTML and CSS, an audio track, a caption file — and Render gives you back a finished video: voiced, captioned, and alpha-capable. The same Scene produces the same frames every run. The open reference renderer runs on your machine today; the hosted, agent-callable pipeline is in preview, behind the same gateway as the rest of the platform.
The takeaway
A Scene is data, not a program you babysit. Render compiles that data into a deterministic, voiced, alpha-capable video — open and local today, and (in preview) callable by a person or an agent through the same metered gateway as everything else on WAVE.
A Scene is the input
The unit of work is the Scene IR — an open protocol, not a WAVE-only file. At its simplest it's dimensions, a duration, some markup, and the media that goes with it:
{
"width": 1280, "height": 720, "fps": 30, "durationMs": 3000,
"html": "<div class='card'>Hello WAVE</div>",
"css": ".card{position:absolute;inset:0;display:grid;place-items:center;font:700 64px Georgia;color:#0a84ff;animation:in .6s ease forwards}@keyframes in{from{opacity:0;transform:translateY(20px)}}",
"audio": { "src": "voice.mp3" },
"captions": { "vtt": "captions.vtt" }
}
Because the surface is HTML and CSS, anything that can emit a Scene can drive Render — a hand-written file, a design tool, a template factory, or a model. You are not writing renderer code; you are describing what the frame should be.
What it does that a renderer-library doesn't
The differences are the point, so here they are plainly. Render takes plain HTML and CSS, not a single framework's component model — so any front-end can produce a Scene. Audio is first-class: the voice track is part of the Scene, and narration can drive the clip's duration rather than being bolted on after. Captions come through as a real text track from a WebVTT, burned in where the renderer supports it. And alpha is a true output — ProRes 4444 with transparency preserved, the format an editor or a live switcher actually expects for an overlay.
It is also safe by construction. Render treats the markup it's handed as untrusted: network egress is deny-by-default, so a Scene can't be turned into a server-side request forgery against your own infrastructure. That's a property you want the moment a Scene comes from somewhere you didn't write — a customer, or an agent.
Run it today
The reference renderer is BSL-1.1 — free for individuals and for organizations under $1M in revenue, converting to Apache-2.0 on its Change Date — and it runs locally right now:
npm install npx playwright install chromium npm run build # one Scene → an MP4 and an alpha ProRes in a single pass node dist/cli.js render scene.json --mp4 out.mp4 --alpha out.mov
What the hosted pipeline adds
The hosted, agent-callable pipeline — the same renderer running on WAVE's edge compute — takes the same scene.json over the gateway and returns the same two artifacts, metered per call. It's in preview today; the local renderer above is what's open and available now.
Where it fits
Render isn't a standalone tool bolted to the side. It's a surface on the same platform as everything else, and it leans on the parts that are already live.
The Media Engine carries transports behind one API, so a clip Render produces can be delivered without a rewrite. The gateway at api.wave.online already carries auth, entitlement, and metering once, for every product — so when the hosted pipeline graduates from preview, Render is priced and paid for exactly like a transcript or a transport, with no separate billing to build.
Callable by an agent, not just a person
That's what makes Render interesting in the agent economy. A deterministic video API is something an autonomous agent can actually use: it sends a Scene, it gets back a known-good artifact, and it pays per call through the same x402-metered gateway a human does. No dashboard, no seat, no human in the loop — a Scene in, a video out, the meter ticking once.
The point
The interesting thing about Render isn't that you can describe a video in HTML — plenty of tools let you describe a video in something. It's that the description is open, the output is deterministic and alpha-capable, and the call is metered by the same engine that bills the rest of the platform. That's what turns "render a video" from a project you operate into a primitive you call — whether you're a person writing a Scene by hand, or an agent generating ten thousand of them.
The reference renderer Read the docs
✦a Scene in, the same frames out — every time