MiniMax-H3 Multishot — Seamless Chain: multi-shot scenes that render as one continuous take (picture + audio)

Support

Everything here is free and stays free — the format spec, the nodes, the workflows, the cartridges, the LoRAs. If it saved you a night of debugging (it contains several hundred of mine), tips keep the 5090 warm:

• ☕ Buy me a coffee on Ko-fi

• 💛 Sponsor on GitHub

• 🔁 Liberapay (recurring)

• ⚡ Or right here: the Civitai tip button on this page sends Buzz directly.

2.6.0 adds the extend take

One prompt, one continuous speech, as long as you want. Set take_seconds on MASTER CONTROLS - or open H3_Extend_Take, now the main workflow - and give the writer one premise. The panel sizes a window for your card and the count that fills the time; the writer writes ONE speech and cuts it across the windows at sentence boundaries; the chain continues it in H3's own voice, no TTS, no per-shot budgeting. Verified: seven renders including a 65-second seven-window take, every join continued the speech. Details in this version's notes.

Known limit in 2.6.0: the chain's texture ratchet is not fully solved for long takes - we measure about +13% fine texture per join at 736x1280 with every anti-drift setting on. Under about 4 windows (30-40 seconds) it is slight; at 7 windows it is visible sharpening. Keep extend takes to about 4 windows for now; a fix is in progress.

2.5 is the memory release

Four new memory systems, all measured, two of them fully automatic:

• The random-slowdown fix (automatic). High-resolution renders used to take anywhere from 27 minutes to 3 hours for identical work - a lottery caused by the Windows driver quietly demoting GPU memory when the card fills past roughly 95%. The pack now detects that zone and streams a few GB of weights instead of riding the ceiling. The lottery render became 15 minutes, every time. Nothing to configure.

• low_ram_master. Long chains used to hold every finished shot in system RAM until the final join - tens of GB at the very last step, after all the sampling was already paid for. Switch it on and shots stream to lossless disk staging as they finish; peak RAM stays near two shots no matter how long the chain, with verified-identical output.

• Remote text encoder. The text encoder runs for seconds per shot and holds 15+ GB the rest of the time. Point the new node at any second PC running ComfyUI with this pack and that memory leaves your render card - identical results, verified across machines, with a local cache so repeated text never touches the network. One flag on the switches panel turns it on; it ships off.

• H3 TAE Decode. 2-second full-resolution draft previews from a 9 MB tiny decoder, versus about a minute per shot through the real VAE. For seed hunts and batch triage, never finals.

Plus a Speed Boosters panel - Spectrum, TeaCache, block cache and ComfyUI's own EasyCache, each measured (-11% to -29%) and eye-tested. All ship OFF: the three real ones are faster but can visibly distort people, and block cache turned out to do nothing at 14 steps (0 hits measured on every run) - honest notes on each. Defaults across the workflows are retuned for 16-24 GB cards. Full details in this version's notes.

Guides

• Make talking videos with MiniMax-H3: the 5-minute guide - what to open, what to type, what each setting costs your card.

• Every setting explained: the deep manual - every workflow, every dial, what it does and what breaks if you move it.

What this is

A ComfyUI node pack and three workflows that render a multi-shot MiniMax-H3 scene as one continuous take: no visible cut at the shot boundaries, no colour shift between shots, and continuous audio across the whole piece. H3 natively generates blocks of roughly 10-15 seconds; this pack chains those blocks into arbitrarily long scenes and hands back a single master video with a single master audio track.

How identity holds with no reference images

This is the part most people do not expect. A 40-second two-character scene held both faces across every shot with zero reference images supplied. Two mechanisms do it, and neither works alone.

• The frame relay carries the instance. Every shot begins from an actual rendered picture of the character - the previous shot's last frame - so the specific face, the wardrobe weathering, the exact hair propagate as pixels rather than being re-imagined from text. Drift can only accumulate per join, not per frame.

• Verbatim text carries the category. Repeating each character's appearance description word-for-word in every shot re-asserts everything a picture cannot pin down, and authors anyone who walks into frame partway through. Once they are in a handed-over frame, they join the relay too.

Reference images and the identity bank are still there for long chains, characters who leave frame for a long stretch, or when you need a specific pre-existing face - they are just no longer the price of entry.

Voice identity across the chain

Chained shots used to re-perform the voice from text each time, and it drifted. Two controls end that, and the shipped default turns one of them on:

• voice_ref - feed a clean solo speech clip and it anchors every shot as <Audio 1>. Mono clips, sample rate and length are all guarded internally.

• self_anchor_voice - no file at all. Shot 1's own rendered voice becomes the reference for every later shot. Write shot 1 so the character speaks a clean solo line.

Both ride the checkpoint's reference rows, so they need ref2va. On fl2va they do nothing except cost tokens - see the checkpoint note below.

Which workflow

Three, each with one clear reason to exist.

• H3_Seamless_Chain_v2 - everything. Master controls, the LLM writer, the speed boosters, the remote encoder lane, identity and voice anchors, an episode/batch prompt source, FFLF boundary plates and an audio spine. The optional lanes ship gated off, so the default path stays simple.

• H3_Seamless_Chain_CORE - the same job with zero third-party packs. Type your shots into the script box and queue. Start here if you want a render before installing anything else.

• H3_Keyframes - a different job: a hand-built sampling graph for anchoring a single clip at chosen frame positions with per-anchor condition strength. Not multishot, does not chain.

Master controls, and the dials that matter

One panel drives resolution, frames per shot and steps for the sampler, and also feeds the writer so it paces dialogue to the real shot length. Shipped defaults: H3_Extend_Take 1280x736 landscape, take_seconds 30; H3_Seamless_Chain_v2 736x1280, 192 frames x 4 shots; 14 steps, euler/beta57, the curve-Q5_1 checkpoint. The resolution floor is deliberate - the base model distorts faces below roughly 1 megapixel, so shrinking the canvas to save VRAM costs you faces first. The dials worth knowing:

• continuity - context_pin (raw-latent join, needs the Motion Context pack), first_frame (the model's own trained hand-off, no extra pack), cut for episodic work, or flf_chain for boundary plates.

• seed_per_shot - leave it on. Measured: varying the seed per shot holds the face; one seed for every shot drifted both face and voice. Identity lives in the conditioning, not the seed.

• chain_gain_control - ships at flatten. Each shot's tail anchors the next and the model returns roughly 1.3x the anchor's texture energy, so sharpness ratchets across a chain without it.

• Speed boosters - all ship OFF. Spectrum, TeaCache and EasyCache are real speed but can visibly distort people; block cache does nothing at the shipped 14 steps (0 hits measured on every run - only worth it at 30+ steps). The three real ones - fine for empty rooms and landscapes, compare for yourself before using them on faces. Never stack Spectrum with TeaCache: no extra speed, badly damaged output.

• low_ram_master - turn ON for long chains or under 32 GB of system RAM. Shots stream to lossless disk staging instead of accumulating in RAM; identical output, verified.

• remote_encoder (VRAM / SPEED SWITCHES panel) - OFF by default. With a second ComfyUI PC on your network, turn it ON and the text encoder's 15+ GB moves over there. The how-to note sits next to the encoder node.

• output_scale / upscale_model - upscaling happens after decode, per shot, so it works with every continuity mode including context_pin. output_scale is a lanczos resize (measured 1.78x faster than rendering the same output size natively, and visibly softer - resolution, not detail); upscale_model takes ComfyUI's own Load Upscale Model (ESRGAN and friends) for synthesized detail.

• master_normalize - leave it at luma+contrast. It levels both the brightness AND the contrast of the finished chain against one global target taken from shot 1. Measured: texture growth per hop 1.126 -> 1.047 at 960x544, with contrast spread across shots falling from ~11% to under 0.5%.

• memory_frames - leave it at 0. The bank's RECENT slots hand each shot's accreted output forward on top of the pin, so invented detail compounds. Measured over ten shots: at the old default the drift accelerated; at 0 it holds flat, and motion continuity did not suffer.

• pin_frames - leave it at 22. Longer pins also cut the sharpening, but the head trim scales with them, so speech planned under the replay gets clipped.

• Audio drifts the other way: chained audio gets duller per hop where chained video used to get sharper. There is no per-shot dial for it. For cut-grammar content it can be avoided outright: continuity=cut with bank_pinned=1, memory_frames=0 conditions every shot's audio on shot 1 alone - measured flat.

• preview_first_shot - writes shot 1 the moment it decodes, so a bad take can be cancelled before the whole chain renders.

Which checkpoint

ref2va ships as the default, as the curve-Q5_1 GGUF (~14 GB): it carries the reference rows that voice anchoring and the identity bank need. fl2va has no reference rows and chains just as well - the voice rides the frame relay instead of being pinned - and it lands on a supplied frame where ref2va only nudges toward one. The two are the same file size at every quant level.

Writing a script

One prompt per shot, --- on its own line between them. The mechanics of a join are handled for you; whether the join reads as invisible is decided by the writing. These rules were each written after a specific failure:

• The airlock. Every shot after the first opens holding the previous shot's exact closing arrangement, with about two quiet seconds before anyone speaks. The head of a chained shot is discarded on decode - anything you put there is thrown away.

• Give the hold something to do. A held framing with nothing happening renders as a literal freeze. Write in a breath, a weight shift, an eyeline change.

• Land settled. End each shot back in a stable arrangement, dialogue finished, about two seconds spare.

• A line never straddles two shots. The LLM writer budgets this automatically now. Hand-writing? A chained shot at 192 or 243 frames fits roughly 6-10 spoken words; 362 frames fits 12-20. Over budget renders as crammed, garbled speech; far under budget renders slow and robotic.

• Repeat the descriptions word-for-word. Each character's appearance and the room and lighting, identical in every shot. Rewording between shots is the single most common cause of a face changing mid-scene.

• Silent shots with visible people: say what mouths are doing ("lips pressed closed") or the model invents mumbling. A thing revealed mid-shot is written as already present, or it pops in.

Camera cuts inside a shot are free and share one audio bed - so put cuts inside shots, and continuity between them. A worked four-shot two-hander ships as example_script.txt.

Quick fixes

• A word clips at a join - the script put dialogue too close to a boundary. Move the whole line, do not split it.

• Sharpening increases every shot - the texture ratchet. chain_gain_control=flatten ships on; check it was not turned off.

• A render randomly crawls - as of 2.5.0 the pack detects and fixes the main cause automatically (watch for the "driver headroom" line). If it still happens: drop frames or resolution, or load a smaller quant of the DiT.

• The machine dies at the final join on a long chain - turn low_ram_master ON.

• People look subtly wrong - if you enabled Spectrum, TeaCache or EasyCache, that is the trade. Turn them off; keep block cache.

• LLM API error 404, model not found - the writer's model_name is not pulled on the endpoint it is pointed at. See the prompt-writer section below.

• Red or missing nodes - an optional pack is not installed. The optional nodes ship bypassed, so this only bites if you un-bypassed one: re-bypass it with Ctrl+B, delete it, or use the CORE workflow.

• GGUF architecture error - the pack teaches ComfyUI-GGUF the minimax_h3 architecture at startup, so installing it is normally the whole fix. If the error persists, run python apply_gguf_arch_patch.py from the pack folder once and restart.

• Audio dulls on a very long chain - expected; restart the chain on a scene cut, where a fresh start costs nothing.

The prompt writer needs a model you actually have

The full workflow ships pointed at a local Ollama with model_name = qwen3:14b. Pull it before the first queue or the run stops immediately with LLM API error 404: model 'qwen3:14b' not found:

ollama pull qwen3:14b

Any OpenAI-compatible endpoint works - put its URL in base_url and the exact tag in model_name; ollama list prints the tags you have and it must match character for character. A remote or hosted endpoint is often the better choice, because a local writer large enough to be good competes with H3 for the same card.

Running the writer locally? Turn on unload_model_after on the writer node. It frees that model from Ollama the moment the script is written, so the video model gets the card - otherwise it sits for the server default of five minutes, which is your whole first shot.

Want no LLM at all? Set the master panel's use_file_prompts to manual entry, delete the writer, and feed your own shot script straight into the sampler's script input - one prompt per shot, separated by --- lines. The CORE workflow already works this way.

Requirements

Always: ComfyUI v0.30.0 through v0.33.1 - tested at three points and supported across the range (native MiniMax-H3 support), this node pack, a MiniMax-H3 checkpoint, the H3 text encoder, and the video and audio VAEs. The CORE workflow needs nothing else - it is built from this pack plus stock ComfyUI nodes.

For the FULL workflow. ComfyUI validates every node class in a graph before it will queue, so a missing pack stops the whole workflow - not just its own feature. Each can be removed instead; INSTALL.md gives the one-widget change or node deletion for every entry.

• ComfyUI_JoyAI_Echo_GGUF_Nodes - the LLM prompt writer (JoyEcho_LLMEnhance). It is inside the release zip - copy it into custom_nodes/ with the main pack. It is RealRebelAI's pack, modified with attribution (the NOTICE inside lists every change); use that copy, not upstream - the workflow drives inputs the upstream release does not have, and with upstream those values are dropped silently. Hand-written scripts can delete the writer instead.

• ComfyUI-H3-Motion-Context - continuity = context_pin, the shipped default, plus interior keyframe anchors. Removal: continuity = first_frame.

• RES4LYF - the beta57 scheduler the full workflow ships with. Removal: scheduler = beta (measured cost: lip-sync 8/10 vs 10/10, everything else equal; CORE ships beta already).

• Booster packs (Spectrum, TeaCache, block cache) - each switch names its pack and prints an install link if it is missing; the graph queues either way. EasyCache is built into ComfyUI, nothing to install.

• ComfyUI-Custom-Scripts - the in-canvas script preview, a leaf node; removal: delete it.

• ComfyUI-GGUF - quantised checkpoints and encoders.

Install in one click: search H3 Multishot in ComfyUI-Manager - the pack is on the Comfy Registry as comfyui-h3-multishot. The zip on this page stays the complete bundle - both node packs, the workflows and the docs.

Models

GGUF quants of the H3 checkpoint are at huggingface.co/joeygambino/MiniMax-H3-GGUF - Q8_0 for 32 GB, Q5_1 for 24-32 GB, Q4_0 for 16 GB. The shipped default is curve-Q5_1 (~14 GB), which the new automatic headroom rule keeps comfortable on 16 GB cards as well. The text encoder and both VAEs are at huggingface.co/Comfy-Org/MiniMax-H3. GGUF encoder quants are at huggingface.co/joeygambino/MiniMax-H3-encoder-GGUF; keep the -mmproj vision sidecar, and load it with this pack's H3 CLIP Loader (safetensors + GGUF) rather than the stock GGUF loader - the vision path is what carries frames between shots.

What is verified, and what is not

Stated plainly, because a release note is a claim.

• Verified: chained renders reviewed blind by two independent models and reported as one continuous take with consistent colour and unbroken audio; a 40-second two-character scene holding both faces with no reference images; the streaming master at 42.8 dB against the in-RAM path; the remote encoder identical across two machines; the driver-headroom rule on both its branches; every booster measured on the same seed and eye-tested on finished video.

• Not verified: very long chains still dull the audio slightly per hop. flf_chain has not been rendered against a fully colour-matched plate set.

Credits

The context_pin join and interior keyframe anchoring build on ComfyUI-H3-Motion-Context by NikoDemon80. The script preview uses ComfyUI-Custom-Scripts by pythongosssss. GGUF loading builds on ComfyUI-GGUF by city96. Speed boosters integrate ComfyUI-Spectrum-MiniMax-H3 by xmarre, ComfyUI-MiniMaxH3-TeaCache by Icyoung and comfyui-minimax-h3-blockcache-T8 by T8mars. Thanks to @viralesveras for contributions to earlier versions.

Free, and it stays free. If it saved you time: Ko-fi · GitHub Sponsors · Liberapay.