Hy-Nomas in ComfyUI: Run Tencent’s Interactive World Model With WASD Controls

Most AI video models give you one clip and stop. Hy-Nomas, released by Tencent Hunyuan on October 21, 2026, works more like a video game engine. You describe a world in text, and the model renders it as 720p video at 24 fps. Then you keep steering it, turn by turn, with new text instructions and camera moves from your keyboard and mouse. Each new segment remembers what came before, so you can walk down a street, turn around and still find the same buildings behind you. Two days after the release, a community port called ComfyUI-HyNomas brought it to ComfyUI, with an interactive explorer node you can drive with WASD. This guide explains what Hy-Nomas is, which files to download, how to set up the ComfyUI nodes, how to write world prompts and camera paths, and what to expect on a 16 GB GPU.

What Is Hy-Nomas?

Hy-Nomas (“Towards Free-Form Interactive World Generation”) is what researchers call a world model: a video generator that you can interact with while it runs. Instead of writing one prompt and waiting for a finished clip, you build the video in turns:

1. You describe the opening: the perspective (first person, third person follow or observer), the style (real world, CG, video game, animation or anime), the main subject and the scene.
2. Hy-Nomas renders the first segment.
3. You decide what happens next. You can type a change (“it starts to snow”, “the dragon lands on the tower”), move the camera with the keyboard and mouse, or do both at once.
4. Hy-Nomas renders the next segment, continuing from the last one, and so on.

Tencent released everything: the weights, inference code, training code, data annotation code, a benchmark called Hy-Nomas-Bench with 280 test cases, and an online demo at hy-nomas.hy.tencent.com. One of their gallery examples is a 60-second video built from five 12-second text turns, which gives you an idea of how far a single world can go.

If you have only used clip generators like MiniMax H3 or Wan, the closest thing you may have tried is chaining clips with an extender. Hy-Nomas builds that chaining into the model itself, and adds real camera control on top. If you want a comparison with the clip-based models, see my best local AI video models roundup.

How It Works: Segments and Memory

Hy-Nomas is autoregressive across segments. Each turn you take becomes one video segment. Inside a segment, the model looks at all frames in both directions, the way a normal video diffusion model does. Between segments, it uses a key/value cache: a compressed memory of the earlier segments that the new segment can attend to. That cache is what lets the world stay consistent when you come back to a place you already saw.

Camera control works through camera matrices. When you press W or drag the mouse, your moves are recorded at 24 fps and turned into a camera trajectory for the next turn. The model only receives the direction and relative speed of the movement, because translations are normalised per turn. Rotation is scaled up by 2.5x by default, so mouse looks have a visible effect. Text and camera guidance are both set to 1.0 in the distilled model.

The output frames are not decoded by a normal VAE. Hy-Nomas uses a fine-tuned version of NVIDIA’s PixelUMM decoder, which turns small 4x16x16 blocks of latents into pixels in a single step, working over 10-frame windows with 5 frames of overlap. That decoder is why the VAE file is so large (15.8 GB), and it is also where the licence catch comes from (see below).

Specs at a Glance

Tencent has not published a total parameter count yet. The technical report is marked “coming soon”.

License: What You Can and Cannot Do

This part matters if you make videos for clients or monetised channels. The Hy-Nomas model code and DiT weights are released under Apache 2.0, which allows commercial use. However, the ComfyUI port’s README points out that the PixelUMM decoder weights are a fine-tune of NVIDIA PixelUMM under the NVIDIA One-Way Noncommercial License, and marks them as non-commercial only. Since every frame you see passes through that decoder, the safe reading is that videos from the standard pipeline are for personal, research and experimental use. If you plan to use Hy-Nomas output commercially, read both licences yourself first.

Install ComfyUI-HyNomas

Hy-Nomas has no native ComfyUI support yet and there is no Comfy-Org repack. The working option is the community pack by Nynxz, which the author describes as “pure ComfyUI and torch” with no extra requirements.

1. Update ComfyUI to a current build.
2. Install the pack:

   cd ComfyUI/custom_nodes
   git clone https://github.com/Nynxz/ComfyUI-HyNomas

3. Restart ComfyUI. The two example workflows appear under Templates, Custom Nodes, and are also in the pack’s example_workflows folder:
   • nomas_explore.json: the interactive explorer
   • nomas_world.json: a scripted world with an opening turn, a camera turn and a text turn, decoded to video

Model Files and Folders

The ComfyUI port uses converted weights from nynxz/Hy-Nomas, not the original Tencent files. The pack refuses Tencent’s own distilled_int8 format with a message, so do not try to load that one.

If you already run Qwen-Image, you have the text encoder. The fp8 scaled version is the better pick on 16 GB cards. In total, plan for about 35 GB of disk space with the INT8 DiT.

The Nodes Explained

The pack uses ComfyUI’s stock loaders and adds its own world nodes:

Using Nomas Explore (WASD Mode)

This is the fun way to use Hy-Nomas. Load nomas_explore.json, check that the three loaders point at your files, and queue it once to build the opening turn. Then:

1. Click inside the viewer so it captures your keyboard.
2. Move with W, A, S and D, turn with the arrow keys, or drag the mouse to look around. Your moves are recorded at 24 fps and queued for the next turn.
3. Press Text turn to type a change in words instead of (or together with) a camera move.
4. Each new turn renders only its new frames, plus 5 overlap latents that are cross-faded into the previous turn so the join is smooth.
5. Use Undo to throw away a turn you do not like, and New world to start over.
6. When you are happy, press Save video. It writes an MP4 to ComfyUI/output/video.

It is not real time. Each turn takes seconds to render, so think of it as “move, wait, watch” rather than playing a game. Short moves of 1 to 3 seconds per turn give you the most control.

Scripted Worlds With Camera Paths

If you want a repeatable result, use nomas_world.json instead. Here the camera moves are written as text in the Nomas Camera Path node, one move per line, in the format <keys> <seconds>:

w 2
w+left 1.5
wait 1
look 30 0 1
s 1

• w 2: walk forward for 2 seconds
• w+left 1.5: walk forward while turning left for 1.5 seconds
• wait 1: hold still for 1 second
• look 30 0 1: a mouse drag of 30 horizontally and 0 vertically over 1 second
• s 1: step back for 1 second

The total of the seconds sets the length of that turn, so this example makes a 6.5 second segment. Chain several Nomas World Continue nodes to build a longer world: for example, a camera turn that walks into a market, then a text turn that says “a street performer starts juggling fire”, then another camera turn that circles him. Decode the final latent with VAE Decode and save it with your usual video node.

Writing Good World Prompts

The Nomas World Prompt node splits the opening into fields, which helps a lot. Some tips:

• Pick the perspective on purpose. First person works best for walking and exploring. Third person follow is better when the subject matters, such as a character or vehicle. Observer suits scenes you watch from a distance.
• Describe one subject clearly. The node supports one subject, referred to as <|Subject1|>. Give it a short, concrete description (“a red-haired girl in a yellow raincoat”) and keep using the tag in later turns.
• Make the scene explorable. “A narrow medieval street with market stalls on both sides and a cathedral at the far end” gives the camera somewhere to go. “A beautiful place” does not.
• Change one thing per text turn. Hy-Nomas was trained on turns with a description of the change, so “the sky turns orange as the sun sets” works better than rewriting the whole scene.
• Match the style to the training data. The official gallery covers real world, CG, video game, animation and anime styles. Stay within those for the best results.

Here is an example opening in plain words:

Perspective: third-person follow
Style: video game
Subject: <|Subject1|> is a small explorer robot with a round body, one blue eye and two thin legs
Scene: a mossy forest of giant mushrooms, with glowing spores floating in the air and a stone archway ahead
Action: <|Subject1|> walks slowly towards the archway

Then follow it with a camera turn (w 3) and a text turn such as “<|Subject1|> passes under the archway and a hidden valley with a waterfall appears”.

Note that every world starts from text. The port has no image-to-world input, so you cannot start from a photo yet.

Running It on 16 GB VRAM

Tencent’s reference setup uses eight GPUs, and their single-GPU configuration targets a 24 GB RTX 4090 with heavy offloading: the DiT and cache in INT8, the decoder in FP8, and each model moved to the GPU only for its stage. Neither Tencent nor the port author has published a VRAM figure. The ComfyUI port uses ComfyUI’s normal memory management, so offloading works as it does for other big models. On a 16 GB card like my RTX 5080, these settings give you the best chance:

• Use the INT8 DiT (9 GB), not the 17.1 GB bf16 file.
• Use the fp8 scaled text encoder.
• Keep window mode on. It is the default and keeps 18 past latent frames on the GPU (always including the first and the newest). Full mode keeps every frame and costs about 0.2 GB of VRAM per latent frame, which adds up fast.
• Use short turns. The history budget does not limit the memory used by the current segment, so a 12-second turn needs far more VRAM than a 3-second one.
• Have plenty of system RAM. Offloaded models sit in RAM. The port stores the INT8 cache in memory-mapped files in ComfyUI’s temp folder, so long worlds lean on the page cache, so I would plan for 64 GB of RAM with this pipeline.
• Use a fast SSD for both the model files and ComfyUI’s temp folder.

For reference, one user reported about 21 seconds per 3-second turn on an RTX 5090 with the INT8 DiT at 1280×704, plus about 4 seconds of decoding per 10-latent window. Expect a 16 GB card to be noticeably slower because of the offloading. For general ComfyUI memory fixes, my 16 GB out of memory guide covers launch flags and settings that also apply here.

The Official Tencent Repo (Linux, Multi-GPU)

If you have a Linux box with several GPUs, you can run the original code from Tencent-Hunyuan/Hy-Nomas. Tencent recommends their Docker image hynomasoss/hynomasoss:cu130, which bundles PyTorch, FlashAttention and MagiAttention. A manual install needs Python 3.12+, uv, the CUDA 13.0 toolkit and a C++ compiler:

git clone https://github.com/Tencent-Hunyuan/Hy-Nomas.git
cd Hy-Nomas
docker pull hynomasoss/hynomasoss:cu130
# or: uv sync --extra all && source .venv/bin/activate

The official pipeline reads its turns from a JSON prompt file with fields like segments, visual_description_long, description_change and contained_actions, and camera moves from trajectory files with camera-to-world matrices. The web demo also needs Tencent’s separate prompt enhancement service (Nomas-PE). For most people on Windows with one GPU, the ComfyUI port is the easier route.

The official release also includes two LoRAs: a Cinematic LoRA for better visual quality and a Robotics LoRA trained on dual-arm robot footage. LoRAs need the floating point (bf16 or fp32) DiT, because the INT8 loader cannot apply a separate LoRA at inference time.

Limitations

• Not real time. Each turn takes seconds to tens of seconds, even on top cards.
• Text only start. No image-to-world input in the ComfyUI port yet.
• Big downloads. About 35 GB for the smallest working set.
• Non-commercial decoder. The PixelUMM licence limits commercial use of the output.
• Young port. ComfyUI-HyNomas is a few days old and unofficial, and the speed figures so far come from single users. Expect updates and the occasional breaking change.
• Memory grows with the world. Long sessions need lots of system RAM and disk cache.

FAQ

What is Hy-Nomas?

Hy-Nomas is Tencent Hunyuan’s open interactive world model. It generates 720p, 24 fps video one segment at a time, and you control each segment with text instructions and camera moves.

Does Hy-Nomas work in ComfyUI?

Yes, through the community pack ComfyUI-HyNomas by Nynxz. It is not built into ComfyUI and there is no official Comfy-Org repack yet.

How much VRAM does Hy-Nomas need?

Tencent’s single-GPU setup targets a 24 GB RTX 4090 with offloading. No official VRAM number is published. In ComfyUI, the 9 GB INT8 DiT with offloading, window mode and short turns is the way to try it on 16 GB.

Can I use Hy-Nomas videos commercially?

The Hy-Nomas model is Apache 2.0, but the PixelUMM decoder weights are under NVIDIA’s non-commercial licence. Treat the output as non-commercial unless you have checked both licences for your use.

Can I start a world from my own image?

Not in the ComfyUI port. Every world starts from a text description.

How long can a Hy-Nomas world be?

There is no fixed limit, since you keep adding turns. Tencent’s gallery includes a 60-second video made from five 12-second turns. In practice, RAM and disk cache set the limit.

Final Thoughts

Hy-Nomas is the first open world model that feels usable on a home PC. Walking through a world you described in one sentence, and steering it with WASD, is very different from waiting for a single clip. It is slow, the downloads are huge and the decoder licence rules out commercial work for now, but the ComfyUI port makes it easy to try. Start with nomas_explore.json, keep your turns short, and use window mode on a 16 GB card.

More local AI video guides on Freakyjolly:

• Best Local AI Video Models in 2026
• MiniMax H3 Extender: Turn 1 Reference Image Into Multiple Connected Clips
• Best MiniMax H3 Text-to-Video Workflow for ComfyUI
• MiniMax H3 Out of Memory in ComfyUI: 16 GB GPU Fixes

Sources

• Hugging Face: tencent/Hy-Nomas (model card)
• GitHub: Tencent-Hunyuan/Hy-Nomas
• GitHub: Nynxz/ComfyUI-HyNomas (README)
• Hugging Face: nynxz/Hy-Nomas (ComfyUI weights)
• Hugging Face: tencent/Hy-Nomas-Bench
• ComfyUI Wiki: Hy-Nomas news