By requesting access you agree to the Data Sample Evaluation Terms: the sample sessions and metadata in this repository are for internal evaluation only. Models trained on samples are evaluation artifacts and may not be deployed, released, or used commercially. No redistribution of the data in any form, no publication without written consent from Origin Lab, and deletion within 30 days of download — including evaluation weights, or ceasing all use of them. Access to the full corpus is licensed separately, per agreement.

PRIVATE PREVIEW. The v0.4.0 corpus is fully published; numbers are measured from the delivered packages (2026-09-20). Two titles capture at 30 FPS (disclosed per-game at release). Sample sessions are not staged in this repository yet. Do not share outside Origin Lab.

OriginLab Game Recordings v0.4.0

Human gameplay captured in-engine under per-title licenses at 1080p / 60 FPS CFR: pre-HUD and post-HUD RGB, surface normals, metric depth, audio, camera telemetry, keyboard and mouse inputs, in-engine action events and game state, and world telemetry, plus per-frame training tables. This release nearly doubles the roster to 20 games with balanced per-game hours, and adds the first Unity-engine title alongside Unreal.

Playable previews of every modality, per-game statistics and the release changelog are at app.originlab.ai/data.

Four games, side by side. Each tile is one session's mosaic: its four visual streams composed as quadrants of a single decoded video, so within a tile the streams cannot drift.


Sessions	231
Hours	175.0
Games	20
Size	≈5.8 TB
Capture	1080p / 60 FPS CFR, in-engine SDK, shared frame clock

Dataset summary

This dataset is real people playing real games, recorded from inside the engine, not from a screen capture. Every session pairs what the player saw with what the engine knew: pre-HUD and post-HUD RGB, dense depth and surface normals for every frame, game audio, the exact camera pose, every key press and mouse movement, and time-ranged labels for what was happening in the game.

The thing we sweat the most is alignment. Every stream in a session shares the same t=0: depth frame k is RGB frame k, and telemetry timestamps are milliseconds on that same clock. The frame index is the only join key: no offsets, no sync work on your side.

Against other datasets

The table compares this release with recent game and simulator datasets that publish geometry or control signals. Existing game datasets provide one of: engine-hooked depth and camera pose for a single title; player inputs or replay logs without geometry; or internet gameplay video with model-estimated depth and camera. Simulators provide dense ground truth without human play. This release covers 20 commercial titles with engine depth, camera pose, surface normals, keyboard and mouse input, game events and state, and audio on one frame clock. Optical flow and foreground masks are in progress.

Dataset	Source	Sequences	FPS	Resolution	Frames	Depth	Camera pose	Surface normals	Player input	Game events, state, text	Audio	Optical flow	Fg. masks
Origin v4 (ours)	20 commercial titles, engine hooks	231 sessions	60 / 30	1920×1080	≈34.7M	✅ engine, 10-bit metric	✅ engine	✅ g-buffer	✅ keyboard + mouse	✅ events + state fields	✅	🔧	🔧
WildWorld (ECCV 2026)	1 title (Monster Hunter Wilds), ReShade + engine hooks	3,434 clips, up to 30 min	30	1280×720	108M	✅ render buffer, 8-bit	✅ engine	❌	semantic action triplets, not input	✅ state + skeletons + VLM captions	❌	❌	❌
EgoCS-400K (2026)	1 title (Counter-Strike), replay-rendered	400K videos	?	?	10,000 h	❌	✅ replay	❌	✅ inputs + view angles	✅ events + states + language	?	❌	❌
WorldCam-50h (2026)	3 titles (CS, Xonotic, Unvanquished), screen capture	~300 videos	30	?	50 h	❌	🟡 ViPE	❌	✅ keyboard + mouse	🟡 captions	❌	❌	❌
Sekai-Game (NeurIPS 2025)	1 title (Lushfoil), UE5 hooks	60 h	30	1920×1080	6.5M	❌	✅ UE hooks	❌	❌	✅ location + captions	✅ AAC stereo, verified in files	❌	❌
OmniWorld-Game (2025)	5 AAA titles, internet video	96K clips	24	1280×720	18.5M	🟡	🟡	❌	❌	🟡 captions	❌	🟡	🟡
TartanAir V2 (2023)	63 simulator environments (AirSim / UE), no gameplay	?	?	640×640	?	✅	✅	❌	❌	✅ segmentation	❌	✅	✅ segmentation

✅ ground truth from the engine, replay or recorder · 🟡 estimated by a model · ❌ absent · 🔧 in progress · ? not stated in the source we checked.

Supported tasks

Task	Why this dataset
Depth estimation	Dense engine-rendered relative depth for every RGB frame (log-encoded, comparable across time): no pseudo-labels, no stereo reconstruction. Ideal for scale-invariant / ordinal MDE.
World models & video prediction	Long, continuous sessions with dense action and camera conditioning signals.
Imitation learning	Frame-level keyboard/mouse actions paired with what the player saw.
Camera pose & ego-motion	Per-frame 6-DOF camera extrinsics straight from the engine.

Sampled frames

UMAP embedding of SigLIP features for 24,254 sampled frames from both releases (hollow: v0.3.0; filled: v0.4.0; colour: title); nearby points are visually similar frames. The interactive version shows the recorded frame and engine depth for 3,032 of the points and lists each title's contribution scores from the next section.

Games

Titles are anonymized for licensing; real titles are disclosed under the full-dataset agreement.

One bar per title, one segment per session, from metadata/sessions.parquet. Ten titles carry over from v0.3.0; ten are new. 2 sessions have incomplete index entries (hatched): duration from the frame accounting, size estimated from the title's bytes per hour.

Contribution of each title

Each title's contribution is a leave-one-out Vendi score (Friedman and Dieng, 2023): the drop in the effective number of distinct frames when the title is removed, divided by the drop when the same number of random frames is removed from the other titles. A ratio of 1.0 equals random footage of the same size; above 1.0 the title holds frames the rest of the corpus lacks. It is computed on SigLIP embeddings of the RGB frame (appearance) and of the engine depth map (geometry, independent of colour and art style).

Game 15 and Game 3 add mainly appearance (depth ratios 0.39 and 0.90); Game 12 and Game 7 mainly geometry (RGB 0.79 and 1.02); Game 6, Game 2, Game 17 and Game 11 both; Game 16 little of either. Game 8 (RGB 1.00) is covered by Game 10. Game 18's depth ratio is affected by the depth-unit issue under Considerations.

Scene coverage, v0.3.0 to v0.4.0

Both releases are placed on one map: SigLIP features projected onto nine terrain prompts (those of the v0.3.0 card) and reduced with a single UMAP fit; equal samples (9,170 frames per release, 20 draws) are binned on a 40×40 grid. Left and centre: per-cell share of each release; right: v0.4.0 minus v0.3.0. Blank frames (0.5%) are excluded; labels are zero-shot.

v0.4.0 occupies 1,105 cells to v0.3.0's 1,055; 82 cells are new, and each of the 33 cells no longer occupied is adjacent to an occupied v0.4.0 cell. The overlap of the two distributions, Σ min(p₃, p₄), is 0.68 and does not depend on the grid.

Camera motion

Camera motion from the engine pose over 210,285 three-second windows: translation speed, angular rate and a rule-based motion class. References: OmniWorld-Game (estimated pose, 2,085 windows) and RealEstate10K (structure-from-motion, rotation only, 663 windows). Median angular rate is 23.3°/s against 12.9 and 4.5; effective motion classes 3.63 of 6 against 1.83. Estimation noise inflates the reference rates, so the gaps are lower bounds.

Dataset structure

One folder per session, eighteen files grouped by modality (video/, depth/, telemetry/, tables/), no archives to unpack, plus telemetry/gameclock.jsonl where the title exposes a readable clock. A 1-hour session measures about 35 GB: four video renditions (≈31 GB), the depth stream (≈3.8 GB), and roughly 200 MB of telemetry and tables. Everything the capture recorded ships decomposed — there is no container to parse.

There are no predefined train/validation/test splits: the release ships as whole sessions, and metadata/sessions.parquet is the per-session index (anonymized game label, duration, sync status, byte counts) from which to cut your own.

Data files and fields

File	Purpose
`video/prehud.mp4`	1080p H.264 high profile, 60 FPS CFR, HUD removed, in-engine capture with game audio
`video/posthud.mp4`	The frame exactly as the player saw it, HUD included, on the same 60 FPS clock
`video/normals.mp4`	Per-pixel surface orientation rendered by the engine (world frame), same clock
`video/mosaic.mp4`	The four visual streams composed as quadrants of one video — a playable sync proof, not extra data
`video/mosaic_layout.json`	Which mosaic quadrant holds which stream
`depth/depth.hevc`	10-bit HEVC elementary stream, log-encoded relative depth
`depth/depth_meta.jsonl`	Per-frame depth params: depth_transform, range, FOV
`depth/decode_contract.json`	Session decode contract: near plane (makes depth metric), pinhole intrinsics, per-stream frame accounting (fps, dup counts), and the world frame
`telemetry/camera.jsonl`	Camera pose keyed by frame index and QPC (≈2 samples per frame): position, pitch/yaw/roll
`telemetry/input.jsonl`	Mouse (position and dx / dy deltas), keyboard (key_down / key_up with modifiers), scroll, and window-focus events, frame-indexed
`telemetry/events.jsonl`	In-engine action events: a schema kind (weapon_fired, enemy_killed, item_pickup, ...) plus the engine's own label, frame-indexed
`telemetry/state.jsonl`	Sampled game state (health, active tool, ...): field, unit, and value per sample, frame-indexed
`telemetry/annotation.jsonl`	AI mechanic-detection intervals (label, category, confidence) where available
`telemetry/world.json`	World telemetry: engine, world-to-meters scale, handedness, gravity
`telemetry/gameclock.jsonl`	In-game clock samples, where the title exposes a readable clock (roughly two thirds of sessions)
`telemetry/inventory.jsonl`	One record per changed inventory slot (toolbar or bag) with item id, resolved item name, count, ammo, and decay, frame-indexed
`telemetry/quest.jsonl`	One record per quest or objective change with resolved quest and objective names, progress / goal, and state, frame-indexed
`telemetry/ability.jsonl`	One record per ability or stat change with resolved name, level, value, and state, frame-indexed
`tables/frames.parquet`	One row per video frame, training-ready: camera pose, held-keys bitmask, mouse deltas, state columns, and event flags, all pre-joined on the frame index
`tables/events.parquet`	One row per in-engine event with resolved labels
`tables/conversion_manifest.json`	Every binning rule and cap used to build the tables, so they are re-runnable
`session.json`	Manifest: files + sizes, fps, the shared-clock alignment statement, frame accounting, and the sync audit (sync_status / sync_report)

What is new vs v0.3.0

	v0.3.0	v0.4.0
Games	10	20, balanced to at most 10 h per game
Engines	Unreal	Unreal + the first Unity title
Inventory	not captured	per-slot changes with resolved item names (`telemetry/inventory.jsonl`)
Quests	not captured	quest / objective changes with progress and state (`telemetry/quest.jsonl`)
Abilities	not captured	ability / stat changes with level and value (`telemetry/ability.jsonl`)
Game state fields	30	36 (adds ui_screen, activity_state, weather, radiation_level, body_temperature, stance)
Event kinds	74	76 (adds item_dropped, heal_received)

Coverage varies by title: a game only emits the streams its engine integration supports, and each session's manifest counts what it carries.

In-engine events & game state

Action events are recorded in-engine on the shared frame clock and carry a stable schema kind. On Unreal titles the event also carries the engine's literal function label; on Unity titles events come from memory polling with canonical kinds and the label field is null. Game state is sampled continuously; the tables pre-join both onto the per-frame grid.

// telemetry/events.jsonl: in-engine action events (frame on the shared clock)
// (illustrative records: labels carry the engine's literal function name)
{"frame":203057,"qpc":1200000000001,"kind":"weapon_fired",
 "source":"ue_processevent","confidence":255,"unit":"raw",
 "arg_i":0,"arg_f":0.0,"label":"OnPrimaryFireShot"}
{"frame":203399,"qpc":1200000005702,"kind":"enemy_killed",
 "source":"ue_processevent","confidence":255,"unit":"raw",
 "arg_i":1,"arg_f":0.0,"label":"HandleTargetDeath"}

// telemetry/state.jsonl: sampled game state (continuous polling)
{"frame":0,"qpc":2333965391459,"field":"health",
 "source":"memory_poll","unit":"normalized_0_1","value":1.0}
{"frame":8811,"qpc":2334112289031,"field":"active_tool",
 "source":"memory_poll","unit":"raw","value":3}

Dataset creation

Consenting, compensated players record long sessions with our in-engine SDK, guided by a proprietary direction process. Depth and camera state are read from the engine at capture time, so depth is a measurement, not an estimate. Depth ships byte-identical to capture, never re-encoded. Before a session ships, an automated audit measures RGB-to-depth alignment across the whole session: a session certifies when the measured lag holds within a frame, and any session measured beyond that is withheld. Footage too static to measure ships marked unverified rather than certified, and sync_status in the metadata says which.

How to use it

Requires ffmpeg and numpy. RGB is H.264 mp4. depth/depth.hevc decodes with ffmpeg -f hevc to gray16le; the value is log-encoded relative depth (0 = near, max = far), comparable across frames. Train on the encoded value directly, or on 1 − value as nearness; converting to linear depth compresses near-heavy scenes toward 0. Mask value == max (sky and far clip). Frame k of one stream is frame k of every other. tools/load_session.py shows the full decode; it uses the flat v1 filenames, so point it at the video/, depth/ and telemetry/ paths above.

# depth_transform = 2  (logarithmic), K = 4000
# luma: 0..65535 (ffmpeg gray16le) or 0..1023 (raw 10-bit); normalize to [0,1]
import numpy as np
K = 4000.0

def decode_depth(luma):                       # luma: uint array from the HEVC frame
    q = luma.astype(np.float32) / 65535.0     # /1023.0 if you read raw 10-bit
    d = (2.0 ** (q * np.log2(1.0 + K)) - 1.0) / K
    return d            # relative depth in [0,1]: 0 = NEAREST, 1 = farthest

valid = luma < 65535    # value == max => sky / far clip: undefined depth, mask out of losses

# METRIC: multiply by near_plane_cm from depth/decode_contract.json. This is planar Z
# (along the optical axis), not Euclidean ray distance.

What is in this repository

The full corpus lives in this repository — request access with the form above and download directly.

sessions/<uuid>/ — the complete release: one folder per session, exact delivery layout (231 sessions, 175.0 hours, ≈5.8 TB).
metadata/sessions.parquet — the session index (anonymized game labels, duration, sync status, byte counts). This is what the dataset viewer renders.
metadata/files.parquet — the per-session file manifest (names and sizes), so you can audit any download against what this card advertises.
samples/<uuid>/ — a handful of quick-start sessions (a subset of sessions/).
assets/previews/ — the mosaic preview.
tools/ — the session loader, OLDT depth extractor, and a parallel resumable downloader.

Pull one session:

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="originlab/game-recordings-v4",
    repo_type="dataset",
    allow_patterns=["metadata/*", "sessions//*"],
    local_dir="./",
)

Drop allow_patterns to pull the whole corpus — transfers resume and already-complete files are skipped.

Alternative delivery

Teams on AWS can request manifest-based in-cloud delivery instead: a signed list of every file with links valid for seven days, consumed by tools/download_dataset.py (multi-connection, resumable). Contact Origin Lab after approval.

Considerations for using the data

Mechanic annotations are model-generated with confidence scores; coverage and label vocabulary vary by title.
Depth comes from the engine's depth buffer, so translucent effects (fog, glass, particles) follow how the engine renders them.
Sessions are guided free play: a proprietary direction process steers players through open-ended missions and challenges to maximize action diversity and minimize redundancy, so the action distribution is broader than natural play. Idle and menu time still occurs and is flagged in the annotations where detected.

Stream coverage by title: Game 19 has no input stream; Game 3 has no events or state; Game 6 has no state; Game 17 and Game 7 log fewer than 100 events per hour.
Depth units: the near-plane constant in the decode contract differs from the encode-time value on all Game 18 and Game 20 sessions, and on the Game 10, Game 8 and Game 14 sessions that record 10 cm where their siblings record 0.85 or 3 cm. Treat depth on those sessions as relative, not metric.
Depth range varies by genre and player behavior: many frames are near-field dominant and rarely reach the far plane. Sample or weight for depth-range diversity if your model needs far content.
Personal and sensitive information: audio is game audio from the title process — no microphone or player voice is captured — and no personally identifying information about the players ships in any stream or metadata file.
In this distribution, game-identifying strings are redacted from the text sidecars: the title value of window_focus input events (the foreground window's literal title) and any occurrence of a real game title in the JSON/JSONL files. The events and fields themselves remain, so game-focus spans and decode contracts stay usable; redaction slightly shrinks those text files relative to the sizes recorded in metadata/files.parquet. Media files are byte-identical to delivery.

Licensing

All gameplay is recorded under non-exclusive licenses with the rights holders and captured by consenting, compensated players.

Samples in this repository ship under the Data Sample Evaluation Terms accepted when you request access: internal evaluation only. You may inspect the samples and train models with them to judge their effect; models trained on samples are evaluation artifacts and may not be deployed, released, or used commercially. No redistribution, no publication without written consent, and deletion within 30 days of download, including evaluation weights or ceasing all use of them.

The full dataset is licensed per agreement, with production training and deployment rights defined in your contract. Contact Origin Lab to license.

See LICENSE.md for the complete terms.

Sources and methods for the figures

Comparison table: transcribed from each dataset's paper or repository (WildWorld, arXiv 2603.23497; EgoCS-400K, 2606.18180; WorldCam-50h, 2603.16871; OmniWorld, 2509.12201; Sekai, 2506.15675; TartanAir V2, tartanair.org). Audio checked with ffprobe on released files, 2026-09-21: WorldCam-50h has no audio stream; Sekai-Game carries AAC stereo; OmniWorld-Game releases PNG frames; the others follow their cards. Our depth is stated in engine units; sessions whose near-plane constant disagrees with their title's other sessions are excluded from metric claims.

Figures: SigLIP base (224 px) embeddings of RGB frames and of depth maps rendered as grey images on a fixed log scale, 0.1 to 100 m. UMAP: n_neighbors 25, min_dist 0.15, fixed seed. Vendi: 2,048 frames per draw, two draws, two random-removal baselines per draw, kernel exp(−d/0.10) on cosine distance.

Citation

@misc{originlab2026gameplaycore,
  title  = {OriginLab Gameplay-Core: Frame-Synced RGB-D Gameplay with
            Actions, Camera Pose, and Mechanic Annotations},
  author = {Origin Lab},
  year   = {2026},
  url    = {https://app.originlab.ai}
}

Downloads last month: 201

Total file size:

5.95 TB