Introduction

GameDirector is out of paper-and-demo mode. Researchers from Tencent, Nanyang Technological University, NUS and A*STAR pushed the first public release of the code to Jimntu/GameDirector_code on Oct 11 (07:19 UTC), and the checkpoints went up at onepiece1999/GameDirector on Hugging Face (Apache-2.0 on the model card). It's a player-configurable game world model: you give it a first frame and a player input track, and it streams back boss fights where the game rules actually hold. You can run it today on a local NVIDIA GPU. A 61 GB training set also went up on HF alongside it.

The problem it targets is one every end-to-end world model runs into. A model that learns everything from pixels can make a fight look right, but it can't keep count. HP drifts, cooldowns get skipped, and the boss "dies" when the model feels like it. GameDirector takes the rules out of the pixels.

How the loop works

The project page and README describe three stages that run in a closed loop:

  • Configure. You pick the scene, the characters and the skills, then set HP, attack strength and skill meters to whatever you want.
  • Direct. After each generated cell, AttackNet detects player and boss hits and SituationNet estimates distance and facing. Hard-coded combat rules update HP, skill meters and cooldowns. A local Gemma 4 E2B planner picks the boss's next skill, and rule enforcement checks that choice before it goes through.
  • Generate. The checked state becomes a structured text prompt. A causal autoregressive world model built on Wan2.2-TI2V-5B renders the next 0.25-second cell (four frames), and those frames go back to the director.

The project page claims 99.6% mechanics fidelity, against 21–34% for end-to-end baselines, and a 39.9% gain in boss decision quality over the best end-to-end setup. The release covers No Rest for the Wicked, Hollow Knight and a "Vampire" game: 13 characters in total, 5 players and 8 bosses.

What shipped

  • world_model/ar_world_model.safetensors (10 GB), plus attacknet.pt and situationnet.pt (150 MB each), with SHA256SUMS
  • Eight one-click example rollouts (3 NRFTW, 5 Hollow Knight) that include first frames and 240-cell player tracks
  • Training code for all three networks, plus GameDirector-Training-Data (23,966 NRFTW and 10,324 HK samples; the Vampire split is not included)

Runtime needs Python 3.10+, an NVIDIA GPU with CUDA and bf16, and FFmpeg. The documented downloads total about 55 GB (GameDirector weights, the Wan2.2 VAE and T5, the UMT5 tokenizer and Gemma 4 E2B). The repo doesn't state a minimum VRAM figure.

Run it

git clone https://github.com/Jimntu/GameDirector_code.git && cd GameDirector_code
python3 -m venv code/.venv && code/.venv/bin/pip install -U pip huggingface_hub
code/.venv/bin/pip install -r code/requirements.txt
python3 -m venv code/.venv-gemma && code/.venv-gemma/bin/pip install -r code/llm/requirements.txt

hf download onepiece1999/GameDirector \
  --include "attacknet/*" --include "situationnet/*" --include "world_model/*" \
  --local-dir model
(cd model && sha256sum -c SHA256SUMS)
hf download Wan-AI/Wan2.2-TI2V-5B \
  --include Wan2.2_VAE.pth --include models_t5_umt5-xxl-enc-bf16.pth \
  --local-dir model/Wan-AI/Wan2.2-TI2V-5B
hf download Wan-AI/Wan2.1-T2V-1.3B --include "google/umt5-xxl/*" \
  --local-dir model/Wan-AI/Wan2.1-T2V-1.3B
hf download google/gemma-4-E2B-it --local-dir external_models/gemma-4-E2B-it  # accept license first

export GAMEDIRECTOR_LLM_MODEL="$PWD/external_models/gemma-4-E2B-it"
EXAMPLE_TICKS=2 ./example/run_rollout.sh hk   # quick smoke test

For your own setup, ./code/run.sh infer --game nrftw --image first_frame.png --player-prompts player_track.json --vocabulary-file vocabulary.json --player-hp 800 --boss-hp 1600 --ticks 12 lets you set the starting combat state yourself. The bundled examples use 30 Euler steps, CFG 2.0 and a single KV-cache session with a 3+17 attention sink. A rollout stops when either side dies, or after 12 ticks (60 seconds).

Caveats

This is a research stack, not a game you can ship. The checkpoints only know the three games they were trained on, and those are footage-derived models of commercial titles. The dataset is marked license: other, and the GitHub repo has no license file even though the weights card says Apache-2.0. Read both before you build anything on it.

Conclusion

GameDirector's idea is simple: let the world model render the frames and let a small director keep the rules. HP, cooldowns, boss tactics and win conditions live in explicit state, not in the pixels. It's the same split we've been tracking across the playable-world stacks this month, and this one ships with weights. If you're building boss fights, roguelike encounters or any world model that needs real rules, this is the repo to clone this week.

—Titus