World Models, Scaled: V-JEPA 2.1 on Eight Chimera Cores
Last month we ported Meta's V-JEPA 2.1 world model to a Chimera core in an afternoon, and our Kernel Arena made it more than twice as fast in a day and a half. Then we asked how much further it could go. Chimera scales by adding cores, and our SDK splits a model across them in software. In our simulator, with each core given its own memory bandwidth, the same V-JEPA code runs 6× faster on eight cores, with output identical to one core.
Written by Jacques van Rhyn and Gang Li

Last month we ported Meta's V-JEPA 2.1 world model to Chimera. Agents working from our SDK skills had the full encoder running on our simulator about an hour and a half after the first prompt, and the Kernel Arena made it more than twice as fast in a day and a half. One QC-Ultra core ended up watching 23 clips a second, from a model that hadn't run on our chip a few days before.
That left an obvious question: how much further could it go? Chimera is built to scale: a chip can carry several identical cores, and because they're programmable, our SDK can split one model across them in software. We've already done this for NVIDIA's Alpamayo driving model on four cores and the pi0.5 robot model on eight. V-JEPA was the obvious next candidate.
We moved it from one QC-Ultra core to eight. The model, its weights and its accuracy checks didn't change at all. In our simulator, with each core given its own DDR bandwidth, V-JEPA now watches 138 clips a second, six times as many as on one core. On our test clip, its output is bit-identical to the single-core result. Chimera was designed to scale, so adding cores only meant updating the model's kernels.
How one clip is split
On one core, a clip takes 61.4 million cycles, and almost all of it is matrix multiplies and attention. Giving each core its own clip would raise throughput, but each clip would still take as long. A robot needs to understand what its camera just saw as quickly as possible, so instead, all eight cores work on the same clip together.

The work in one clip on one core, from the simulator's profile: the work the eight cores divide between them.
V-JEPA cuts a 16-frame, 256 × 256 clip into 2,048 patches and runs them through 12 transformer blocks. Each block has an attention step, where every patch looks at every other patch, and a two-layer MLP.

The whole encoder runs on the GPNPU as one program. The host only decodes the video and collects the tokens.
On eight cores the work divides like this:
- Most layers are split by patch. Each core takes 256 of the 2,048 patches.
- The first MLP layer, the largest matrix multiply in the block, runs on a 2 × 4 grid of cores, split by patch and by output column.
- Attention is split into four groups of heads, and each group into two halves of the queries.
- After each step, the cores synchronize before starting the next one.
None of this is built into the hardware. Because Chimera is programmable, the split lives in the kernels: they know how many cores they're built for and divide the work to match. The same program runs on one core or eight, and on our test clip the two give the same output, bit for bit.
The results
Measured on our cycle-accurate instruction-set simulator with our current SDK. Each QC-Ultra core has 16 MB of on-chip memory and 16 MACs per processing element, runs at 1.4 GHz, and gets its own 128 GB/s of DDR read bandwidth and 128 GB/s of write bandwidth, the simulator's default:
| 1 core | 8 cores | |
|---|---|---|
| cycles per clip, full 12-block encoder | 61.4 million | 10.2 million |
| latency per clip | 43.9 ms | 7.25 ms |
| clips per second | 23 | 138 |
| speedup | 6.05× |
(One core is a little slower than the 43.5 ms in our last post, which was measured on SDK 26.10. Most of the difference is the move of our kernel compiler to LLVM 21, which cost about 1% on one core and 0.3% on eight.)
Eight cores get us just over 6×, not far off the 8× you'd get if nothing were lost to coordination. Each transformer block scales about 6×. The input stage, which turns the clip's pixels into patches, is harder to split and scales about 4.7×.

Left: the full encoder on our current SDK. Right: each kernel's speedup, measured on the first block on SDK 26.10. Attention, a third of the work, scales best.
Eight cores have enough throughput to start a new clip on every frame from four 30 fps cameras. Each clip takes 7.25 ms once it starts, so four clips arriving at the same moment finish in about 29 ms, before host processing.
Same answer on one core or eight
On many accelerators, changing how work is split changes the order in which numbers are added up, and that changes the last few bits of the output. The difference is tiny, but it makes results harder to compare from one configuration to the next.
On the full-encoder demo clip, the eight-core output matched the one-core output bit for bit on every token. That's by design: every kernel splits the work by patch or by output column and never splits a sum, so each number is added up in the same order on one core or eight. Both configurations had the same mean token cosine similarity of 0.9996 against the floating-point model.
What memory decides
The 6× assumes each core gets its own 128 GB/s of DDR read bandwidth and 128 GB/s of write bandwidth, our simulator's default, or about 1 TB/s each way across eight cores. More cores need more data, and how well they scale depends on how much bandwidth feeds them.
We also measured the opposite case, with all eight cores sharing a single 128 GB/s for reading and 128 GB/s for writing. There the first block, with the input stage, scales 2.1× instead of 5.7×.

The same eight cores and the same kernels, fed two ways. Measured on SDK 26.10.
Today every core reads its own copy of most of the weights, and every kernel reads its input from DDR and writes its output back. Together the eight cores read about 185 MB for the input stage and the first block, where one core reads 105 MB.
Both of those are software, so both can be fixed in software. The first MLP layer already splits its weights across a grid of cores so that each core reads only its share; the same treatment for the other matrix multiplies cuts the duplicated reads. Keeping each core's patches on chip between kernels cuts the round trips to DDR. We'll report the shared-bandwidth numbers as those changes land.
For a chip designer, this makes core count and DDR bandwidth one decision rather than two.
Built to scale
The Chimera architecture scales the way software does: add cores, keep the code. If you're sizing a chip for world models, or for whatever comes after them, we'd love to model your workload with you.