README.md

---
license: cc-by-nc-4.0
task_categories:
  - image-to-video
  - depth-estimation
  - robotics
language:
  - en
tags:
  - benchmark
  - multi-view
  - 4d
  - world-model
  - video-generation
  - 3d-point-tracking
  - point-trajectories
  - camera-pose
  - depth
pretty_name: VP-WorldBench
viewer: false
size_categories:
  - 1K<n<10K
---

# VP-WorldBench

VP-WorldBench is a **multi-view 4D benchmark for video world models**, created as part of the **Video-Point Model (VPM)**
project ([paper](https://arxiv.org/abs/2610.06940) · [project page](https://rootyjeon.github.io/video-point-model/) ·
[code](https://github.com/vpm-project/VPM)). It tests whether generated videos stay consistent across views and move
like the real 3D scene.

It has 1,200 synchronized multi-view clips in four subsets: simulated and real, robot and general scenes. Every clip
comes with:

- 🎥 **synchronized multi-view videos** (2–4 views)
- 📷 **camera intrinsics and per-frame world-to-camera poses** of every view
- 📍 **ground-truth 3D point tracks** with per-view visibility (256–1,536 points per clip)
- 📝 **language captions**
- 🗺️ dense **depth** for Simul-Robot, Simul-General and Real-General, plus subset-specific **labels**: object and robot
  labels, joint actions, person masks and 2D/3D keypoints, and quality flags

<img src="https://huggingface.co/datasets/rooty2020/VP-WorldBench/resolve/main/assets/example.png" width="100%">

*Rows from top: Simul-Robot, Simul-General, Real-Robot, Real-General. Each row shows all views of one clip at the same
instant.*

## Subsets

| subset | source | clips | views | fps | resolution | frames / clip | 3D points / clip | depth |
|:--|:--|--:|--:|--:|:--|:--|:--|:--|
| **Simul-Robot** | Unreal Engine, GR1T2 humanoid tabletop pick & place | 500 | 3 | 20 | 1280×1280 | 81–680 | 768–1,536 | rendered |
| **Simul-General** | CARLA, pedestrians (332) and vehicles (168) seen by following cameras | 500 | 4 | 15 | 1280×1280 | 81–181 | 256 | rendered |
| **Real-Robot** | RB-Y1 dual-arm robot with dexterous hands, teleoperated, ego + exo cameras | 100 | 2 | 15 | 1280×720 | 139–325 | 768 | – |
| **Real-General** | one person in a 47-camera capture studio, 4 selected views | 100 | 4 | 15 | 1024×768 | 150 | 937–1,061 | reconstruction |

All clips are test clips.

## Ground truth

| subset | 3D tracks | visibility | depth |
|:--|:--|:--|:--|
| Simul-Robot | exact: surface samples of the replayed objects and of the robot links | renderer depth test | rendered |
| Simul-General | exact: skinned surface samples of the followed agent | depth test against the rendered depth | rendered |
| Real-Robot | forward kinematics of the measured joints (arm + hand surface points), time-aligned to the video | robot self-occlusion | – |
| Real-General | pseudo-GT: surface tracks triangulated from up to 46 views (median 1.6 mm cross-validation error) + body-model tracks | z-buffer against the per-frame reconstruction | multi-view reconstruction |

All 1,200 clips pass the toolkit's deep validation:
- every video frame and depth image decodes;
- every per-clip file matches its checksum;
- cameras and track invariants (visible ⊆ in-frustum ⊆ valid) hold;
- depth agrees with the tracks.

Known caveats are machine-readable in `sample.json` `flags`, with their rules in `attributes.flag_rules`. Examples are
a target hidden in a view at the conditioning frame, or a manually fitted head-camera extrinsic on Real-Robot.

## Dataset Structure

```
VP-WorldBench/
├── README.md
├── index.json                       # one record per clip: attributes, flags, frame counts, query counts
├── assets/example.png
└── <Subset>/                        # Simul-Robot, Simul-General, Real-Robot, Real-General
    ├── _source/                     # subset-level provenance (Real-General: caption process and accuracy)
    └── <clip_id>/
        ├── sample.json              # metadata, provenance, attributes, quality flags, file checksums
        ├── videos/view{k}.mp4       # H.264, one file per view
        ├── cameras.npz              # K (V,3,3), w2c (V,T,4,4)
        ├── tracks3d.npz             # xyz (T,N,3) metres, valid (T,N), in_frustum / visible (T,N,V), groups, parts, kinds
        ├── captions.json            # caption (+ instruction / time-segmented captions / structured attributes)
        ├── depth/depth.zip          # 16-bit PNG per view and frame (Simul-*, Real-General)
        ├── labels/                  # subset-specific labels
        └── source/                  # original per-clip files (provenance)
```

**Conventions.**
- The world frame is right-handed, in metres, with +z up.
- Cameras use OpenCV axes and world-to-camera matrices for every view and frame.
- Intrinsics refer to the stored video, with integer pixel coordinates at pixel centres.
- Depth is planar camera z.

The full specification is in
[`docs/DATA_FORMAT.md`](https://github.com/vpm-project/VPM/blob/main/vp-worldbench/docs/DATA_FORMAT.md).

| size | Simul-Robot | Simul-General | Real-Robot | Real-General | total |
|:--|--:|--:|--:|--:|--:|
| all files | 95 GB | 160 GB | 3.2 GB | 15.6 GB | 274 GB |
| of which depth | 79 GB | 106 GB | – | 11.4 GB | 196 GB |

## Usage

```bash
# everything (~274 GB)
hf download rooty2020/VP-WorldBench --repo-type dataset --local-dir data/VP-WorldBench
# or without depth (~77 GB)
hf download rooty2020/VP-WorldBench --repo-type dataset --local-dir data/VP-WorldBench --exclude "*/depth/*"
# or one subset
hf download rooty2020/VP-WorldBench --repo-type dataset --local-dir data/VP-WorldBench --include "Real-Robot/*" --include "index.json"
```

The toolkit ([`vp-worldbench`](https://github.com/vpm-project/VPM/tree/main/vp-worldbench), package `vpm_worldbench`,
CLI `vpmwb`) reads the data, exports model inputs and scores predictions:

```bash
pip install -e "vp-worldbench[metrics,fvd]"
vpmwb validate --root data/VP-WorldBench
```

```python
from vpm_worldbench import Benchmark
s = Benchmark("data/VP-WorldBench").sample("Real-Robot/episode_000")
frames = s.frames(view=0, indices=[16, 17, 18], size=(848, 480))   # RGB uint8
K, w2c = s.K(0, size=(848, 480)), s.w2c(0, [16])                   # intrinsics follow the resize
tracks = s.tracks                                                   # xyz, valid, in_frustum, visible, kind, ...
uv, vis, in_frame = s.tracks2d(0, size=(848, 480))                  # projected GT 2D tracks
depth = s.depth(0, [16], size=(848, 480))                           # metres (None for Real-Robot)
```

## Benchmark

**Multi-view video generation** (protocol `vpm-v1`). Given frame 16 of every view, generate the next 64 frames of
every view. The generated views are scored on three axes:

- **appearance:** PSNR, SSIM, LPIPS and FVD;
- **cross-view consistency:** Cross-view MEt3R. This is the distance between the generated clip's cross-view MEt3R
  and the real video's, averaged over clips. Each clip's MEt3R is the mean over all view pairs and timesteps.
- **3D motion accuracy:** δ. The generated views are lifted to 3D tracks (MVTracker + MoGe-2) and compared with the GT
  tracks:
  - δ_avg counts every frame of every point;
  - δ mov. counts only the frames where the GT point has moved, so a static video scores 0.

The protocol can be changed: reference frame, I2V/V2V context length, horizon, frame step, views and resolution.

Image-to-video baselines are scored on all clips. Each view is generated independently from its own first frame.
Cross-view MEt3R is lower-better; the real-video row shows its raw MEt3R.

| subset | method | FVD ↓ | PSNR ↑ | Cross-view MEt3R ↓ | δ_avg ↑ | δ mov. ↑ |
|:--|:--|--:|--:|--:|--:|--:|
| Simul-Robot | *real video / frozen points* | – | – | (0.428) | 60.7 / 84.5 | 22.0 / 0.0 |
| | HunyuanVideo-1.5 (480p I2V, step-distilled) | 98.3 | 20.19 | 0.022 | 45.3 | 4.8 |
| | Wan2.2-TI2V-5B | 314.8 | 15.79 | 0.108 | 32.2 | 2.9 |
| | Cosmos3-Nano | 104.6 | 20.02 | 0.040 | 43.3 | 6.4 |
| Simul-General | *real video / frozen points* | – | – | (0.482) | 60.1 / 7.3 | 55.7 / 0.0 |
| | HunyuanVideo-1.5 (480p I2V, step-distilled) | 115.8 | 11.45 | 0.061 | 25.2 | 17.8 |
| | Wan2.2-TI2V-5B | 206.1 | 10.43 | 0.076 | 19.9 | 12.2 |
| | Cosmos3-Nano | 167.4 | 10.99 | 0.062 | 24.3 | 17.0 |
| Real-Robot | *real video / frozen points* | – | – | (0.499) | 75.1 / 61.9 | 48.2 / 0.0 |
| | HunyuanVideo-1.5 (480p I2V, step-distilled) | 426.4 | 16.03 | 0.102 | 34.6 | 24.3 |
| | Wan2.2-TI2V-5B | 550.5 | 14.58 | 0.159 | 26.5 | 13.6 |
| | Cosmos3-Nano | 326.1 | 16.36 | 0.099 | 37.2 | 16.1 |
| Real-General | *real video / frozen points* | – | – | (0.591) | 68.0 / 37.6 | 48.0 / 0.0 |
| | HunyuanVideo-1.5 (480p I2V, step-distilled) | 94.7 | 20.75 | 0.014 | 29.9 | 3.6 |
| | Wan2.2-TI2V-5B | 122.6 | 17.46 | 0.030 | 28.2 | 4.0 |
| | Cosmos3-Nano | 56.2 | 21.80 | 0.015 | 31.9 | 3.9 |

Full tables, with SSIM, LPIPS, AJ, OA, survival, ADE, standard errors and the Cross-view MEt3R floors, are in the
[toolkit README](https://github.com/vpm-project/VPM/tree/main/vp-worldbench).

**Further tasks on the same data**, each with input export, baselines and an evaluator in the toolkit:

| task | input → prediction | metrics |
|:--|:--|:--|
| 3D point tracking / 3D motion | multi-view (or one) video + query points → 3D tracks | δ_avg, AJ, OA, survival, ADE, scene flow |
| 2D point tracking | one view + 2D queries → 2D tracks; cross-view correspondence | TAP-Vid AJ, <δ^x_avg>, OA |
| video depth | one view → per-frame depth | AbsRel, δ<1.25, RMSE |
| 4D reconstruction | multi-view video → cameras + point maps | RRA/RTA, ATE, RPE, Chamfer, F-score |
| novel-view synthesis | other views + target camera → held-out view | PSNR, SSIM, LPIPS |
| segmentation | video + click/box prompt → masks | J&F, point precision/recall/IoU |
| video understanding | video(s) + question → answer | QA accuracy, caption retrieval, temporal grounding |

## Sources

| subset | derived from |
|:--|:--|
| Simul-Robot | renders of humanoid (Fourier GR1T2) pick & place episodes in Unreal Engine scenes, produced for this benchmark |
| Simul-General | CARLA renders of pedestrians and vehicles with target-following cameras, produced for this benchmark |
| Real-Robot | the RB-Y1 WujiHand2 teleoperation dataset (100 episodes, ego + exo), with 3D arm and hand point tracks from forward kinematics; videos and tracks time-aligned for this benchmark |
| Real-General | 100 ten-second clips of an in-house 47-camera capture, with surface and body-model tracks, reconstruction depth, SAM2 person masks, 2D/3D keypoints and motion captions produced for this benchmark |

The Real-General captions were written by vision-language-model annotators and checked by model verifiers.
`Real-General/_source/CAPTIONS.md` gives the process and the measured accuracy.

**People.** Real-General shows real, identifiable people. Use the data only for research on video and 4D perception
and generation. Do not use it to identify or profile the people shown. To request the removal of a clip, contact the
maintainer: Byungwoo Jeon, imbw2024@kaist.ac.kr.

## Citation

```bibtex
@article{vpm2026,
  title   = {Learning the 4D World through Point Trajectory Forecasting},
  author  = {Jeon, Byungwoo and Hong, Sunghwan and Kim, Dohyeon and Lee, Jonghoon and Park, Jungwoo and Lee, Inhee and
             Baek, Doosan and Kim, Jinil and Lim, Taehyun and Joo, Hanbyul and Pollefeys, Marc and Xie, Saining and
             Shin, Jinwoo},
  journal = {arXiv preprint arXiv:2610.06940},
  year    = {2026}
}
```

## License

VP-WorldBench is released under the
[Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)](https://creativecommons.org/licenses/by-nc/4.0/)
license. Copyright Byungwoo Jeon. The evaluation toolkit is released separately under Apache-2.0. Simulator assets
shown in the renders remain under the terms of their owners.