Pulse Render

H3's ceiling is ~15 seconds per call. Pulse Render is how you get past it.

MiniMax H3 generates one window per call, trained up to 362 frames - about 15 seconds at 24fps. Anything longer means splitting the timeline into chained windows, and that's a completely different job from a single generation. That job is what Pulse Render does: it walks a PULSE_TIMELINE from a Pulse Slate node, renders one window per H3 call, writes each finished segment to disk, and stitches the result.

The thing that makes it worth your time isn't the rendering - it's the segment cache. Every window lands in ComfyUI/output/<run_dir>/<run_id>/ as it completes, with a manifest fsynced before the next window starts. The practical consequences:

• Kill the render at window 9 of 12, requeue, and windows 0–8 load from disk while 9–11 render.
• Edit one shot, and only the window holding it re-renders - at its original seed.
• Change the seed, the steps, or the upstream patch chain, and everything goes (all three change what comes out).
• Seeds are derived from the set of shots in a window, so inserting a shot at the top doesn't reroll every window after it.

The inputs that matter

The required timeline comes from Pulse Slate. model is the ref2va checkpoint with every patch already applied upstream - this node samples with the model it's handed, so a patch applied downstream does nothing at all. vae and audio_vae are both required, because H3 always builds a joint audio+video latent. Everything else is choices:

• cache_mode - auto reuses whatever's unchanged; force_rerender ignores the cache; reuse_only refuses to render anything and aborts naming the first missing window. That last one is how you assemble a final cut without regenerating a frame.
• dry_run - the report and nothing else: no sampling, no decode, no file writes. This is the habit that saves you: a wrong reference binding renders successfully and hands you a well-formed film of the wrong person. The report's per-shot ordinal map is how you catch it before spending GPU time.
• low_memory (default on) - accumulates assembled frames as 8-bit and releases VRAM between windows. The finished video is assembled by stream-copying the segment files, so a twelve-window film never exists in RAM.
• seam_treatment - where two windows meet, the container seam is gapless by construction, but the two sides are independent generations: a score that restarts, a level that steps. audio level-matches the join with an equal-power dip; audio+colour also grades a window's opening toward the previous exit frame, decaying over 12 frames. off is for A/B-ing - colour matching occasionally makes things worse.
• use_reference_audio - on a lip_sync shot, H3's audio is a re-synthesis of your recording (close, but not your take). This muxes the original recording into the film instead. Off by default, because it silences everything the model scored around the voice; reversible without re-rendering.
• run_dir / run_id - folder naming; an empty run_id derives from the timeline, so the same project reopens into the same folder across sessions.

Outputs: video, frames, audio, segment_paths (a string listing the run folders - feed those to PulseBench for the speed table), and report.

The patch chain is upstream, and it's not optional in practice

Pulse Render consumes a patched MODEL and doesn't patch anything itself. The documented chain, wired by you:

UNETLoader → SpectrumApplyMiniMaxH3 (history_storage: system_ram)
  → PatchSageAttentionKJ → Sol-Attn → Pulse Slate / PulseRender

Order matters: Sol-Attn must come after the Sage patch, or Sage shadows it and you get no speedup - and the graph still runs and still produces output. Wire patches into both model inputs (model for references, model_fl2va for anchors). Every approximation on the incoming model is detected and folded into the cache key, so changing tau_start re-renders the affected segments instead of silently reusing ones rendered at the old sparsity.

And system_ram is not a speed setting. On a 32 GB card, Spectrum storing history in system RAM is what makes a 362-frame window fit at all; set it to vram and a full-length window likely OOMs. The node warns - on its face and in the console - when it finds no attention or offload patch, but never blocks. Running unpatched is a legitimate choice; the warning just makes it a choice instead of an accident.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/Addis-Pulse-Studio/comfyui-pulse-studio

Restart ComfyUI. Nothing to pip install - zero dependencies, just torch/numpy/Pillow/av from your ComfyUI, which must be 0.30.0+ with H3 support in the host build. Grab the weights from Comfy-Org/MiniMax-H3 into the minimax/ subfolders (ref2va DiT ~20 GB, fl2va ~20 GB if you use anchored continuity, text encoder ~15 GB, two VAEs). They carry the geofenced MiniMax H3 Community License - no US, EU, UK or Korea - and on Linux/macOS the example graphs' loaders show red until you re-pick each file (Windows-authored backslash paths).

Honest troubleshooting

The long-form path (PulseSlate_LongForm.json) runs end to end on real hardware - a >15 s multi-window render completed on the author's box - but the seam-by-seam listening pass is explicitly not written down yet. Treat seam quality as unconfirmed; if a seam sounds wrong, that's seam_treatment and the report, not a fault in your install. And if save_segments is off, there are no segment files to join - take frames + audio instead, or turn it back on.