No state, so no cause.
A model sees a hostile fall. It never sees its health, its AI state or the player’s reload timer, so it has no way to learn why anything on screen happened.
In the Standard: 04 World stateMost world models learn from pixels. Under every pixel of a shipped game sits what the engine knew: depth, identity, state and intent. We capture all of it, on one clock, licensed from the studio.
Licensed at the sourceStudio paid on every saleNo SDK, no dev build, no source code
07
06
05
04
03
02
01Example frame · The Desolation · one tick, every buffer
What every capture carries
Most gameplay data is video and a log of key presses. A model trained on it has to guess depth, identity and state before it can learn how the world works, and some of what it needs was never recorded.
The engine computed every one of those answers exactly, on every frame, and threw them away.
What video and inputs cannot teach a model
A model sees a hostile fall. It never sees its health, its AI state or the player’s reload timer, so it has no way to learn why anything on screen happened.
In the Standard: 04 World stateDepth, motion and camera pose have to be estimated from the picture. Every error the estimator makes becomes training data.
In the Standard: 01 Rendering · 08 Camera and 3DA left click is Fire in a fight and Click in a menu. A log of buttons records the press and leaves the model to work out which one the player meant.
4.2× better latent-action learning from true action labels on 2.5% of the data, where distractors were present. Nikulin et al. · ICML 2025 [1]In the Standard: 03 InputsThe HUD is drawn into every frame and every sound is mixed into one track. A model learns the health bar as part of the world, and neither can be pulled apart afterwards.
+18.8% motion quality from the same clips without HUD overlays. Shen, Jin, Chen · arXiv 2026, preprint [2]In the Standard: 01 Rendering · 02 AudioAll four are in the Standard.
Train against the engine’s answers, not guesswork.
Third-party results, cited in full below. None is a measurement of ZENOS data.
ZENOS Standard 1.0 sets nine properties, one for each chapter below, and each one you can open in the files and check. Hold any gameplay dataset to the same list.
| Property | Typical gameplay data | ZENOS Standard 1.0Every capture, every tick |
|---|---|---|
| 01Rendering | The final frame, HUD burned in | Every buffer the engine drewHUDPre-HUDNormalsDepthMotion |
| 02Audio | One mixed track | The game's own mix, splitMaster MixMixer-Category Stems48 kHz OpusTick-Locked Samples |
| 03Inputs | Keys and mouse, or actions inferred from video | Every press, and what it meantKeyboardMouseGamepads60 Hz ReadingsGame ActionsAction States |
| 04World state | None, or read off the HUD | Every entity, on screen or offEntity ClassTransforms in MetresSource ValuesEvery Tracked Entity |
| 05Labels | Generated by a model, rules unseen | A locked, traceable ontology384 Label Classes97 Labels16 DomainsDefinitionsRulesProvenance |
| 06Segmentation | None, or predicted by a model | Every object, separated and classedInstance IDsSemanticPanopticBoundsObject CountsOcclusion |
| 07Pixel to entity | None | Every pixel resolves to its entityPixel-to-Entity LookupPer-Tick Entity StateCross-Frame Identity |
| 08Camera, 3D and multiview | Unknown, or estimated; one view at a time | Calibrated on every tick, synced across viewsfx · fy · cx · cyCamera PoseProjection TermsMultiview Sync |
| 09Provenance | A licence claim | Auditable to the fileEmbedded Licence IDContent Validation |
| Met in full | 0 of 9 | 9 of 9 |
metpartly metmissing
How we capture it. Every row above comes from the shipped build, with no studio integration and no lead time. PRISM reads the game while people play it, so any licensed title can meet the standard.No SDKNo Dev BuildNo Source CodeAny Engine
Why it is safe to train on. Every title is licensed from the studio that owns it, under terms both sides can point to.Per-Title LicenceStudio Revenue ShareNo-Recreation Clause
Seven buffers from one render, each 1920 × 1080 at 30 frames a second and never scaled or cropped. HUD over Pre-HUD is the frame the player saw.
Depth, Segmentation, the HUD matte and the Normals mask are lossless, so what you decode is exactly what the engine wrote. Pre-HUD on its own is the frame with no interface on it, the footage the HUD-free study above trained on [2].
Every element of the interface as colour plus an exact alpha matte, so a model can learn the screen with or without it.
CharactersProps
The master mix plus one stem per category of the game's own mixer, recorded from the engine rather than separated afterwards. Every file is locked to the capture grid: tick k starts at sample 1,600 × k, so any sound can be read against the frame and the state of the same tick.
tick 48,653−4.00 s
A game's stems are its mixer's named buses, or categories it declares by keyword. Either way the split is the engine's own, which is why a model can hear the weapon, the world and the interface as different things.
What was pressed and what it meant, on the same tick as the frame. Keyboard, mouse and up to four gamepads are read twice per tick, and beside them sits the game's own action system, recorded after its key bindings: every action, its value, and whether it was idle, pending or active.
raw delta−3, +1counts, two readings summed
Gamepads in XInput slots 0 to 3 are read the same way, with sticks and triggers as values. This player used keyboard and mouse, so the pad is idle here.
What the game understood
Actions are read after the game's own key bindings. Rebind Fire to any key or button and this row still says Fire.
Every device is read twice per tick. A key down for a single 1/60 s reading still lands in that tick's row, and mouse motion is summed from raw counts, never sampled, so a flick is never dropped or counted twice.
Actions are the game's own reading of the player, after its bindings, so intent stays readable however the controls were set. Each action's default bindings ship in the game's data beside it.
Input row k is frame k of every video and state file. No offsets to estimate, no alignment pass between what was pressed and what was drawn.
Every entity the game tracks, on screen or off, with its world transform, its class and its exact kind. Every field records the game object and path it was read from, so any value traces back to the engine. Positions ship twice: as the game stored them, and normalised to metres on one right-handed, Y-up frame, so titles from different engines line up.
The camera keeps the boss in view for all 10 s, and the state still holds five breeding eggs outside it. On tick 48,782 one egg’s Health drops to 0 and a hunter enters the state beside it, off screen. Trails show each entity’s previous 10 seconds, fading with age. The camera hangs above and behind squad 1 looking down: the light wedge is its view from above, the shaded area the ground it sees on the selected tick.
One locked vocabulary for every title: 384 label classes across 97 labels in 16 domains, each label with a written definition. Values are computed from captured state by stated rules, never by watching the pixels. Any value traces back to the game state it was computed from and the rule that computed it, on any tick.




















Horizontal gait tier.
valuesidle · walking · running · sprinting
Provenance on this tick
computed · one game field, its values mapped onto the ontology's own
Read from data_game_state.vtx at the same tick. Stamped with ontology 3.33.1 and band set blake2b:51c5753d….
Every value on these bars is computed from that tick's game state by the rule shown, with V1's band edges, so the same inputs give the same value on every run. A label made by a model can change with the model version, the prompt or the context, and nothing records why. A rule can be changed once and every hour already captured re-derives from its stored state, with no recapture.
AssertedSet by a person in the game’s label profile, for a fact that holds across the whole game, such as every level being outdoors in daytime. Fixed for the title, it never changes during play.
ComputedDeterministic logic over captured values: a game field mapped onto the ontology’s values, bands, thresholds, comparisons, deltas, state machines.
InferredAnything probabilistic, from a model or vision. Named as such, never mixed in silently.
ApplicableThe game has the system and this capture labels it, with the rule written beside it.
Not capturedThe game may have it, but this capture does not read it. Listed, so you know.
Not applicableThe game has no such system, so the column is empty.
critical · low · medium · high · full, from health as a fraction of its range. Not written while the entity is dead or respawning, so a corpse never reads as critical.
The condition of the entity itself, health, armor, shield, stamina and other gauges, life state and damage taken.
Discrete health band derived from health.percent. There is no dead band: death is vitals.life_state = dead, and 0% health bands as critical.
not written when vitals.life_state is dead or respawning
65 enum labels hold one value at a time; 32 boolean labels are independent flags. 18 are bands of a measured number, with edges fixed by the ontology so a band means the same thing in every title.
Instance, semantic and panoptic segmentation from the engine's own object-ID pass, with Bounds drawn from the same IDs. Every object in the scene is separated, classed and boxed on every frame, stable from one frame to the next and exact at the pixel.
Game entitiesProps
At training resolution · objects kept


World models usually train at 256 on the short side. Of the 113 objects in this frame, 109 keep their own ID at 455 × 256, and 109 squashed to 256 × 256.
What is where, how many, which one, and what is in front of what: the structure of the scene, separated object by object and held at low resolution.
Masks, boxes and counts with exact answers on every tick, so a model's own predictions can be scored automatically. The ground truth for self-improvement loops, at any volume.
Bounds, object counts and what hides what all fall out of the same IDs. No annotators, no detector to correct.
Every pixel resolves to the entity that drew it, and every entity resolves to its full state on that tick. The instance ID under the pixel is the key: one lookup turns a patch of colour into a player, an enemy or a door, with its health, weapon, pose and every other property the game holds. Vision and state arrive as one table, already joined.
Every mask carries the entity's class, health and weapon on that tick.
Instance IDs hold from frame to frame, so tracking needs no association step and no re-identification model.
Train a model to read state from pixels with the true state under every pixel, on every tick, in every title.
Point at any object · click to pin it here




Every tick carries the pixel intrinsics and projection of the camera that drew it, and the player camera's pose in metres. With them, depth becomes distance and every pixel goes back to where it stood in the world. Every tick is also placed on UTC from public time servers, so captures of one match recorded on different machines, in different sessions, line up to the tick and land on the same ground.
camera 1fov 34° vcamera 2fov 34° vcamera 3fov 28° vsquad 1HP 2,400squad 2HP 2,400squad 3HP 858
One moment rebuilt from the depth and camera files of three captures on three machines, each point coloured by its view's pre-HUD frame. If the intrinsics, poses or depth were off, the three views would not land on the same ground.
Three players in one match, each recorded on their own machine in their own session. Each machine's clock is checked against time.cloudflare.com and time.aws.com through the capture (diamonds: one probe every 37.5 s), and every tick carries its UTC instant with the uncertainty stated. The same moment is frame 48,773 in one file and 49,699 and 49,730 in the others, and they line up without matching sound or pictures. Bar starts and probe marks are drawn to illustrate; the frame numbers are real.
Two independent public time sources, asked throughout every capture. Each tick is stamped in UTC with its own uncertainty, so a machine's clock error never reaches the data unmeasured.
Different machines, sessions and start times land on one timeline. No clapperboard, no audio matching, no visual alignment pass.
The standard requires every capture of a shared match to be syncable this way, so several players' views join into one scene with a lookup.
A capture is a folder you can audit. The licence travels inside every file, every stream is checked for real content, and only a capture with a passed verdict is delivered. Nothing is stitched: every boundary is kept.
For every video, new + repeated + empty + nothing drawn equals total. A frame of default values is never written.
A 50/50 net revenue share with the studio. Non-exclusive.
Labs are contractually barred from training models to recreate the game.
One minute of The Desolation with every layer on this page, a readme and a notebook that opens it. Tell us who you are and we will email you your own download link, with an evaluation licence attached.
desolation-minute/
README.md
open_the_minute.ipynb
LICENSE.md evaluation licence
capture-1794415146022/ player one’s view
capture-1794415239971/ player two, same moment
each capture folder holds
manifest.json provenance, hashes
manifest_system.json capture machine
rgb.mp4
rgb_prehud.mp4
rgba_hud.mp4
depth.mp4
normal_screenspace.mp4
motion.mp4
segmentation_instance.mp4
segmentation_semantic.mp4
segmentation_panoptic.mp4
audio_master.opus
audio_stem_N.opus 22 stems
data_game_state.vtx
data_camera.vtx
data_input.vtx
data_alignment.vtx
data_system_health.vtx
data_segmentation_instance.vtx
data_segmentation_semantic.vtx
data_segmentation_panoptic.vtx
labels.parquet
Thanks for asking for the minute. Your download link is on its way to the work email you gave us. It is yours alone and works for 14 days.
Please try again, or email [email protected] and tell us what you are training.
Need more than a minute? Request the hour →
No. Video and inputs are two of the nine rows in the standard. The other seven are what the engine knew.
PRISM reads the running game at the engine level, from the shipped build. No plugins, source code or development build required.
The studio's. Every title is licensed from its studio, the studio earns from every sale, and no lab may train a model to recreate the game.
All of them, including custom in-house engines. PRISM reads the running game rather than plugging into an engine, so the engine is never the constraint.
No title has every system, so none carries every label. Each label table lists what applies to its game and what its capture read, so a gap is always stated.
Because 60 doubles what you store, move and decode, and we have not seen evidence that it trains better models. What matters at 30 is that nothing is lost. Every frame on the grid is accounted for, and every repeat states its reason. Input is read twice per tick, so even an action shorter than a tick keeps the key or button that fired it.
No. A modality list counts every variant and every option a studio integration could unlock. The standard lists what every capture carries, from the shipped build, with no SDK and no lead time. Counted line by line, the nine rows hold about two dozen streams.
The minute is for evaluation, and its licence says what you can do with it. Training data comes under a licence per order.