Recorded sessions of real players, paired with engine data exported from Unity replays. Each recording includes video with and without UI, audio, depth, surface normals, motion, camera telemetry, entity telemetry, action inputs, and gameplay events.

All visual modalities share a zero-based frame index at 1920 × 1080 and 30 FPS constant frame rate: depth frame k is RGB frame k. Structured telemetry joins to the same frames, providing aligned observations, actions, and world state. The export combines what the player saw with camera, geometry, and gameplay signals from the engine.

Dataset Preview

View sample video on the Dataset Preview page.

Recording durations

Video duration	Recording count	Total duration (HH:MM)
10 – 30 minutes	96	26:37
30 – 60 minutes	26	18:40
Over 60 minutes	11	12:24
Total	133	57:41

Overlapping recordings

127 of the 133 recordings (95.5%) have connection intervals that overlap another recording on the same server. All such overlaps occur on uk-1, covering approximately 10 hours 14 minutes with at least two concurrent connections and a peak of 21 concurrent connections.

Dataset source

The dataset is designed to be anonymous. Sessions are de-identified: player nicknames are replaced with session-specific identifiers, and chat text is obfuscated. Unredacted chat is available under a commercial licence only.

The source is server-recorded play rather than independently annotated video. Replaying the sessions in Unity produces the videos and corresponding engine signals.

What you can train

Application	Signals
World models and video prediction	Video, actions, camera motion, and entity state
Imitation learning	Player observations paired with normalised action inputs
Depth and normal estimation	RGB paired with engine depth and surface normals
Camera pose and ego-motion	Camera pose, calibration, and velocity
Entity tracking and spatial reasoning	Entity identities, classes, transforms, and screen-space bounds
Gameplay-event prediction	Interaction modes, locations, progress, and game events

Dataset structure

Each recording occupies one directory named [UTC]_[serverName]_[session], containing four videos, three per-pixel archives, and eight structured data files. The recording metadata filename is the directory name plus .json. index.csv combines all the recording metadata .json in one file.

File	Contents
`camera+ui+audio.mp4`	1080p, 30 FPS CFR player-view video with UI and audio
`camera+audio.mp4`	Corresponding video without UI, with audio
`camera+bbox.mp4`	Entity-box visualisation; inspection only, not for training
`thumbnails.mp4`	Half-size 2 × 2 camera/depth/normals/motion grid; inspection only, not for training
`depth.tar.zst`	Per-frame linear-eye planar depth, `R16_UNorm`
`normals.tar.zst`	Per-frame view-space normals, octahedral `RG8_UNorm`
`motion.tar.zst`	Per-frame image-space motion
`<recording>.json`	Recording metadata, durations, and gameplay statistics; basename matches the directory
`general.json`	World, image, and signal conventions
`camera.jsonl`	Camera pose, motion, cuts, and calibration
`entities.json`	Entity IDs, names, models, classes, local centres, and half-extents
`entities.jsonl.gz`	Per-frame entity state and screen-space information
`events.jsonl`	Chat, interaction modes, locations, game information, and progress
`input.jsonl`	Normalised actions and typing
`edits.jsonl`	Source-time intervals removed during export

Video and audio quality

Video is encoded with NVIDIA's hardware H.264 encoder using the High 4:4:4 Predictive profile and 8-bit YUV 4:4:4. Colour information is retained at full pixel resolution rather than subsampled, helping preserve fine coloured edges and UI text. Constant quantisation at QP 12 applies a low quantisation setting instead of targeting a fixed bitrate, allowing bitrate to vary with scene complexity. These settings prioritise very high visual quality and minimise compression artefacts.

The Zstandard archives preserve the stored, quantised engine buffers losslessly.

Audio is recorded directly from the game as stereo 48 kHz WAV and encoded as stereo AAC at 192 kbps.

Depth-rendering behaviour

Depth comes from the engine's depth buffer. Translucent effects such as fog, glass, and particles follow how the engine renders them, so their appearance in RGB may differ from what is represented in depth.

Data fields

Field or signal	Meaning
`frame`	Zero-based association with video and per-pixel data
`t`	Output time in milliseconds: `round(frame * 1000 / frame_rate)`
`gt`	Server game clock in milliseconds; used to align overlapping recordings on the same server
`seq`	Stable sorting key across JSONL streams
Entity `id`	Joins per-frame entity state to the static catalogue
`type`	`camera`, `camera_params`, `spatial`, `event`, or inputs. Each `type` contains additional parameters

World coordinates use metres and Unity's left-handed, Y-up, +Z-forward convention. Images have a top-left origin. Entity telemetry includes transforms, world centres, engine reported velocities, and screen-space projected bounding boxes.

Inputs describe a shared action space across keyboard/mouse, gamepad, and touchscreen. WASD movement is reported as stick; key and mouse event names represent logical actions. For example, space is jump and e is push. Camera look uses mouse_move deltas, clicks/taps use interaction coordinates, and typing is reported as Unicode strings.

Example JSONL records

These examples are taken from DATA_FORMAT.md. Each line is a separate JSON object.

A camera pose and velocity record from camera.jsonl:

{"type":"camera","frame":1,"t":33,"gt":3062337,"seq":16,"px":-5.473,"py":32.967,"pz":97.805,"yaw":12.719,"pitch":48.066,"roll":0.0,"vx":2.432,"vy":-0.043,"vz":-1.692,"avx":0.58,"avy":3.572,"avz":-0.094}

Camera position is in metres, orientation in degrees, linear velocity in metres/second, and angular velocity in radians/second.

A spatial event from entities.jsonl:

{"type": "spatial", "frame": 3, "t": 100, "gt": 12504187, "seq": 30, "id": 899, "px": 20.807, "py": 20.035, "pz": 84.210, "cx": 20.797, "cy": 20.920, "cz": 84.211, "vx": 0.000, "vy": 0.000, "vz": 0.000, "yaw": 90.000, "pitch": 0.000, "roll": 0.000, "avx": 0.000, "avy": 0.000, "avz": 0.000, "sx": 0.391, "sy": 1.000, "sz": 0.391, "screen": {"center_x": 0.4995, "center_y": 0.5072, "center_in_view": true, "min_x": 0.4878, "max_x": 0.5111, "min_y": 0.4153, "max_y": 0.5924, "bounds_in_view": true}}

We provide 3d center world position and screen-space bounding box in addition to standard pose and engine reported velocity. Join the stable id with entities.json for additional information, such as 3d extents and semantic classification.

A progress event from events.jsonl:

{"type":"event","frame":44928,"t":1497600,"gt":4559904,"seq":712920,"kind":"progress","level_name":"RedLightGreenLight","level_number":1,"money_earned":5000}

Camera look, movement, and jump actions from input.jsonl:

{"type":"mouse_move","frame":61,"t":2033,"gt":3064370,"seq":796,"dx":3,"dy":0}
{"type":"stick","frame":2517,"t":83900,"gt":3146220,"seq":13332,"x":0.0236,"y":-0.8504}
{"type":"key_down","frame":4995,"t":166500,"gt":3228833,"seq":26565,"key":"space"}
{"type":"key_up","frame":4999,"t":166633,"gt":3228967,"seq":26602,"key":"space"}

mouse_move contains camera-look deltas; stick contains normalised movement. The space action represents jump, including equivalent gamepad and on-screen controls. These examples illustrate separate records from the specification, not one contiguous excerpt.

How to use it

Join modalities by frame, and apply the current camera calibration when decoding geometry. Stream the sequential .tar.zst archives into memory rather than extracting whole recordings to disk.

The example below reads recording metadata, streams JSONL (including gzip), and pairs sequential RGB frames with raw depth, normals, and motion payloads.

from pathlib import Path
import gzip
import json
import tarfile

import av
import zstandard as zstd


def jsonl(path):
    path = Path(path)
    opener = gzip.open if path.suffix == ".gz" else open
    with opener(path, "rt", encoding="utf-8") as stream:
        for line in stream:
            if line.strip():
                yield json.loads(line)


def archive_frames(path):
    with open(path, "rb") as source:
        with zstd.ZstdDecompressor().stream_reader(source) as decoded:
            with tarfile.open(fileobj=decoded, mode="r|") as archive:
                for member in archive:
                    if member.isfile():
                        with archive.extractfile(member) as payload:
                            yield payload.read()


def rgb_frames(path):
    with av.open(str(path)) as video:
        for frame in video.decode(video=0):
            yield frame.to_ndarray(format="rgb24")


recording = Path("path/to/[UTC]_[serverCommonName]_[sequence]")
metadata = json.loads(
    (recording / f"{recording.name}.json").read_text(encoding="utf-8")
)
camera = jsonl(recording / "camera.jsonl")
inputs = jsonl(recording / "input.jsonl")
entities = jsonl(recording / "entities.jsonl.gz")

streams = (
    rgb_frames(recording / "camera+audio.mp4"),
    archive_frames(recording / "depth.tar.zst"),
    archive_frames(recording / "normals.tar.zst"),
    archive_frames(recording / "motion.tar.zst"),
)
for frame, (rgb, depth_raw, normals_raw, motion_raw) in enumerate(
    zip(*streams, strict=True)
):
    # Decode raw buffers using DATA_FORMAT.md and current calibration.
    # Consume telemetry records matching this frame for training.
    pass

DATA_FORMAT.md supplies NumPy decoders, frame grouping, and machine-learning pipeline examples.

Quality criteria

Included recordings have:

At least 10 minutes of retained video.
No more than two inactivity edits.
At least one death or completed level.

Licensing

This dataset is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0), as declared on its Hugging Face repository. You may use, copy, redistribute, and adapt the dataset for non-commercial or commercial purposes, provided you give appropriate credit to Wonderful Worlds, include a link to the licence, and indicate any changes made.

See the full CC BY 4.0 licence for the terms.

Citation

@misc{wonderfulworlds2026multiplayer,
  author       = {{Wonderful Worlds 5G Ltd}},
  title        = {{Wonderful Worlds Multiplayer Game Recordings}},
  year         = {2026},
  howpublished = {Hugging Face dataset},
  url          = {https://huggingface.co/datasets/wonderfulworlds/multiplayer-456guys-sample}
}

Want more?

24 August – 7 November 2026 summary

Video duration	Recording count	Total duration (hours)
10 – 30 minutes	27,919	7,559
30 – 60 minutes	3,918	2,613
Over 60 minutes	1,129	1,912
Total	32,966	12,084

Contact dataset@wonderfulworlds.io to license the entire 12k+ hrs dataset.

Cloud-based interactive Agent Gym also available.

Downloads last month: 173

Total file size:

5.36 TB