---
license: cc-by-nc-4.0
pretty_name: MineEngine
language:
- en
tags:
- minecraft
- multiplayer
- world-model
- video
- first-person
- depth
- segmentation
- embodied-ai
- game
size_categories:
- 1K<n<10K
configs:
- config_name: default
  data_files: metadata.parquet
---

# MineEngine dataset

Two-player Minecraft episodes recorded with [MineEngine](https://github.com/Ziyang-Ye/MineEngine), an automated multiplayer
data engine. In every episode two bot players act together in one shared world: building, breaking, PvP, fighting mobs,
riding, farming, redstone, water and lava. For each player the dataset has the first-person video, the action of every frame
and the camera pose that rendered it; for each world, a state log that replays the world exactly; and for every frame a
per-pixel **white box** rendered from that log: block type, block state, face, entity id, depth and dig stage.

<p align="center"><img src="assets/overview.jpg" width="960" alt="The shared world, both players' first-person clips, their white boxes and the per-pixel channels"></p>

| | |
|---|---|
| Episodes | 2,952 (two players each) |
| First-person video | 82.5 h (41.3 h per player), 1280 × 720, 20 fps |
| Episode types | 38 (of the 45 in MineEngine) |
| Biomes | 44, plus flat worlds; dawn, day, dusk and night; clear, rain, snow and thunderstorms |
| White box | per frame, 192 × 336 channels + a 384 × 672 white-box video |
| Size | 267 GB, one tar file per episode |

<p align="center"><img src="assets/scenes.jpg" width="960" alt="Sixteen episode types: real frame over its white box"></p>

## Files

```
metadata.parquet                      one row per episode (see below)
episodes/<wave>/<batch>/<episode>.tar one file per episode
```

Inside `<episode>.tar`:

```
<episode>/capture/Alpha.mp4                 first-person video, 1280 × 720, 20 fps
<episode>/capture/Alpha.camera_meta.json    per-frame camera meta of that video (render time, pose, FOV)
<episode>/capture/Alpha.actions.json.gz     per-frame actions, position, yaw / pitch, player state
<episode>/capture/Alpha.meta.json           recorder meta
<episode>/capture/Alpha.episode_info.json   episode type, environment (biome, time, weather), skins, roles
<episode>/capture/Bravo.*                   the same for the second player
<episode>/capture/world.events.jsonl.gz     world-state log: block changes, entities, damage, digging ... per tick
<episode>/capture/world.snapshot_start.json.gz, world.snapshot_end.json.gz
<episode>/whitebox/episode.json, states.json, types.json, world.npz
<episode>/whitebox/Alpha/gbuf.npz           white-box channels [F, 192, 336]
<episode>/whitebox/Alpha/cams.npz           camera per frame (c2w, eye, yaw, pitch, vfov, t_ms, pair_ok)
<episode>/whitebox/Alpha/proxy.mp4          the white box as a video, 384 × 672
<episode>/whitebox/Alpha/state.jsonl.gz     per-frame state: the player, the other player, every entity, events
<episode>/whitebox/Bravo/...
```

The white-box channels (`logdepth`, `shade`, `edge`, `pid`, `btype`, `bstate`, `face`, `fx`, `block`) are documented in
[docs/whitebox_channels.md](https://github.com/Ziyang-Ye/MineEngine/blob/main/docs/whitebox_channels.md); the capture files
in [capture/OUTPUT_SCHEMA.md](https://github.com/Ziyang-Ye/MineEngine/blob/main/capture/OUTPUT_SCHEMA.md). Frame `i` of
`gbuf.npz`, `cams.npz`, `proxy.mp4` and `state.jsonl` is the same moment.

`metadata.parquet` columns: `episode`, `path`, `wave`, `batch`, `episode_type`, `category` (build / destroy / fight / move /
interaction), `world` (normal / flat), `biome`, `time_of_day`, `weather`, `seconds`, `valid`, `size_bytes`, `sha256`.
`valid` is false for the 44 episodes in which a bot reported an error during the episode; their files are complete as recorded.

## Usage

```python
import io, json, gzip, tarfile
import numpy as np
from huggingface_hub import hf_hub_download

path = hf_hub_download("ZiyangYe/MineEngine", "episodes/w1/w1_j0_b0/w1_j0_b0_000013_000.tar", repo_type="dataset")
with tarfile.open(path) as tf:
    ep = "w1_j0_b0_000013_000"
    gbuf = np.load(io.BytesIO(tf.extractfile(f"{ep}/whitebox/Alpha/gbuf.npz").read()))
    actions = json.loads(gzip.decompress(tf.extractfile(f"{ep}/capture/Alpha.actions.json.gz").read()))
    tf.extract(f"{ep}/capture/Alpha.mp4", "out")          # the first-person video
print(gbuf["btype"].shape, len(actions))
```

Select episodes with `metadata.parquet`, e.g. all PvP episodes at night:

```python
import pandas as pd
m = pd.read_parquet("hf://datasets/ZiyangYe/MineEngine/metadata.parquet")
m[(m.category == "fight") & (m.time_of_day == "night")]
```

The white box can also be re-rendered from the logs with the MineEngine code (`python -m mineengine.cap2proxy`), for
example at another resolution.

## How it was made

Captured with MineEngine on headless Linux GPU servers, four worlds per RTX 6000D GPU, in two waves (October 2026). Each world
runs a Paper 1.21 server with the MirrorBot plugin, two Mineflayer bots and two Minecraft clients with the capture mod. The
white boxes were rendered with `mineengine.cap2proxy` from the world-state logs. Player skins are MineEngine's procedural skins
and the Minecraft default skins.

## Licence

The dataset is released under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/). The Minecraft content visible in
the videos and images is © Mojang / Microsoft and is shown under the
[Minecraft Usage Guidelines](https://www.minecraft.net/en-us/usage-guidelines).
NOT AN OFFICIAL MINECRAFT PRODUCT. NOT APPROVED BY OR ASSOCIATED WITH MOJANG OR MICROSOFT.