MiniMax H3 Easy 3D Latent Upscale (Built-in)

Latent upscalers are the unglamorous half of any video pipeline. You generate at something your GPU can survive, then you pay again to make it look like it wasn't generated at that size. MiniMax H3 Easy 3D Latent Upscale (Built-in) is the pack's own, and - fair warning - the class name betrays its history: it still registers as MiniMaxH3EasyLatentUpscaler3D and lands in the video/MinimaxH3 category, because it came in from the upstream Easy project. Everything else in this pack is prefixed AICG3D_H3_ to dodge node-name collisions. This one kept the old name on purpose, so older graphs still resolve.

What it is

A neural upscaler that operates on H3's latent directly, with a temporal dimension. It is not LatentUpscale (the core node that just resamples a tensor) and it is not a pixel-space model like the ESRGAN family. It's a small 3D conv net - residual blocks plus temporal convolutions - that was trained to predict the latent at a larger spatial size while keeping the frame count identical. Everything downstream in a two-pass chain depends on that: no frame is added or dropped, so audio stays in sync and the second-pass sampler gets the same timeline back.

It's the engine inside AICG-渲染器（二采放大）, and you can use it standalone when you want to build the chain yourself.

Inputs that matter

• latent - an H3 latent. It takes a wildcard, and internally handles both 4D and 5D: a 4D input is treated as a single frame and gets a temporal axis temporarily added.
• model_name - a checkpoint from models/latent_upscale_models. The pack registers that folder if it doesn't exist yet. If the list shows a placeholder like (place models in: …), you have no models and the node will refuse to run - there's no "just resize" fallback.
• mode - a dynamic combo with three options, and this is where beginners get lost, because the extra fields change with it:
  • scale by multiplier → a scale float (1.0–4.0, default 2.0)
  • target dimensions → width / height in pixels (default 1280×704)
  • megapixels → a megapixels float (0.1–16.0, default 1.0), which resolves the aspect from the latent and fits the area
• align - output grid alignment, default 32, and 32 is the right answer for H3. The node rounds the target up/down to that grid before converting back to latent space, so your "1280" can come out as 1280-ish. If a requested target rounds below the source, it errors rather than downscaling.
• enable_chunking - on by default: temporal overlap blending for long clips. Long video latents are exactly where a naive upscale runs out of memory.
• device and precision - cuda / rocm / cpu, and fp32 / fp16 / bf16. It normalises the latent with fixed mean/std, infers in your chosen precision, then denormalises and hands back a latent in the original dtype on CPU, moving the model off the GPU when it's done.

One output: latent, upscaled. Wire it into the concat node or the second-pass sampler.

The practical bit

Latent upscaling plus a low-denoise second pass is the standard "hires fix" logic from images, ported to video: the upscale gets you resolution cheaply, and the second pass at denoise ~0.5 puts real detail back in. Skip the second pass and you've got a big, soft clip that flatters nobody. The KB's upscaling writeup makes the same point for stills - an upscale without a generation pass is just interpolation with extra steps.

Two-pass is also where the cost lives: you're paying for both a full first pass and a decent-denominator second pass. Which is why the pack pairs this node with MotionCache and a 4-step distilled sampler for drafts, and saves the full chain for takes you're keeping.

Installing

In the pack:

cd ComfyUI/custom_nodes
git clone https://github.com/JGRFW/comfyui-AICG3D

Or via ComfyUI Manager (search AICG3D / 短剧工作台). Restart. Then you still need a checkpoint - this node is useless without one:

ComfyUI/models/latent_upscale_models/

Where people get burned

• Empty latent_upscale_models folder. The node shows a placeholder entry and throws Place a MiniMax H3 latent upscaler checkpoint in models/latent_upscale_models. That's not a corrupt install, it's a missing file.
• Expecting scale by multiplier at 1.0 to do something. It's an explicit early return: same latent, no work. The same is true if your aligned target lands exactly on the source size, which surprises people who typed target dimensions that were already "close enough."
• Feeding it a pixel-space latent from a different model family. It'll happily take a 4D tensor and give you garbage; the model checkpoint is H3-specific.
• Ignoring align. H3's VAE wants 32-pixel alignment, and picking an odd target dimension to hit an exact pixel count is how you trade a tiny crop for visible mush on the edges.