Hunyuan-GameCraft

Hunyuan-GameCraft

Tencent Hunyuan · Video · Coding

Hunyuan-GameCraft is Tencent's open model that turns one picture, a prompt and keyboard or mouse input into controllable game video. It runs on a consumer GPU.

Interface preview of Hunyuan-GameCraft

About Hunyuan-GameCraft

What Is Hunyuan-GameCraft

Hunyuan-GameCraft is an open video generation model built by the Tencent Hunyuan team for game scenes. You give it a single reference image, a text prompt and an action signal, and it produces footage where the camera moves the way a player would move it. Tencent released the inference code and weights for version 1.0 on August 14, 2025, and the paper is on arXiv.

Most video models treat a scene as a clip to replay. This one treats it as a space you steer. When you press W, the model doesn't learn "forward" as an idea. It translates that key into a concrete camera path, a sequence of positions and rotations, and draws the world along that path. That approach is why it handles speed and angle, not just direction, and why the scene keeps its shape when you turn away and come back.

It isn't a full game engine, and it doesn't do interactive game video generation the way a runtime would. It generates video, not interactable geometry, so you can't drop its output into a playable build the way you would a 3D scene. Treat it as a production tool for prototypes and previsualization, not a runtime. You need a supported NVIDIA GPU and the setup skill to run it locally.

Getting Started

  1. Clone the Hunyuan-GameCraft repository from GitHub and install the Python dependencies listed in the project
  2. Download the pretrained model weights from Hugging Face or the project page
  3. Prepare a reference image of your scene and write a short prompt that describes it
  4. Run inference, passing your keyboard or mouse action signal to drive the camera through the scene
  5. Review the generated clip and adjust the prompt or the action path for another pass

Product Information

A quick look at Hunyuan-GameCraft's pricing, supported platforms, and performance.

Free PlanYes
Paid PlansFree (open source, self-hosted)
PlatformLinux (NVIDIA GPU), open source code and model weights on GitHub and Hugging Face
DeveloperTencent Hunyuan
CategoryVideo · Coding
Release DateAug 2025
Latest UpdatedAug 2025
Website Visits1.7K
Website Global Rank11.2M
API AvailabilityNo

Best for

The users, tasks, and scenarios where this tool fits best.

Users

  • Game developers prototyping scenes
  • Indie creators and solo devs
  • AI researchers studying world models
  • 3D and concept artists

Tasks

  • Turning a still into moving game footage
  • First and third person camera work
  • Long takes with consistent scenes
  • Previsualization for pitches

Scenarios

  • A studio wants to show a level's feel in a concept meeting before any engine work starts
  • A solo creator has one good scene image and needs video of it for a portfolio or trailer
  • A researcher needs a cheap, reproducible interactive video model to test camera control ideas on
  • An artist wants to test how a scene reads when the viewer walks through it from a different angle

Key features

Image to controllable game video

Hunyuan-GameCraft starts from a single reference image and a text prompt, then generates a moving game scene from it. You aren't animating frame by frame. A light action encoder reads your input and drives the camera through the scene. The result is footage that looks like gameplay rather than a slideshow of the still. This is the core of what the model does, and everything else supports it.

Unified keyboard and mouse control

The model maps standard keyboard and mouse input into one shared camera space. In practice, that means it understands speed and angle, not just left or right. You can move forward while turning the view, the kind of combined action a real player performs without thinking. Discrete key presses become smooth camera motion through interpolation, which is what keeps the output from looking jerky.

Hybrid history conditioning for long takes

Long videos usually fall apart. The scene shifts shape, objects vanish, and the world forgets what it looked like a few seconds ago. Hunyuan-GameCraft uses a hybrid history-conditioned training strategy that extends the sequence autoregressively while keeping the original scene information. Turn the camera away and back, and the layout is still there. This is what makes multi-minute walks hold together instead of degrading.

Model distillation for real-time use

A model this size would normally need a data center to feel interactive. Tencent distilled it so inference runs faster and lighter while keeping consistency across long sequences. The result is deployment on a consumer card like an RTX 4090 rather than a cluster. Lower overhead is the difference between a research demo and something a developer can actually sit and drive.

First and third person views

The framework generalizes beyond a single viewpoint. It handles first-person scenes, where the viewer is the camera, and third-person scenes, where a character is on screen and the camera trails it. Both come from the same reference image setup. That range matters because games don't use one camera style, and a model locked to a single view has limited use.

Trained on large-scale game data

The model was trained on over one million gameplay recordings spanning more than 100 AAA games, then fine-tuned on a curated synthetic set for precision. That breadth is why it handles varied art styles, from realistic streets to stylized villages, and keeps visual fidelity across them. The finetuning pass is what tightens control rather than just widening coverage.

Pros and cons

Pros

  • Turns a single image into moving, steerable game video, cutting the cost of a modeling and rendering pipeline
  • Unified keyboard and mouse control gives fine action control, including speed and angle, not just direction
  • Hybrid history conditioning keeps long takes consistent, so scenes survive big camera moves
  • Distillation lets it run on a consumer GPU like an RTX 4090 instead of a server cluster
  • Open source code and weights, so you can inspect, run and build on it yourself

Cons

  • It generates video, not interactable 3D geometry, so output can't go straight into a playable build
  • Running it locally means dealing with Python setup, dependencies and model downloads before you see anything
  • It needs an NVIDIA GPU with enough memory, so it isn't a browser tool you open on any laptop
  • There's no hosted API, so teams that want a managed service have to self-host the whole stack

Frequently asked questions

It takes a reference image, a text prompt and a keyboard or mouse action, and generates game video where the camera moves the way you steer it. You get playable-looking footage from a single still.