Introduction

Tencent researchers just released the code and weights for a cleaner way to steer top-down game world models. ActionRoPE, from Tencent with the National University of Singapore and Nanyang Technological University, went public on GitHub and Hugging Face on October 20, a day after the paper. It targets top-down and isometric games, where every player move shifts the camera by a known amount. Instead of teaching a video model what "walk right" means, it writes that shift straight into the model's position encoding. The code is Apache-2.0, and there are checkpoints for four open video models, from 1.3B to 33B parameters.

If you've tried an AI world model, you've probably seen the problem it solves. Walk away from a tree and come back, and the tree has moved or been redrawn. ActionRoPE's headline result is that it cuts that "revisit drift" by 66% compared with the best learned method the team tested.

What shipped

  • Name and team: ActionRoPE + Coordinate-Conditioned Noise Scheduling (CNS), from Tencent, NUS and NTU (project lead Yeying Jin)
  • Modality: action-controlled game video. You give a first frame and a list of moves, and it generates 81 frames at 16 fps and 832×480, about 5 seconds
  • Open vs closed: the code is Apache-2.0. Each checkpoint follows its base model's license: Wan2.2 (Apache-2.0), SkyReels-V2 (Skywork license), LTX-2.5 (LTX-2.x Community License) and MiniMax-H3 (MiniMax-H3 Community License)
  • Where to run it today: clone the GitHub repo and pull weights from teawhite/ActionRoPE. It's built on DiffSynth-Studio. There's no ComfyUI node or hosted demo yet
  • Checkpoints: Wan2.2-TI2V-5B (10 GB full DiT), SkyReels-V2-DF-1.3B (2.9 GB), LTX-2.5 22B (38 GB, LoRA merged) and a 1.2 GB MiniMax-H3 33B LoRA. Each one needs its base model's files too
  • Training code: full fine-tuning recipes for all four backbones, plus a data format you can fill with your own gameplay captures

How it works

Most game world models treat an action like extra conditioning, much like a prompt. The model has to learn from data how far "right" should move the world, and it often gets it a little wrong every frame.

ActionRoPE takes a more direct route. In a top-down or isometric game, walking moves the camera by a known number of pixels. So the method shifts the rotary position of every video token by that amount. A patch of ground keeps the same position address in every frame, and the first frame becomes the anchor for the whole clip. Nothing is learned on the control path.

Those world coordinates also show which parts of each frame were already visible in the first frame and which parts are new. CNS uses that split: tokens the model has already seen get a denoising schedule that settles earlier, so new areas are painted against a world that's already stable. The same known/new map goes in as a tiny extra input channel of about 15K parameters.

The numbers

The team tested on 982 first frames with three checks: how closely speed matches the command, how accurate the direction is, and whether you end up back at the same frame after walking out and returning.

  • Against other control methods on Wan2.2-5B: revisit drift dropped to 7.8, compared with 22.6 for AdaLN (the strongest baseline, which adds 66.5M parameters), 35.3 for a linear layer and 40.2 for cross-attention. Median direction error was 0.68 degrees, and only 5 clips failed, compared with 7 to 57 for the others
  • Speed tracking: the slope of measured vs commanded speed was 0.981 with R² 0.952 (1.0 is perfect)
  • Across backbones: the same recipe works on all four models. Drift was 15.3 on SkyReels 1.3B, 7.8 on Wan2.2 5B, 12.8 on LTX-2.5 22B and 22.0 on MiniMax-H3 33B
  • On a single H200: a clip takes about 15 seconds on Wan2.2 (18 GB VRAM), 35 seconds on SkyReels (11 GB), 105 to 120 seconds on LTX-2.5 (70 GB) and 36 seconds plus 23 seconds of text encoding on MiniMax-H3 (75 GB)

These numbers come from the authors' own tests on their own top-down game data, so treat them as a strong first result, not an independent benchmark.

Try it

The Wan2.2 checkpoint is the lightest high-scoring option, at 18 GB of VRAM:

git clone https://github.com/TeaWhiteBro/ActionRoPE.git && cd ActionRoPE
python3.12 -m venv .venv && source .venv/bin/activate
pip install torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt
huggingface-cli download teawhite/ActionRoPE --include "wan2.2-ti2v-5b/*" --local-dir checkpoints
huggingface-cli download Wan-AI/Wan2.2-TI2V-5B --local-dir models/Wan2.2-TI2V-5B

python scripts/sample.py --model wan \
    --ckpt checkpoints/wan2.2-ti2v-5b/actionrope_cns.safetensors --model_dir models/Wan2.2-TI2V-5B \
    --first_frame my_frame.png --actions "up-right*1.5:24,idle:16,left:40" \
    --prompt "In a 2.5D top down view, the player is in a dark cave lit by blue crystal glow." \
    --out clip.mp4

Actions are written as direction*speed:frames segments that add up to 80 frames. Directions are idle, the four cardinals and the four diagonals. Speed 1.0 matches the training data's walk speed of 69.2 px/s horizontally and 46.0 px/s vertically. The prompt only describes the scene, and moves never go in the text. You can also pass a custom camera path with --offsets offsets.json, and switch backbones with --model skyreels | ltx | h3.

Why it matters for game builders

  • Exact movement: if your game already knows the player's position, you can hand that path straight to the world model instead of hoping it learned what "walk right" means
  • Coming back to places: less revisit drift means a room still looks like that room when you come back. That's the minimum for a top-down RPG, roguelike or farming loop
  • Pick your hardware: the same method runs from a 1.3B model on an 11 GB card up to a 33B MiniMax-H3 LoRA, so you can prototype small and scale later
  • Your own art style: the training code takes 81-frame clips with per-frame camera offsets taken from game state, so you can fine-tune on captures from your own top-down project

One limit: this only covers planar cameras. Free-look 3D, first-person and rotating views are outside what ActionRoPE models.

Original Source

https://github.com/TeaWhiteBro/ActionRoPE

https://huggingface.co/teawhite/ActionRoPE

https://teawhite.cn/ActionRoPE/

https://arxiv.org/abs/2610.25861

Conclusion

ActionRoPE is a narrow idea, and that's why it works. When the game already knows exactly how the camera moved, there's no reason to make a video model guess. Put the move into coordinates, let regions you've already seen settle first, and the world stays where you left it. For anyone building AI-rendered top-down or isometric games, it's one of the few world-model releases this month with full training code, four ready checkpoints and a size that fits on one GPU.

Want to see the biggest backbone on its own? Try MiniMax H3 on Gen.

—Titus