Introduction

Multics just went fully runnable. ARC Lab at Tencent IEG and The University of Hong Kong released training and inference code on GitHub (Apache-2.0) alongside open weights on Hugging Face. The model jointly generates first-person videos of one shared environment for N players. Each player contributes an initial view (first frame), a text prompt, actions, and a camera trajectory. Overlapping views stay consistent instead of drifting into separate dreams. Modality: image-to-video world model for multi-player POV. Open code and open weights. Where to run it today: local Linux with an NVIDIA GPU, CUDA 12.8, and Python 3.12 — no Space, fal, Replicate, or Comfy node yet. This is research video generation of a shared scene from controls, not a claim of real-time playable FPS.

What shipped

  • Code (Apache-2.0): inference.py, train.py, the multics/ package, configs, tests, and bundled example inputs for 4, 6, 8, and 10 players. The release commit landed October 12; the repo flipped public the morning of October 14.
  • Weights: download the full inference bundle with hf download TencentARC/Multics --local-dir models (~29.9 GB). The main DiT checkpoint is about 15.68 GB. The card lists Apache-2.0; model weights and example content keep upstream terms (see THIRD_PARTY.md).
  • Project page: karine-huang.github.io/Multics. The arXiv badge still says "Coming soon" — no paper ID yet.
  • Training data credit: OpenCS2 (CC-BY-4.0 Counter-Strike 2 POV footage). Example captions read like first-person shooter beats on an ancient-ruins map.

How it works

Most world models generate one ego stream. Multics is built for N simultaneous players in the same scene. Communication runs at three levels — player, group, and global — with dynamic grouping from recent camera trajectories under a fixed budget. Hub tokens (five local hubs per group plus six global hubs) keep cross-player consistency and per-player action/camera control without paying full O(N²) all-to-all attention.

The concrete drop that matters for builders: the 4-player checkpoint generalizes to 6, 8, and 10 players without retraining, because group-token parameters are shared (num_groups = ceil(log2(num_players))). Each player stream is 165 RGB frames (42 latents). Defaults are 50 denoising steps at CFG 5.

Training initializes from Wan2.2-TI2V-5B (the HF card also tags Wan2.1-T2V-1.3B for the text-encoder stack). The bundle ships the Wan2.2 VAE and Wan2.1 UMT5-xxl encoder. The stack sits on Wan plus DiffSynth-Studio. Do not treat Multics as a 1.3B toy — the DiT path is the 5B TI2V line.

Pro Tip

Start with the bundled 4-player cases (--case 1 through 5), then stress the same checkpoint with --num_players 8 or 10. If your multi-view consistency holds there, you have a signal worth measuring before you touch training.

Run it

Linux, Python 3.12, NVIDIA GPU, CUDA 12.8 toolkit, and a C++ compiler. From the repo root:

git clone https://github.com/TencentARC/Multics.git
cd Multics
uv sync --locked
source .venv/bin/activate

hf download TencentARC/Multics --local-dir models

# 4-player demo case 1
python inference.py --config configs/inference_demo.yaml \
  --checkpoint models/multics/4players/checkpoints/model.ckpt \
  --hparams models/multics/4players/hparams.yaml \
  --case 1

# same checkpoint, 8 players (no retraining)
python inference.py --config configs/inference_demo.yaml \
  --checkpoint models/multics/4players/checkpoints/model.ckpt \
  --hparams models/multics/4players/hparams.yaml \
  --num_players 8 --cases 1 2

Outputs land under outputs/inference/ (including grid videos such as 4infer6/video1_grid.mp4). Example counts: five 4-player cases, three at 6, two at 8, two at 10. VRAM is not published in the README — budget for a serious local GPU before you pull the full ~30 GB bundle.

Training (8 GPUs by default):

hf download Wan-AI/Wan2.2-TI2V-5B \
  --include 'diffusion_pytorch_model*.safetensors' \
  --local-dir models/Wan-AI/Wan2.2-TI2V-5B

uv sync --locked --extra distributed
NPROC_PER_NODE=8 bash scripts/train.sh \
  --config configs/train.yaml \
  --dataset_path /path/to/data \
  --metadata_file_name train.csv

Why game devs should care

Shared-scene consistency is the hard part of multiplayer world models. If you are building NPC rehearsal tools, spectator AI, or synthetic multiplayer trajectories for training agents, Multics gives you an open recipe that scales player count without a new fine-tune per lobby size. It sits in the same lane as other open game world models we have covered — think Matrix-Game and Helix World — but the headline here is one scene, many egos, not a single-agent dream. The OpenCS2 training domain means the defaults look like CS2-style POV; treat that as research footage, then retarget with your own precomputed inputs if your game is elsewhere.

Caveats

  • Not real-time play: the repo makes no speed claim. You get generated multi-view video, not a live playable client.
  • Local-only surface: no hosted demo. CUDA 12.8 + large download + unspecified VRAM.
  • Paper still pending: evaluate claims against the demos and your own runs until the arXiv ID lands.
  • Upstream licences: code is Apache-2.0; Wan components and example content follow their own terms.
  • Domain bias: OpenCS2 first-person shooter footage will color zero-shot look and motion until you retrain.

Conclusion

Multics is the open multi-player world-model drop teams have been waiting on from Tencent ARC and HKU: hierarchical communication, a 4-player checkpoint that stretches to 10 players, and full train/infer code with weights you can pull today. Clone the repo, download the bundle, run case 1, then push --num_players and see whether your shared scene still holds.

—Titus