ROWBench: Do Video Models Render What the Program Specifies?
Zheng-Hui Huang, Guixu Lin, Yu-Ju Tsai, Jian-Kai Zhu, Fengbo Lan, Yu-Lun Liu, Yung-Yu Chuang, Kaipeng Zhang and 1 others
Alaya Lab
Published October 1, 2026 · on the feed October 2, 2026 · ▲ 66 · arXiv 2610.02205
The abstract
Programmable world models separate executable dynamics from visual generation, offering a promising foundation for next-generation game engines. However, their visual adherence to explicit rules and interactions remains insufficiently evaluated. Existing benchmarks assess visual quality, controllability, and instruction or physical adherence, but rarely test fidelity to fine-grained, program-specified world events. We introduce PROWBench, comprising 170 programmatically constructed episodes and 600 proxy videos covering diverse scenes and interactions. PROWBench logs entity states and timestamped events, including those outside the camera's field of view, as replayable world records, from which it renders synchronized views and proxy representations. This enables generated videos to be checked against the observable consequences of program execution. An extensible framework constructs scenes, controls behaviors, and can render each camera view in different representations, such as coarse 3D, and bounding boxes. The benchmark covers first- and third-person perspectives, with synchronized multi-view observations available for a subset of episodes. Grounded in these records, PROWBench evaluates entity control, long-horizon memory, and, with two VLM-based metrics, Logic-Render Alignment and Interaction Success Rate, adherence to the prescribed timeline and the visual realization of timestamped engine-recorded events.
The Brief
2:26A short podcast summary of the paper. Written and voiced by AI.
Transcript
ROWBench. Do Video Models Render What the Program Specifies?. By Zheng-Hui Huang and eight others, from Alaya Lab. Published on the first of October. Its code repository is a placeholder: a readme, and nothing to run yet.
Programmable world models split executable dynamics apart from visual generation, which makes them a promising foundation for the next generation of game engines. How faithfully their visuals follow the explicit rules and interactions of the program has not been evaluated well. Existing benchmarks look at visual quality, controllability, and adherence to instructions or to physics. They rarely test whether a video matches fine-grained world events that a program specified. If the program says a door opens at a certain moment, existing benchmarks rarely check that the video shows the door opening then.
The benchmark, written PROWBench in the abstract, checks generated videos against the observable consequences of program execution. It evaluates entity control and long-horizon memory. Two further metrics, both based on vision language models, cover timing and events: Logic-Render Alignment measures adherence to the prescribed timeline, and Interaction Success Rate measures whether timestamped events recorded by the engine are actually realised on screen.
PROWBench holds one hundred and seventy programmatically constructed episodes and six hundred proxy videos, covering diverse scenes and interactions. Each episode logs entity states and timestamped events as a replayable world record, including events outside the camera's field of view. From those records it renders synchronized views and proxy representations. An extensible framework builds the scenes, controls behaviours, and can render any camera view in different forms, such as coarse 3D or bounding boxes. Both first-person and third-person perspectives are covered, and a subset of episodes adds synchronized multi-view observations.
The abstract reports no results for any model. It describes what the benchmark measures and how it is built, but not what it found when video models were put through it, so there are no scores to relay here. Whether current models render what the program specifies, the question in the title, is left for the paper itself to answer.
A world record logged by the engine works as a script the video is supposed to follow, down to events off camera. Grading a generated video against that script asks a narrower and stricter question than whether it looks good: did it show what the program said happened. Because the record also holds what happened out of view, even memory can be checked, against events the camera never saw.
Paper Quest · 7 chapters · about 37 min
Play this paper
Learn it by doing: make the calls the authors made, guess the result before you see it, and defend it in a viva graded on your own words. Chapter 1 is right here.
Chapter 1 🧩 · The problem
A program can be perfectly right while its video is quietly wrong. How would you catch it?
You run a game where a program decides everything: who moves where, when a door opens, who wins a fight. A video model draws what happens.
The road ahead
- 1 · The problem ~6 min When a program runs a game world and a video model draws it, existing benchmarks rarely check that the video shows what the program actually did.
- 2 · What came before ~3 min
- 3 · The key idea ~9 min Log what the program does as it runs, render matching inputs from that log, then check each generated video against it.
- 4 · Choose your own research ~3 min
- 5 · Build the method ~8 min Build episodes from a program, log them as world records, render views and proxies, then check generated videos against the record.
- 6 · Field test ~3 min
- 7 · The viva ~5 min Three questions from the examiners, answered in your own words. Win it for the paper’s trophy.
Free, with Google or an email address. Your stars and progress are kept.