Introduction

RIGen is out with open code and weights. Researchers at The Hong Kong University of Science and Technology and Vivix Group published a generative first-person shooter world model that generates gameplay video and audio chunk by chunk, while a separate rule engine tracks real game state: health, ammo, death and enemy strategy. The code was published on October 16 (UTC) and updated today. The RIGen checkpoint, built on Lightricks' LTX-2.3 22B video-and-audio model, is on Hugging Face. You run it locally on a CUDA GPU.

Most playable world models stop at "press W, camera moves forward." RIGen goes a step further: shoot an enemy and it loses health, empty your magazine and you're out, and a low-health enemy can choose to retreat. That's the gap between a walking simulator and an actual game loop.

What shipped

  • Name and vendor: RIGen (Reciprocally Interactive Generation), from HKUST and Vivix Group Limited. Paper: arXiv 2610.20811
  • Modality: action-conditioned video and audio world model for first-person gameplay, trained on the open-source arena shooter Xonotic
  • Open vs API: open weights. BF16 (55.7 GB) and FP32 checkpoints of the Stage-2 autoregressive model, under the LTX-2.x Community License
  • Where to run it today: locally, by cloning the repo's main branch and pulling weights from Hugging Face. There's no hosted demo
  • Also released: the RIGen-Xonotic dataset and the data engine that captured it, so you can record your own maps, weapons and opponent behavior

How it works

The project page describes three layers that run in a loop:

  • State and rules: an event-driven state machine stores player and enemy health, life or death, ammo and opponent strategy. Firing uses a round, hits lower health, zero health means death
  • Interaction reasoning: an InternVL3-8B agent reads recent frames, controls and state, predicts what should happen next, and checks the previous chunk's frames so what's on screen overrides unverified guesses
  • Audiovisual generation: the LTX-2.3 backbone generates the next chunk of video and audio from a global scene prompt, local guidance (visibility, damage, death) and your controller input

The training data is big for a game world model: 95,731 accepted Xonotic recordings, about 176.8 hours of video, across 28 maps and nine weapon types, with 42 enemy appearance references. The released config generates 832×480 at 20 fps.

Running it

Use Python 3.11 with CUDA PyTorch, then install FlashAttention 4 separately:

git clone -b main https://github.com/murphylmf/RIGen && cd RIGen
python3.11 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python -c "from flash_attn.cute import flash_attn_func; print('FlashAttention 4: OK')"

Pull the RIGen weights plus the LTX-2.3 components and the Gemma 3 text encoder (gated, so request access and run hf auth login first). The README has the exact hf download and copy commands. The main checkpoint is:

hf download Murphyyyy/RIGen weights/model.safetensors --local-dir .model_downloads/RIGen

By default a VLM plays for you. Serve it in a second terminal:

vllm serve OpenGVLab/InternVL3-8B --served-model-name internvl3-8b \
  --trust-remote-code --port 8012

Then run the bundled test case:

python inference/run_rigen.py --case-id test_case \
  --initial-enemy-hp 50 --rollout-blocks 6 --output-dir outputs/test_case

The rollout, final video and generated actions.json land in outputs/test_case/.

Pro Tip

To drive the game yourself and skip the VLM server, feed your own controller file:

python inference/run_rigen.py --case-id test_case \
  --initial-enemy-hp 50 --rollout-blocks 6 \
  --no-player-controller --no-visual-feedback \
  --action-file actions/example.json --output-dir outputs/test_case_custom

Each block is 16 rows. Axes are [left_x, left_y, right_x, right_y] from -1 to 1 (strafe, forward or back, look left or right, look up or down). Buttons are [fire, aim, melee, jump, reload, Y], but only fire, jump and reload are used, so keep the others at 0. If your file is shorter than the rollout, blocks repeat. That makes it easy to script test runs, like an empty-the-magazine sequence, and check whether the model's ammo and damage hold up.

Why game teams should care

  • State you can trust: health and ammo live in an explicit rule engine, not just in pixels, so you can read them, change the rules and test them
  • A reusable capture pipeline: the Xonotic data engine is the reusable part. It records video, audio, controls, camera poses and game events together, which is the kind of dataset any team training its own gameplay model needs
  • Controller-native input: actions come in as gamepad axes and buttons, so it's simple to connect to a real controller or a bot

Caveats

  • Heavy hardware: the README doesn't list VRAM requirements, but the BF16 checkpoint alone is 55.7 GB, on top of a 22B LTX-2.3 stack, a Gemma 3 12B text encoder and an 8B VLM. Plan on a data-center-class GPU
  • Not real time: this generates rollouts block by block. It isn't a 60 fps playable client
  • License: the weights fall under the LTX-2.x Community License, which requires a paid commercial agreement for companies with $10M or more in annual revenue. The GitHub code repo has no license file yet, and the dataset carries GPL upstream terms from Xonotic
  • Arena isn't a separate download: the paper's RIGen-Arena prototype (sustained-combat tuning, distillation and a video refiner) isn't a separate download. What's published is the Stage-2 checkpoint and one verified test case
  • One game, one genre: everything is trained on Xonotic deathmatch. Treat it as a research base for your own data, not a general FPS generator

Original Source

https://github.com/murphylmf/RIGen

https://huggingface.co/Murphyyyy/RIGen

https://murphylmf.github.io/RIGen/

https://arxiv.org/abs/2610.20811

Conclusion

RIGen is one of the first open releases where a generative shooter keeps score properly: bullets get used up, health goes down, and enemies react to what's happening. It's heavy and limited to one game, but the weights, the dataset and the capture engine are all open. If you're building toward playable generated worlds, it's a solid base to learn from.

—Titus