MiniMax H3 Easy SelfLift

If you know hi-res fix on images - generate small, upscale the intermediate, finish with a low-denoise second pass - SelfLift is that idea folded into a single sampler. MiniMax H3 Easy SelfLift doesn't sample anything; it builds a sampling plan you hand to MiniMax H3 Easy Sample, Segment Sample, or Sample Setup. The plan is a plain data object - nothing is patched into the MODEL - so one strategy node can feed several samplers.

Given H3 is a 33B, ~42.5 GB model, anything that bends the cost curve of sampling is worth a look - though note the weights are geofenced (the Community License excludes the US, EU, UK and South Korea), which is a licensing question before it's a VRAM question.

How it works

The first transition_step Euler evaluations run on a smaller spatial grid - the target latent dimensions multiplied by lowres_scale, rounded to even numbers. At the transition the sampler captures both its current state and its clean prediction. That clean prediction is then lifted onto the full-resolution grid, the state is carried across the sigma gap with the same Euler update the sampler would have made, fresh noise is added at the resumed sigma, and the remaining evaluations run at the real resolution.

The lift has two flavours, and this matters before you touch the widgets. With upscaler_model set, the low-res clean latent goes through the pack's built-in 3D latent upscaler (which only changes the spatial grid - the temporal axis is preserved). Left on none, it's lifted with a plain nearest-neighbour latent resize: crude, but free and perfectly usable for a first experiment. Then there's rho, the correction ratio, which blends in a pixel anchor: the low-res latent is decoded with the H3 video VAE, resized in RGB, re-encoded, and the difference against the direct lift is applied to the fraction of latent elements with the largest disagreement - rho is that fraction, and w_min/w_max are the weights at the bottom and top of the selected band. Set rho to 0 and you're on the pure upscaler (or nearest-neighbour) path. Raise it and you pay for a mid-sampling VAE round trip, and mixing rho with a learned upscaler triggers a warning in the log calling the hybrid experimental. Believe it.

The inputs that matter

• transition_step (default 5) - how many evaluations happen small. It must be at least 1 and strictly less than the number of steps in your schedule, so with the bundled 8-step setup the ceiling is 7. At 8 steps and a transition of 5 you get 5 cheap steps and 3 full-price ones.
• lowres_scale (default 0.8, range 0.25-1.0) - the spatial factor. 0.8 is 64% of the pixels; going much lower makes the lift do more work than the model.
• upscaler_model - the picker scans models/latent_upscale_models/. The shipped SelfLift workflow points at minimax_h3_latent_upscaler_3d_fp16.safetensors, which is the file you want if you're downloading the H3 3D latent upscaler. none is a valid, cheap choice.
• advanced - a UI switch, nothing more. Ticking it reveals cfg, rho, w_min, w_max, upscaler_device, upscaler_precision and upscaler_chunking; the backend deliberately ignores the value itself. Reach for it to move the upscaler to rocm on AMD, to cpu when VRAM is tight, or to drop precision to fp32 if you get garbage on an unusual card.

The only output is sampling_plan, wired into the optional Sampling plan input of MiniMax H3 Easy Sample (sampling_plan), Segment Sample, or Sample Setup.

Install

Pack-level install covers this node - Manager, search ComfyUI-MiniMaxH3-Easy, choose Nightly, or:

cd ComfyUI/custom_nodes
git clone https://github.com/nkxx188/ComfyUI-MiniMaxH3-Easy.git

Then restart and put the H3 3D latent upscaler checkpoint in:

ComfyUI/models/latent_upscale_models/

The pack's only pip dependencies are requests and psutil, so there's nothing exotic to break. The fastest way to see it working is to import workflow/8.MiniMax_H3_Easy_SelfLift.json - that example is reference-to-video, 5 seconds, Euler + simple at 8 steps, with the strategy feeding the sampler.

Where it fails loudly (on purpose)

SelfLift validates rather than silently producing mush. It requires Euler (KSamplerSelect set to euler) with s_churn at 0, and a rectified-flow / CONST model. It recomputes the Euler step by hand across the resolution switch, so anything else is rejected with a message naming the problem.

It also requires an empty video latent: t2v, i2v, first/last-frame and reference-to-video all qualify because the keyframe arrives through conditioning, not the latent. Anything putting real pixels into the latent - the Selected Video refine path, encoded-video refinement - is rejected, and Soft/Hard AV prefixes aren't supported either. Digital Human is the exception, with its locked driving audio and masks preserved across both stages.

One practical thing worth knowing: when a learned upscaler is used on CUDA or ROCm the node pre-unloads the H3 denoiser before loading the upscaler weights, so both big models aren't resident at once, and the full-resolution stage reloads H3 afterwards. Right call for VRAM, but it means a SelfLift run spends time on a reload. If you're near the edge of your card, leave upscaler_chunking on and lower lowres_scale rather than hunting for a hero setting.