ComfyUI Core Adds H3 Latent Upscaling and Sol-H3-VAE Support

ComfyUI merged two core pull requests on October 28, 2026 that move MiniMax H3's high-resolution path out of custom nodes and into the core. PR 17412 adds latent upscaler model support with a dedicated H3 node, and PR 17411 teaches the VAE loader to open Sol-H3-VAE, the distilled fast decoder from NVIDIA's Efficient-Large-Model team. Both were authored by Kijai and both landed after the v0.43.1 tag, so they show up in master and nightly builds, not in the current 0.43.x release.

The pairing targets the two expensive parts of a 2K H3 job: growing the latent without a VAE round trip, and decoding the finished clip.

A low-resolution pass upscaled in latent space with the H3 latent upscaler, from its model card.

The video comparison from the same repository.

What landed in core

Neither PR ships a checkpoint. They make existing community weights load with the stock loader, so an H3 upscaler that used to need a node pack now runs on core nodes alone.

Upscaling inside the latent

H3 latents carry 24 channels and a separate audio stream. The latent upscaler from LBH-123-AI works directly on the video latent with a 3D convolution backbone: 345,280,216 parameters, 24 in and out channels, 512 base channels, 12 input and 12 output blocks, with a temporal convolution every two blocks at kernel size 5.

The point is to skip decode -> pixel upscale -> encode through H3's VAE, which the model card describes as roughly 5B parameters. Its author also reports that plain bilinear or bicubic interpolation of H3 latents produces ghosting, which the learned upscaler is trained to avoid. Training used about 80,000 paired samples, split into roughly 70,000 video pairs and 8,000 2K image pairs, with 2x as the dominant scale in the mix.

Core reads the architecture from the state dict, so the block counts, channel width and temporal kernel come from the weights themselves rather than from a side config. The node output keeps H3's nested latent, which means the audio half passes through unchanged and the generated soundtrack survives the upscale. A noise mask on the input latent is dropped.

Two differences from the companion node pack are worth knowing:

• The core node takes a target size, not a scale factor. MiniMax H3 Latent Upscale With Model defaults to 2560x1440, with a step of 32 and the usual resolution ceiling. The community node instead exposes a continuous 1.0x to 4.0x scale.
• The upscale alone does not add detail. It resizes the latent, so the second sampling pass at the new resolution is what puts detail back. Running a low step count there leaves the result soft.

If the requested size matches the latent size, the core node returns the input untouched rather than running the model.

Sol-H3-VAE as a drop-in decoder

Sol-H3-VAE is a fast video decoder for H3 that replaces the stock 36-layer VAE decoder with a 24-layer noncausal decoder of 1.62B parameters, distilled from it. It decodes whole frames with windowed attention instead of spatial tiles, and decodes each native 5-latent block bidirectionally. According to its model card, it takes the same normalized latents and returns the same frames as the H3 VAE decoder, and leaves the audio decoder alone.

The card reports 45.4 dB PSNR against the H3 decoder on held-out latents spanning 720p to 2K, and 38.2 dB on a generated 768p clip. The GB200 figures come from a captured CUDA graph, the RTX 5090 figure is eager mode.

Opening that checkpoint in core took more than a new filename pattern:

• The released file stores its decoder without the decoder. prefix, so the loader remaps keys on the fly and fills in H3's latent mean and standard deviation when they are absent.
• The noncausal decoder changes the frame math. Its output is 4 frames per latent, with the first latent of every 5-latent block keeping one: 4t - 3 * ceil(t/5) frames for t latents, with the matching inverse for encoding.
• Because the whole clip is decoded at once instead of in tiles, the PR adds a separate memory estimate so the loader can plan VRAM before the decode starts.
• Quantized Sol VAE builds load too: the loader detects int8 with conv-rotation weights and switches to mixed-precision ops.

The released file is a single sol_h3_vae.safetensors of about 6.5 GB in fp32.

Wiring it into a graph

1. Put the upscaler checkpoint in ComfyUI/models/latent_upscale_models/. The H3 release ships bf16 and fp16 at about 691 MB each, plus a 1.38 GB fp32 .pth.
2. Put sol_h3_vae.safetensors in ComfyUI/models/vae/ and load it with the regular VAE loader.
3. Chain Load Latent Upscale Model into MiniMax H3 Latent Upscale With Model between the low-resolution sampling pass and a second sampler pass at 2560x1440 or above.
4. Decode the refined latent with the Sol VAE.

The upscaler weights are Apache-2.0. ComfyUI's template library still only carries the hosted H3 API templates, so there is no official 2K local template for this pairing yet, and the timings above are the model cards' own measurements rather than ComfyUI benchmarks.

Availability

• Upscaler: LBH-123-AI/Minimax_h3_latent_Upscaler (Apache-2.0, bf16 / fp16 / fp32 checkpoints, plus two example workflows in the repository)
• Fast decoder: Efficient-Large-Model/Sol-H3-VAE, with the reference Python package under code/ and the ComfyUI stage of the wider runtime in the Sol-Engine branch of NVlabs/Sana
• Core changes: PR 17412, PR 17411