MiniMax H3 2K and 4K Upscale in ComfyUI: Latent Upscaler, Sol-H3-VAE and Open-H3-Regenerate-2K

MiniMax H3 makes beautiful clips, but most of us render them at 720p or lower because full-resolution sampling is slow and eats VRAM. This week that changed. ComfyUI core now has native support for a MiniMax H3 latent upscaler and for Sol-H3-VAE, a much faster decoder, and NVIDIA’s Sana team released Open-H3-Regenerate-2K, a refiner that turns a low-resolution draft into a sharp 2K or even 4K video. This guide explains what each piece does, which files you need and exactly where they go, how to build the two-pass 2K workflow in ComfyUI, and what to expect on a 16 GB card.

What Is New for MiniMax H3 Upscaling

Three separate releases landed in the same week, and together they give H3 users a real path to 2K video on local hardware.

• ComfyUI PR 17412, merged on October 28, 2026 by Kijai, adds a MiniMax H3 branch to the core Load Latent Upscale Model node and a new node called MiniMax H3 Latent Upscale With Model. The new node takes an H3 video latent and a target size (2560×1440 by default, in steps of 32) and returns a bigger latent.
• ComfyUI PR 17411, merged the same day, teaches the normal VAE loader to detect Sol-H3-VAE. It adds the key remapping, the noncausal decoder path, int8 decoder support and a memory estimate so ComfyUI knows how much VRAM decoding will take.
• Open-H3-Regenerate-2K from NVIDIA’s Sana team is a LoRA refiner on top of a frozen H3 transformer. It takes a fast low-resolution draft and regenerates it at 768p, 1080p, 2K or 4K.

Neither ComfyUI pull request ships model weights. The weights come from the community and from NVIDIA, and they load through the stock loader nodes once your ComfyUI is new enough.

If you are new to H3 in ComfyUI, start with our best local AI video models overview and the MiniMax H3 out of memory fixes for 16 GB. This article assumes you can already generate a basic H3 clip.

Why Upscale in Latent Space?

The usual way to make a video bigger is to decode it to pixels and run a pixel upscaler such as SeedVR2 or an ESRGAN model. That works, and we covered it in MiniMax H3 to 1080p 60 FPS with RIFE and SeedVR2. But a pixel upscaler can only sharpen what is already there. It cannot invent new detail that matches the scene, so faces and textures from a 544p render stay soft.

A latent upscaler works one step earlier. It enlarges the compressed latent that H3 produced, before the VAE turns it into pixels. You then run a short second sampling pass at the new size. Because the model samples again, it adds real detail that fits the prompt: skin texture, hair, fabric weave, distant text. The first pass decides the motion and composition at low cost, and the second pass only has to refine.

The trick is not new. Image users have done “hires fix” for years. What is new is a latent upscaler trained for H3’s 3D video latent. A plain bilinear resize of a video latent produces mush, while this model is a small 3D convolutional network trained to predict what a bigger H3 latent should look like, frame by frame and across time.

Step 1: Update ComfyUI to a Nightly Build

Both nodes arrived after the 0.43.x stable release, so a stable install will not show them. You need ComfyUI master or a nightly build from October 29, 2026 or later.

Git install (Windows, Linux or macOS):

cd ComfyUI
git checkout master
git pull
pip install -r requirements.txt

Windows portable: run update/update_comfyui.bat from the portable folder. If your copy is pinned to stable, run update/update_comfyui_nightly.bat instead, or switch the channel in ComfyUI Manager under Update ComfyUI.

ComfyUI Desktop: the desktop app follows stable releases, so the nodes will appear there after the next release. Until then, use a portable or git install for this workflow.

After restarting, double-click the canvas and search for MiniMax H3 Latent Upscale. If the node appears, you are ready.

Step 2: Download the Files (With Exact Paths)

You need the normal H3 files plus the upscaler. The Sol VAE and the Regenerate LoRA are optional extras covered later.

Base MiniMax H3 files (Comfy-Org repack)

All four are on the Comfy-Org/MiniMax-H3 page. If you already run H3, you have these.

MiniMax H3 latent upscaler

The weights are on LBH-123-AI/Minimax_h3_latent_Upscaler under the Apache-2.0 licence. Download one file:

Put it here:

ComfyUI/models/latent_upscale_models/minimax_h3_latent_upscaler_3d_conv_v1_bf16.safetensors

If the latent_upscale_models folder does not exist, create it, then restart ComfyUI or press R to refresh the model lists. On Windows portable the full path looks like ComfyUI_windows_portable\ComfyUI\models\latent_upscale_models\.

Optional: the companion custom node

The upscaler’s author also publishes a custom node with a simple scale factor (1.0x to 4.0x) instead of a target width and height. You do not need it for the core workflow, but some people find a scale slider easier.

cd ComfyUI/custom_nodes
git clone https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler
pip install -r Comfyui_Minimax_h3_latent_Upscaler/requirements.txt

It installs into ComfyUI/custom_nodes/Comfyui_Minimax_h3_latent_Upscaler/ and reads the same model file from ComfyUI/models/latent_upscale_models/. Skip the pip line if the folder has no requirements.txt. On Windows portable, use ..\..\python_embeded\python.exe -m pip install -r instead of plain pip.

Step 3: Build the Two-Pass 2K Workflow

Start from your normal H3 text-to-video or image-to-video workflow (our Pika H3 Flex guide has a fast 6-step one). Then add the second pass:

1. First pass, low resolution. Sample at about 960×544 with your usual steps. This pass sets the motion, framing and timing. Keep the seed fixed while you tune it.
2. Load Latent Upscale Model. Add this core node and pick minimax_h3_latent_upscaler_3d_conv_v1_bf16.safetensors.
3. MiniMax H3 Latent Upscale With Model. Connect the first sampler’s LATENT output and the upscale model. Set the target to 2560×1440 for 2K, or 1920×1088 for 1080p. Both values must be multiples of 32.
4. Second pass, high resolution. Feed the upscaled latent into a second KSampler (or SamplerCustomAdvanced) with the same model, prompt and conditioning. Use a denoise around 0.4 to 0.6, or a sigma schedule that starts partway down, so the model refines instead of starting over.
5. Decode. Use VAE Decode (Tiled) with the stock H3 video VAE on 16 GB cards, or the Sol-H3-VAE on 24 GB and above.
6. Combine. Merge the audio as usual and save with Video Combine or Save Video.

A community test on the Pika H3 Flex LoRA used exactly this shape: 6 steps at 960×544, a latent upscale, then 4 steps at 1920×1088, ending at 2560×1440 output in 3 minutes 17 seconds. That gives you a realistic starting point.

Do not skimp on the second pass. The most common complaint is a soft, plastic-looking result. That almost always means the second pass had too few steps or too low a denoise, so the model never added detail. Start with 4 steps with a turbo or Acc LoRA, or 8 to 10 steps without one, and raise the denoise before you raise the steps.

Estimate for a 16 GB card like the RTX 5080: expect roughly 4 to 8 minutes for a 5-second clip at 2560×1440, with the second sampling pass and the tiled decode taking most of that time. This is worked out from the community result above and the file sizes, not a measured test.

If you use LoRAs, keep the same LoRAs in both passes. Our best MiniMax H3 LoRAs list marks which turbo LoRAs are safe at low step counts.

Sol-H3-VAE: Faster Decoding

At 2K, decoding can take longer than the second sampling pass. Sol-H3-VAE from NVIDIA’s Efficient-Large-Model group replaces the stock decoder with a 24-layer noncausal decoder (1.62B parameters) that decodes the whole clip at once instead of chunk by chunk.

File and path:

ComfyUI/models/vae/sol_h3_vae.safetensors

The file is about 6.5 GB in FP32. Load it with the normal Load VAE node. Thanks to PR 17411, ComfyUI detects it and switches to the right decoder automatically.

Quality holds up well. The model card reports 45.4 dB PSNR against the original decoder on held-out latents and 38.2 dB on a generated 768p clip, which is very close in normal viewing.

The catch is VRAM. Because it decodes the whole clip in one go, it needs about 24 GiB at 720p and about 48 GiB at 2K with CUDA graphs on. That puts 2K decoding out of reach for 16 GB and even 24 GB cards. On 16 GB, keep the stock VAE with tiled decoding. On a 24 GB card, Sol works for 720p and 768p clips. At 2K it is a tool for 48 GB workstation cards and cloud GPUs.

Licensing is split. The code is Apache-2.0, but the weights fall under the MiniMax H3 licence, so commercial use follows the same rules as H3 itself.

Open-H3-Regenerate-2K: Draft to 2K and 4K

The latent upscaler gives you a 2K version of your own two-pass render. Open-H3-Regenerate-2K takes a different route. It is a refiner trained to take a fast, cheap draft (384p to 768p) and regenerate it at 768p, 1080p, 2K or 4K, for clips from 5 to 15 seconds.

How it works

The H3 transformer stays frozen. A merged rank-576 LoRA rides on top of it, built from three parts: the rank-384 refiner itself, the LightX2V FL2VA Turbo v1.2 LoRA (rank 128) and an LMS Sharp LoRA (rank 64). The draft is upscaled, re-noised to sigma 0.909, and then denoised in only 3 Euler steps (sigmas 0.909, 0.857, 0.667, 0) with CFG turned off. Few steps and no CFG make it fast. NVIDIA reports 22.45 seconds on one B200 against 87.26 seconds for a normal high-resolution render, and testers preferred the refined clip in 87% of 200 blind comparisons.

Using it in ComfyUI

There are no official ComfyUI nodes yet. The reference code in the NVlabs/Sana repo (sol-engine branch) is a command-line tool that needs Linux, Python 3.11, PyTorch 2.11 and CUDA 13.0.

The easiest ComfyUI route is Kijai’s converted refiner LoRA:

ComfyUI/models/loras/minimax_h3_open_regenerate_2k_refiner_rank_384_bf16.safetensors

Download it from Kijai/MiniMax-H3-experimental. This is the rank-384 refiner on its own, so you stack the turbo LoRA yourself to match NVIDIA’s recipe. A practical setup:

1. Load your H3 diffusion model, then add the refiner LoRA at strength 1.0 and a LightX2V turbo LoRA with a LoraLoaderModelOnly node each.
2. Encode or upscale your draft to the target size (the latent upscaler from Step 3 works well here).
3. Use a custom sigmas node with 0.909, 0.857, 0.667, 0, the Euler sampler, and CFG 1.0.
4. Decode with tiled VAE decode, then combine audio.

Two community conversions also exist: father558/H3-Open-Regenerate-2K-ComfyUI-r128 (a smaller rank-128 version) and DrakenZA/Open-H3-Regenerate-2K-ComfyUI. Be careful with home-made conversions. A straight key rename of the original LoRA gives wrong weights because of how the SwiGLU feed-forward layers are laid out, and the result looks noisy or washed out. Stick to the files above, which handle that layout.

What Works on 16 GB, 24 GB and 48 GB

The upscaler itself is small (345M parameters), so it is never the bottleneck. The second sampling pass and the decode at 2560×1440 are what fill your card. On 16 GB, the usual H3 memory tricks matter more than ever: the int8 ConvRot diffusion model, the NVFP4 text encoder, unloading the text encoder after encoding, and a smaller tile size in VAE Decode (Tiled). Our 16 GB out-of-memory guide covers each one. The 12 GB row is an estimate based on the file sizes, not a measured result.

Which Upscale Method Should You Use?

For most people, the latent upscaler is the one to try first, because it is native, small and uses the nodes you already know. Regenerate-2K is the most exciting for quality, but it is still experimental in ComfyUI. Pixel upscalers stay useful as a final polish, or for clips that did not come from H3.

Troubleshooting

The MiniMax H3 Latent Upscale node is missing

Your ComfyUI is on the stable 0.43.x channel. Update to master or nightly as shown in Step 1, then restart. Clearing the browser cache can also help if the node list looks stale.

The model does not show in Load Latent Upscale Model

Check the folder name. It must be ComfyUI/models/latent_upscale_models/, not upscale_models, which is for pixel upscalers. Refresh with R after moving the file.

The 2K result looks soft or waxy

Raise the second-pass denoise in small steps (for example from 0.4 to 0.55) or add 2 to 4 steps. Also check that the second pass uses the same LoRAs and prompt as the first.

The motion changes in the second pass

The denoise is too high, so the model is re-imagining the clip. Lower it until the motion matches the first pass.

Out of memory at the decode step

Switch to VAE Decode (Tiled), lower the tile size and temporal tile length, and do not use Sol-H3-VAE at 2K on cards under 48 GB.

Regenerate LoRA output is noisy or grey

You are probably using an incorrect conversion. Use Kijai’s file or one of the two community conversions listed above, keep CFG at 1.0 and use the 3-step sigma list.

FAQ

Is the MiniMax H3 latent upscaler free?

Yes. The weights are Apache-2.0 and the ComfyUI nodes are part of core, so there is nothing to buy.

Where does the MiniMax H3 latent upscaler file go?

In ComfyUI/models/latent_upscale_models/. Create the folder if it does not exist.

Do I need a custom node?

No, if you run a ComfyUI nightly from October 29, 2026 or later. The optional companion node only adds a scale slider.

Can I make 4K MiniMax H3 videos on a 16 GB GPU?

Not realistically yet. 2K is a reasonable ceiling on 16 GB. 4K output with Regenerate-2K is aimed at 48 GB-class and data-centre GPUs.

Is Sol-H3-VAE better than the stock VAE?

It is much faster and very close in quality, but it needs far more VRAM. On consumer cards the stock VAE with tiled decoding is still the safer choice.

Does this work for image-to-video and reference-to-video?

Yes. The upscaler works on the H3 latent, so it does not matter which H3 mode made it. Keep the same conditioning in the second pass.

Final Thoughts

Native latent upscaling is the biggest quality upgrade H3 users have had since launch. You can now plan your shot cheaply at low resolution, then spend GPU time only on the final 2K pass. On a 16 GB card, the latent upscaler with a tiled stock VAE is the practical choice today. Sol-H3-VAE and Open-H3-Regenerate-2K point to where things are heading, and as more ComfyUI-native nodes arrive, 2K and 4K H3 video on home hardware will only get easier. We will update this guide when these nodes reach the stable release.

More MiniMax H3 guides:

• Pika H3 Flex in ComfyUI: 6-Step MiniMax H3 LoRA Setup
• MiniMax H3 to 1080p 60 FPS: RIFE + SeedVR2 Workflow
• Best List of LoRAs for MiniMax H3
• MiniMax H3 Out of Memory in ComfyUI: 16 GB GPU Fixes

Sources

• ComfyUI PR 17412: MiniMax H3 latent upscaler and PR 17411: Sol-H3-VAE support (merged October 28, 2026)
• Hugging Face: LBH-123-AI/Minimax_h3_latent_Upscaler
• Hugging Face: Efficient-Large-Model/Sol-H3-VAE
• Hugging Face: Efficient-Large-Model/Open-H3-Regenerate-2K
• Hugging Face: Kijai/MiniMax-H3-experimental
• Hugging Face: Comfy-Org/MiniMax-H3