Datasets:

originlab
/

frame-synced-multiplayer

license: other
license_name: origin-lab-data-license
license_link: LICENSE.md
pretty_name: Origin Lab Frame-Synced Multiplayer
task_categories:
  - reinforcement-learning
  - robotics
  - depth-estimation
  - image-to-video
annotations_creators:
  - machine-generated
source_datasets:
  - original
tags:
  - video
  - multi-view
  - multi-agent
  - multiplayer
  - world-models
  - video-prediction
  - imitation-learning
  - embodied-ai
  - physical-ai
  - game-agents
  - theory-of-mind
  - collaborative-perception
  - slam
  - rgbd
  - metric-depth
  - camera-pose
  - action-labels
  - game-engine
  - frame-synchronization
  - licensed-data
  - origin-lab
size_categories:
  - n<1K
extra_gated_heading: Request access to Origin Lab Frame-Synced Multiplayer
extra_gated_prompt: >-
  Two access tracks, defined in LICENSE.md. Track A, Internal Evaluation: 90
  days to train and evaluate models internally to assess the data. No obligation
  to publish anything. Track B, Non-Commercial Research: research use with
  attribution; publish freely. Under both tracks there is no commercial use, no
  deployment, and no redistribution in any form. Commercial licensing requires a
  direct agreement with Origin Lab: originlab.ai/hf.
extra_gated_fields:
  Name: text
  Organization: text
  Work email: text
  Access track:
    type: select
    options:
      - Track A, Internal Evaluation (90 days)
      - Track B, Non-Commercial Research
  Intended use: text
  I agree to the terms of my selected track in the LICENSE file: checkbox
configs:
  - config_name: matches
    data_files: metadata/matches.parquet
    default: true
  - config_name: timesync
    data_files: matches/*/timesync.parquet
  - config_name: visibility
    data_files: matches/*/annotations/visibility.parquet

Origin Lab Frame-Synced Multiplayer: Eight Players, One Frame Clock

Six to eight players, each on their own PC on residential internet, each recording their own live view of one match, and frame k on every machine is the same server instant, verified four independent ways, with the verification script in this repo. Every player ships the full engine stack at 1080p / 60 FPS on one shared frame grid. Because the alignment is measured rather than assumed, the release also ships per-frame cross-player annotations: who has whom in view, at what angle and distance, and who is being watched without knowing it.

Version 0.2.0. Single title, four arena maps, 3v3 and 4v4.

One match, one frame clock: six players' synchronized views, with their camera telemetry (position and 90° view frustum) rendered on the minimap below at the same server instants. When two frustums cross on the minimap, you watch it happen in the video tiles.


Matches	16 (ten 6-player, six 8-player)
Player-sessions	108
Player-hours	108.0
Size	~3.8 TB
Shared grid frames	3,454,524
Engine events	377,079
View-crossing intervals	73,676
Titles	1 (anonymized; disclosed under agreement)
Capture	1080p / 60 FPS CFR, in-engine SDK, one shared frame clock across machines
Delivery	everything in this repository (~3.8 TB): all video, depth, telemetry, alignment, annotations, tools. Selective download by path prefix

Watch full playable previews of every modality, side by side and in sync, at app.originlab.ai/data.

Dataset summary

This dataset is a multiplayer companion to game-recordings-v3: each player folder is the same eighteen-file session layout, recorded with the same in-engine SDK, and everything v3 ships per session, this release ships six to eight times over per match. What is new is the relationship between the sessions. Multi-view gameplay datasets to date are replay-rendered: one demo file re-rendered per viewpoint, synchronous by construction because there is only one clock, and the real client-side frames, input timing, and depth are lost. Here six to eight independently-clocked consumer PCs on residential internet each capture their own live view of a shared match, and the synchronization is achieved and then measured. A scheduled start pins every machine's frame grid to one server instant, per-machine clock rates are calibrated before capture and re-checked every minute during it, and the worst validated player pair in the release slides 0.44 frames over a full hour. Most matches hold under a quarter frame.

Because the alignment is measured rather than assumed, the release can ship what no single-view dataset has: per-frame cross-player annotations. For every ordered player pair at every grid instant, the data records whether one player holds the other in view, with angular offset, screen position, and distance, plus interval events built on top (mutual sight, first sight, blindside). All of it is computed deterministically from the engine's own camera pose; no annotators were involved.

Supported tasks

Task	Why this dataset
Multi-agent world models & video prediction	Up to eight adversarial viewpoints of one live scene with per-frame depth and pose: reproject one player's view into another's and measure the agreement. Public multi-agent gameplay corpora that we are aware of top out at two cooperative agents; pointers to others are welcome in Discussions.
Imitation learning & game agents	Every opponent's observation and action is recorded, not just the ego player's: opponent-conditioned policies, team coordination, and offline evaluation against real human adversaries.
Theory of mind & joint attention	Frustum-geometric labels for "A has B in view; B does not have A in view", computed from engine camera pose. Occlusion is not resolved in the shipped labels; the depth maps are what refining them into true line-of-sight requires.
Collaborative BEV perception	Six to eight synchronized egocentric RGB-D streams with per-frame pose observing one shared scene: the on-foot analogue of cooperative-perception benchmarks, with BEV occupancy derivable directly from depth and pose. No LiDAR or 3D boxes ship.
Collaborative SLAM & 3D reconstruction	Posed RGB-D video from multiple agents covering one arena (6,000 to 15,000 m² per match) from different viewpoints: cross-agent loop closure, sub-map fusion, and multi-view-consistent geometry, with engine depth and pose as ground truth.
Player-behavior modeling	Verified-human aim with synchronized camera pose, target visibility, and hit events: a legitimate-behavior baseline with geometric ground truth that server-side logs cannot supply.
Depth, pose & ego-motion	Every per-session task v3 supports, per lane: dense engine depth for every RGB frame, per-frame 6-DOF camera extrinsics, frame-level actions.

Matches

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

Match	Map	Players	Hours	Size (GB)	Sync (worst pair)	Engine events	Crossings	Coverage (m²)
game7-6p-0078	arena-a	6	1.0	210	0.28 frames	46,132	3,443	6,320
game7-6p-0081	arena-b	6	1.0	211	0.22 frames	31,517	3,488	6,112
game7-6p-0087	arena-a	6	1.0	210	0.20 frames	39,471	3,914	6,356
game7-6p-0090	arena-a	6	1.0	210	0.30 frames	40,080	3,150	6,224
game7-6p-0092	arena-b	6	1.0	210	0.23 frames	23,244	3,774	6,000
game7-8p-0093	arena-b	8	1.0	280	0.34 frames	16,008	6,416	6,104
game7-6p-0094	arena-b	6	1.0	211	0.19 frames	43,074	4,059	6,064
game7-8p-0095	arena-b	8	1.0	279	0.18 frames	23,845	7,317	6,112
game7-6p-0096	arena-c	6	1.0	210	0.23 frames	21,946	3,081	7,356
game7-8p-0097	arena-c	8	1.0	279	0.21 frames	11,713	4,264	7,812
game7-6p-0098	arena-c	6	1.0	210	0.20 frames	10,043	2,723	8,232
game7-8p-0099	arena-c	8	1.0	279	0.44 frames	12,928	4,984	8,072
game7-6p-0100	arena-d	6	1.0	209	0.17 frames	17,620	4,095	15,616
game7-8p-0101	arena-d	8	1.0	281	0.23 frames	11,579	7,603	14,580
game7-6p-0102	arena-d	6	1.0	210	0.19 frames	12,510	4,480	13,596
game7-8p-0103	arena-d	8	1.0	281	0.27 frames	15,369	6,885	15,268

Matches span four arena maps in two team formats (3v3 and 4v4); every match certifies within half a frame across all player pairs.

Dataset structure

One folder per match: match.json (manifest and QA), timesync.parquet (the cross-player frame lookup), one players/pNN/ folder per player each holding the standard eighteen-file session layout, plus match-level sync/ (fold tables, live residuals, anchor solve, aim-sweep evidence) and annotations/. A six-player hour measures about 210 GB; an eight-player hour about 280 GB. No splits are imposed. For comparable results we suggest holding out game7-8p-0103 and game7-6p-0096 (one per team format, distinct arenas) as test matches; metadata/matches.parquet carries the map column for map-disjoint splits of your own.

Modality	Files	Notes
Pre-HUD RGB	`video/prehud.mp4`	1080p / 60 FPS CFR, clean render
Post-HUD RGB	`video/posthud.mp4`	the frame exactly as the player saw it
Surface normals	`video/normals.mp4`	camera-space, same clock
Metric depth	`depth/depth.hevc` + `depth_meta.jsonl` + `decode_contract.json`	frame k is RGB frame k
Mosaic preview	`video/mosaic.mp4` + `mosaic_layout.json`	four streams, one decode
Camera telemetry	`telemetry/camera.jsonl`	pose and orientation at render rate
Keyboard & mouse	`telemetry/input.jsonl`	raw events, frame-indexed
Engine action events	`telemetry/events.jsonl`	kills, damage, jumps, weapon events
Game state	`telemetry/state.jsonl`	sampled in-engine state
Game clock	`telemetry/gameclock.jsonl`	where the title exposes one
Training tables	`tables/frames.parquet`, `tables/events.parquet`	pre-joined on the frame index

Time model

Four named time domains, each mapping's accuracy published: qpc_raw → qpc_corrected → server_time_us → frame_grid_index (see metadata/time_domains.md). timesync.parquet is the only sanctioned cross-player frame lookup: capture gates during game loading screens carry per-machine durations, so linear frame arithmetic across players is invalid on gated matches. The shipped table gives the exact mapping, with an in_pause flag per player per instant.

Cross-player annotations

Computed from the engine's camera pose, with no annotators or models in the loop, and regenerable with your own thresholds (tools/crossings.py; definitions in each file header). Three tiers: dense per-frame visibility (in_frustum, angular offset, screen position, distance, confidence), interval events (sees, mutual_sight, crossing, first_sight, sight_break, and blindside, where one player holds another in view unreciprocated), and per-frame interaction graphs. Visibility is frustum-geometric: occlusion is not resolved (no world geometry ships), and the depth maps are exactly what refining in_frustum into true line-of-sight requires.

Verify the sync yourself

Every synchronization claim on this card is re-derivable from shipped artifacts:

python tools/verify_sync.py --match game7-6p-0081

Four independent evidence chains ship per match:

Clock fits: pairwise grid slide from ten-second clock samples. Across all 318 player pairs in the release (15 per 6-player match, 28 per 8-player), the worst pair lands at 0.44 frames (7.3 ms) over 60 minutes, and most matches hold under a quarter frame.
Live residuals: each recorder refits its clock every minute during capture, so the claim is falsifiable mid-match, not just after the fact.
Event bookkeeping: every kill and damage event exists on two machines off one server tick. Solving all pairwise offsets as an over-determined system yields per-machine anchors with ±6–9 ms error bars.
Aim geometry: at each matched hit, the attacker's camera ray (from its own telemetry) must point at the victim's position (from the victim's telemetry). Median aim error collapses to 1.4° only at true alignment, across roughly 4,800 matched events per match, and the consistent −70 to −100 ms optimum is the game's lag-compensation window, measured from the data itself.

Dataset creation

Consenting, compensated players record live matches with our in-engine SDK. Capture starts on a scheduled server instant established per session by a min-RTT clock handshake; each machine's clock rate is calibrated against its recording history before capture and monitored throughout, and the frame grid ticks on the corrected clock. Depth and camera state are read from the engine at capture time, so depth is a measurement, not an estimate. Before a match ships, the four-chain audit above runs across every player pair, and a match certifies only when all pairs hold within half a frame. Of 18 matches captured for this release, 16 certified and ship; 2 were withheld for missing the half-frame gate.

How to use it

from datasets import load_dataset

matches = load_dataset("originlab/frame-synced-multiplayer", "matches")
timesync = load_dataset("originlab/frame-synced-multiplayer", "timesync")
visibility = load_dataset("originlab/frame-synced-multiplayer", "visibility")

Videos and depth are plain files under matches/*/players/*/ in the standard v3 layout, so the v3 loader and depth decode pattern apply per lane, and per-modality selective download works by path prefix (telemetry only, one player only). To align anything across players, join through timesync.parquet on frame_grid_index.

What is in this repository

The complete release:

matches/*/players/pNN/: every player-session in the standard eighteen-file v3 layout — video renditions, depth, telemetry, training tables (~3.8 TB total, LFS).
metadata/matches.parquet: the match index (map, players, duration, sync status, event and crossing counts). This is what the dataset viewer renders.
matches/*/timesync.parquet and matches/*/annotations/: the full alignment tables and cross-player annotations.
matches/*/sync/: the complete verification evidence per match.
assets/previews/: the preview GIFs above. assets/plots/: residual and pairwise-alignment figures.
tools/: verify_sync.py, the crossings generator, and the fold-table reader.

Use huggingface_hub.snapshot_download with allow_patterns for selective pulls (one match, one player, telemetry only). Teams on AWS can request direct in-cloud delivery instead.

Considerations for using the data

Cross-player visibility is frustum-geometric; occlusion is not resolved. The shipped depth maps support refining it into true line-of-sight.
Camera telemetry is emitted at each machine's render rate (roughly 90–320 Hz here) with occasional dropouts; gridded pose carries a gap_masked flag and is never interpolated.
Absolute wall-clock alignment is bounded at ±120 ms by the network handshake; all sub-frame claims are relative cross-player alignment, which is what the shared frame grid provides.
Capture pauses during game loading screens, with per-machine durations. Use timesync.parquet for any cross-player lookup; frame arithmetic alone is not valid on gated matches.
Game titles are anonymized as "Game N" in the public metadata; real titles are disclosed under the full-dataset agreement.
Players and personal data. No microphone or player voice is captured; audio is game audio from the title process only. No legal names, contact details, faces, or biometric data ship in any stream or metadata file. Post-HUD video may show player-chosen in-game display names in scoreboards, kill feeds, and similar UI; these are pseudonymous handles. Every player recorded consented in writing and was compensated, under agreements that cover distribution and licensing of these recordings. Pre-HUD RGB carries no HUD and therefore no display names, so a name-free lane ships for every player in every match. Licensees may not attempt to identify any player (LICENSE.md, clause 8).

License

Origin Lab Data License (LICENSE.md). Two tracks; select one when requesting access.

Track A, Internal Evaluation. 90 days to train and evaluate models internally in order to assess the data. Origin Lab does not require you to publish or open-source anything you train. Delete at the end, or convert to a commercial agreement.
Track B, Non-Commercial Research. Research use with attribution. Papers, open weights, and benchmarks are welcome.

Under both tracks: no commercial use, no deployment, and no redistribution of the data in any form. Any commercial use of the data, or of a model trained on it, requires a direct license from Origin Lab: originlab.ai/hf.

All gameplay is recorded under license from the rights holders by consenting, compensated players.

Citation

@misc{originlab2026framesync,
  title  = {Origin Lab Frame-Synced Multiplayer: Multi-Player Gameplay on One
            Verified Frame Clock with Cross-Player Annotations},
  author = {{Origin Lab}},
  year   = {2026},
  url    = {https://huggingface.co/datasets/originlab/frame-synced-multiplayer}
}