Introduction

MBZUAI just released a sharper checkpoint for Memorizon, an open world model you steer with WASD keys. On October 20 the team at MBZUAI's Institute of Foundation Models put Luffuly/memorizon-1280x704-50step on Hugging Face. It runs at Wan2.2-TI2V-5B's native 1280×704 resolution. You give Memorizon one photo and a string of key presses, and it generates a first-person walk through that place at 16 fps, one second at a time. The code is Apache-2.0 on GitHub, and both checkpoints are open weights.

The project is built around one problem every AI world model has. Walk away from a building, turn around a minute later, and the building has changed. Memorizon is trained specifically so that places still look the same when you come back to them.

What shipped

  • Name and team: Memorizon, from Tingting Liao, Xuezhi Liang, Hao Li and Guangyi Liu at the Institute of Foundation Models (IFM), MBZUAI
  • Modality: image-to-video world model. You give it one image plus keyboard actions or a camera path, and it streams a long first-person video
  • New today: a 1280×704 checkpoint that runs 50 sampling steps with CFG 4. The earlier Luffuly/memorizon checkpoint, from early October, is a 4-step distilled model at 864×480
  • Open vs closed: open weights and code, Apache-2.0. Both checkpoints are fine-tunes of Wan2.2-TI2V-5B
  • Where to run it today: clone the repo and run scripts/generate.py, or use the Python pipeline. The weights download on first use. You need a GPU with at least 40 GB of memory and ffmpeg. There's no ComfyUI node or hosted demo yet
  • Training code: the full recipe is included, from fine-tuning Wan2.2 on long spans to distilling down to 4 steps with Self-Forcing and DMD

How it works

Most streaming world models only attend to a short window of recent frames. If you come back to a spot after a few minutes, the first visit has already left the window, so the model has nothing to stay consistent with. You could train on clips long enough to hold both visits, but dense attention over minutes of video gets very expensive.

Memorizon separates the two. Each training sample covers a long span, up to 400 seconds, but the loss is only scored on the last few chunks. Those chunks don't read the whole history. Each one pulls in the few earlier frames whose camera view overlaps with its own most, and those picks are merged into one shared memory bank. The bank has a fixed size, so the input stays short no matter how long the span is.

The paper's numbers back that up. Going from 100-second to 400-second training spans adds only 12% to the step time. Compared with a sliding-window baseline, retrieval improves revisit consistency on every test split. Training on spans long enough to reach the first visit adds another 24% to 30%, with some cost in image quality. When the team filled the memory bank with frames from a different episode, revisit correlation fell by 83%, which shows the model really uses what it retrieves.

Try it

git clone https://github.com/TingtingLiao/memorizon.git && cd memorizon
conda create -n memorizon python=3.11 -y && conda activate memorizon
pip install -e .

# native-resolution checkpoint, steered by keyboard (one key per 0.25 s)
python scripts/generate.py --checkpoint Luffuly/memorizon-1280x704-50step \
    --image photo.jpg --actions "w*16 l*24 w*16 l*24" --output out.mp4

The controls work like a game:

  • w and s move forward and back by 0.25 m, and a and d strafe left and right
  • j and l turn left and right by 7.5°, and i and k look up and down
  • . stays still, *N repeats a key N times, and keys can combine in one step, so wl walks forward while turning right

So w*16 l*24 means four seconds walking forward, then a 180° turn over six seconds. That's a quick way to test whether the scene behind you survives.

If you skip --prompt, Qwen3-VL-8B captions your first frame automatically. Custom prompts should follow the same style, starting with a perspective line like "First-person perspective — character not visible." and then one descriptive paragraph. For full control, --trajectory takes a [T, 4, 4] array of camera poses. The repo includes sample walks recorded in Unreal Engine scenes.

For faster drafts, swap in --checkpoint Luffuly/memorizon to use the 4-step 864×480 model.

Why it matters for game builders

  • Real game controls: WASD plus look keys maps straight onto a first-person controller, so you can pipe player input into it without inventing an action format
  • Places that persist: the whole training recipe is aimed at revisits, which is what turns a pretty video into a space you can actually explore and return to
  • Two speeds: prototype with the 4-step 864×480 model, then render hero shots with the 1280×704 checkpoint
  • Your own worlds: the training config supports longer spans just by changing one setting, and the data format is documented, so a studio could fine-tune on walkthroughs captured from its own engine

The limits are real, though. You need 40 GB of VRAM, the 50-step checkpoint is much slower than the distilled one, and training uses 32 GPUs across 4 nodes. The quality numbers are the authors' own, not an independent benchmark.

Original Source

https://huggingface.co/Luffuly/memorizon-1280x704-50step

https://github.com/TingtingLiao/memorizon

https://huggingface.co/Luffuly/memorizon

https://tingtingliao.github.io/memorizon/

https://arxiv.org/abs/2610.00544

Conclusion

Memorizon doesn't try to make a world model see everything at once. It teaches the model to look up the few frames that matter when you return somewhere, which keeps training cost flat while spans stretch to minutes. With a keyboard interface, Apache-2.0 code, and now a native-resolution checkpoint, it's one of the easier open world models to drop into a first-person prototype, as long as you have a 40 GB card.

—Titus