# ComfyUI Minimax H3 Latent Upscaler: upscale 24-channel H3 latents without the 5B VAE round-trip > A custom ComfyUI node that resamples Minimax H3 latents in latent space with a trained network, so you generate low-res and refine high-res instead of paying for a full VAE decode and re-encode. **LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler** — Neural latent upscaler for Minimax H3 (24ch). Bypasses costly 5B-param VAE decode/encode. Upscale low-res latents directly, then refine. Accelerates high-res video gen, outperforms naive interp. - Repository: https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler - Stars: 738 · Forks: 53 - Language: Python - License: MIT - Published: 2026-09-17 · Updated: 2026-09-17 · Language: en - Canonical page: https://hysenlabs.com/projects/lbh-123-ai-comfyui-minimax-h3-latent-upscaler ## The problem: Minimax H3's VAE makes high-resolution video generation expensive Minimax H3 ships a VAE of roughly 5 billion parameters. That number matters because the standard route to a high-resolution clip runs through it twice: decode the low-res latent to pixels, upscale the pixels, then encode back to latents for the refinement pass. Both directions are full VAE passes over a large tensor. The README frames the alternative directly: upscale the latent itself with a trained network, then refine at the target resolution. Latents carry 24 channels for video, and the node operates on that tensor rather than on decoded frames. The intended pipeline is generate low, upscale the latent, refine high. This is for people already running Minimax H3 inside ComfyUI who have watched a high-resolution job spend most of its wall clock outside the sampler. It is not a general-purpose upscaler and it does not touch other models' latents. The README is explicit that the gain is speed only: "This saves time, not VRAM." Peak memory stays close to generating high-res directly, because the refinement pass still runs at the target resolution. Anyone hoping to fit a bigger job on the same card should read that line twice. ## Two backbones: a 2D ResBlock node and a fully 3D-convolution node Both variants register under the `video/MinimaxH3` category and differ in how they treat time. The 2D node uses a 2D ResBlock backbone with Temporal 3D-Conv layers inserted for temporal consistency. It upscales spatially, H and W, and leaves the time dimension untouched. The README calls it lightweight and fast, driven by a single `scale` factor between 1.0x and 4.0x. The 3D node is a fully 3D-convolution backbone: 3D ResBlocks, TemporalConv, and trilinear interpolation. It processes the spatiotemporal volume jointly, which the README attributes to stronger temporal coherence, at higher compute and memory cost. It exposes three resize modes in one node: `scale by multiplier`, `target dimensions`, and `megapixels`. The two size-based modes align output to a configurable pixel grid and derive the effective scale automatically, and the README notes the 3D node computes that equivalent `scale` internally and feeds the same trained model, so any target inside 1.0x to 4.0x works. A hard boundary applies to both: upscaling only. `scale = 1.0` returns the input unchanged, and an effective scale below 1.0 raises an error. There is no downscale path. The design trade-off is honest. The 2D node is cheaper but only inserts temporal layers into a spatial backbone; the 3D node spends more memory for joint spatiotemporal processing. Pick based on whether your clip's motion coherence matters more than throughput. ## Installing the node and running a first latent upscale The repository is a ComfyUI custom node: a Python package with `__init__.py`, a `nodes/` directory, `workflow_templates/`, and `examples/`. The README does not give a pip install line or a model download step, so the installation path is the one ComfyUI custom nodes normally take, placing the repository inside the `custom_nodes` directory, which matches the repository layout. After placing the directory and restarting ComfyUI, the nodes appear under the `video/MinimaxH3` category. The README does not document a requirements file or any weights the nodes expect, so treat the repository contents as the source of truth for that. A minimal first use is the 2D node with a modest multiplier. Load a Minimax H3 latent, feed it in, and set the scale factor. The README states the precision selector supports `fp32`, `fp16`, and `bf16` on both nodes, added in the 2026-08-18 entry. Start with `bf16` and drop to `fp32` only if you see artifacts you can attribute to precision. The output latent then goes into your refinement sampler at the target resolution. The README points to the `workflow_templates/` and `examples/` directories for worked examples, including an added 3D example workflow. ## The MMH3 Split Upscale combo is a different mechanism entirely The three-node combo added on 2026-08-28 does not use a trained upscaler network at all. It performs a tiled, hires-fix style re-sampling upscale inside the diffusion sampler. It takes the H3 AV latent, nested video at 24 channels plus audio at 32 channels, splits it into temporal chunks and spatial tiles, runs the sampler on each piece, then stitches with seam denoise, two-level color matching, and temporal anchors. The two `* Split Params` nodes configure splitting and feed the main `MMH3 Split Upscale` node. Both are optional: leave them unconnected for a single full-frame pass. It requires `model`, `conditioning`, and `sampler`/`sigmas`, because it re-runs sampling at higher resolution. The README states this combo is a decomposed and re-optimized version of the Comfyui-MMH3-UltimateUpscale project, broken from one monolithic node into three composable nodes. The listed improvements over the original are more stable seams via a `seam_denoise` cap and a probe-gated `seam_polish` second pass, zero color drift via spatial and temporal two-level matching with a global color reference pinned to the first block and to every chunk, triple temporal anchors, spatial params simplified to overlap and fade percentages snapping to the latent grid, and a lighter footprint because the built-in upscale model was removed in favor of an external pre-upscaled latent. That last point is the real cost of the combo: you supply the pre-upscaled latent yourself. It is not a drop-in replacement for the neural 2D or 3D nodes, and the README does not present it as one. ## Why naive latent interpolation is not the same thing You can resize a latent tensor with bilinear or bicubic interpolation in a few lines. The README names the failure mode: ghosting and double-image artifacts. Interpolation has no notion of what the latent encodes, so it spreads energy across neighboring positions and produces a soft, doubled result that the refinement pass then has to fight. This node replaces that with a trained network, which is the entire reason it exists as a separate project. The README compares its role to the latent upscaler in LTX2.3, which is a useful reference point if you have used that pipeline: same idea, different model, different latent channel count. The 3D node's temporal handling is the other differentiator. The 2026-08-23 entry records a fix for temporal-chunk edge artifacts using replicate padding and weighted overlap blending, which the README says eliminated end-frame flicker. That is a specific class of artifact that a per-frame 2D interpolation upscale would produce and that a joint spatiotemporal pass is built to avoid. So the honest comparison is not "this node versus bicubic." It is "this node versus a full VAE round-trip, with bicubic as the cheap option you already know does not work." ## Memory behaviour, chunking, and where this node is the wrong tool The 3D node has accumulated a set of memory controls worth reading before you file a bug. The 2026-08-26 entry covers zero-copy model loading, ComfyUI's native `soft_empty_cache`, and explicit `.contiguous()` calls to reduce RAM and VRAM spikes during load and inference. Post-inference CPU offload became an optional `force_unload` toggle, default on. The `enable_chunking` toggle was renamed to `enable_temporal_chunking` and its effective chunk stride raised from 24 to 32. Model files can now live in subfolders, `target dimensions` and `megapixels` upper limits were raised to 8192 px and 16 MP. The 2026-08-23 entry adds the case where you should turn chunking off: short clips, to use full-context inference. That is the clearest statement of when the chunked path is wrong for a job. Chunking exists for long videos; on a short clip it costs you context for no benefit. The wrong-tool case is broader. If your bottleneck is VRAM rather than time, this node does not help, per the README's own warning. If you need to go below 1.0x, it errors. If you need more than 4.0x, the trained model does not cover it, and the README does not document a chained or iterative path to get there. And if your pipeline is not Minimax H3, the 24-channel assumption makes the node irrelevant. The 2026-08-21 entry also records that width and height are independently aligned to the align grid, default 32, fixing a bottom light band issue. If you see banding at the edges of an output, that alignment is the first thing to check. ## Maintenance, licence, and what the repository does not tell you The last push to the default branch was on 2026-08-28, and the repository is not archived. That is recent enough that the codebase reflects the current state of the nodes described above, including the Split Upscale combo. The licence is the gap. The repository metadata does not state one, and the README does not mention licensing terms. For a ComfyUI custom node that a team might ship inside a commercial video pipeline, that absence is a real blocker rather than a formality, because the default position without a licence is that no rights are granted. This is not legal advice; it is a description of what the repository does and does not say. If you need a licence answer, the maintainer is the only source. Upgrade cost is low in the ordinary case: it is a custom node directory, so pulling the latest commit and restarting ComfyUI is the mechanism. The risk is in the renames. `enable_chunking` became `enable_temporal_chunking`, and the three resize modes were merged into a single node on 2026-08-19. Saved workflows that reference the old node names or the old toggle will need editing after an update. The README does not document a migration path for saved workflows, so budget time for that if you have a library of them. There are no releases listed for the repository, so pinning to a tagged version is not an option. Pin to a commit hash if you need reproducibility. ## Conclusion Adopt it if you already run Minimax H3 in ComfyUI and your bottleneck is the decode, pixel-upscale, encode round-trip through the ~5B-parameter VAE; the two-node latent path is the whole point. Do not adopt it expecting a VRAM saving, because the README states plainly that the refinement pass still runs at target resolution and peak memory stays comparable to generating high-res directly. Before wiring it into a workflow, check the licence, since the repository does not state one, and confirm the 4.0x cap and the upscale-only rule against your intended target size. ## FAQ ### What is a latent upscaler? A latent upscaler resizes the compressed latent representation a model works in, rather than decoding it to pixels first. This project does that for Minimax H3's 24-channel latents using a trained neural network, which the README says avoids the ghosting and double-image artifacts that bilinear or bicubic latent interpolation produces. ### What is a latent upscaler in the context of Minimax H3 video generation? In this project it means resampling the 24-channel Minimax H3 latent directly with a trained network, then refining at the target resolution. The README describes the purpose as accelerating high-resolution video generation by skipping the slow decode, pixel-upscale, encode round-trip through the roughly 5B-parameter VAE. ### How do I use the ComfyUI Minimax H3 Latent Upscaler? Place the repository in ComfyUI's custom_nodes directory and restart ComfyUI, then find the nodes under the video/MinimaxH3 category. Feed a Minimax H3 latent into the 2D or 3D node, set a scale factor between 1.0x and 4.0x, and send the output latent into your refinement sampler at the target resolution. ### What is the difference between the 2D and 3D nodes in the Minimax H3 Latent Upscaler? The 2D node uses a 2D ResBlock backbone with Temporal 3D-Conv layers inserted for temporal consistency, upscales spatially, and leaves the time dimension untouched. The 3D node uses a fully 3D-convolution backbone with 3D ResBlocks, TemporalConv and trilinear interpolation, processes the spatiotemporal volume jointly for stronger temporal coherence, and is heavier on compute and memory. ### Does the Minimax H3 Latent Upscaler reduce VRAM usage? No. The README states that it saves time, not VRAM, because the refinement pass still runs at the target resolution, so peak memory is comparable to generating high-res directly. The gain is purely speed. ## Sources - [Issues](https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler/issues) - [LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler on GitHub](https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler) - [README](https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/lbh-123-ai-comfyui-minimax-h3-latent-upscaler