StreamRender-H3 Real-Time Video Generation Model: 8GB+ VRAM, File List

StreamRender-H3 Real-Time Video Generation Model: 8GB+ VRAM, File List

At a Glance

Item Value
Repository Efficient-Large-Model/StreamRender-H3
Publisher guide Efficient Large Model (NVIDIA and MIT): models and licenses
Published 2026-10-11
License minimax-h3-community
Formats safetensors / PyTorch (bin)
Source type Primary source (the publisher itself)

Values determined by this site’s code when the information was collected. Dates are JST.

Overview

Efficient-Large-Model has released “StreamRender-H3", a model capable of real-time streaming diffusion rendering. This system adopts a configuration that splits interactive virtual worlds into two roles: a “Code Game Engine" and a “Streaming Diffusion Render".

The game engine side manages the state of the world, such as physics calculations and maps via code, and streams semantic maps frame by frame. Built on top of MiniMax-H3 Ref2VA, StreamRender-H3 is a two-step streaming video generation model that renders input semantic maps into real-time photorealistic videos while maintaining the appearance set by reference images and text prompts.

Specifications

The published specifications for StreamRender-H3 are as follows:

  • Component configuration: Consists of two trained models, a backbone renderer and a Fast Causal H3 VAE decoder.
  • Renderer architecture: A 50-layer EMA backbone based on MiniMax-H3 Ref2VA with LoRA pre-merged.
  • Decoder architecture: Employs a pruned and distilled 24-layer Causal ViT decoder built through a self-improving agent loop.
  • Output resolution: Supports 720p.
  • Decoding processing unit: Processes two available latent frames per call.
  • Denoising steps: Executes two denoising steps per chunk via a distilled student model.
  • Streaming policy: Adopts a streaming policy of S=2 / W=2 / C=2.
  • Context referencing method: The decoder does not reference future latent frames and processes causally using only cached past context.
  • License: Released under the minimax-h3-community license.

Performance and Quality

According to the public repository, the breakdown of the provided weight components is presented as follows:

Directory Model Checkpoint
backbone/ Streaming H3 renderer, full 50-layer EMA backbone with LoRA merged 1008b / step224
causal_decoder/ Fast Causal H3 VAE, a pruned and distilled 24-layer causal decoder step6000 / 20261005-v1

According to the processing performance released by the publishers, the diffusion renderer part recorded a processing time of 217.96 milliseconds per streaming step in an environment with 8 GB200 GPUs. It is explained that this achieves a 3.67x speedup compared to the PyTorch baseline.

Additionally, regarding the Fast Causal H3 VAE decoder, it is reported that it can decode two 720p resolution latent frames in 24 milliseconds in a single GB200 GPU environment. By combining a causal decoding architecture that does not read ahead into future frames with distillation technology, it achieves low-latency frame generation suitable for interactive applications.

Strengths and Use Cases

StreamRender-H3 is specialized for use cases that stream-convert world states computed on the code side into low-latency, realistic videos in interactive environments such as games and simulators.

In this model, logical world state management such as map shapes, physical behaviors, and rules is left to the “Code Game Engine", and semantic maps streamed frame by frame from the engine are accepted as input. Then, based on a single pre-given reference image and text prompt, it is possible to continuously and interactively render photorealistic video responding to player actions (such as running and moving) while unifying the overall visual style.

As the tag information also includes “video-generation", “streaming", “interactive", and “world-model", unlike conventional batch-processing text-to-video generation, it is strongly intended for use as a world model or interactive content production foundation where responsiveness to operations is required. Because it adopts a causal processing pipeline that does not depend on future frames, it excels at streaming output of dynamic scene developments that change according to user inputs without breaking down.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch)

Your VRAM Quantization File size Est. memory needed
8GB (RTX 4060 / 3060 Ti, etc.) Original precision(causal_decoder) 6.0GB 7.2GB
80GB class (A100 / H100) Original precision(backbone) 61.7GB 74.1GB

Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.

Can You Run It Locally?

The publisher distributes this model as safetensors / PyTorch (bin).

License — minimax-h3-community: A custom license from the publisher. Check the original terms directly, including whether commercial use is permitted.

Compiled by this site’s code from the published formats and the license field. License summaries are not legal advice — check the publisher’s original terms before relying on them.

Our Own Measurements

Measurements We Did Not Take

We have not confirmed that this site meets the commercial-use terms of this model’s license (minimax-h3-community). Because this site carries advertising, we did not run the model (no CPU run, answers, quantization comparison, conversion or generation).

Distributed Files

Weight files published in Efficient-Large-Model/StreamRender-H3, listed by this site from the Hugging Face API. Sizes are the actual file sizes.

File Size
backbone/model-*-of-00009.safetensors 66.28GB (9 split files)
backbone/original_header.bin 0MB
causal_decoder/causal_vit24_step6000.safetensors 6.47GB

How to Get It

Model weights for StreamRender-H3 are available from the Hugging Face repository. Since it is not a gated model, it can be downloaded without individual application or license approval. The distribution format is safetensors.

When acquiring the weights, use snapshot_download from the huggingface_hub library and run the following:

from huggingface_hub import snapshot_download
snapshot_download("Efficient-Large-Model/StreamRender-H3",
                  local_dir="./StreamRender-H3")

Downloading requires approximately 72.75 GB of capacity. The distributed renderer weights are saved as 9 safetensors shards while maintaining the original tensor values, but the current runtime requires a single combined backbone file. Therefore, you need to run the following script after downloading to reconstruct the files:

python StreamRender-H3/download_assets.py

This reconstruction process requires an additional 66.28 GB of disk space, and original SHA-256 hash verification is automatically performed during processing. SHA256SUMS and inventory.json are also provided in the repository for file integrity verification.

For environment setup and inference execution, use the runtime code published at NVlabs/Sana — StreamRender-H3. In the runtime configuration file (manifest), specify the paths for the combined weights and decoder as follows:

  • backbone entry: backbone/1008b_step224_backbone_ema_merged.safetensors
  • causal_decoder entry: causal_decoder/causal_vit24_step6000.safetensors

The repository released this time contains only two trained model components (renderer and causal decoder). Other dependencies required for runtime execution must be prepared separately following the instructions in the runtime README and configs/assets.example.json. Detailed project information is also summarized on the StreamRender-H3 Project Page.

Related Articles

What to Read Next

Sources