Two access tracks (see LICENSE.md). Internal Evaluation License: 90-day
internal evaluation, no publication or release obligation, no deployment or production use; delete or
convert at the end. Full dataset / commercial: production training and deployment rights per agreement
with Origin Lab. No redistribution of the data in any form.

Origin Lab Game World Scans: Posed RGB-D Sweeps of Frozen Game Worlds

Work in progress. Session files are uploading now and this card is being finalized. The full release is scheduled for October 13, 2026; until then the file tree, the metadata and the numbers below can still change.

102 hour-long scans of 16 game worlds with the world frozen and the camera moving. Each session is one named world, swept by a trained operator with the player hidden and simulation time stopped: a full turn from the center, a perimeter flight, then close orbits of individual structures. Every frame carries the engine's own metric depth, world-space normals and camera pose on one 60 FPS frame clock, so consecutive frames are true multi-view observations of a scene that does not change. Nothing here was reconstructed after the fact.

For sparse-view 3D reconstruction, novel view synthesis, camera-conditioned generation and world models, and metric depth and normal estimation.

Version 2.0.0

Four worlds, side by side. Each tile is one session's mosaic: clean RGB, post-HUD RGB, world-space normals and depth as quadrants of a single decoded video, so within a tile the streams cannot drift.


Sessions	102
Hours	86.1
Worlds	16 games, anonymized as Game N
Size	~3.4 TB
Capture	1920x1080, 60 FPS constant, in-engine SDK, one shared frame clock
Camera	free camera, player hidden, world time stopped
Delivery	whole sessions under `sessions/<uuid>/`, no archives to unpack

Dataset summary

This is game footage recorded from inside the engine with the camera detached from the player and the world paused. What ships is not a reconstruction of each flight but its ground truth: the pose the engine rendered each frame with, the depth buffer it computed, the surface normals it shaded with, and the intrinsics it projected through, all on the same frame index as the pixels.

Every stream in a session shares one frame clock. Ticks that any stream failed to capture are dropped from all of them before delivery, so frame k of the RGB, normals and depth files is the same instant, and line k of depth/depth_meta.jsonl carries depth_frame = k. Join on depth_frame, not on position, and the pairing stays correct even if a future revision drops ticks: join depth on its depth_frame and you never need to know. Every session in this release certifies on that frame accounting.

Supported tasks

Task	Why this dataset
Sparse-view 3D reconstruction	Exact per-frame extrinsics and intrinsics with metric depth over a scene that holds still for the whole session.
Novel view synthesis	Long, smooth trajectories that circle the same structures from many distances and heights.
Camera-conditioned generation and world models	Dense posed frames over unbroken hour-long flights, with the camera path as the only thing that moves.
Monocular and metric depth, normal estimation	Engine depth and world-space normals on every frame, with the near plane and intrinsics written per session in the decode contract.

Capture protocol

Each session covers one named world of its game (a district, a biome, an interior) for up to an hour. The operator flies a free camera at reduced speed while the game runs with the player model hidden and world time stopped, following a fixed scan order:

A slow full turn from the center of the area.
A flight along the perimeter at mixed heights.
Close orbits around individual objects and structures.

Every session was reviewed by hand for camera coverage and stream quality before it was accepted, then audited automatically for capture stalls, duplicate frames and stream completeness.

Composition

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

Game	Sessions	Hours	Size (GB)
Game 2	3	3.0	100
Game 3	6	4.7	160
Game 4	9	9.0	309
Game 5	5	5.0	168
Game 6	5	5.0	173
Game 7	5	5.0	168
Game 8	10	10.0	493
Game 9	8	8.0	491
Game 10	2	2.0	66
Game 11	5	5.0	165
Game 12	9	7.1	268
Game 13	11	5.4	209
Game 14	9	3.0	135
Game 15	2	2.0	69
Game 16	8	6.8	279
Game 17	5	5.0	192

Measured over the delivered packages (session.json frame accounting):

	Across the 102 sessions
Frames	18.6 million on the shared clock
Median session	60.0 minutes, unbroken
Depth coverage	100% of RGB frames carry a depth frame
Pose coverage	99.2% of frames, never below 94.8% in a session
Depth grid	1920x1080 in 63 sessions; 960x540 to 1536x864 internal render grids in the other 39
Duplicate frames	median 6% per stream, worst session 46% (depth), 39% (RGB)

The capture grid is constant-rate: when a tick has no fresh frame the encoder repeats the previous one, and depth/decode_contract.json counts those repeats per stream under frame_accounting.<stream>.dup_count. Filter or downweight on it rather than assuming every frame is fresh. Depth is captured at the title's internal render resolution; read width and height from the decode contract per session and reproject through its intrinsics rather than assuming one resize.

Dataset structure

One folder per session under sessions/<uuid>/, grouped by modality, no archives to unpack. A one-hour session measures about 35 GB. metadata/sessions.parquet is the session index the viewer renders and metadata/files.parquet lists every delivered file with its size.

File	Purpose
`video/prehud.mp4`	1080p H.264, 60 FPS CFR, HUD removed, with game audio
`video/posthud.mp4`	The frame as the screen showed it, HUD included, same clock
`video/normals.mp4`	Per-pixel surface orientation in the world frame
`video/mosaic.mp4`	The four visual streams as quadrants of one video, a playable sync proof
`depth/depth.hevc`	10-bit HEVC elementary stream, log-encoded planar Z, frame k is RGB frame k
`depth/depth_meta.jsonl`	Per-frame depth parameters, keyed by `depth_frame`
`depth/decode_contract.json`	Near plane (makes depth metric), pinhole intrinsics, transform constants, frame accounting, world frame
`telemetry/camera.jsonl`	Camera pose by frame index and QPC, position and pitch/yaw/roll
`telemetry/pose_render.jsonl`	The pose each depth image was rendered with, where the SDK records it
`telemetry/input.jsonl`	Keyboard, mouse deltas, scroll and window focus: the operator's camera control
`telemetry/events.jsonl`, `telemetry/state.jsonl`	In-engine events and sampled game state, few by design with time stopped
`telemetry/world.json`	Engine, world-to-meters scale, handedness, gravity
`tables/frames.parquet`	One row per frame: pose, held-keys bitmask, mouse deltas, state columns
`session.json`	Manifest: files and sizes, fps, the alignment statement, frame accounting, sync audit

How to use it

from huggingface_hub import hf_hub_download, snapshot_download
import pyarrow.parquet as pq

REPO = "originlab/game-recordings-free-camera-v2"
sessions = pq.read_table(hf_hub_download(REPO, "metadata/sessions.parquet", repo_type="dataset"))
snapshot_download(REPO, repo_type="dataset", local_dir="./game-world-scans",
                  allow_patterns=["metadata/*", "sessions/a6055c38-a796-458d-b635-2cef9a13021d/*"])

Depth ships as a plain HEVC stream. Read its luma with ffmpeg -f hevc -i depth.hevc -vf extractplanes=y -pix_fmt gray10le -f rawvideo -, which gives the exact codes 0-1023, then decode with the constants in that session's depth/decode_contract.json:

import json
import numpy as np

contract = json.load(open("depth/decode_contract.json"))
tc = contract["transform_constants"]
K, far, sky_min = tc["K"], tc["far_plane_encode"], tc.get("sky_min_code10", 1022)
max_valid = tc.get("max_valid_code10", 1020)
near_cm = contract["near_plane_cm"]

def decode_depth_cm(code):                    # code: 10-bit luma (gray10le)
    q16 = np.where(code >= max_valid, max_valid * 64, code * 64 + 31.5)
    rel = ((1 + K) ** (q16 / 65535) - 1) / K  # in [0,1], proportional to distance
    cm = rel * far * near_cm                  # planar Z along the optical axis
    return np.where(code >= sky_min, np.nan, cm)   # NaN = sky / far clip

More previews of every modality, side by side and in sync, are at app.originlab.ai/data.

Considerations for using the data

World time is stopped, but some titles keep animating particles, foliage or water while frozen; treat those regions as non-static.
The player model is hidden; HUD elements still appear in video/posthud.mp4 and are absent from video/prehud.mp4.
Depth comes from the engine's depth buffer, so translucent effects such as fog, glass and particles follow how the engine renders them.
Worlds are anonymized as Game N in the public metadata; real titles are disclosed under the full-dataset agreement.
Personal and sensitive information: audio is game audio from the title process, no microphone or operator voice is captured, and no personally identifying information about the operators ships in any stream or metadata file.
Game-identifying strings are redacted from the text sidecars: the title value of window_focus input events and any occurrence of a real game title in the JSON and JSONL files. Media files are byte-identical to delivery.

Licensing

All footage is recorded under exclusive licenses with the rights holders and captured by consenting, compensated operators. Access is gated; request the track you need in the access form:

Internal Evaluation License: 90-day internal evaluation, train and evaluate models solely to assess the data's value. No publication or release obligation, no deployment or production use. At the end of the period, delete the data and evaluation weights, or convert to a commercial agreement.
Full dataset / commercial: production training and deployment rights defined per agreement. Contact Origin Lab to license.

No redistribution of the data in any form. See LICENSE.md for the complete terms.

Citation

@misc{originlab2026gameworldscans,
  title  = {Origin Lab Game World Scans: Posed RGB-D Sweeps of Frozen Game Worlds},
  author = {Origin Lab},
  year   = {2026},
  url    = {https://huggingface.co/datasets/originlab/game-recordings-free-camera-v2}
}

Related datasets from Origin Lab

game-scenes-posed-rgbd, posed RGB-D flythroughs of game worlds, the first release of this capture protocol.
game-recordings-v4, frame-synced RGB-D gameplay with actions, events and game state.
game-depth, RGB paired with the engine's dense depth buffer.
frame-synced-multiplayer, eight players on one frame clock.

Downloads last month: -

Total file size:

1.77 TB