You need to agree to share your contact information to access this dataset
This repository is publicly accessible, but you have to accept the conditions to access its files and content.
The weight file in this repository is a Model Derivative of MiniMax H3 and is governed by the MiniMax H3 Community License Agreement. Its Applicable Territory is worldwide EXCLUDING the European Union, the United Kingdom, the Republic of Korea and the United States of America. Confirm that you are outside those territories and accept the licence before downloading.
Log in or Sign Up to review the conditions and access this dataset content.
FastH3 Live
A continuous, unattended video+audio stream generated by FastH3 (the 4-step DMD2 distillation of MiniMax-H3) on a single consumer GPU, plus everything needed to get there: the converted weights, a 321-scene prompt library, and the streaming server.
Point VLC at a local URL and it plays without stopping — new clips are generated while the previous ones play.
Built and measured on one RTX 5090 (32 GB, Windows 11) with ComfyUI.
v1.1.0 — 448×448 at 18 fps, up from 512×288 at 12. See Changes.
What is actually in here
| File | What it does |
|---|---|
stream_fasth3.py |
The stream: generate → retime → HTTP/UDP push. Multi-viewer, reconnectable. |
prompts_scenes.txt |
321 scenes — 181 solo, 40 two-handers, 100 ensembles of three to five |
h3_characters.json |
503 verified-usable characters + a 14-name high-confidence pool. Ships ready to use. |
validate_scenes.py |
Checks a scene file against the H3 shot grammar; run it before adding scenes |
build_h3_characters.py |
Optional: rebuilds the character file from the upstream index |
submit_h3.py |
Submits a ComfyUI workflow straight to /prompt, bypassing frontend widget snapping |
profile_h3_nodes.py |
Per-node timing over ComfyUI's websocket — the only way to see where a run actually goes |
custom_nodes/h3_fast_writer/ |
H3FastWriteVideo (5× faster than SaveVideo, encodes off-thread) and H3VideoVaeTiling |
validate_fasth3_mapping.py |
Checks a converted checkpoint against a reference one, empirically |
stamp_license_metadata.py |
Writes licence and modification notices into a safetensors header |
make_fasth3_t2va_workflow.py |
Generates the ComfyUI workflow, validated against the live node registry |
FastH3_4step_T2VA.json |
The workflow itself |
st_read.py |
Seek-based safetensors reader (Windows cannot mmap a 21 GB file under load) |
custom_nodes/h3_block_attention/ |
The ComfyUI node that switches H3's attention backend per block |
minimax_h3_fl2va_..._int8_convrot.safetensors |
The converted 4-step DiT, 20.97 GB — drop it into models/diffusion_models/ |
minimax_h3_video_vae_w4a8_from_fp16.safetensors |
The quantized video VAE, 1.74 GB — drop it into models/vae/ |
The weight file is a Model Derivative of MiniMax H3 and is not under the Apache
licence that covers the rest of this repository. Read NOTICE and
LICENSE-MiniMax-H3.txt -- including the territory restriction -- before downloading it.
Quick start
You need a working ComfyUI with MiniMax-H3 support, its VAEs and text encoder, and
ffmpeg on disk.
1. Get the DiT
Put minimax_h3_fl2va_fasth3_dense_pruned_int8_convrot.safetensors in your ComfyUI
models/diffusion_models/ folder. It was converted from
FastVideo/FastVideo-FastH3-4-step-Preview-v1-Dense-DataFree; NOTICE records exactly
what the conversion changed.
It is built from the Dense-DataFree student, not the VSA one, on purpose: the VSA
student carries 50 to_gate_compress tensors that stock ComfyUI has no code for, so it
silently drops them and emits pure noise.
2. Get the VAEs and the text encoder
Put minimax_h3_video_vae_w4a8_from_fp16.safetensors and minimax_h3_audio_vae_fp32.safetensors
in models/vae/. The video VAE shipped here is quantized from the official fp16 weights:
it decodes as fast as any other quantization (9.2 s → 6.5 s against fp16 at 362 frames) and
stages 1,657 MB of host RAM instead of 2,677 MB, which matters because the full model set
already stages about 41 GB. Any other H3 video VAE works too — point --video-vae at it.
Quantized VAEs need ComfyUI 0.31.0 or newer, otherwise they decode to black frames.
The MiniMax-H3 text encoder is not redistributed here; the workflow expects
qwen3vl_32b_minimax_h3_int8_convrot.
3. Install the attention backend — do not skip this
Copy custom_nodes/h3_block_attention/ into your ComfyUI custom_nodes/ folder and
install the sage attention kernels:
pip install sageattention # a compiled wheel matching your CUDA + torch
This is worth more than every other optimisation in this repository combined. See Attention backend below.
4. Install the writer node
Copy custom_nodes/h3_fast_writer/ into your ComfyUI custom_nodes/. ComfyUI's own
SaveVideo spends 3.78 s per clip in a single-threaded Python per-frame loop; this node
does the same job in 0.26 s by converting in chunks and encoding on a background thread.
It is a fifth of the run — see Measurements. Without it, pass
--writer savevideo and expect roughly 3.5 fps less.
5. Stream
python stream_fasth3.py
Defaults to 448×448 at 18 fps, which is what this machine sustains. Every clip logs the scene index, the seed and the playback rate the current pace would support:
clip 0004 scene 042 seed 760153647 Tom Hanks 20.2s queue=2
streamed 0002 scene 163 seed 505225748 buf=1 gen 19.7s (avg2 19.9) play 20.11s margin +0.21s/clip sustains 18.2fps OK
Open the printed URL (default http://127.0.0.1:9000) in VLC. You can connect during the
prefill and simply wait.
Edit the paths at the top of stream_fasth3.py (FFMPEG, COMFY_OUT) for your machine.
Attention backend
Attention is 64% of every denoising step at these settings, and ComfyUI does not switch
it for you. MiniMaxH3BlockAttentionSplit is an ordinary node: if it is not in the graph,
nothing happens and the model runs on pytorch attention. There is no global setting, and
the startup log line Using pytorch attention is what that looks like.
Measured on one RTX 5090 at sequence 15448 (512x288, 362 frames), per block and across all 50 blocks:
| backend | ms/block | x50 blocks |
|---|---|---|
sage attention |
14.41 | 0.72 s |
pytorch attention |
40.97 | 2.05 s |
attention_flash |
100.25 | 5.01 s |
End to end that is 3.24 s/step -> 1.92 s/step, and 23 s -> 17.5 s per clip. It is the single largest win available on one GPU.
The node splits the stack: head_pct and tail_pct keep that share of the first and last
blocks on the slower, higher-fidelity backend, because the ends are the
quantisation-sensitive part. The shipped workflow uses 0/0 -- every block on sage,
which was clean in testing. If a 4-step output degrades, raise both to 20 before giving up
on sage.
Requirements: the sageattention package (a compiled wheel matching your CUDA and torch --
this build was tested against 2.2.0+cu130torch2.10.0andhigher) and the node in
custom_nodes/. ComfyUI prints its available backends at startup;
SAGE_ATTENTION_IS_AVAILABLE must be true.
Why 448×448
Because the VAE charges by the tile, not by the pixel — and because the flares set a floor that a comfortable aspect ratio cannot reach cheaply.
MiniMaxH3VideoVAE decodes in fixed 256 px spatial tiles. tiling=True, tile_size=256 is
hardcoded in its constructor, nothing in a graph can reach it, and split_tiles hands each
pass a whole tile no matter how little picture is in it. Decode time therefore tracks
the tile count and barely notices the resolution (362 frames each):
| resolution | pixels | tiles | VAE decode |
|---|---|---|---|
| 320×192 | 61,440 | 2 | 2.35 s |
| 512×288 | 147,456 | 6 | 6.98 s |
| 576×320 | 184,320 | 6 | 6.31 s |
| 768×432 | 331,776 | 8 | 8.74 s |
512×288 and 576×320 differ by 25% in pixels and by nothing at all in decode cost. They are both six tiles.
A side of length L costs ceil tiles with a 64 px minimum overlap, so the boundaries are:
≤256 → 1 tile, 257–448 → 2, 449–640 → 3, 641–832 → 4. The cheap shapes are the ones
that sit just under a boundary. Both sides must also be multiples of 16.
Put that together with a floor of roughly 200,000 pixels and the whole menu is short:
| resolution | pixels | aspect | tiles | sampler | VAE | total | sustains |
|---|---|---|---|---|---|---|---|
| 576×320 | 184,320 | 1.80:1 | 6 | 11.42 s | 6.60 s | 20.23 s | 17.9 fps |
| 448×448 | 200,704 | 1.00:1 | 4 | 12.71 s | 4.35 s | 19.17 s | 18.9 fps |
| 832×256 | 212,992 | 3.25:1 | 4 | 13.81 s | 4.87 s | 21.04 s | 17.2 fps |
| 640×368 | 235,520 | 1.74:1 | 6 | 16.62 s | 6.79 s | 25.87 s | 14.0 fps |
448×448 is the only shape that carries more pixels than 576×320 while costing less: four tiles instead of six pays for the extra 9% of picture and leaves change. Those extra pixels are the point — 576×320 still shows faint flares on some scenes, and 448×448 has shown none.
There is no comfortable aspect ratio at four tiles, and this is arithmetic rather than taste. Two tiles top out at 448×256 = 114,688 px, far under the floor. Three tiles top out at 640×256 = 163,840 px, which flares. Four is the minimum that clears the floor, and four comes in exactly two shapes: near-square, with both sides ≤448, or ultra-wide, where one side is ≤256 and the other must then exceed 720 px to make up the pixels — 2.8:1 or wider. 16:9 is not on the menu at any tile count that is cheaper than what 576×320 already costs.
So the choice was square-and-clean, ultra-wide-and-clean, or a normal aspect ratio with visible flares. This ships square.
If you would rather have the aspect ratio, nothing breaks:
python stream_fasth3.py --width 640 --height 368 --fps 14 # 1.74:1
python stream_fasth3.py --width 832 --height 256 --fps 17 # 3.25:1, scope-and-then-some
python stream_fasth3.py --width 576 --height 320 --fps 17 # 1.80:1, occasional flares
Re-derive --fps after any such change: it is 362 / (measured seconds per clip), and the
stream prints what the current pace actually sustains on every line.
The one thing that makes this work: retiming
FastH3 authors motion at 24 fps. On one RTX 5090 at 512×288, a 362-frame clip costs about 20.7 s of compute for 15.08 s of video — a ratio of 1.37, so a naive stream falls behind immediately and never recovers.
The stream plays those same frames at a lower container rate, and slows the audio by the same factor with a real phase vocoder so pitch is preserved:
| fps | plays for | ratio | motion speed |
|---|---|---|---|
| 24 | 15.08 s | 1.37 ✗ | 100% |
| 18 | 20.11 s | 1.03 | 75% |
| 14 | 25.86 s | 0.99 | 58% |
| 12 | 30.17 s | 0.69 ✓ | 50% |
There is no way around this trade on one GPU. Playback seconds at correct speed are
frames ÷ 24 no matter what the container says, so dropping frames to restore speed also
restores the 1.37 ratio. Slow motion is the only lever, and content chooses how visible it
is: fast subjects (surf, sparks, trains) read as deliberate slow-motion, near-static
atmosphere reads as normal, and mid-speed human activity is where it looks wrong.
--stretch selects the audio treatment. The default is rubberband; atempo is offered
for comparison but bottoms out at exactly 0.5 (= 12 fps) and rings audibly on rain and
wind at that limit.
Prompts
321 scenes in the official MiniMax-H3 shot grammar: [Shot 1] carries no timestamp, later
shots open with a strictly increasing MM:SS.mmm cut, camera motion comes only from the
documented vocabulary, and dialogue sits inside <d>[English] …</d>. All cut times fall
inside the 15.08 s generated timeline. validate_scenes.py enforces every one of those
rules, and the shipped file passes clean — worth running before you add your own, because
a malformed block does not fail loudly, it just quietly produces a clip that ignores the
instruction.
| scenes | slots | what they are |
|---|---|---|
| 181 | {NAME} |
one character in a situation |
| 40 | {NAME}, {NAME2} |
two-handers, lines passing between (S1) and (S2) |
| 100 | {NAME}..{NAME5} |
ensembles of three to five, all in frame from the first shot |
The ensembles exist because of a specific failure: a solo scene often spends its 15 seconds arriving at the character, so the recognisable face lands as the clip ends. An ensemble opens on the whole group already standing in the room, so every face is present from frame one and the fifteen seconds go to the interaction between them instead.
However many slots a scene declares, that many characters are drawn under the same
curated/full split and forced to be distinct — a five-hander is five different faces. At
draw time the stream picks a random scene and a random cast, 30% from the curated pool and
70% from the full verified list by default (--curated-share). The combinations run past
10^13; the pool is not the limit.
The scene file is re-read on every draw, so you can add scenes while the stream runs. That is the hook for viewer-submitted prompts: append to the file and they enter the rotation.
Measurements
Everything below was measured on this machine, not estimated.
Where a run goes (448×448, 362 frames, warm and back to back), taken from ComfyUI's
websocket node events. /history reports one number for the whole prompt, which cannot
separate the text encoder from the sampler from the VAE; profile_h3_nodes.py reads the
per-node executing events instead.
| node | time | share |
|---|---|---|
SamplerCustomAdvanced — DiT, 4 steps |
12.71 s | 66% |
VAEDecode — video |
4.35 s | 23% |
MiniMaxH3ImageToVideo — text encode |
~1.7 s | 9% |
H3FastWriteVideo |
0.26 s | 1% |
VAEDecodeAudio |
~0.2 s | 1% |
| total | 19.17 s |
An earlier version of this table read "video VAE decode 12.1 s (55%), H.264 encode 0.33 s
(1.5%)". It was produced by subtraction — re-running with the image path deleted — which
lumps VAEDecode and the save node into one figure and hands the whole sum to the VAE.
Per-node timing splits them: that 12.1 s was about 7 s of VAE plus about 4 s of ComfyUI's
save node. Do not measure a pipeline by deleting parts of it if a per-node timer is
available.
The save node was a fifth of the run. ComfyUI's SaveVideo encodes through a
single-threaded Python loop that, per frame, allocates a float array, clips it into a
second, casts into a third and copies out a fourth. ffmpeg alone does the identical
362-frame payload in 0.21 s.
| writer | node time |
|---|---|
SaveVideo (stock) |
3.78 s |
VHS_VideoCombine |
1.31 s |
H3FastWriteVideo, synchronous |
0.73 s |
H3FastWriteVideo, async (default) |
0.26 s |
No hardware encoder closes that gap, because the encoder was never the bottleneck:
h264_nvenc measured slower end to end than libx264, having to stand up a second CUDA
context on an already-full card. The async mode hands the frames to a background thread
and returns, so ComfyUI starts the next prompt instead of holding an idle GPU; the clip
lands under a .part name and is renamed into place when complete, so "the final name
exists" is the completion signal.
Quantizing the VAE below int8 buys no speed. int8 beats fp16 because comfy-kitchen's
TensorWiseINT8Layout runs an int8 matmul; a W4A8 build expands its 4-bit weights back to
int8 for that same matmul, so it is exactly as fast.
| video VAE | staged | decode |
|---|---|---|
| fp16 | 4,965 MB | 9.2 s |
| int8_convrot | 2,677 MB | 6.5 s |
| w4a8 | 1,657 MB | 6.5 s |
It is still worth building. The full model set stages about 41 GB against 64 GB of host RAM, and freeing 1 GB measurably tightened clip times and cut the outliers — see Host RAM below.
Free VRAM does not buy VAE decode speed at this size. Swapping the 21 GB DiT for a
12.5 GB one, which frees 8 GB during the decode, changed VAEDecode by nothing
measurable (7.3 s against 7.4 s). An earlier note here claimed the opposite from a
719-frame end-to-end comparison; that difference was elsewhere in the run.
Host RAM is a real constraint, and it converts into speed. The text encoder stages 25.9 GB, the DiT 20.0 GB, the VAEs 2.2 GB — about 48 GB against 64 GB of physical RAM. Left to drift, this machine ran with 2.6 GB free and 28 GB of ComfyUI's commit in the page file, and clip times went bimodal: 15 s runs interleaved with 20–38 s ones, with no paging visible in the counters at the moment of the slow run. A fresh boot was worth 1.7 s per clip; the smaller VAE was worth another 1.5 s and, more usefully, collapsed the spread. Check the page file before trusting any measurement here.
Attention backend at sequence 15448 (ms per block, ×50 blocks):
| backend | ms/block | ×50 |
|---|---|---|
| sage | 14.41 | 0.72 s |
| pytorch | 40.97 | 2.05 s |
Quantization, on real FastH3 weights:
| format | bits | relative L2 | DiT size |
|---|---|---|---|
| int8_convrot | 8.00 | 9.9e-3 | 20.97 GB |
| asym_w4a8_int8 | 4.50 | 7.3e-2 | 12.54 GB |
| nvfp4 | 4.50 | 9.4e-2 | 12.53 GB |
| convrot_w4a4 | 4.00 | 1.65e-1 | 10.8 GB |
NVFP4 gives no speedup here: comfy-kitchen's FP4 matmul takes its fast path only when both operands are NVFP4, and activations are BF16, so it dequantizes and runs at exactly BF16 speed (67.88 ms/block against BF16's 67.85). The ranking also inverts with clip length — int8 wins at 362 frames, W4A8 wins at 719.
Resolution floor. Large coloured flares appear when the frame carries too few pixels. It is driven by total pixels and not by the short edge — 640×256 (163,840 px) flares badly despite a longer long-edge than 512×288.
The floor is not sharp, and it is scene-dependent, which is what makes it easy to under-measure: a handful of scenes will pass at a size that a wider sample fails. An earlier version of this note put the floor at 147,456 px on exactly that kind of small sample. On a wider one, 576×320 (184,320 px) still shows faint flares on some scenes and 448×448 (200,704 px) has shown none. Treat ~200,000 pixels as the working figure, and judge new sizes on a spread of scenes rather than one.
Length is not a constraint: 719 frames (30 s) is clean throughout.
Changes
v1.1.0
Throughput went from 13.7 to 18.9 sustainable fps on the same card. Nothing about the model changed; four things about how it is driven did.
H3FastWriteVideoreplacesSaveVideo, which was spending 3.78 s per clip in a single-threaded Python per-frame loop — a fifth of the whole run, producing a file that is re-encoded a second later anyway. The node converts in chunks and encodes on a background thread, so the graph sees 0.26 s and the GPU starts the next prompt instead of waiting. No hardware encoder was involved;h264_nvencmeasured slower.- 448×448 replaces 576×320. The VAE decodes in fixed 256 px tiles and charges full price per tile, so this shape needs four where the old one needed six — while carrying 9% more pixels, which is what stops the colour flares. See Why 448×448.
- A W4A8 video VAE, quantized from the official fp16 weights and shipped here. Not faster to decode, but 1 GB lighter in host RAM, which on a 64 GB machine holding 41 GB of staged weights turned into both speed and a much tighter spread.
- The producer keeps two prompts in ComfyUI's queue rather than submitting one and waiting, so no GPU time is lost between jobs.
Also: 100 ensemble scenes of three to five characters, all in frame from the first
shot; per-clip logging of the scene index, seed and the playback rate the current pace
sustains; validate_scenes.py; and profile_h3_nodes.py, which is what made the rest of
it findable — the old measurements in this README were taken by deleting parts of the
pipeline and were wrong about where the time went.
v1.0.0
Initial release: converted 4-step DiT, 221 scenes, the streaming server.
Attribution
- MiniMax-H3 — MiniMaxAI/MiniMax-H3
- FastH3 — FastVideo (hao-ai-lab), the 4-step DMD2 distillation
- Character index — malcolmrey/various,
h3-center/known-characters/INDEX.md.h3_characters.jsonis derived from itsgoodsection; only characters that repo verified as reliably reproducible are included. - ComfyUI and comfy-kitchen — the quantization layouts and H3 model code
- The 181 scenes and the code in this repository are original work.
Licensing
Two licences, and they do not overlap. NOTICE is the authoritative statement.
The weight file is a Model Derivative of MiniMax H3, distributed under the
MiniMax H3 Community License Agreement (full text: LICENSE-MiniMax-H3.txt). No extra
terms are imposed on it. Its modification notice -- exactly what was changed relative to
upstream -- is in NOTICE, and is also recorded inside the file's own safetensors
metadata.
Everything else -- code, the 321 scenes, the character pools, the workflow, the custom
node -- is Apache-2.0 (LICENSE).
Territory: read this before downloading the weights
The MiniMax H3 Community License applies only within its Applicable Territory: worldwide excluding the European Union, the United Kingdom, the Republic of Korea and the United States of America. Section V.4 states the Works and their Outputs may not be used, reproduced, modified, distributed or displayed outside it.
If you are in one of those places, this licence does not authorise you to download or use the weight file. The code and the scene library are Apache-2.0 and carry no such restriction.
Powered by MiniMax H3.
Using this responsibly
This tool exists to point a video model at a list of names, unattended, and broadcast the result. That deserves a plain statement rather than a disclaimer.
The names are real people. The character list is largely actors and the roles they played. Generated video of an identifiable person is a synthetic likeness, and publicity and personality rights apply in most jurisdictions regardless of how the video was made.
Do not use this to:
- present generated footage as real, or as documentation of something that happened
- imply that any person endorses, said, or did anything
- produce sexual, defamatory, or harassing material involving a real person
- impersonate anyone, including for satire that a reasonable viewer would not read as satire
If you stream this publicly, label it as AI-generated where viewers can see it, not only in a description they have to open. A continuous stream gives no natural pause in which a viewer works out what they are looking at; the labelling has to be persistent.
Live viewer-submitted prompts are the highest-risk part of this design: an open text box wired to a video model that knows hundreds of real faces will be tested by your audience within minutes. Moderate the input, not just the output.
You are responsible for what you generate and publish. So is the person who runs the stream, which for this repository is not the author.
- Downloads last month
- -