PokeDreamer dataset: Pokémon Red gameplay transitions with RAM labels

License. The frames are screenshots of Pokémon Red (© Nintendo, Creatures Inc., GAME FREAK inc.) recorded by the author, shared for research use only; this project is not affiliated with them. The RAM labels and file layout are released with the code under MIT (see the GitHub repo's LICENSE). No ROM is included.

• Code and results: https://github.com/xoTEMPESTox/PokeDreamer (MIT)
• Website: https://pokedreamer.priyanshusah.com
• Trained models: https://huggingface.co/xxxTEMPESTxxx/PokeDreamer
• Numbers below are copied from lab/results/dataset_stats.md, lab/results/README.md and lab/results/v3_dwm_eval.md in the GitHub repo, or are file counts/sizes of this repository.

Native-resolution Game Boy screen frames from Pokémon Red (PyBoy emulator), one frame per button press, with the game's RAM state read at every step (map ID, player tile, facing, battle flag, party HP). The RAM fields are what make the data useful for world-model research: imagined frames can be scored against the true game state in tiles and maps, not only in pixels. The diffusion world model, frame probe, upsampler and colorizer in the model repository were trained on it.

Files

path	files	bytes	episodes x steps	used by
transitions_0001.npz .. transitions_0020.npz	20	343,018,913	200 x 1,000 = 200,000	the base dataset: every v3 model (python -m lab.data)
v3/collect_v2/transitions_0001..0030.npz (+ coverage.json, explore.json)	32	603,867,901	300 x 1,000 = 300,000	the extended dataset, part 1: Viridian City, Route 22, Route 2, forest south gate, Viridian Forest, Viridian interiors (python -m lab.data --ext)
v3/collect_v3/transitions_0001..0030.npz (+ 2 json)	32	589,538,720	300 x 1,000 = 300,000	the extended dataset, part 2: Route 2, Viridian Forest, north gate, Pewter City, Pewter Gym, Pewter Pokémon Center, Mart, Museum and houses
v3/collect/transitions_0001..0020.npz (+ coverage.json)	21	332,227,873	200 x 1,000 = 200,000	a first exploration run (mostly Route 22 and Viridian Forest; never reached Pewter). Not used by any published model or by lab/data.py; kept for completeness
splits.json, splits_ext.json (if present)	2			episode-level splits written by lab/data.py (seed 0), see "Splits"

Total 1,000,000 steps in 1,868,658,191 bytes (107 files before the cards and splits). Each chunk holds 10 episodes of exactly 1,000 steps (10,000 rows). The world model wm31 was trained on the base + extended data: 800,000 frames, 676,284 training windows (v3_dwm_eval.md).

Format

Each transitions_NNNN.npz is a NumPy archive with 13 arrays of length N = 10,000 (the same keys in every chunk, base and extended):

key	shape, dtype	meaning
obs	(N, 144, 160, 3) uint8	RGB screen after the action. The Game Boy screen is 4 shades of grey; the RGB channels are equal, and the v3 models use a 72x80 greyscale downsample (cv2.INTER_AREA, lab/data.py)
actions	(N,) uint8	button pressed at this step: 0 down, 1 left, 2 right, 3 up, 4 A, 5 B, 6 start, 7 pass (no button)
rewards	(N,) float32	always 0.0 (placeholder)
episode_starts	(N,) bool	True on the first step of an episode (10 per chunk)
map_ids	(N,) uint8	current map ID from WRAM (e.g. 0 Pallet Town, 38 Red's bedroom, 40 Oak's Lab, 12 Route 1, 1 Viridian City, 13 Route 2, 51 Viridian Forest, 2 Pewter City, 54 Pewter Gym)
xs, ys	(N,) uint8	player tile coordinates on the current map
facings	(N,) uint8	0 down, 4 up, 8 left, 12 right
in_battles	(N,) bool	battle active
dialog_opens	(N,) bool	text-box flag as read from RAM; it is True on about 95% of base steps, so it is not a usable dialog indicator (dataset_stats.md)
badges	(N,) uint8	badge count (0 throughout the base data)
party_hps, party_max_hps	(N, 6) int16	current / max HP of the six party slots

One step is one button press held for 8 frames followed by 24 emulated frames, about 0.40 s of game time and exactly the time to walk one tile (v3_dwm_eval.md). The RAM fields describe the state after the action.

import numpy as np
from huggingface_hub import hf_hub_download, snapshot_download

p = hf_hub_download("xxxTEMPESTxxx/PokeDreamer", "transitions_0001.npz", repo_type="dataset", token=False)
d = np.load(p)
print(d["obs"].shape, d["map_ids"][:5], d["xs"][:5], d["ys"][:5])

# the whole base dataset (343 MB) and the extended episodes (1.19 GB), into the layout lab/data.py expects:
snapshot_download("xxxTEMPESTxxx/PokeDreamer", repo_type="dataset", token=False, allow_patterns=["transitions_*.npz"], local_dir="work/hf/dataset")
snapshot_download("xxxTEMPESTxxx/PokeDreamer", repo_type="dataset", token=False, allow_patterns=["v3/collect_v2/*", "v3/collect_v3/*"], local_dir="work/hf_ext")
# then move/symlink work/hf_ext/v3/collect_v2 -> work/collect_v2 and work/hf_ext/v3/collect_v3 -> work/collect_v3, and run:
#   python -m lab.data          # work/cache_72x80.npz, work/splits.json, work/dataset_stats.md
#   python -m lab.data --ext    # work/cache_ext_72x80.npz, work/splits_ext.json

The files are not in a datasets-library layout; load_dataset does not apply. Load them with NumPy.

How the data was collected

Base dataset (200 episodes, collected for v2): v2/scripts/collect_data.py in the GitHub repo. For each episode a fresh PyBoy session loads one of the project's save states and runs 1,000 steps, 24 emulator ticks per action, choosing actions with a frozen PPO agent (the PokemonRedExperiments baseline policy, which downsamples the screen to 40x36) or, for a fraction of episodes, uniformly random buttons. Measured start maps over the 200 episodes: Red's bedroom (map 38) 81 episodes, Pallet Town (map 0) 45, Oak's Lab (map 40) 74 (dataset_stats.md). The player moves on 37.2% of steps, changes map on 0.24%, and is in battle on 12.2%; the action counts are down 43,557, left 36,518, right 43,690, up 33,713, A 35,621, B 5,334, start 819, pass 748. Map coverage: Red's bedroom 39.8% of steps, Oak's Lab 18.0%, Route 1 17.2%, Pallet Town 12.9%, Viridian Pokémon Center 8.2%, Viridian City 1.8%, with Red's 1st floor, Blue's house, Route 2 and the Viridian Mart under 1% each. The recorded data leaves the house only 3 times.

Extended dataset (600 episodes, collected 2026-11 for v3): lab/collect.py, a two-phase Go-Explore collector with 8 parallel emulators starting from the project's Pokédex save state (Viridian City, Charmander L8). Phase A explores (unrecorded) with momentum walks, 5% A, 5% B, never Start, and a battle reflex, keeping an archive of cells; low-HP cells are replaced from healthy ones. Phase B records 1,000-step episodes in the format above from start cells sampled uniformly over the target maps and then over that map's archive cells. collect_v2 targeted Viridian City to the forest (coverage: battle on 16.1% of steps; never reached the north gate or Pewter); collect_v3 seeded its archive with 30 save states taken along three real gym-quest runs (Route 2 to the Pewter Gym, seeds 100-102) and targeted Route 2, the gates, the forest, Pewter City and its buildings, reaching all of them (battle on 14.1% of steps). Per-map step counts and first-reached episodes are in each folder's coverage.json. No human input in either phase.

Splits (by episode, never by frame)

The project's rule: held-out sets are whole episodes, so evaluation windows never overlap training windows (lab/results/README.md). lab/data.py writes them deterministically with seed 0:

split	episodes	definition
train	139 (base) + 540 (extended)	everything not held out
test_id	16	random 10% of the base episodes that do not start in Pallet Town
test_ood	45	every base episode that starts in Pallet Town (map 0): a held-out start location
test_ext	60	random 10% of the 600 collected episodes

Episode IDs count episodes in file order (np.cumsum(episode_starts) - 1); the extended episodes are offset by 200 when merged (lab/data.py::merge). splits.json / splits_ext.json list the IDs.

Intended use

• Training and evaluating world models / dynamics models of a 2D tile-based game with exact state ground truth.
• Probing what a visual model knows about game state (map, tile, battle), as the frame probe in the model repo does.
• Offline navigation data: the base data is dominated by one agent's behaviour around Pallet Town and Route 1; the extended data covers the road to Pewter City.

Limitations

• Behaviour policy bias. The base episodes come from one PPO agent (plus random episodes) looping in a small area, with 39.8% of steps in Red's bedroom. The extended episodes come from an exploration heuristic; neither is human play.
• Rare events are rare. Map changes are 0.24% of base steps; the house is left 3 times in 200,000 steps. World models trained on this data under-predict wild battle onsets (2.9% imagined vs 27.2% real within 10 steps on Route 1, v3_dwm_eval.md).
• dialog_opens is not usable (see above); rewards is a placeholder; badges is 0 in the base data.
• Coordinates are per map and meaningless across a map change; the v3 evaluations exclude in-battle steps and map-change steps from position metrics.
• The Game Boy RNG makes battles and encounters depend on frame timing; the data records one trajectory per episode, not the distribution.
• Frames are 4-shade greyscale stored as RGB (the three channels are equal).

Not included, and legal note

No ROM, no save states, no game code. The frames are screenshots of Pokémon Red (Nintendo / Game Freak / Creatures) captured on an emulator from the owner's own cartridge, released for non-commercial research and education; the RAM-derived labels and this repository's metadata are MIT-licensed. Reproducing the collection requires your own ROM (lab/README.md section 2.2).

Citation

@misc{sah2026pokedreamer,
  author       = {Sah, Priyanshu},
  title        = {PokeDreamer: measuring a diffusion world model of Pok\'emon Red with RAM ground truth},
  year         = {2026},
  howpublished = {\url{https://github.com/xoTEMPESTox/PokeDreamer}},
  note         = {v3. Data: \url{https://huggingface.co/datasets/xxxTEMPESTxxx/PokeDreamer}}
}