MiniMax H3 Two-Stage Sampler

What it is

A drop-in replacement for the sampling half of an H3 graph. Most of your denoising steps run on a spatially downscaled AV latent, then the result gets lifted to target resolution and the schedule finishes there. The class is MiniMaxH3TimelineSelfLiftSampler; the menu calls it MiniMax H3 Two-Stage Sampler.

It looks like hi-res fix and is not the same thing. Hi-res fix re-encodes to pixels and runs a fresh second pass with its own step budget. This one adds no steps - it reuses the final low-resolution model evaluation for the transition - and by default it never leaves latent space.

Reach for it when you are chasing length. H3 does 4–15 seconds, and the usual workaround for longer output is last-frame chaining, which drifts and softens. This pack joins segments in latent space instead, and this node is what makes a minute of video a reasonable wait rather than an afternoon. For one short clip, you gain almost nothing. Keep the plain sampler.

The mechanism, honestly stated

The runtime is a MiniMax H3 adaptation of SelfLift progressive-resolution sampling. The author credits facok/comfyui-SelfLift and bundles it, so do not install that pack alongside - you would be fighting two copies of the same code.

In order: downsample the latent by lowres_scale; run transition_step denoiser evaluations there; take the clean endpoint prediction from the last of those; build two versions of it at target resolution - a direct lift (nearest-neighbour, or a learned H3 latent upscaler if you point it at one) and a pixel-VAE round trip (decode, upscale, re-encode); diff them to locate where the cheap lift is least trustworthy; correct the worst rho fraction of locations toward the pixel anchor, weighted between w_min and w_max; then re-noise at the transition sigma and complete that Euler interval without another denoiser call. That last part is why your step count does not change.

H3 specifics: the latent is nested, so the audio stream has no spatial dimensions and simply rides through the reused boundary step. Multi-segment runs also carry the previous segment's low-resolution tail into the prefix, with a full-resolution continuation chain alongside it.

Caveat, from the author's own tooltip: the paper's step split was tuned on an image model, and H3 "requires independent validation."

Inputs that matter

Sampler is the big one: standard Euler only. The node reuses the transition step's prediction to hold NFE constant, and a wrapper or another integrator breaks that count - hence an explicit error about too many low-resolution callbacks.

Transition step is the number of low-resolution evaluations; the rest run at full resolution, so high-res steps = total steps − transition step. The README's rule of thumb is 25% high-res: on an 8-step schedule, set 2. It must be at least 1 and strictly less than the scheduler's step count.

Latent upscaler picks the direct lift. none means nearest-neighbour; anything else comes from ComfyUI/models/latent_upscale_models/, and the first H3-shaped checkpoint there becomes the default. rho leans between the two routes: at 0 it trusts the learned upscaler and skips the VAE round trip entirely. Set rho above 0 with the upscaler at none and you get SelfLift-zero, the fully training-free route - start near 0.6. w_min and w_max are the correction floor and ceiling; the note that H3's nearest-lift error is widespread enough to want 1.0 suggests the paper's 0.5 is not sacred here.

The rest is stock plumbing - model, positive, negative, vae, latent_image (target size and duration), sigmas, seed, cfg - plus optional model_hires for the high stage only.

Output is a single LATENT - the nested H3 AV latent. Decode it with the video VAE and the audio VAE like any other H3 sample.

Install

It ships with the pack, so there is nothing extra to install:

cd ComfyUI/custom_nodes
git clone https://github.com/Songssx/ComfyUI-MiniMaxH3-TimelineDirector.git

Drop an H3-compatible latent upscaler into ComfyUI/models/latent_upscale_models/ and restart. In practice you rarely wire this node by hand: turn on Two-stage sampling in the Material Planner, pick the upscaler, set the high-resolution step count, and the Finite Segment Sampler builds one of these per segment - it fixes cfg for you too (1.0 in the current build). Manual wiring is for the native-loop path, between Prepare Loop Segment and your decoders.

Where people get burned

• "Two-stage sampling requires a latent upscaler under ComfyUI/models/latent_upscale_models", or the blunter "LTX upscalers use a different architecture." The upscaler has to be an H3 latent lifter; a good LTX model with the right filename does not count.
• rho=0 with the upscaler at none. Both routes are off, so there is nothing to lift with. Pick one.
• High-resolution steps ≥ your scheduler steps. More high-res steps than the schedule has is not a thing.
• RAM, not VRAM, is the ceiling on long clips. The pixel-anchor branch decodes, upscales and re-encodes in deliberate 32-frame chunks, because a naive whole-clip pass on a long video can eat tens of gigabytes of system memory and stall the transition mid-run. A noise mask plus highres_tiling is refused outright.