Introduction

Most multiplayer world models still try to render every player's view inside one joint generator — cost scales with the lobby. WorldCast (CUHK-Shenzhen, SLAI, Tsinghua SIGS, Voyager Research / Didi Chuxing, USTC) flips that contract: each player runs a local client on its own GPU, exchanges only compact player + scene state, and still keeps Counter-Strike 2 rounds visually coherent across independent cameras.

On 2026-10-02 the team pushed open inference code on GitHub and Apache-2.0 weights on Hugging Face ZiyangYe/WorldCast — including a 4-step distilled student (worldcast_4step_bf16.safetensors, ~10.2 GB, stage-4 step 600) fine-tuned from Wan2.2-TI2V-5B. Project page: ziyang-ye.github.io/WorldCast-Page.

What shipped

PieceStatusWhere

Inference clients + lock-step pool

Open

Ziyang-Ye/WorldCast

4-step generator + depth head/read-out + fixed prompt emb

Open (Apache-2.0)

ZiyangYe/WorldCast on HF

Six recorded example rounds (~200 MB)

Open

tools/download_examples.py

Live multiplayer web demo scaffold

Open

tools/serve_demo.py

State model (closed-loop poses)

Not released

docs mark Table 2 / 4a closed

Training code (all four stages)

Later

README roadmap

Modality: action-conditioned video world model for Counter-Strike 2 (OpenCS2). Open vs API: open weights + inference, not a hosted API. Decode path: 16 fps, 672×384 mp4 via Wan2.2 VAE. Paper numbers cite ~15 GiB GPU memory per client on an NVIDIA H20, 16+ FPS per client for 2–16 players, and about 3.5 Mb/s received per client at 16 players.

Pro Tip

WorldCast's headline engineering move is the camera-aligned player state field plus a shared scene-state bank of generated blocks. Peers publish finished latent blocks into a pool directory; a later client that turns into the same doorway can reuse what another client already dreamed — instead of inventing a conflicting room. That is the multiplayer consistency trick, not another "bigger joint DiT."

Run it today

git clone https://github.com/Ziyang-Ye/WorldCast && cd WorldCast
python -m venv .venv && source .venv/bin/activate
pip install --upgrade pip
pip install torch          # CUDA build for your driver
pip install -e .
# optional, paper-bit kernel:
# pip install flash-attn --no-build-isolation

python tools/download_weights.py --out-dir weights
python tools/download_examples.py   # ~200 MB of six recorded rounds
bash examples/run.sh mirage_r16     # three clients, ~30 s

Three-client session (after paths yaml is filled):

python tools/run_session.py --config configs/infer/worldcast_4step.yaml \
    --config weights/paths.yaml --config data/paths.yaml \
    --group-of 59 --gpus 0,1,2 --out-dir runs/dust2-r09
python tools/decode.py --config weights/paths.yaml --latents runs/dust2-r09/*/*/latents.npy

Without flash-attention, pass --attention sdpa. Demo without GPUs (local coordinator + fake workers):

pip install -r requirements/demo.txt
python tools/serve_demo.py --role local --workers 2
# open http://localhost:8100 in two browser windows

Why game makers should care

  • Distributed by design — no centralized multi-view generator bottleneck as you add players.
  • Runnable primary today — HF weights + GH inference + six example rounds, not paper-only.
  • Game-native domain — CS2 / OpenCS2 with controls, weapons, observer signals, and map geometry in the client loop.
  • Concrete release artifact — the Table-3 4-step student is the file you actually load (stage: 4, step: 600 in safetensors metadata).

If you are building multiplayer dream engines, persistent shared worlds, or engine-side neural observers, WorldCast is the cleanest clock-hot open stack that treats lobby scale as a first-class systems problem.

Limits

Be honest with the release board: the state model that predicts player positions in closed loop is not in this drop — Table-3 reproduction uses recorded player states and GT visibility. Full OpenCS2 round dumps beyond the six examples are still gated behind their data docs. Training code is promised later. You need serious VRAM (~15 GiB class per live client) for the real generator path; the localhost demo without GPUs is a network scaffold, not the Wan student. CS2 content is research-oriented; Valve trademarks apply — not affiliated or endorsed.

Original Source

Conclusion

WorldCast is a same-day open multiplayer world-model release: distributed CS2 clients, Apache-2.0 4-step Wan2.2 student weights on HF, and runnable example rounds — built so every player owns a GPU and the lobby still shares one world. Clone the repo, pull the 10.2 GB student, and run mirage_r16 before the next joint-generation paper claims "multiplayer."

—Titus