Part I
What raea aims to do
Make one engine that renders anything a person can describe: a reel, a game, an app's moving parts, a document, a score. In raea they are all the same kind of thing, arrays of state stepped through time and drawn on the GPU, so one engine and one stage hold every one of them.
Own every pixel it draws, so that each frame is also data. The timeline, the structure, what perception saw in the footage and what the agent meant by each part all stay queryable after the render, because nothing was handed to a browser and lost.
Think in the same space it draws in. Shots, sounds and movements become hypervectors, long strings of bits that bind and compare in a single GPU pass, so raea can reason about what it made without a network trained on video.
Be fast and deterministic enough to check itself. Faster than real time on a laptop or a phone, and the same input giving the same pixels every time, so an agent can render, look, measure and fix in a loop, and a person can trust what comes out.
- 1
describe
- 2
write as code
- 3
render on the GPU
- 4
look and measure
- 5
change a line
↻ step 5 goes back to step 3, and only the frames that changed render again
Part II
What we believe
§1
Own the pixels.
raea doesn't borrow a browser to draw. It draws every frame itself, on the GPU, so it knows what is in every frame: the timeline, the structure, what perception saw in the footage. All of it is data raea can query, because raea made it.
A renderer that screenshots a web page owns nothing but the screenshot.
“we own the GPU and we're off of a browser and off of the CPU, we ultimately own the pixels”
the founder's notes
- —part: StatCard · bigPop={cued("two percent")}
- —caption: JUST 2 PERCENT · frame 126
- —take: cj.mov · word "two" at 31.63 s
- every pixel above is also a row raea can query
§2
Media is arrays.
Bevy keeps a game's world as columns: every position in one array, every color in another. That is how an analytics database stores a table, and it is how K, the array language finance runs on, thinks about everything.
Frames, audio, embeddings and game state are all arrays too. Once you see that, one engine can hold all of them, and the operations you need are the same few: map, reduce, compare, bind.
- 01
ECS
Bevy keeps a world as columns: every position in one array
- 02
Columnar
an analytics table: one array per field, scanned whole
- 03
K
an array language: verbs over whole arrays, read right to left
- 04
Hypervector
8,192 bits: meaning as a pattern you can XOR and count
- 05
AV1
a codec: frames as blocks predicted from blocks
§3
Hypervectors are how it remembers.
I wrote KGPU to run a small K dialect as WGSL compute shaders on the GPU, bit for bit equal to a reference interpreter on the CPU. Its first job is hyperdimensional computing: every shot, sound and movement becomes a long string of bits, and XOR, majority and rotation combine them.
Those bit strings bind what trained models see (frozen encoders like SigLIP) to what hand-built classifiers measure, in one space raea can search and reason over without training a network on video. Measured on held-out creators, this “sandwich” tells which way time runs in a clip better than V-JEPA does.
shot
sound
bound
bound: 54 of 128 bits differ. Bind again with “sound” and you get “shot” back exactly.
/ kgpu/kernels/cv_hdc.k: each row signed onto 8192 seeded hyperplanes, 256 words a row r:i%256 wd:i!256
§4
Faster than real time.
A game engine draws frames faster than your eyes need them, so a game can play at 120. Video tools then render that same kind of picture slower than it plays back.
raea renders like the game engine it is. Speed is what lets an agent check its own work: render, look, measure, change a line, render again, many times, in the time one browser render takes.
“nobody actually needs to see 120 frames per second. Yet we do.”
the founder's notes
§5
One language agents already speak.
Every model knows TypeScript, React and CSS well, and for describing pictures they are the best language there is. raea keeps them and changes what's underneath: the components describe a frame, and the engine renders it the way a game engine would.
Its surface was built in the order agents reach for things, counted over 50 compositions they wrote, so the parts they use most were the parts finished first.
“agents need to know less DSLs and random things”
the founder's notes
§6
Your device is enough.
raea runs on the GPU in your Mac and the GPU in your iPhone, with Core ML for the models. Making something shouldn't mean renting a sandbox from someone and waiting for it.
It's Rust, so it compiles to native code everywhere and can compile to WebAssembly. On the iPhone, the agent's tools already run inside Wasmtime.
“What you need is just on your device”
the founder's notes
768 floats → 8,192 bits, per frame
every layer above, per 2 s window
§7
Same input, same pixels.
raea is compiled ahead of time, its games are pure steps, and KGPU's kernels use integer arithmetic in a fixed order. A recorded play renders back to the same pixels, and a kernel on the GPU matches its interpreter on the CPU bit for bit.
Determinism is what makes an agent's work checkable. If the same request can give a different picture, you can't test it.
played live
rendered from its keys
SSIM ≥ 0.999 on every checked frame · kgpu: 0 of 1.79 M bits differ, GPU against CPU
§8
Not everything is a 9:16 video.
Video, games, documentation, desktop apps, mobile apps: each gets its own form. A game plays, a deck clicks through, a document reads, a reel has a timeline, and they all come out of the same engine onto the same stage.
“not everything is a video and in a 9x16”
void/src/app.rs
§9
The words are the clock.
Most videos are someone talking, so raea times an edit by what was said. The CJ reel's “2%” lands on “two percent”, wherever that word ends up after the cut. A cue set in seconds goes stale the first time the cut changes.
bigPop={cued("two percent")}
§10
Pictures come from the material.
raea doesn't generate images or video from a prompt. Footage is what someone filmed; motion, type and games are drawn by code; music and sound are composed for each piece, and every made sound is logged with its prompt and seed.
filmed
footage someone shot
written
motion, type and games drawn by code
composed
music and sound, prompt and seed logged
§11
Look before you show.
void watches its frames back, checks every caption against the voice and measures the mix before you see anything. A person sets the bar: a reference becomes it only after someone has watched it with sound and approved it.
“easily the best one ive seen”
media/golden/10-cj-reel/reference/APPROVED
- ✓frames against the approved referenceSSIM ≥ 0.95
- ✓loudness−14.1 LUFS · target −14 ± 0.5
- ✓captions against the voicewithin 1 frame
- ✓approved by a person, with sound16 Oct 2026
§12
A black box that speaks plainly.
I didn't come from programming. A terminal agent was the first tool that let me build anyway, and void is meant to feel like that first time: a black window you talk to, showing what it's doing in plain lines, with no shell jargon on screen.
“as simple as it felt the first time I used Claude Code in a terminal”
the founder's notes
❯land the stat card a beat earlier
Moving it to “two”, a beat before “percent”.
✓write edit.tsx · 2 lines
✓look frame 126
Part III
Where it came from
Agents got good at writing video as code, in TypeScript and React, and I liked that part. What I didn't like was what happened next: the code went to a headless browser to be rendered, one screenshot at a time. A YouTube-length edit with a lot of footage could take hours. The scope was narrow too. Those renderers make video, and only video.
Every tool I've ever made anything serious in works the other way. Premiere, Resolve and After Effects, Blender and Unreal, CapCut, even RPG Maker and Aseprite: they all lean on the GPU, and the most powerful creative systems in the world are game engines. So I started with one. raea runs on Bevy, in Rust, and an agent lives inside it.
a headless browser
- React→
- Chrome page→
- screenshot→
- encode
one screenshot a frame; video only
raea
- React→
- Bevy on the GPU→
- composite in K→
- hardware encode
5.3 ms a frame for Pong; video, games, apps
Part IV
What's still open
§13
The web, from the inside.
raea should be able to make and run websites too. The likely route: compile the engine to WebAssembly and draw with WebGPU, which Bevy and wgpu both target, so a site gets raea's renderer instead of the browser's. None of that is built yet.
- raea, in Rust→
- WebAssembly→
- WebGPU→
- a page
§14
A model that thinks in tables.
raea started as an experiment: put an agent inside a data-oriented engine and let a tabular foundation model (TabPFN) suggest what to make next. The engine worked. The suggestions are still an open question.
| window | SigLIP: product | YAMNet: speech | face | cut | next? |
|---|---|---|---|---|---|
| 0:00–0:02 | 0.12 | 0.91 | yes | — | ? |
| 0:02–0:04 | 0.64 | 0.88 | yes | 1 | ? |
| 0:04–0:06 | 0.71 | 0.12 | no | — | ? |
§15
A vision model made of bits.
If hypervectors can carry what frozen encoders see, they may be the start of a vision model and of a compression scheme that keeps meaning, not just pixels. Media is the data machines learn from, and how we render and compress it decides what they can learn.
the frame
fewer bits
fewer still