MiniMax H3 Latent Upscaler + Refine (3D)

The fastest way to get a sharp MiniMax H3 clip isn't to generate it sharp. It's to generate small, upscale the latent, then run a short second H3 pass to add detail back - the two-stage trick that's become the default for expensive video models. This node does both of those stages in one box, which makes it the most useful thing in this pack and the most finicky to wire correctly.

The MiniMax H3 Latent Upscaler + Refine (3D) takes a low-resolution H3 latent, runs the learned 3D upscaler on it, rebuilds clean high-resolution H3 state, generates fresh noise on that enlarged grid, and then executes a real H3 sampling pass internally using the sampler, noise, and sigmas you feed it. The LATENT that comes out is final - wire it to VAE Decode and you're done. If you're on the companion H3 Continuum pack for long multi-chunk generations, it processes chunk lists in order so each continuation's protected prefix picks up the post-refine tail of the chunk before it.

What it does, step by step

The README spells out the pipeline, worth knowing before you judge a "broken" result:

1. learned video upscale (2× default)
2. optionally offload the upscaler to CPU (offload_after_upscale)
3. rebuild clean high-res joint H3 AV latent state
4. generate independent fresh noise directly on the enlarged grid
5. build the H3 guider - positive-only by default, or CFG if you connect negative on the native fallback path
6. run the supplied SAMPLER with your SIGMAS and denoise mask
7. return the result as the final LATENT

There's no manual pre-noising and no DisableNoise stage - the node follows ComfyUI's normal advanced-sampler contract and lets the model's own noise_scaling do its thing.

The inputs that actually matter

Beyond the sizing controls shared with the 3D upscaler (mode, scale, width/height, megapixels, align, keep_proportion), this node adds the sampling machinery:

• noise, sampler, sigmas - required. Wire RandomNoise into noise, a KSamplerSelect into sampler, and a partial-denoise schedule into sigmas. This is the big one: sigmas[0] must be < 1. The node rejects a full-denoise schedule starting at 1.0, because H3's CONST parameterization gives a clean latent zero weight from full noise. A short partial-denoise pass is the intended use - and remember, doubling latent H and W roughly quadruples the tokens per transformer step, so benchmark the pass before you commit to it.
• refine_state (optional) - the preferred path when you're on H3 Continuum. It carries the exact per-chunk model wrapper and conditioning that sampler 1 actually used, so the refinement is faithful instead of approximated. Connect Continuum's video_latents → latent, audio_latents → audio_latent, and refine_state → refine_state. A valid refine_state takes precedence over stale model/positive wires, so don't leave old ones hanging around thinking they're helping.
• model + positive (optional) - the native fallback when you're not on Continuum. negative + cfg are optional CFG-style extras for that path only.
• lock_audio (default true) - keeps pass-1 audio exactly as-is and masks it out of refinement. Turn it off if you want sampler 2 to remix the audio too. Audio never goes through the learned upscaler, which is a nice touch.

Do not add an external BasicGuider, DisableNoise, or SamplerCustomAdvanced around this node - it builds and runs the sampler internally, and extra guider wiring will fight it.

Install

Same pack, same drill:

cd ComfyUI/custom_nodes
git clone https://github.com/xmarre/Comfyui_Minimax_h3_latent_Upscaler.git

Restart (or use ComfyUI Manager's search for "Minimax H3 Latent Upscaler"). Only extra dependency is einops. The model checkpoint goes in ComfyUI/models/latent_upscale_models/ from LBH-123-AI/Minimax_h3_latent_Upscaler on HuggingFace - until it's there, model_name is an empty dropdown. Continuum interop needs the H3 Continuum release that exposes refine_state - upgrade that too if you're chasing the chunk-list path.

Where people get burned

Three things, in order of how often I've seen them: (1) a full-denoise sigmas schedule starting at 1.0 - rejected, and confusing if you don't know why; (2) treating the learned upscaler as the cost - the refinement pass is the expensive part, at roughly 4× the tokens per step for a 2× spatial upscale; (3) mixing Continuum refine_state with leftover manual fallback wires and assuming they cooperate. The node is explicit: valid refine_state wins, invalid state fails closed. Also mind the H3 license: it excludes the US, EU, UK, and South Korea, so whether you can legally run this pipeline depends on where you are.

Get the sigmas right and it's genuinely the nicer workflow.