H3-World Turns a Keyboard Into a Prompt Compiler, and the Whole Thing Is 131 MB
A look at the action-control LoRA that lets you drive a character and a camera through generated video with W, A, S and D, what it actually does under the hood, and the three numbers that decide whether you can run it.
The released H3-World checkpoint is 131,227,832 bytes. The model it steers is about 135 gigabytes. That ratio, roughly a thousand to one, is the most interesting fact in generative video this week, and it is stated plainly in the project's own setup table where most releases would have buried it.
Here is what those 131 megabytes buy. You give the system one still image and a short sequence of keystrokes. W walks the character forward. A and D strafe. I, J, K and L move the camera, with F for fast. Out comes about five seconds of video in which those things actually happen, in the order you scheduled them, with sound. No new architecture. No action encoder. No control network. A rank-32 adapter and a patch file.
I want to argue that this is a bigger result than the demo video makes it look, and also that the word "interactive," which appears in the first sentence of both the GitHub and Hugging Face READMEs, is doing work it has not earned yet. Both things are true, and holding them at once is the only way to use this well.
Why a 131 MB adapter is the story
For two years the assumption in controllable video has been that control needs plumbing. If you want camera moves you build a camera-conditioning branch. If you want character actions you train an action module and feed it a separate embedding stream. Every control axis costs you an architecture.
H3-World says no. The paper's finding, from Danze Chen, Zeqing Wang and Yeying Jin at Tencent and the National University of Singapore, working with Ziyue Lin and Xingyi Yang at Hong Kong Polytechnic University, is that MiniMax H3 could already respond to natural-language descriptions of character behavior and camera motion, zero-shot, before anyone trained anything. It just responded vaguely. Ask for "walk forward, then turn left" and you get a five-second smear where both instructions apply to the whole clip at once.
So the fix is not to add a control system. The fix is to schedule the language the model already understands.
That reframing is why the numbers are so small. The adapter learns 65.6 million parameters, which the authors put at 0.199% of the 33-billion-parameter backbone. It trained on 8,000 gameplay clips pulled from the ABot-World-Explorer-500h dataset, for 10,000 optimization steps. Compare that to what a from-scratch action-conditioned video model costs and the gap is not close.
If you make things for a living, the practical read is this: the next control scheme you get will probably not require a new model either. It will require somebody deciding what W means.
What actually happens when you press W
This is the part worth understanding, because it changes how you should write prompts for it.
H3-World converts keyboard state into one language instruction per future video latent. Not one instruction for the clip. One per latent, and the ComfyUI build exposes 37 of them. Your keystroke sequence gets compiled into a stack of short text instructions, each addressed to a specific slice of time in the video that has not been generated yet.
Then it binds each instruction to its slice. The paper calls this temporal attention routing. Both READMEs call it directed attention routing, which is the same mechanism under a second name, so do not be thrown when you see both. What it does is restrict each instruction's attention to its intended interval, which is what stops the "turn left" you scheduled for second four from bleeding backward into second one. The paper's own word for the problem is control leakage.
The analogy that made it click for me: this is not a joystick wired into the model. It is a keyframe track wired into the prompt. You are not steering during generation. You are writing a schedule of sentences and handing the whole schedule over at once. The keyboard is a compiler front end and the language instructions are the output.
Once you see it that way, the design decisions stop looking arbitrary. The full key-to-language mapping lives in a single readable file, code/abot/action_script.py. That means the vocabulary is editable. If you want a new action, you are not training a new module, you are writing a new sentence and deciding which latents get it.
About the word "interactive"
The GitHub README opens with "H3-World is the first interactive world model built on MiniMax-H3." Note the qualifier at the end, which is doing a lot of load-bearing work, and note what happens when you actually run the thing.
The official inference command takes a single --action-preset flag. You pick from eleven of them: still, forward, back, strafe-left, strafe-right, tilt-up, tilt-down, pan-left, pan-right, pan-left-fast, pan-right-fast. You add a seed, a step count, a frame count, and an output path. Then you wait for a 5.2-second clip.
Nothing responds to you while it renders. There is no loop, no state, no next frame conditioned on what you just pressed. The ComfyUI build is the same shape: a fixed contract of 832x480, 124 frames at 24 fps, 50 Euler steps, CFG 1.0, and an action timeline you author before you hit queue.
I do not think this is dishonest, exactly. The research sense of "interactive world model" is a model that accepts action inputs, and this one does. But a creator reading that phrase pictures playing something, and you cannot play this. You author an action score and render it, the same way you would render anything else. Budget your expectations there and the tool is excellent. Arrive expecting a game and you will be annoyed inside ten minutes.
The honest framing is that H3-World is a directable clip generator with a keyboard-shaped interface for describing motion. That is genuinely useful and it is not the same claim.
Put this into practice
Two paths, and I would take them in this order.
1. Try it hosted, in about five minutes. There is a free Space at hugging-apps/h3-world-action-demo. Start here, because the next path costs you a 135 GB download and you should know whether the motion quality is good enough for your work before you spend an evening on it. Feed it an image with a clear single subject and a readable ground plane. Interior spaces work better than open landscapes for the same reason they do in games: the camera has something to move relative to.
2. Run it in ComfyUI, in about an hour if the base model is already down. This is the path most people will want, and it exists because someone mirrored the LoRA into an install-ready folder layout on September 4.
- Install the node pack through ComfyUI Manager, searching for
MiniMax H3 Audio T8. Then fully quit ComfyUI and relaunch it. Restarting the server is not enough and the nodes will show up red. - Get the LoRA:
hf download t8star/Minimax-H3-World-Comfy --include "loras/**" --local-dir ComfyUI/models. It has to land atComfyUI/models/loras/minimax/H3-World/step-10000.safetensors. - You also need the full MiniMax H3 base at
models/diffusion_models/minimax_h3_fl2va_int8_convrot.safetensors, plus the Qwen3-VL text encoder and both the video and audio VAEs. This is the hour. - Put
ffmpegon your PATH. The final save step needs it and will fail at the very end of a render if it is missing, which is the most annoying possible place to fail. - Open
examples/workflows/26-h3-world/2026-09-04_H3_World_I2VA_832x480_124f_50step_Advanced.json. Swap in your first frame and your model paths. Change nothing else on the first run.
The setting people will want to fiddle with first is resolution, and that is the one to leave alone. The contract is fixed at 832x480 for a reason, and a first frame at a different aspect ratio gets proportionally covered and then center-cropped. It will not stretch your subject, it will cut off the edges of it, which is worse because you might not notice.
If you want to go to the source instead, the official repo runs on Python 3.10 and CUDA 12.8 with torch 2.10.0, and it needs a specific patched checkout of DiffSynth-Studio. You clone DiffSynth, check out the exact commit recorded in code/diffsynth_base_commit.txt, and apply code/diffsynth_h3_action.patch. Do not skip this. The Hugging Face card is blunt about why: "loading the LoRA through an unmodified MiniMax-H3 pipeline will not reproduce the reported behavior." The routing mechanism lives in the patch, not in the weights. A 131 MB file plus the wrong pipeline gives you a normal video with a slight accent.
The repo also ships a held-out test frame at examples/first_frame.png and a matching scene prompt, so you can reproduce their exact result before you try your own image. Do that first. It is the fastest way to find out whether your install is right.
Honest limitations
The base model is the real cost, and it is not VRAM. Everyone fixates on VRAM and this is a download problem. About 135 GB for MiniMax H3 base weights per the project's own table. The 131 MB adapter is free in every sense that does not matter.
Five seconds is the ceiling, and it is a hard one. 124 frames at 24 fps is roughly 5.17 seconds. There is no continuation path in this release. Every shot is an island.
One preset per run, in the official CLI. The ComfyUI build gives you a custom mode where you write action segments as JSON, which is the real capability, but the reference implementation is one preset for the whole clip. If you were picturing a complex choreographed move on your first attempt, plan on the JSON path.
It does not stack. In ComfyUI you cannot combine this with OpenVDN, SLA, VSA, Sol-Attn or BlockCache. Each of those takes over the model or the attention path, and so does this. The speed tricks you may already be running are off the table for these renders.
Memory is genuinely tight. The node pack's own serial tests on a 16 GB card with the full base left between 535 and 890 MB of VRAM free. Run one job at a time. If you need headroom, drop the frame count before you drop the step count.
The evidence base is one parking garage. The pack reports a blind test in which users correctly identified the continuously-forward version on a fixed sample, described as a man in a yellow floral shirt in a dim multi-level concrete parking garage. That is a real result and it is one scene from the held-out split of the training distribution. The paper claims generalization to unseen scenarios. I would test your own content before believing that about your own content.
And the license, which decides everything else. The LoRA is Apache 2.0. That badge covers 131 MB out of roughly 135 GB. The base weights ship under the MiniMax H3 Community License Agreement, whose applicable territory excludes the European Union, the United Kingdom, South Korea and the United States. Read that sentence again if you live in one of those places. The node pack's README states it directly in its license section, which is more honesty than most ports offer, and it is also the reason a lot of readers of this article should treat H3-World as a thing to understand rather than a thing to run.
What I would watch next
The result that matters here is not the demo. It is that 0.199% of a video model's parameters was enough to turn a vague language interface into a precise temporal one. If that generalizes, the interesting work for the next year is not in training bigger generators. It is in designing the vocabularies. Somebody has to decide what W means, and what the sentence attached to it says, and which latents receive it.
That file, action_script.py, is a text file you can open. Eleven presets is a starting vocabulary, not a limit. The obvious next move is somebody publishing an action script for something that is not a game: a dolly and a rack focus and a whip pan, mapped to keys, trained on footage that is not gameplay clips.
If you get the ComfyUI path running on your own images, I would like to know what broke. My guess is that it holds up on interiors and falls apart the moment the first frame has no clear ground plane, but that is a guess, and it is the kind that one afternoon of your renders would settle better than another paper would.
Sources: arXiv:2609.01560 · H3-World weights · official code · ComfyUI package · node pack · hosted demo
Medium metadata
Title: H3-World Turns a Keyboard Into a Prompt Compiler, and the Whole Thing Is 131 MB
Subtitle: A look at the action-control LoRA that lets you drive a character and a camera through generated video with W, A, S and D, what it actually does under the hood, and the three numbers that decide whether you can run it.
Tags: AI Video, ComfyUI, Generative AI, Open Source, Machine Learning
Suggested kicker: The adapter is 131 MB. The model it steers is 135 GB. That ratio is the point.