The weight files in this repository are Model Derivatives of MiniMax H3 and are 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.

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 721-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.

v2.1.0 — real time, and the textured patches are gone. The material is authored at 24 fps and generation sustains 33.6, so playback defaults to 24: 100% motion speed on one card, with 4.3 s of slack per clip. v2.0.0 got to real time on a depth-distilled video VAE (the Light VAE); v2.1.0 adds a different sampler and, with it, the answer to an artefact this README had been blaming on the wrong thing since v1.2.0. 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
`prompts_scenes_2.txt`	400 more scenes, all ensembles of three to five. Pooled with the above by default
`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
`record_demo.py`	Records a fixed-length demo reel with two burned-in clocks as proof it is real time. See Recording a demo
`cast_familiar.txt`	The 158-name "most people will place this face" tier `record_demo.py` draws from
`custom_nodes/h3_fast_writer/`	`H3FastWriteVideo` (5× faster than `SaveVideo`, encodes off-thread) and `H3VideoVaeTiling`
`custom_nodes/h3_light_vae/`	`H3LightVAELoader` — loads an H3 video VAE at the decoder depth stored in the checkpoint. Required for the Light VAE; ComfyUI's own loader cannot
`bench_light_vae.py`	A/B harness for video VAEs: depth, tile geometry and tile batching as separate arms
`compare_light_vae.py`	Decodes one latent with two VAEs and keeps both clips, so the picture difference can be judged rather than argued
`bench_accel_fps.py`	Re-measures the `--accel` ladder. Refuses to run if ComfyUI was launched without `--vram-headroom`
`convert_taomate_lora_for_comfyui.py`	Converts TaoMate-H3's 3-step LoRA into a ComfyUI MiniMax-H3 LoRA. It is a pure rename; the script's docstring is the proof, which is the part that took the work
`bench_three_step.py`	The six-arm harness that found out where the textured patches actually come from
`bench_accel_fps.json`	The raw `--accel` numbers behind the table below, including one invalidated round kept as evidence
`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/`
`taomate_h3_3step_t2av_comfyui.safetensors`	TaoMate's 3-step LoRA, converted, 2.48 GB — what `--sampler taomate3` loads. Drop it into `models/loras/`. Needs the official base DiT too, which is linked rather than shipped
`lynnreal_omni_light_vae_int8_convrot.safetensors`	The Light VAE, 2.12 GB — 26 decoder blocks instead of 36, quantized to int8. The default since v2.0.0, and what makes 24 fps reachable. Drop it into `models/vae/`
`minimax_h3_video_vae_w4a8_from_fp16.safetensors`	The official video VAE, quantized, 1.74 GB — the 36-block decoder, kept as the `--no-light-vae` fallback. Drop it into `models/vae/`

The weight files are Model Derivatives of MiniMax H3 and are 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.

It is also not the best DiT for this pipeline. Everything here defaults to it so that a download runs with nothing else fetched, but a checkpoint from another author is the same speed with a cleaner picture, and does ref2va as well — there is a better DiT than the one in this repository has the measurements and the two commands.

Quick start

You need a working ComfyUI with MiniMax-H3 support, its VAEs and text encoder, and ffmpeg on disk. This repository is not a full H3 bundle: it ships only the pieces that change the speed, and assumes H3 already runs on your machine. If it does not yet, start from Comfy-Org's own H3 release — Comfy-Org/MiniMax-H3 has the audio VAE (vae/minimax_h3_audio_vae_fp32.safetensors) and all three text-encoder quantisations — and confirm H3 generates at all before coming back here. ComfyUI 0.31.0 or newer; quantized VAEs decode to black frames on older builds.

To pull everything here in one go (the web UI has no download-all button):

hf download jacokon/fasth3-live --repo-type dataset --local-dir .

1. Launch ComfyUI with --vram-headroom 3 — this one is not optional either

Add it to your launcher's launchArgs (ComfyUI Desktop: installations.json) or to your command line. Without it ComfyUI thrashes the model weights across PCIe and no stable live rate is possible — not a uniform slowdown, but clip times that go bimodal: 14 s runs interleaved with 25–47 s ones.

The diagnostic, if you want to confirm it on your own machine: during a slow clip, PCIe read throughput sits at 9–13 GB/s instead of the normal 1.5, and GPU power drops from 450 W to 340 W — the card is waiting on transfers, not computing. With the flag, clip time standard deviation here is 0.11 s; without it, 1.62 s.

It is also the single easiest way to publish a wrong measurement of this repository. It leaves --accel sage and --accel sla almost untouched while making spectrum — the default — bimodal, which inverts the ranking between them. bench_accel_fps.py reads /system_stats and refuses to run if the flag is absent, for exactly that reason.

2. 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.

3. Get the VAEs and the text encoder

Only the video VAEs ship here. The audio VAE (minimax_h3_audio_vae_fp32.safetensors) and the text encoder come with any standard MiniMax-H3 install, so if H3 already runs you have them; if not, both are in Comfy-Org/MiniMax-H3. They are not redistributed here because they are unmodified official files — this repository ships only what it changed.

Put both video VAEs from this repository, alongside your existing minimax_h3_audio_vae_fp32.safetensors, in models/vae/:

lynnreal_omni_light_vae_int8_convrot.safetensors — the default since v2.0.0. The decoder is LynnReal's depth distillation: 26 ViT blocks where the official one has 36, requantized here to int8. It decodes in 1.90 s against the official VAE's 3.19 s, and that second is what put this stream over 24 fps. See The Light VAE.
minimax_h3_video_vae_w4a8_from_fp16.safetensors — the official 36-block decoder, quantized from the official fp16 weights. Kept because --no-light-vae is the way back if you decide the distilled decoder's picture costs you something, and because it is what every pre-v2.0.0 measurement in this README was taken on.

The Light VAE needs its loader node, which is step 6 — ComfyUI's own VAELoader cannot load it. It builds 36 decoder blocks unconditionally and loads non-strictly, so pointing it at a 26-block checkpoint prints one Missing VAE keys line and then decodes ten randomly initialised blocks into garbage. Nothing fails; the picture is just wrong. If the node is missing, stream_fasth3.py says so and falls back to the official VAE rather than letting that happen.

Any other H3 video VAE works too — --no-light-vae --video-vae <name>. Quantized VAEs need ComfyUI 0.31.0 or newer, otherwise they decode to black frames.

The workflow expects the text encoder as qwen3vl_32b_minimax_h3_nvfp4_awq, one of the three quantisations Comfy-Org publishes and the one this project defaults to since v1.2.0: it encodes a prompt in 0.70 s against int8_convrot's 1.67 with no cost to the sampler. Neither is redistributed here; both come with a standard H3 install, and --clip takes whichever you have.

4. 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.

5. Optional but recommended — the Spectrum node

The shipped default is --accel spectrum, which is worth another 18% off the sampler at no visible cost. It is one clone, and it is not redistributed here because it is GPL-3.0 and this repository is Apache-2.0:

cd ComfyUI/custom_nodes
git clone https://github.com/xmarre/ComfyUI-Spectrum-MiniMax-H3.git

Without it the stream still runs — it says so once and falls back to sage, 21.6 fps instead of 25.6, which means losing 24 fps playback. See Going faster than sage.

6. Install the Light VAE loader — required for the default VAE

Copy custom_nodes/h3_light_vae/ into your ComfyUI custom_nodes/ and restart ComfyUI. It adds one node, H3LightVAELoader, which builds the same comfy.sd.VAE object the stock loader does but takes the decoder depth from the checkpoint instead of hardcoding 36. It also applies the student's own tile geometry (272/16, the scale it was distilled at) and batches a chunk's spatial tiles into one decoder call.

Nothing under comfy/ is patched: both constructors already accept the arguments, and the node threads them through for the duration of its own build call.

7. Optional but recommended — the base DiT for the default sampler

The default --sampler taomate3 needs two files. One ships here (taomate_h3_3step_t2av_comfyui.safetensors → models/loras/); the other is an official Comfy-Org build that this repository does not redistribute, because it is unmodified:

hf download Comfy-Org/MiniMax-H3 \
  --include "diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors" \
  --local-dir .

Put it in models/diffusion_models/. Without it the stream says so once and falls back to --sampler fasth3, the student this repository ships — which still holds 24 fps but brings back the textured patches on roughly one frame in ten. See the sampler.

If you would rather convert the adapter yourself than trust the copy here, the script that did it ships too:

hf download TaoLiveAIGC/TaoMate-H3 --local-dir taomate_src
python convert_taomate_lora_for_comfyui.py --src taomate_src \
  --out <ComfyUI>/models/loras/taomate_h3_3step_t2av_comfyui.safetensors

8. 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.

9. Stream

python stream_fasth3.py

Defaults to 448×448 at 24 fps — the rate the frames were authored at, so motion plays at 100% speed — with --sampler taomate3, the Light VAE, --accel spectrum and the nvfp4 text encoder. Measured 33.6 fps sustained, so 24 runs with 4.3 s of slack per clip. Without the Spectrum node it falls back to sage; without the TaoMate adapter and its base DiT it falls back to the fasth3 student, which still holds 24 but brings the patches back. The first line states the budget, and every clip logs the scene index, the seed and the playback rate the current pace would support:

playback 15.08s per clip at 24 fps (motion at 100% speed); to keep up, generation must average under 15.08s
clip 0004  scene 042  seed 101003  Tom Hanks   13.6s  queue=3
streamed 0004  scene 074 seed 101003  buf=2  gen 13.6s (avg3 13.7)  play 15.08s  margin +1.34s/clip  sustains 26.3fps  OK

sustains is the whole readout: it is 362 / seconds per clip, i.e. the playback rate this generation rate supports. Watch that and the OK/BEHIND beside it rather than any number in this README — it is measured on your card, not on mine. The first clip is always marked as a cold start and excluded, because it includes staging about 41 GB of weights.

The scene and seed on each line are a reproduction key. If a clip shows a flare or anything else worth looking at twice, those two numbers regenerate exactly that clip, and compare_light_vae.py will decode the same latent through both VAEs for a side-by-side.

A borderless player opens by itself once the port is actually serving; --no-player suppresses it. The stream is also just a URL (default http://127.0.0.1:9000) — open it in VLC from this or any other machine, during the prefill if you like.

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.

Going faster than sage: `--accel`

Sage is not the end of it, but the arms that beat it do not all keep the picture. Measured on t2va, 448×448 × 362 frames, 4 steps, A-B-B-A with three runs per arm and only the last one counted (bench_attn.py). Sage was run at both ends as a drift check and came back 12.65 s twice:

arm       sampler   fps ceiling   picture
sage      12.97 s   21.6          the baseline
spectrum  10.34 s   25.6          as good as sage          <- shipped default
sla       10.87 s   24.8          faces and hands readable
sol       11.73 s   ~18           faces and hands smear
solspec    9.64 s   ~21           worse still

The sampler column is from bench_accel_fps.py, and the ceilings for the top three are streamed rather than isolated — 22 clips each for sage and spectrum, 11 for sla, raw numbers in bench_accel_fps.json. They were re-measured for v2.0.0 because the Light VAE takes about 1.3 s off every arm, so the old ceilings (17.5 / 20.2 / 19.7) understated all of them. sol and solspec were not re-measured — their sampler times are the original ones and their ceilings are therefore stale and marked ~; they were ruled out on picture, so a better number would not change anything.

The re-measurement also corrected sla. The old table had it tied with spectrum at 10.36 s, which made it look like a free alternative. Measured properly it is 10.87 against spectrum's 10.34 — it loses on speed as well as on picture, so it has no case at all.

The default also switched text encoder, which is worth as much again and costs nothing -- qwen3vl_32b_minimax_h3_nvfp4_awq encodes a prompt in 0.70 s where int8_convrot takes 1.67, and the sampler does not slow down to pay for it (10.05 s against 10.40). Both are official Comfy-Org files, so this is a filename, not a download. Together with Spectrum that was 22.1 fps, from 17.5 -- and with v2.0.0's Light VAE and --vram-headroom 3 the same stack streams 26.4.

An older note in this project said the smaller encoder was a trap -- that being small enough to stay resident, it would squeeze the DiT and cost more than it saved. That was measured before the VAE and the canvas got smaller. It is no longer true here, and it was worth re-measuring rather than inheriting.

The speed order is almost exactly the inverse of the quality order. Sol is the one that looked most promising on paper — a drop-in kernel replacement with no step skipping — and it is the one that destroys faces. Nothing in the timings predicted that; it took watching clips back at a matched --fps. Do not ship an arm on its seconds alone.

The gaps are not evenly spaced. Every arm was watched again on the fused turbo bake (see there is a better DiT than the one in this repository). The order came out identical — sage > spectrum > sla > sol — which is worth knowing on its own, because it means these rankings are a property of the arms and not of the checkpoint they were first measured on. But the distances between them are nothing alike:

sage ── small ── spectrum ──────── large ──────── sla ──────── large ──────── sol

That redraws what the table above implies. "faces and hands readable" makes sla sound like a near-miss for the top; it is not. Sage to spectrum is a step you have to look for. Spectrum to sla is not. The shipped default is not sitting midway down a gentle ladder — it is one small step below the best arm, with a cliff immediately under it. So the arms below the default are not degraded versions of it worth reaching for when you need speed; they are a different tier, and sla at the same 10.36 s as spectrum has no case at all.

(Ordering here is from watching clips at a matched --fps, not from a metric. The two top arms have measured seconds on the bake — 19.17 s and 15.99 s — and the lower two were judged on picture alone, since nothing about their timings was going to rescue them.)

--accel spectrum is the default from v1.2.0. It keeps sage and stacks SpectrumApplyMiniMaxH3 on top, which forecasts post-transformer features with a Chebyshev ridge fit and skips the full evaluation on some steps. 18% off the sampler for no visible cost.

The node ships warmup_steps=1 and tail_actual_steps=1 with bootstrap_first_forecast on: the first and last steps are real model evaluations and the middle ones are extrapolated.

⚠ Correction, v2.1.0

Every version of this README up to and including v2.0.0 blamed Spectrum for the textured patches described below. That was wrong. The patches belong to the FastH3 student's weights. Measured with bench_three_step.py, six arms at one seed, watched end to end: the student has them under Spectrum, under Spectrum with a promoted tail anchor, and under plain sage with four honest evaluations and no forecasting at all. That last arm is the counterexample that kills the explanation. Base H3 driven by TaoMate's 3-step LoRA has none, at three steps or at four. Every student arm patched, every TaoMate arm clean.

The obvious replacement — that patches track the number of real evaluations — dies on the same arm, which spends four of them. See the sampler.

Two numbers in the old text were also wrong. "A 4-step schedule runs at roughly 2 NFE" was inherited rather than measured and is withdrawn; so is a claim, briefly published in the code, that Spectrum cannot amortise itself over a three-step ladder — measured, it is worth 3.0 s/clip there against 2.6 on the student's four-step one.

What survives unchanged: Spectrum is faster than sage, costs nothing visible of its own, and remains the default. The artefact it was accused of is fixed by --sampler taomate3, which is the v2.1.0 default, not by changing --accel.

Measured against --accel sage on five scenes at 448×448 × 362 frames, both on the FastH3 student:

arm       median     picture
sage      19.17 s    the patches are present here too -- see the correction above
spectrum  15.99 s    the shipped default

What the patches look like matters more than how many there are. Not a uniform softening, and not concentrated in fine detail like hair or weave: a distinct texture in the places that go soft, a patterned artefact rather than a blur, landing anywhere in frame with no pattern anyone here has been able to state. Roughly 10% of frames.

That shape is why it was worth chasing to the end rather than averaging away: a single affected region draws the eye. Chasing --accel for it was two releases of looking in the wrong place.

Two composition facts worth keeping:

Sol and Spectrum add up (11.73 and 10.36 alone, 9.64 together) because they remove different work — Sol makes the same maths faster, Spectrum evaluates fewer steps.
SLA and Spectrum do not (10.36 each, 10.54 together). Both cut redundancy, so stacking buys nothing and costs the extra bookkeeping.
EasyCache did nothing at all, and structurally cannot here: it skips a step when its neighbours agree, and four steps have no such redundancy. Do not spend time tuning it.

Only spectrum needs a pack that is not in this repository: ComfyUI-Spectrum-MiniMax-H3 (GPL-3.0). sol and sla need ComfyUI-sol-attn (Apache-2.0) and ComfyUI-PlagueKind-Nodes (MIT) respectively, and are documented for completeness rather than recommended. If a pack is missing, --accel says so by name at startup instead of failing later.

cd ComfyUI/custom_nodes
git clone https://github.com/xmarre/ComfyUI-Spectrum-MiniMax-H3.git

Run --accel sage for the v1.1.0 behaviour.

The sampler: where the patches actually came from

python stream_fasth3.py                      # --sampler taomate3, the default
python stream_fasth3.py --sampler fasth3     # the student this repository ships

For two releases the textured patches on roughly one frame in ten were blamed on Spectrum's extrapolation, and the fix was assumed to be an --accel arm nobody could afford. Both halves were wrong. bench_three_step.py ran six arms at one seed and the answer was not in --accel at all:

arm	weights	evaluations	patches
`fasth3` + spectrum	FastH3 student	forecast	yes
`fasth3` + spectrum, promoted tail	FastH3 student	+1 real	yes
`fasth3` + sage	FastH3 student	4 honest	yes
`taomate3` (3-step ladder)	base H3 + TaoMate LoRA	3 honest	no
`taomate3` on a 4-step ladder, two spacings	base H3 + TaoMate LoRA	4 honest	no

The third row is the one that decides it. Four honest evaluations, no forecasting anywhere, patches still there — so it was never the extrapolation, and it is not the evaluation count either. It is the DMD2 student's weights. The patches are an artefact of the distillation this repository is named after.

What `taomate3` is

TaoMate-H3's 3-step LoRA, from the Alibaba TaoLive AIGC Team: base MiniMax H3 driven by a rank-128 adapter on their own sigma ladder (time_shift_sigmas(num_steps=50, shift_scale=12) taken at indices 0, 16, 33, 49 — four sigma points, three intervals). Their shift is 12.0 video / 3.0 audio, which is what the shipped workflow already carries, so only the ladder changes.

Their own runtime does not run here — it hardcodes 4 or 8 GPUs with TP2 × Ulysses, Linux, a Hopper FlashAttention-3 build and vLLM. This uses only the weights.

Three properties make it usable, and all three had to be checked rather than hoped for:

The conversion is a pure rename. The two transformations every other published H3 adapter needs are both no-ops: TaoMate trained against MiniMax's native module layout, so the QKV projection is already one fused tensor in ComfyUI's order and the SwiGLU input projection is already gate-first. It is the diffusers port that is value-first. Swapping the halves here would be the silent-corruption bug, not the fix.
It carries no adaln_proj. This is why it works on our checkpoints when no other turbo LoRA does: the others were trained against the non-pruned AdaLN, and ours is rank-reduced onto an 8-dimensional SVD basis.
The LoRA merges back into int8. ComfyUI's set_weight requantizes from float, so the adapter costs no extra resident weight.

Measured

One freshly started server, --vram-headroom 3, --accel passed explicitly on every arm, 10 counted clips each, A-B-A with the two Spectrum replicates agreeing to 0.1 s (bench_sampler_stream.json):

arm	s/clip	sustains	margin
`fasth3` + spectrum — the v2.0.0 default	13.8	26.2 fps	+1.24 s/clip
`taomate3` + sage	13.8	26.3 fps	+1.33 s/clip
`taomate3` + spectrum — the v2.1.0 default	10.8	33.6 fps	+4.32 s/clip

Two things fall out of that. Swapping the weights is free: at matched --accel the two stacks are the same 13.8 s/clip, so losing the patches costs nothing. And Spectrum stacks on a three-step ladder — 3.0 s/clip, against the 2.6 s it is worth on the student's four-step one. There is no three-step penalty, which is the opposite of what was briefly published in the code and is corrected in bench_sampler_stream.json.

Why it is not simply "better"

It needs a 21 GB official base DiT that this repository does not redistribute. A fresh download therefore cannot run it, and the stream says so once and falls back to fasth3 rather than stopping — the same rule --accel and --light-vae follow. The student is still what ships, still the fallback, and still the thing the repository is named after.

It is also only measured for t2va. The adapter is a T2AV distillation, so stream_chat keeps its own route for reference mode and does not load it there; pointing it at ref2va weights would be patching the wrong model. TaoMate's Ref2AV adapter is announced but not released.

The Light VAE: how 24 fps happened

The video decode was the second-largest cost in a run and the only big one nobody had attacked. --accel work had taken the sampler from 12.65 s to 10.34; the decode sat at 3.19 s and had been declared finished, because quantizing below int8 buys no speed and enlarging the tile destroys the picture. Both of those are still true. What was left was the decoder itself.

LynnReal's Light VAE replaces the decoder with a depth distillation: 26 ViT blocks where the official one has 36. It is published as part of LynnReal-Omni and is a Model Derivative of MiniMax H3 under the same Community License as the other weight files here — not under the Apache licence that covers this repository's code. The encoder, latent statistics and latent interface are untouched — all 122 encoder and latent-statistic tensors are bit-identical to the official fp16 weights, which was checked rather than assumed. So the only thing that changes is reconstruction.

Measured at 448×448 × 362 frames, medians over four counted runs with /free between arms (bench_light_vae.py):

video VAE	decoder	tile	`VAEDecode`
official w4a8, ComfyUI's per-tile loop	36 blocks	256/64	3.19 s
official w4a8, tiles batched	36 blocks	256/64	2.98 s
Light VAE, w4a8	26 blocks	272/16	2.47 s
Light VAE, int8 — shipped	26 blocks	272/16	1.95 s
Light VAE, int8	26 blocks	256/64	1.79 s

Two things that will mislead you here

The first version of this measurement said the Light VAE was slower. The release ships fp16, and this project runs int8 — so the first comparison was 26 fp16 blocks against 36 int8 ones, and fp16 lost by enough (4.60 s) to hide the entire architectural win. comfy-kitchen's int8 path uses Blackwell's int8 tensor cores, and inside this decoder it also switches the attention to int8_attention; together that is worth about 2× on this decode. Align the precision before comparing two models. Requantizing the release's fp16 to int8 is where the 1.95 s came from.

w4a8 is slower than int8 here, which contradicts the table further down this README. That table says a W4A8 build is exactly as fast as int8, because it expands its 4-bit weights back to int8 for the same matmul. The missing qualifier is that the expansion cost is roughly constant: it hid inside a 6.5 s decode and does not hide inside a 2 s one. Hence int8 for this file (2.12 GB) rather than w4a8 (1.36 GB). Pick a quantization by the absolute decode time of the decoder in front of you, not by that table's ranking.

Streamed, which is the number that matters

Both arms back to back in one session, 12 counted clips each, --vram-headroom 3 set:

arm	s/clip	sustains	margin	spread
`--no-light-vae` (36 blocks)	15.0	24.2 fps	+0.14 s/clip	14.9–15.1
default (Light VAE)	13.7	26.4 fps	+1.38 s/clip	13.5–14.1

Read that honestly: the official decoder clears 24 fps too. It does it by 0.14 s per clip, which is not a margin anything survives. v1.2.0 reported 22.1 fps for that same stack, and the difference is not the VAE — it is --vram-headroom 3, which that release did not document. So the move from 22.1 to 24.2 was a launch flag that should have been in the README all along, and the Light VAE is what turns 24 fps from borderline into comfortable: ten times the headroom per clip, and a spread tight enough that no clip in twelve went over budget.

What it costs

The model card for the Light VAE says the quiet part out loud: the same latent need not decode to identical RGB. So this was decomposed rather than argued about — compare_light_vae.py decodes one latent with two VAEs, by adding a second loader wired only into VAEDecode so the sampler result is served from cache and provably not re-run:

change	PSNR (Y)	SSIM
official w4a8 → Light VAE int8 (the whole swap)	35.5 dB	0.963
Light VAE 272 → 256 tile (geometry alone)	40.6 dB	0.985
Light VAE fp16 → int8 (quantization alone)	42.0 dB	0.987

Those are a floor, not the decoders' true agreement: both clips are h264 at the same crf and that compression noise is not common-mode. What the decomposition does establish is where the difference comes from — the distillation, not the quantization and not the tile. For comparison, the official int8 build measures 44.4 dB against fp16 and is invisible.

The thing this project actually cares about is the flare floor, which only shows on a moving clip and only on a spread of scenes — a single frame will not reveal it. If you decide it costs you something, --no-light-vae is the way back, and it still clears 24 fps by a whisker.

--light-vae-tile 256 is 0.16 s faster again and off the scale the student was distilled at. --light-vae-layout comfy uses ComfyUI's square split instead of the student's anisotropic 272/208 one. Neither is recommended; both are there because they were measured.

One thing that catches people: FastH3_4step_T2VA.json still contains a plain VAELoader pointing at the official VAE. stream_fasth3.py substitutes H3LightVAELoader into the API prompt at submit time, so the graph on disk stays the graph you can open and read in ComfyUI. If you run that workflow from the ComfyUI UI directly you get the official 36-block decoder — which is correct, just not the default the stream uses.

The player

stream_fasth3.py now opens a borderless ffplay on the stream by default, once a TCP connect to the port actually succeeds — ffmpeg does not bind until it has probed its input, which is the whole prefill plus the first clip, and a player started before that dies on connection refused.

Borderless because the window is meant to be handed to a screen share: Go Live → Application → FastH3 captures the picture with no player chrome in it, and takes the audio with it. --player-title renames the window, --player-left/--player-top place it, --player-ontop pins it, and --player-software renders on the CPU so the card stays with the sampler. --no-player restores the old behaviour of serving the stream and nothing else.

Recording a demo

python record_demo.py --clips 12 --out demo.mp4

The thing being claimed here is throughput, and that is exactly what a recorded video cannot show by itself: any clip can be made to look real time by generating it slowly and playing it back fast. So record_demo.py burns two clocks into the same frame, advancing at different rates:

VIDEO OUT   the recording's own timecode
GPU TIME    wall-clock seconds the GPU had actually spent by that point

If GPU TIME falls behind VIDEO OUT and keeps falling behind, one card produced that video faster than it plays. That is the whole argument, and it is falsifiable on sight — which is the point of putting it in the picture rather than in a table.

Cast. Who appears is a choice with consequences, so it is a flag rather than a default buried in the code:

`--cast`	What it draws	Why
`familiar` (default)	the 158 names in `cast_familiar.txt`	the ones most viewers place on sight; the 503-name pool is alphabetical and carries no signal about recognisability
`crossover`	characters from unrelated universes in one room	recognisable and self-evidently synthetic: a Klingon beside a Na'vi announces that the clip is generated without having to be believed
`fictional`	the curated pool with living actors removed	looks more like a real scene, which for a demo is the wrong way round
`generic`	appearance descriptions instead of names	the scenes only need somebody standing there, so this shows the same throughput with faces that resemble nobody

--cast-list "Jean-Luc Picard,Data,Worf" picks by hand; the ensemble scenes take three to five names, so a five-name list fills a whole group shot. --scene-range 1-100 restricts which scenes are drawn from (1-based, inclusive), and --first-scene fixes where it starts.

It defaults to a DiT this repository does not ship. --dit points at the fused-turbo bake, which measures the same speed and looks cleaner — see there is a better DiT for where to get it. If you have not fetched it, record_demo.py says so once and records on the DiT that does ship, rather than stopping. --warmup 1 (the default) generates and discards one clip first, because the first job after a cold ComfyUI includes staging about 41 GB of weights and is not part of steady-state throughput.

Section V.4 of the MiniMax H3 licence applies to the recording. Outputs may not be displayed outside the Applicable Territory, whoever is in the cast. That is independent of the --cast question above, which is about likeness rights rather than about the licence.

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

This table is from v1.1.0 — sage, the official VAE, SaveVideo, no --vram-headroom. The absolute numbers are all beaten now (448×448 streams at 13.7 s/clip rather than 19.17), but it is kept as measured because what it is being used for is the tile arithmetic, and that has not changed: cost tracks the tile count, 448×448 is the only shape that gets four tiles with enough pixels to stay above the flare floor, and 16:9 is not on the menu. Note that the Light VAE tiles at 272 rather than 256, which moves the two-tile ceiling per axis from 448 to 528 — so 528×528 would also be four tiles. It is not offered, because the sampler scales with pixels and 39% more of them costs far more than the decode saves.

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

721 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	file
181	`{NAME}`	one character in a situation	`prompts_scenes.txt`
40	`{NAME}`, `{NAME2}`	two-handers, lines passing between `(S1)` and `(S2)`	`prompts_scenes.txt`
100	`{NAME}`..`{NAME5}`	ensembles of three to five, all in frame from the first shot	`prompts_scenes.txt`
400	`{NAME}`..`{NAME5}`	more ensembles, added in v1.2.0	`prompts_scenes_2.txt`

Both files are drawn from as one flat pool, so a file's share of the stream is its share of the blocks. --scenes is repeatable and passing it replaces the default set, so --scenes prompts_scenes_2.txt draws from that file alone.

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	10.34 s	73%
`VAEDecode` — video, Light VAE	1.90 s	14%
everything else — `MiniMaxH3ImageToVideo`, `H3FastWriteVideo`, `VAEDecodeAudio`	1.87 s	13%
total	14.11 s

(Streamed, the same configuration averages 13.7 s per clip over 12 clips. Isolated runs come out slightly higher here because each one pays a re-staging the stream amortises.)

For comparison, the same table at v1.1.0 — sage, official VAE, SaveVideo, and no --vram-headroom — was sampler 12.71 s, VAEDecode 4.35 s, SaveVideo 3.78 s, total 19.17 s. All three of those have since been attacked separately: the attention backend and Spectrum took the sampler, H3FastWriteVideo took the writer from 3.78 s to 0.26, and the Light VAE took the decode.

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 (36-block decoder, 576×320)	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.

That "exactly as fast" has a qualifier, found in v2.0.0. The expansion cost is roughly constant, so it disappears inside a 6.5 s decode and does not disappear inside a 2 s one. On the Light VAE's 26-block decoder at 448×448, w4a8 measures 2.47 s against int8's 1.95 — a 27% penalty on the same geometry, same seed, same settings. Which is why the file shipped here is int8 (2.12 GB) and not w4a8 (1.36 GB), the opposite of the choice made for the official decoder. Read this table as "int8 is the floor for speed", not as a ranking that transfers to a different decoder.

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.

There is a better DiT than the one in this repository

The weights shipped here are a FastH3 4-step student: a distillation, trained on the ladder [999, 749, 500, 250], fl2va/t2va only. They are what the rest of this README measures and what everything defaults to, so that a download runs with nothing else fetched.

They are not the best checkpoint for this pipeline. That is MATLOWAI/minimax-h3-fused-turbo-int8-convrot, which is somebody else's work and better than this one on both counts that matter here.

	FastH3 student (here)	fused turbo
how it gets to 4 steps	distilled	base + lightx2v 8-step turbo LoRA baked in
modes	`fl2va` / `t2va`	`fl2va` / `t2va` / `ref2va`, one file
step counts	4 only — others are off-distribution	4 or 8
size	20.97 GB	20.98 GB — the same; expect no VRAM relief
median clip	16.04 s	15.99 s
picture	the baseline	cleaner — fewer smeared frames

The speed is a tie and the picture is not. Both rows above are the same measurement: five scenes (3–5 characters, from red battle lanterns to white snow glare to flickering train light), 448×448 × 362 frames, 4 steps, --accel spectrum, euler, matched seeds, one scene per clip. Both came in 0/5 over a 22 fps budget. The difference that decides it is that the student smears more often — faces and fabric that hold together on the fused bake come apart on some frames here.

The ref2va row is the other reason. There is no ref2va FastH3 student and there is not going to be one; the fused bake carries a rank-1024 SVD of the (ref2va − fl2va) weight delta, so a single file does reference-to-video as well, with no second transformer to swap in.

Getting it

One 20.98 GB file. hf ships with huggingface_hub; pip install -U huggingface_hub if you do not have it. Point --local-dir at your ComfyUI models directory — the path inside the repo already ends in diffusion_models/, so the file lands in the right folder:

hf download MATLOWAI/minimax-h3-fused-turbo-int8-convrot \
  diffusion_models/minimax_h3_fused_refdelta_r1024_turbo8_mystic07_int8_convrot.safetensors \
  --local-dir ComfyUI/models

Or with git, which also pulls the six preview videos and its workflows:

git lfs install
git clone https://huggingface.co/MATLOWAI/minimax-h3-fused-turbo-int8-convrot

Using it

Nothing else changes — same graph, same text encoder, same VAEs, same --accel spectrum, same 4 steps. Just name it:

python stream_fasth3.py --dit minimax_h3_fused_refdelta_r1024_turbo8_mystic07_int8_convrot.safetensors

To make it the default so you stop typing it, edit the --dit default in stream_fasth3.py. Be aware that the rest of this README's numbers were taken on the student, and that a downloader who has not fetched the fused file will then get an error naming a checkpoint they do not have.

Two things its README recommends that do not apply here

Read its README before adopting more than the file, because two of its recommendations were tuned against a different graph:

res_multistep instead of euler. Measured here at the same speed (15.91 s against 15.99), so it is free, but its claimed benefit is audio and no difference was audible on this pipeline. It was tuned against SLA attention; Spectrum branches internally on which sampler is in use (selective_rollback_correction is documented as Euler-only), so changing it swaps a path validated over hundreds of clips here for one validated over five. Not adopted.
SLA sparse attention, which it reports as ~40% faster than dense. That is against dense; against Spectrum it is a tie (10.36 s each, see the --accel table above) and Spectrum holds the picture better. Nothing to gain.

Its timings are also all from a 96 GB RTX PRO 6000 at 1152×640 × 243 frames. None of them transfer to this pipeline's numbers — the ones in the table above were re-measured here.

Licensing is its own: MiniMax H3 Community License for the base, Apache-2.0 for the merged turbo LoRA, and the Mystic LoRA's Civitai terms. The territorial restriction described under Licensing below applies to its outputs exactly as it does to these.

Changes

v2.1.0

The textured patches are gone, and the stream got 28% faster doing it. Sustained throughput goes from 26.2 to 33.6 fps; playback stays at 24, now with 4.3 s of slack per clip instead of 1.2.

--sampler taomate3 is the new default. TaoMate-H3's 3-step LoRA on base MiniMax H3, converted here into a ComfyUI adapter (taomate_h3_3step_t2av_comfyui.safetensors, 2.48 GB, shipped). --sampler fasth3 is the student this repository ships, and the fallback when the route's 21 GB official base DiT is absent.
The patches were never Spectrum's fault, and this README said they were for two releases. Six arms at one seed settled it: the FastH3 student has them even under plain sage with four honest evaluations and no forecasting. They are an artefact of the DMD2 distillation's weights. The correction is marked inline in Going faster than sage, and the sampler has the table.
Two numbers retracted with it. "A 4-step schedule runs at roughly 2 NFE" was inherited rather than measured. And a claim that briefly lived in the code — that Spectrum cannot amortise itself over a three-step ladder — was an artefact of an arm mislabelled sage that had in fact run with Spectrum; measured properly, Spectrum is worth 3.0 s/clip on three steps. bench_sampler_stream.json records both the bad round and the good one.
Swapping the weights is free. At matched --accel, fasth3 and taomate3 both run 13.8 s/clip. The 3 s comes from Spectrum stacking on top; losing the patches costs nothing.
record_demo.py and stream_chat follow the same default. stream_chat's reference mode deliberately does not: the adapter is a T2AV distillation and ref2va is different weights.
convert_taomate_lora_for_comfyui.py ships, and its docstring is the interesting part — establishing that the conversion is a pure rename was the whole job, because the QKV fusion and SwiGLU half-swap that every other H3 adapter needs are both no-ops here and applying either would corrupt it silently.

v2.0.0

The stream runs in real time. The frames are authored at 24 fps and generation now sustains 26.4, so --fps defaults to 24 and the retiming that made every previous release play in slow motion is no longer doing anything. On one RTX 5090. That is the whole release; the version number is major because the headline claim of this repository changed.

The Light VAE is the new default. LynnReal's depth-distilled H3 video decoder, 26 ViT blocks against the official 36, requantized here to int8 and shipped as lynnreal_omni_light_vae_int8_convrot.safetensors (2.12 GB). VAEDecode goes from 3.19 s to 1.90, and streamed throughput from 24.2 fps to 26.4 — The Light VAE has the arms, the two ways the measurement misleads you, and what it costs the picture.
custom_nodes/h3_light_vae/ is new and required for it. ComfyUI's VAELoader hardcodes 36 decoder blocks and loads non-strictly, so it would load a 26-block checkpoint, warn once, and decode ten randomly initialised blocks into garbage. H3LightVAELoader reads the depth from the file instead. --no-light-vae goes back to the official decoder, which is still shipped.
--vram-headroom 3 is now documented as required, and this is the uncomfortable half of the release. Without it ComfyUI thrashes weights over PCIe and clip times go bimodal; with it, v1.2.0's own stack sustains 24.2 fps, not the 22.1 that was published. So part of this jump is a launch flag that should have been in the README from the start, and every figure in the previous release was taken without it. bench_accel_fps.py now refuses to run if the flag is absent. See step 1.
The --accel ladder was re-measured on the new VAE: sage 21.6, spectrum 25.6, sla 24.8 fps. The ordering is unchanged and spectrum is still the default, but the old table understated every arm, and it had sla tied with spectrum on speed when it is in fact slower. Raw numbers in bench_accel_fps.json, including one invalidated round kept as evidence of what the missing flag does.
record_demo.py ships, with cast_familiar.txt — the demo recorder with two burned-in clocks, so the real-time claim is falsifiable on sight rather than asserted. See Recording a demo.
The measurement harnesses ship too: bench_light_vae.py, compare_light_vae.py and bench_accel_fps.py. Every table in this README can be re-run on your own card, which matters more than usual here, because two of the conclusions in the previous release were wrong for reasons the numbers alone did not show.

v1.2.0

Sustainable throughput goes from 18.9 to 22.1 fps on the same card, the scene library grows from 321 to 721, and the stream now opens its own window.

--accel spectrum is the new default. Sage plus SpectrumApplyMiniMaxH3 takes the sampler from 12.65 s to 10.36 s with no visible cost. Two arms are faster still and both are unusable — see Going faster than sage for the measurements and, more usefully, for what the measurements failed to predict.
The nvfp4 text encoder is the new default, 1.67 s of prompt encoding down to 0.70 with no cost anywhere else. Same model, different official quantisation.
400 more scenes in prompts_scenes_2.txt, pooled with the original 321 by default. --scenes is now repeatable, and passing it replaces the default set.
A borderless player, opened once the port is actually serving, so the window can go straight into a screen share. --no-player for the old behaviour.

The benchmark that produced the table lives in stream_fasth3.set_accel() and is imported by the harness rather than copied into it, so the arm that was measured is the arm that ships.

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.

H3FastWriteVideo replaces SaveVideo, 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_nvenc measured 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
TaoMate-H3 — TaoLiveAIGC/TaoMate-H3 and its 3-step T2AV LoRA, by the Alibaba TaoLive AIGC Team (arXiv 2607.24359). --sampler taomate3 is that adapter, renamed into ComfyUI's layout and nothing else. Their own runtime is a 4-or-8-GPU streaming stack and does not run here; this repository uses only the weights, redistributed under the same MiniMax H3 Community License, with the rename recorded in NOTICE.
The Light VAE — stdstu123/LynnReal-Onmi-light-vae and the ComfyUI bundle in LynnReal-Onmi-beta-0.1, part of LynnReal-Omni (arXiv 2609.15863): the depth-distilled 26-block video decoder that this release defaults to. Redistributed here requantized to int8, under the same MiniMax H3 Community License; NOTICE records exactly what was changed. The batched-tile decode and the device-side output buffer in h3_light_vae follow that bundle's own light_vae.py.
Character index — malcolmrey/various, h3-center/known-characters/INDEX.md. h3_characters.json is derived from its good section; only characters that repo verified as reliably reproducible are included.
ComfyUI and comfy-kitchen — the quantization layouts and H3 model code
Spectrum — xmarre/ComfyUI-Spectrum-MiniMax-H3 (GPL-3.0), what --accel spectrum calls. Install it yourself; it is not redistributed here, so that this Apache-2.0 repository stays Apache-2.0.
Sol-Attn — Saganaki22/ComfyUI-sol-attn (Apache-2.0) and SLA — ComfyUI-PlagueKind-Nodes (MIT), for the --accel sol / --accel sla arms. Measured here, not recommended.
The fused turbo bake — MATLOWAI/minimax-h3-fused-turbo-int8-convrot, the recipe patientx's, built on xmarre/MiniMax-H3-Pruned-Ref-Delta-Fused-r1024-ComfyUI with lightx2v/Minimax-h3-Turbo and Mystic v2.0 merged in. A better DiT for this pipeline than the one shipped here; not redistributed, see the section above.
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 three weight files -- the DiT, the Light VAE and the official video VAE -- are Model Derivatives of MiniMax H3, distributed under the MiniMax H3 Community License Agreement (full text: LICENSE-MiniMax-H3.txt). No extra terms are imposed on them. Their modification notices -- exactly what was changed relative to upstream, including that the Light VAE's encoder is bit-identical to the official one and only its decoder differs -- are in NOTICE, and are also recorded inside each 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 files. The code and the scene library are Apache-2.0 and carry no such restriction.

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: 200

Total file size:

27.3 GB

Papers for jacokon/fasth3-live

LynnReal-Omni: Native multi-modal Video Generation for Agentic Visual Workflows

Paper • 2609.15863 • Published Sep 14 • 56

TaoMate: Anchor-Guided Memory Bridging Evolving and Reference States for Real-Time Audio-Video Digital Human Generation

Paper • 2607.24359 • Published Jul 27 • 2

You need to agree to share your Hugging Face information to access this dataset