DreamerBench

A simulator-generated, multimodal benchmark for world models in contact-rich, frictional robotic manipulation.

DreamerBench provides time-synchronized RGB observations, camera-aligned contact-splat visualizations, proprioception, low-level control actions, and dense physics annotations (contact forces, friction coefficients, and contact-mode flags), together with precomputed discrete visual latents for token-based world models. It is the dataset used to train and evaluate ChronoDreamer, an action-conditioned world model for contact-rich manipulation.

Code	https://github.com/uwsbel/ChronoDreamer
Dataset	https://huggingface.co/datasets/zzhou292/DreamerBench
Generator	Project Chrono multi-physics engine
License	MIT
Point of contact	Json Zhou (zzhou292@wisc.edu)

DreamerBench is a focused benchmark (~12 hours of interaction data), deliberately narrowed to contact-rich tabletop dynamics rather than a broad, web-scale corpus. Its value is the explicit contact/friction supervision that general video datasets omit.

Overview

World models predict how a scene evolves under an agent's actions, enabling planning by imagination. Most video-prediction datasets, however, optimize for visual plausibility and treat contact as an implicit, unlabeled phenomenon: friction coefficients are fixed or weakly randomized, contact forces are rarely logged, and evaluation measures task reward or perceptual quality rather than contact-mechanics accuracy. This is precisely the regime that determines whether a manipulation trajectory succeeds.

DreamerBench targets this gap. It models non-smooth hybrid dynamics with intermittent contact, Coulomb friction, and stick–slip transitions, and exposes the underlying physical quantities as first-class, supervised signals alongside the rendered video.

Highlights

• Contact-centric supervision. Contact modes (no-contact / sticking / sliding / separating), normal and tangential forces, and friction parameters are logged with every frame and projected into camera-aligned contact-splat images suitable as a supervised output channel.
• Multimodal but tractable. Synchronized RGB, contact splats, and proprioception are provided alongside precomputed Cosmos DI8×8 FSQ tokens, so models can train in pixel space or in a discrete latent space without re-running encoders.
• Controlled physical variation. Friction coefficients, object inertial parameters, initial conditions, and control signals are varied across seeds within a small family of scenarios, supporting the study of generalization under physical-parameter shift.

Visual Data Samples

The clips below are representative, time-synchronized visualizations of four example scenarios. Each scenario is shown from three synchronized camera views (Ego, Side 1, Side 2) alongside a Contact Splat rendering that highlights the contact/interaction region (256×256 previews).

Scenario	Ego	Side 1	Side 2	Contact Splat
flashlight-box
flashlight-coca
waterbottle-coca
fea-flashlight

In the contact-splat column, red encodes contact-force magnitude and green–blue encodes the projected force direction in the image plane (see Contact Encoding).

Dataset Description

Simulation Scenarios

DreamerBench currently covers four tabletop interaction motifs involving a hand-held tool and one or more objects. Each scenario provides synchronized ego/side RGB views, contact-splat images, proprioception, low-level actions, and physics annotations, with discrete FSQ tokens precomputed via the Cosmos DI8×8 tokenizer.

Scenario	Objects and interaction	Dominant contact behavior
flashlight_box	Hand-held tool and a box on a planar surface	Sliding and pushing
flashlight_coca	Tool and a tall cylindrical container	Sliding and rolling contact
waterbottle_coca	Bottle interacting with a cylinder	Combined sliding and rolling along the table
fea_flashlight	Four tetrahedron-meshed finite-element (FEA) deformable beams and two standing flashlights (rigid bodies)	Deformable contact and beam bending

For each scenario, multiple random seeds perturb surface friction coefficients, initial object poses and velocities, and the control trajectory, producing families of related but distinct contact sequences.

Data Modalities and Per-Step State

At each simulation step t, DreamerBench logs a state tuple s_t = (o_rgb, o_contact, q, q̇, f_contact, μ, c), together with a low-level action a_t and, optionally, a task reward r_t. An episode is the sequence τ = (s_0, a_0, r_0, s_1, …, s_T). Episodes last 300–600 steps, chosen so that objects undergo multiple contact-mode transitions (impact, stick–slip, rolling, settling).

Signal	Symbol	Description
RGB views	o_rgb	Egocentric and side-camera RGB frames, rendered at 256×256.
Contact splat	o_contact	256×256 camera-aligned image encoding contact-force magnitude (red) and projected direction (green/blue).
Proprioception	q, q̇	Robot joint positions and velocities (N_j = 4 joint channels).
Action	a	3-D end-effector velocity command (x, y, z), generated by an Ornstein–Uhlenbeck process.
Contact forces	f_contact	Per-contact 3-D normal and tangential forces (impulses discretized over Δt).
Friction	μ	Coulomb friction coefficients (e.g., static/kinetic (μ_s, μ_k)), varied across seeds.
Contact mode	c	Discrete flag: no-contact / sticking / sliding / separating.
Reward (optional)	r	Scalar task reward, when a task is defined.
Precomputed tokens	z	Cosmos DI8×8 FSQ discrete tokens (32×32 grid, vocabulary V = 64,000) for the RGB and contact streams.

Contact Encoding via Depth-Weighted Gaussian Splats

Rather than storing contact as a sparse list of points, DreamerBench renders, at every step, a contact-splat image that aggregates all active contacts into a single RGB frame aligned with a reference camera — a format that vision backbones and video tokenizers can consume directly.

For each contact i with 3-D position p_i and force f_i:

1. The point is transformed into the camera frame and projected to a pixel via a pinhole model; a second point displaced along f_i is projected to recover the in-plane force direction.
2. The red channel stores the clipped, normalized force magnitude; the green/blue channels store the normalized 2-D direction.
3. Each contact is splatted as an isotropic Gaussian whose radius grows with force magnitude, multiplied by a depth weight exp(-X_i / τ_depth) so that nearer contacts dominate.
4. Contributions are accumulated and per-pixel normalized, yielding a soft z-buffer over Gaussian "surfels" that compactly encodes spatial footprint, approximate pressure, and projected force direction.

Data Generation

Trajectories are produced with Project Chrono, configured as a multi-physics engine with rigid and (optionally) flexible bodies, Coulomb friction, and penalty- or constraint-based contact handling. The continuous-time dynamics form a non-smooth hybrid ODE/DAE system; DreamerBench records a discretized version suited to sequence modeling.

To excite rich, repeatable contact behavior without high-frequency jitter, the joystick command channel is driven by a three-dimensional Ornstein–Uhlenbeck (OU) process — temporally correlated colored noise — post-processed through a minimum-norm constraint, a deadzone, and a clipped kinematic integrator before being passed to an inverse-kinematics solver. This consistently drives sliding, rolling, and intermittent sticking while avoiding degenerate near-static trajectories, and it admits straightforward ablations (e.g., varying the correlation time or substituting i.i.d. Gaussian noise).

Dataset Structure

Repository Layout

DreamerBench/
├── flashlight_box_{00,01,02,eval}.zip     # raw episodes: RGB, contact splat, proprio, actions, physics
├── flashlight_coca_{00,01,02,eval}.zip
├── waterbottle_coca_{00,01,02,eval}.zip
├── fea_flashlight_{00,01,02,eval}.zip
├── cosmos_tokenized/                       # precomputed Cosmos DI8x8 FSQ latents
│   ├── <scenario>_{60,120,180,eval}_tokenized.zip
│   └── combined_{240,480,720,eval}_tokenized.zip
├── pretrained_ckpt/                        # ChronoDreamer world-model checkpoints
│   ├── mode_0/epoch_{0..9}.zip             # training configuration 0
│   ├── mode_1/epoch_{0..9}.zip             # training configuration 1
│   └── fea_flashlight/epoch_{4..7}.zip     # FEA-only ablation study
├── inference_results.zip                   # rollouts + VLM-AUC evaluation artifacts
├── assets/previews/                        # short MP4 preview clips (shown above)
└── README.md

All archives are tracked with Git LFS.

On-Disk Episode Format

Each scenario archive (e.g., flashlight_box_00.zip) contains multiple episodes and auxiliary files:

• arrays for RGB and contact-splat images, proprioception, actions, and physics annotations;
• precomputed discrete visual tokens for the RGB and contact streams (e.g., video.bin, contact_splat.bin), obtained from the Cosmos DI8×8 tokenizer via finite-scalar quantization;
• JSON metadata describing the token grid size S, vocabulary size V, frame count, frame rate, and segmentation into episodes (segment IDs).

This layout streams naturally in common training stacks (PyTorch, JAX), either as variable-length episodes or as a single concatenated sequence with associated segment IDs.

Precomputed Latents (Cosmos DI8x8)

RGB and contact-splat frames are tokenized with the NVIDIA Cosmos-0.1-Tokenizer-DI8×8, which maps a 256×256 image to a 32×32 grid of discrete tokens (8× spatial compression per axis) via Finite-Scalar Quantization (FSQ). Six latent channels are quantized with per-channel levels (8, 8, 8, 5, 5, 5), giving a vocabulary of V = 64,000 with no learnable codebook. The cosmos_tokenized/ archives ship these latents per scenario and as combined aggregates so that token-based world models avoid repeated encoding.

Data Splits

The dataset is organized by interaction scenario, each provided as sharded training archives plus a held-out evaluation split:

Scenario	Training shards	Eval split
flashlight_box	flashlight_box_00.zip, _01, _02	flashlight_box_eval.zip
flashlight_coca	flashlight_coca_00.zip, _01, _02	flashlight_coca_eval.zip
waterbottle_coca	waterbottle_coca_00.zip, _01, _02	waterbottle_coca_eval.zip
fea_flashlight	fea_flashlight_00.zip, _01, _02	fea_flashlight_eval.zip

For the VLM-AUC evaluation, each scenario additionally contributes 72 human-labeled samples (binary collision / no-collision); the positive/negative ratio reflects the natural contact frequency and is not balanced.

Loading the Data

This dataset is large and Git-LFS–backed — avoid cloning or downloading everything. Fetch only the specific archives you need with huggingface_hub:

from huggingface_hub import hf_hub_download

# Download a single scenario shard (not the whole dataset)
path = hf_hub_download(
    repo_id="zzhou292/DreamerBench",
    filename="flashlight_box_00.zip",
    repo_type="dataset",
)
print(path)

# Example: grab only the Cosmos-tokenized eval latents for one scenario
latents = hf_hub_download(
    repo_id="zzhou292/DreamerBench",
    filename="cosmos_tokenized/flashlight_box_eval_tokenized.zip",
    repo_type="dataset",
)

To browse the available files without downloading them:

from huggingface_hub import HfApi

files = HfApi().list_repo_files("zzhou292/DreamerBench", repo_type="dataset")
print("\n".join(files))

Associated Model and Benchmark

ChronoDreamer World Model

DreamerBench is the training and evaluation substrate for ChronoDreamer, an action-conditioned world model. Given a history of egocentric RGB frames, actions, and joint states, ChronoDreamer jointly predicts future video tokens, contact-splat tokens, and joint angles. It operates on the precomputed Cosmos DI8×8 tokens with a spatial-temporal transformer (24 layers, hidden size 256, 8 heads; factorized spatial and causal-temporal attention) trained with a MaskGIT-style masked-prediction objective over a factorized token vocabulary. The model has roughly 30–50M parameters and was trained for 10 epochs on four NVIDIA A100 GPUs (~10 days) over ~12 hours of interaction data.

Pretrained checkpoints are provided under pretrained_ckpt/ (mode_0, mode_1, and an fea_flashlight ablation).

VLM-AUC Evaluation

VLM-AUC is an offline protocol for measuring world-model quality without ground-truth forces at test time. A predicted rollout is scored for collision severity on a symmetric 1–5 scale by an ensemble of five prompt variants (baseline, evidence-first CoT, conservative gating, future-only temporal boundary, and counterfactual verification); the averaged ensemble score's AUC against human binary collision labels is computed via the Wilcoxon–Mann–Whitney statistic, making it robust to class imbalance.

Three open-weight judges are evaluated — Llama 3.2 90B, Gemma 3 27B, and Qwen3.5 122B — across three conditions: ground truth (GT), epoch-10 predictions, and epoch-1 predictions. The protocol expects the ordering AUC(GT) ≥ AUC(Ep.10) ≥ AUC(Ep.1). At the aggregate level this ordering holds for the larger judges, while the smallest judge inverts the epoch sub-ordering, consistent with reduced calibration at smaller scale. Complete evaluation artifacts — inference logs, reasoning traces, raw outputs, and parsed scores — are archived in inference_results.zip.

Intended Uses and Tasks

DreamerBench supports world models that must account for both visual appearance and low-level contact physics:

• One-step and multi-step prediction in pixel or latent space (image reconstruction error, proprioception error, contact-mode cross-entropy; rollout-degradation metrics such as SSIM and force-sequence deviation).
• Contact- and friction-specific evaluation: contact-onset and mode prediction (precision/recall/F1 on c), normal/tangential force regression, and robustness under friction-domain shift.
• Contact-implicit / contact-aware planning and model-based reinforcement learning from offline trajectories.
• World-model assessment via the VLM-AUC protocol.

Limitations

• Simulation only. All data is generated in Project Chrono and inherits its modeling assumptions; a sim-to-real gap remains.
• Modest volume and contact sparsity. ~12 hours of data, and contact events are a small fraction of frames — likely contributing to post-contact blurring observed in trained models.
• Narrow coverage. Four scenarios and a single robot morphology; far fewer than broad manipulation benchmarks, and generalization across embodiments is not probed.
• Evaluation breadth. The released results focus on video cross-entropy, LPIPS, joint-angle MSE, and VLM-AUC; the full contact/friction metric suite and external world-model baselines (Dreamer, PlaNet, Genie-style) are left to future work.

Additional Information

Licensing

Released under the MIT License.

Citation

A citation for DreamerBench will be provided here at a later date.

Acknowledgments

Developed by the Simulation-Based Engineering Laboratory (SBEL) at the University of Wisconsin–Madison. This work was supported in part by the National Science Foundation under Award No. CMMI-2153855, and used the Euler cluster at UW–Madison and the Project Chrono simulation infrastructure.