Hy-Nomas: Tencent Hunyuan's interactive world model

Hy-Nomas is Tencent Hunyuan's interactive world model: you describe a world, then keep steering it with text instructions and camera moves while the model keeps generating. The team published weights, inference code, training and data-annotation code on October 21, 2026 (tencent/Hy-Nomas | GitHub), plus an online demo and a dedicated benchmark. A community port for ComfyUI followed a day later.

The release is still young on the counters: 21 likes on Hugging Face and 21 stars on GitHub at the time of writing. Everything below comes from the model card, the repository and the official gallery, not from third-party testing.

One world, generated in segments

Hy-Nomas is autoregressive across video segments rather than across frames. Each segment is denoised from Gaussian noise in the model's compressed latent space while attending to a key/value cache of every segment produced before it. The prompt of the current turn, the camera trajectory and that cache are the only inputs, and attention is causal across segments, so generating a segment never needs a future one.

The distilled configuration runs 8 denoising steps with an Euler ODE solver at text and camera guidance 1.0, and writes 720 × 1280 at 24 FPS. Segment length comes from the prompt file: a JSON request lists segments with start and end timestamps, a visual_description_long for the opening, description_change for each later turn, and contained_actions with their own timestamps. Setting inference.video_length=event derives segment lengths from those event times.

The official gallery shows how that behaves over a longer run. This is one 60-second clip, clockwork-flight, built from five text-only turns of 12 seconds each, with a third-person follow camera in a CG style:

A six-second excerpt of the same clip, from the turn where the bird enters the clock tower. Generated by Tencent Hunyuan, captured from the official gallery.

Camera control as a first-class input

Camera motion is not a prompt suggestion but a separate conditioning path. A trajectory file holds camera-to-world matrices c2ws of shape [N, 4, 4] and intrinsics of shape [N, 3, 3], and the model normalises the extrinsics, groups them over four video frames and flattens each group into a 64-dimensional input, which the video tokens query through cross-attention in every double-stream block. Two scales expose the controls: trajectory_translation_scale defaults to 1.0 and trajectory_rotation_scale to 2.5.

Text and camera can also alternate within one run. The gallery separates its samples by style (real-world footage, CG, video game, animation and anime) and by perspective (first-person, third-person follow, third-person observer), and the demo lets you hold WASD and the arrow keys or drag the mouse to move through a generated world, with the move recorded at 24 FPS and played back on the next turn.

A first-person sample from the gallery, circuit-drive: a street circuit seen from inside a racing cockpit. Generated by Tencent Hunyuan.

Inside the model

The framework diagram from the release repository: text, video latents and camera trajectories feeding dual-stream MMDiT blocks.

Video lives in DCAE-V f32t4c32 latents: 32 channels, 32× spatial compression in each direction and 4× temporal compression. Decoding is handled by a fine-tuned PixelUMM decoder with 36 layers, a 4,096-dimensional hidden size, 32 query heads and 8 KV heads, which reconstructs RGB in 4 × 16 × 16 tubelets over temporal windows of 10 latent frames with 5 frames of overlap. That decode is a single step and is separate from the DiT's 8 denoising steps.

The single-4090 configuration

The reference setup spreads one inference group over eight GPUs with 8-way sequence parallelism and distributed decoding. A second configuration targets a single RTX 4090, and the changes are all memory management:

• The DiT weights and the cached keys and values are stored in INT8 while linear layers and attention still compute in BF16.
• The PixelUMM decoder runs in FP8 through CUTLASS kernels, and the DiT uses FlexAttention.
• The text encoder, DiT and decoder are moved to the GPU for their own stage and offloaded to CPU afterwards.
• GPU history is bounded to 18 historical latent frames sampled by temporal_context, with older history archived in system RAM.

The card is explicit about the trade-offs: system RAM has to hold the offloaded models and a growing history archive, CPU to GPU transfers add latency, and the history budget does not cap memory for the current segment. No per-segment timing is published, so speed on a 4090 is unverified as of writing.

LoRA fine-tuning and the prompt service

Two adapters ship with the release. A Cinematic LoRA is offered as an optional visual-quality adapter for a compatible floating-point DiT, and a Robotics LoRA is trained on the RealSource-World robotic-arm dataset and is meant to be merged into the distilled DiT to strengthen simulated manipulation in the generated world. The INT8 loader cannot load a separate LoRA at inference time, so adapter work goes through the BF16 or FP32 weights.

The repository also carries the fine-tuning path: SFT data preparation, offline sequence packing for long sequences, then training and merging. For the web demo there is one hard dependency, Nomas-PE, a separate service that turns a user instruction into a structured generation prompt; offline inference can read prepared prompt files and skip it. A prebuilt Docker image (hynomasoss/hynomasoss:cu130) carries PyTorch, FlashAttention and MagiAttention, which saves building the CUDA kernels by hand.

Hy-Nomas-Bench

Alongside the model the team released Hy-Nomas-Bench, four benchmarks with 280 test cases covering multi-turn free-form text interaction, camera navigation, interleaved text and camera control, and spatial memory. The dataset ships structured prompts, interaction sequences, keyboard timelines and reference camera trajectories, which makes it usable for scoring consistency across a long generated run rather than on single clips.

Availability

There is no native ComfyUI support in this release: no core nodes, and no Comfy-Org repack. The official paths are the GitHub repo with the Docker image, and the hosted interactive demo.

For ComfyUI, the community port Nynxz/ComfyUI-HyNomas appeared on October 23 with converted weights in nynxz/Hy-Nomas:

The port loads the DiT through the stock Load Diffusion Model, the text encoder through Load CLIP using ComfyUI's own qwen_2.5_vl_7b.safetensors with type qwen_image from Comfy-Org/Qwen-Image_ComfyUI, and the decoder through Load VAE, so no custom kernels are needed. Its author reports about 21 seconds for a 3-second turn on an RTX 5090 with the INT8 checkpoint at 1280 × 704, plus roughly 4 seconds of decoding per window. Treat those numbers as one user's measurement on a port that was one day old, and keep the 4090 targets of the official configuration separate from them.