Introduction

Tencent just put Hy-Nomas on Hugging Face: an open video world model that generates a world one segment at a time while you keep steering it with text instructions and camera paths. Weights went public on October 23 under Apache 2.0, inference code is on GitHub, and there's a free web demo if you just want to poke it.

Most world models we've covered take WASD and a mouse. Hy-Nomas takes sentences. Start a scene, then on the next turn say "glowing flowers open beside the path" or "it starts raining" or "switch to watercolor," and the model continues the same world with that change baked in, while a persistent KV cache keeps earlier segments in context.

What shipped

  • Model: Hy-Nomas ("Towards Free-Form Interactive World Generation")
  • Vendor: Tencent Hunyuan
  • Modality: text + camera trajectory to streaming video world (segment-autoregressive)
  • Access: open weights and inference code, Apache 2.0
  • Where to run it today: the hosted Hy-Nomas demo, or locally from the GitHub repo (Docker image recommended)
  • Output: 720×1280 at 24 FPS, 8 denoising steps with the distilled DiT
  • Also released: Hy-Nomas-Bench, 280 test cases for multi-turn text control, camera navigation, mixed text+camera, and spatial memory

What's inside

The backbone is a 54-block dual-stream MMDiT (2,048 hidden) running in DCAE-V latent space (32 channels, 32× spatial and 4× temporal compression). Text comes in through the language half of Qwen2.5-VL-7B-Instruct; camera motion comes in as 4×4 extrinsic matrices through cross-attention in every block. Attention is causal across segments, so each new chunk only looks back. A fine-tuned PixelUMM transformer decoder turns latents into pixels in one step.

The repo ships several checkpoints:

AssetWhat it's for

Distilled DiT (FP32)

Main 8-step model, used by the demo

Distilled DiT (INT8)

Single-GPU low-memory config

Base autoregressive DiT

Non-distilled research checkpoint

Cinematic LoRA

Optional visual-quality adapter

Robotics LoRA

Robot-arm simulation adapter (skip it for games)

DCAE-V + PixelUMM (plus FP8 PixelUMM)

Latent autoencoder and default decoder

Hardware reality

The standard config is built for eight GPUs with 8-way sequence parallelism. The good news for indies is a separate single RTX 4090 config: INT8 DiT weights, INT8 KV cache, FP8 decoder, CPU offload, and a history budget of 18 latent frames on the GPU with older history archived to system RAM. Tencent is honest that this adds latency and that RAM use keeps growing as the world gets longer. The 24 FPS figure is playback rate, not a real-time generation promise.

How to drive it

Offline inference reads a JSON list of worlds. The first segment sets the scene; later segments describe what changes. This is the shape from the model card:

[
  {
    "test_id": "forest_world",
    "Style": "Cinematic fantasy",
    "perspective_view": "Third-person view",
    "subject_list": [
      { "subject_id": "fox", "display_name": "a small orange fox",
        "subject_attribute": "Orange fur, white chest, and a fluffy tail." }
    ],
    "segments": [
      { "start_time": 0, "end_time": 2,
        "visual_description_long": "A small orange fox stands on a stone path in a luminous forest. Blue fireflies drift between the trees.",
        "contained_actions": [{ "start_time": 0, "end_time": 2, "action_description": "The fox walks slowly along the path." }] },
      { "start_time": 2, "end_time": 4,
        "description_change": "Glowing blue flowers open beside the path as the fox continues forward.",
        "contained_actions": [{ "start_time": 2, "end_time": 4, "action_description": "The fox passes the flowers and looks around." }] }
    ]
  }
]

On a single 4090, setup and launch look like this:

git clone https://github.com/Tencent-Hunyuan/Hy-Nomas.git && cd Hy-Nomas
export HY_NOMAS_MODEL_DIR=/path/to/Hy-Nomas-models
bash scripts/inference/inference_from_config.sh configs/experiment/single_gpu_low_mem_inference.yaml \
  dit_weight="$HY_NOMAS_MODEL_DIR/DiT/distilled_int8/diffusion_pytorch_model_ema_0_995_int8.safetensors" \
  model.vae.checkpoint="$HY_NOMAS_MODEL_DIR/VAE/PixelUMM_FT_FP8/diffusion_pytorch_model_fp8.safetensors" \
  inference.prompt="$HY_NOMAS_MODEL_DIR/examples/prompts.json" \
  inference.save_path=./outputs/single_gpu

Add inference.camera_trajectory=/path/to/camera.npz (camera-to-world matrices plus intrinsics) to fly the camera on a scripted path, and use 'inference.video_size=[480,832]' if you want faster, smaller drafts.

Where it fits for game makers

  • Pitch and previs: narrate a level walkthrough beat by beat ("the bridge collapses," "fog rolls in," "cut to dusk") and get one continuous clip instead of stitched shots.
  • Event-driven worlds: the segment-plus-instruction loop maps cleanly onto game events, which makes it a handy testbed for AI-directed set pieces.
  • Not a game engine: there's no physics, collision, or state you can query. It's a video world, so treat it like the AMD Micro-World 2 class of tools: great for prototyping feel, not for shipping gameplay.
  • Demo needs an extra service: the local web demo also needs Nomas-PE, a separate prompt-enhancer server, so budget more GPUs than the single-card inference claim suggests.

Conclusion

Hy-Nomas swaps the keyboard for a director's script: you talk the world forward and steer the camera, and it keeps the earlier world in memory while it goes. Apache 2.0 weights, a 4090-sized config, and a public benchmark make it one of the most open text-steerable world models out there right now. Try the demo first, then pull the INT8 build if you want it in your previs pipeline.

—Titus