Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > Comfyui_Minimax_h3_latent_Upscaler-Plus

ComfyUI Extension: Comfyui_Minimax_h3_latent_Upscaler-Plus

Repo Name

Comfyui_Minimax_h3_latent_Upscaler-Plus

Author
xmarre (Account age: 2627 days)
Nodes
View all nodes(1)
Latest Updated
2026-11-09
Github Stars
0.04K

How to Install Comfyui_Minimax_h3_latent_Upscaler-Plus

Install this extension via the ComfyUI Manager by searching for Comfyui_Minimax_h3_latent_Upscaler-Plus
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter Comfyui_Minimax_h3_latent_Upscaler-Plus in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

Comfyui_Minimax_h3_latent_Upscaler-Plus Description

Comfyui_Minimax_h3_latent_Upscaler-Plus uses neural networks to upscale MiniMax H3 video latents in ComfyUI, with optional H3 refinement, audio preservation, and Continuum sequence support.

Comfyui_Minimax_h3_latent_Upscaler-Plus Introduction

Comfyui_Minimax_h3_latent_Upscaler-Plus enlarges MiniMax H3 video latents directly inside ComfyUI. It uses a trained neural network to increase spatial resolution, with an optional integrated H3 refinement pass to finish the enlarged result.

A latent is the compact representation that H3 works with before a VAE turns it into visible frames. Instead of converting this representation into pixels, enlarging the pixels, and converting them back, the extension works directly on the latent.

This supports a practical two-stage workflow:

Generate at lower resolution
    → Learned latent upscale
    → Brief refinement at the final resolution
    → Decode into visible video

Why use it?

  • Avoid an intermediate VAE round trip. You do not need to decode, upscale in pixel space, and encode again between generation passes.
  • Spend more generation work at a smaller resolution. The initial H3 pass can establish composition and motion before a shorter high-resolution pass.
  • Use a trained enlargement network rather than simple stretching. The network is trained on paired low- and high-resolution H3 latents.
  • Keep audio separate from spatial enlargement. Audio never passes through the learned upscaler.
  • Simplify your graph. The integrated Refine node combines enlargement and second-pass sampling.
  • Work with longer Continuum sequences. The Refine node understands Continuum chunk lists and their protected continuation regions.

Important: this is primarily a time-saving approach, not a way to eliminate high-resolution VRAM requirements. A later H3 refinement pass still processes the full target-resolution video grid.

About the Plus fork

This is the maintained Plus fork of the upstream MiniMax H3 Latent Upscaler. The author retains the upstream learned network and checkpoints while adding H3-aware refinement, Continuum integration, an experimental handoff provider, and correctness fixes.

The Plus fork does not necessarily include every newer upstream feature. In particular, upstream documentation describing sharpness tiers, temporal chunking, ROCm-specific controls, or MMH3 Split Upscale should not be treated as documentation for this fork.

Examples

Watch the video upscale comparison.

Image upscale comparison

How Comfyui_Minimax_h3_latent_Upscaler-Plus Works

1. Enlarge the working representation, not the rendered frames

Think of a latent as H3’s working sketch: it contains information needed to create the video, but it is not a normal image.

A conventional intermediate enlargement would look like this:

Latent → VAE Decode → Pixel upscale → VAE Encode → Latent

This extension replaces those intermediate conversions with:

Latent → Trained latent upscaler → Larger latent

You still decode at the end to obtain visible frames.

2. Use learned spatial reconstruction

The upscaler receives MiniMax H3’s 24-channel video latent. It normalizes the input using the training statistics, processes it through the learned network, and restores the expected latent scale afterwards.

Only width and height increase. The time dimension is preserved, so this is not frame interpolation and does not increase the frame count.

Two network styles are supported:

  • 2D backbone with temporal layers: uses spatial processing alongside layers that consider information across time.
  • Fully 3D backbone: processes the video’s spatial and temporal structure jointly.

The 3D network runs over the entire supplied temporal sequence in one pass. This fork does not divide that network execution into temporal chunks.

3. Optionally refine the enlarged latent with H3

The plain 2D and 3D nodes enlarge the latent without running H3 sampling.

The Upscaler + Refine node also performs a second H3 sampling pass. This gives H3 an opportunity to refine the enlarged representation at the target resolution.

The refinement schedule must begin below full noise:

0 ≤ first sigma < 1

Here, sigma describes the sampling noise level. At a starting sigma of 1.0, H3’s flow formulation gives the existing upscaled latent zero weight. The node rejects that schedule because it would discard the very result you are trying to refine.

Use a partial-denoise schedule, rather than a fresh full-generation schedule.

4. Preserve the relationship between video, audio, and guidance

For integrated refinement, the node:

  1. Enlarges only the video.
  2. Optionally moves the learned upscaler to CPU.
  3. Rebuilds the joint audio-video latent.
  4. Reconstructs protection masks at the enlarged resolution.
  5. Adjusts target-grid keyframe conditioning.
  6. Generates fresh noise for the enlarged audio-video layout.
  7. Runs the supplied sampler and sigma schedule.

Noise scaling is handled through ComfyUI’s normal sampling path. You do not need a separate manual pre-noising stage.

Comfyui_Minimax_h3_latent_Upscaler-Plus Features

Available nodes

All nodes appear in the video/MinimaxH3 category.

NodeWhat it doesWhen to choose it
Minimax H3 Latent Upscaler (2D)Learned video-latent enlargement using a 2D backbone with temporal layers.You have a compatible 2D checkpoint and only need multiplier-based sizing.
Minimax H3 Latent Upscaler (3D)Learned 3D enlargement with multiplier, target-dimension, or megapixel sizing.You want a standalone upscaler and will handle any later H3 sampling yourself.
MiniMax H3 Latent Upscaler + Refine (3D)Learned enlargement followed by an integrated H3 refinement pass.You want a simpler two-pass graph or Continuum refinement.
MiniMax H3 Latent Upscaler Provider (3D) [Experimental]Supplies upscaler configuration to a compatible sampler-time handoff node.You are using a supported progressive workflow such as Flow-Aligned Regenerate.

The plain 2D and 3D nodes are LATENT → LATENT processors. They do not perform H3 generation or refinement.

Three sizing modes for 3D and Refine

ModeHow you control the resultExample
scale by multiplierMultiply the source width and height by scale.2.0 requests twice the width and twice the height.
target dimensionsRequest a pixel width and height.Request 1280 × 704, subject to alignment and aspect-ratio handling.
megapixelsRequest an approximate total image area at the source aspect ratio.1.0 targets 1024² pixels before grid adjustment.

The documented controls are:

ControlDefaultDocumented range
scale2.01.0–4.0
width128064–4096
height70464–4096
megapixels1.00.1–8.0
align32Combined with H3’s 16-pixel requirement
keep_proportiontrueOn or off

In the Refine node, all size controls are visible, but only those belonging to the selected mode take effect.

The 2D node supports scale only, with a default of 2.0 and a range of 1.0–4.0.

Output alignment and aspect ratio

H3 needs dimensions compatible with its internal grid. The 3D and Refine nodes combine your align setting with H3’s 16-pixel VAE requirement.

For example:

  • align=32 produces dimensions on a 32-pixel grid.
  • align=24 produces dimensions on a 48-pixel grid, because 48 satisfies both requirements.

With keep_proportion=true, the node looks for nearby valid width-height pairs that stay close to your requested size while preserving the source aspect ratio as well as possible.

With keep_proportion=false, each dimension is rounded independently. This gives more independent control over width and height, but can change the aspect ratio.

Actual dimensions can therefore differ from the numbers you request.

Only enlargement is supported:

  • A target smaller than the source on either axis is rejected.
  • A target equal to the source size returns the latent unchanged.

The 2D node rounds the scaled latent dimensions directly and does not apply pixel-grid alignment.

Audio protection

The Refine node’s lock_audio setting defaults to on.

SettingResult
OnAudio receives no noise, its denoise mask is zero, and pass-1 audio is restored exactly after sampling.
OffAudio receives normal noise and can be refined alongside video. Any existing audio denoise mask is retained.

Leave audio locked when you want to preserve the first pass’s generated audio while improving the video.

The Provider node never receives audio.

Protected regions and continuation masks

A denoise mask tells H3 which regions may change:

  • 0 means preserve.
  • Fully protected time steps remain protected during refinement.

The Refine node enlarges existing video masks with nearest-neighbour resizing, retaining their protected-region structure.

For Continuum chunk lists, a fully protected continuation prefix is replaced with the preceding chunk’s refined ending before the next refinement pass begins. This makes consecutive chunks connect using the refined content, rather than independently enlarged copies.

Audio prefixes are carried similarly when lock_audio is off. Video geometry must match across chunks for this carry operation.

Keyframes and references

The Refine node treats two kinds of conditioning differently:

  • minimax_keyframes: resized for the target grid, including H3’s internally padded even latent dimensions.
  • minimax_refs: left unchanged because these are independent reference blocks with their own size and positional grid.

Conditioning is copied rather than modified in place. This avoids changing the conditioning objects used elsewhere in your workflow.

Precision, device, caching, and offload

SettingMeaning
deviceChoose cuda or cpu.
precisionChoose fp32, fp16, or bf16 for inference.
offload_after_upscaleMove the cached learned network to CPU after enlargement. Available on 3D, Refine, and Provider nodes.

Defaults differ by node:

NodeDefault precisionDefault offload
2Dfp32Not exposed
3Dfp16Off
Refinefp16Off
Providerbf16Off

Loaded networks are cached by checkpoint, device, and precision, so repeated runs can reuse them.

On the Refine node, enabling offload moves the upscaler to CPU before the second H3 pass. This can free memory occupied by the upscaler, but it does not remove the target-resolution H3 workload. Repeated runs also pay the cost of moving the network back to the processing device.

The 2D, 3D, and Refine nodes fall back to CPU if CUDA is unavailable. The experimental Provider instead raises an error rather than silently changing devices.

Comfyui_Minimax_h3_latent_Upscaler-Plus Workflows

Standalone enlargement with an external second pass

The plain nodes require a video-only, 24-channel latent. If your H3 output contains joint audio and video, separate the streams first:

Joint H3 audio-video latent
    → LTXVSeparateAVLatent
        ├─ Video → Minimax H3 Latent Upscaler (3D) ─┐
        └─ Audio ─────────────────────────────────┤
    → LTXVConcatAVLatent
    → External H3 refinement pass or VAE Decode

The included workflow templates demonstrate image-to-video and reference-to-video patterns with an external second pass using BasicGuider and SamplerCustomAdvanced.

Enlargement and refinement in one node

For a native joint audio-video workflow:

  1. Connect the low-resolution joint AV latent to latent.
  2. Leave audio_latent disconnected.
  3. Connect model and positive.
  4. Connect a noise source such as RandomNoise.
  5. Connect a sampler from KSamplerSelect.
  6. Connect a partial-denoise SIGMAS schedule whose first value is below 1.
  7. Keep lock_audio=true if the first pass’s audio should remain unchanged.
  8. Send the resulting latent to the appropriate decode path.
Low-resolution joint H3 latent
    → MiniMax H3 Latent Upscaler + Refine (3D)
        + model
        + positive
        + noise
        + sampler
        + partial-denoise sigmas
    → VAE Decode

Do not add an external BasicGuider, DisableNoise, or SamplerCustomAdvanced for this integrated refinement pass. The node performs that sampling internally.

For split input, connect video to latent and the corresponding audio to audio_latent.

Optional negative conditioning

  • Without negative, the node uses positive-only guidance, the usual H3 setup.
  • With negative, it uses classifier-free guidance at cfg.
  • cfg defaults to 1.0 and is only used when negative conditioning is connected on the native path.

The output is a decode-ready LATENT list. A single input produces a one-item list.

H3 Continuum refinement

Connect the parallel outputs of H3 Continuum Sampler V3.4:

Continuum.video_latents → Refine.latent
Continuum.audio_latents → Refine.audio_latent
Continuum.refine_state  → Refine.refine_state

The refinement state preserves each chunk’s model options and the exact positive conditioning received by the first sampler.

Important rules:

  • refine_state takes precedence over model, positive, and negative.
  • Leftover native conditioning connections are ignored while state is connected.
  • Invalid refinement state causes an error; it does not silently fall back.
  • The node processes the complete chunk list in order.
  • Run Storage does not persist refinement state. If stored chunks are reused with refine_state connected, Continuum raises an error. Disable Run Storage or regenerate from chunk 1.

See H3 Continuum-Plus for the companion workflow documentation.

Experimental sampler-internal handoff

The Provider node outputs an H3_LATENT_UPSCALER configuration object, not a video latent.

A compatible consumer calls the provider when it needs to transfer a clean video estimate from a smaller grid to an exact larger grid. The provider itself performs no H3 sampling.

For Flow-Aligned Regenerate:

  • Connect the Provider to the consumer’s learned-upscaler input.
  • Select learned_3d wherever the consumer exposes a transfer-mode selection.
  • Follow the consumer’s current workflow instructions rather than applying standalone Refine wiring.

The companion’s recommended progressive interface is MiniMax H3 Native Source Continuation, using VDN-H3-Plus and the learned provider. Sol-H3 is optional.

The older general Target Input interface behaves differently for exact protected prefixes: its documented exact-prefix fallback performs no learned-upscaler call. This is a consumer policy, not a Provider failure.

View the companion’s workflow examples.

Comfyui_Minimax_h3_latent_Upscaler-Plus Models

Documented 3D checkpoints

Pretrained weights are available from the MiniMax H3 Latent Upscaler model repository.

The Plus documentation explicitly lists these files:

CheckpointStored precisionCompatible nodes
minimax_h3_latent_upscaler_3d_bf16.safetensorsbf163D, Refine, Provider
minimax_h3_latent_upscaler_3d_fp16.safetensorsfp163D, Refine, Provider
minimax_h3_latent_upscaler_3d_fp32.pthfp323D, Refine, Provider

These are precision variants of the same 3D architecture, not separate artistic styles. Selecting one does not choose a different creative look.

The node’s precision control sets the computation precision independently of how the file is stored. The Provider preselects the documented bf16 file when available.

2D checkpoint compatibility

The 2D node needs a checkpoint with the expected 2D-backbone layout. A 3D checkpoint cannot be used as a substitute and produces a missing-weights error.

The upstream project also documents newer 2d_conv_v1 and 3d_conv_v1 releases. However, their newer sharpness, architecture, sizing, and chunking capabilities are not established by the supplied Plus documentation. Do not assume those capabilities or their compatibility apply to this fork.

Architecture and training background

The documented default 3D network has:

  • 24 input channels.
  • 12 encoder and 12 decoder residual blocks.
  • 512 internal channels.
  • Temporal convolutions after every second residual block.
  • A learned scale embedding.
  • Trilinear feature resizing between encoder and decoder.

The loader reads actual block counts, channel width, and temporal-layer structure from the checkpoint. Attention layers in the learned network are disabled during inference.

The original Plus documentation describes upstream training on approximately 80,000 paired samples, mainly video clips with additional 2K images. Training included fixed and arbitrary enlargement factors between 1× and 4×, with 2× receiving the largest stated share.

Newer upstream releases report different training data and benchmarks. Those results should not be substituted for measurements of the documented Plus checkpoint and workflow.

What's New with Comfyui_Minimax_h3_latent_Upscaler-Plus

Documented release

The supplied release information identifies Latent Upscaler-Plus v0.2.2. It is listed as unchanged in the coordinated release tables that include it.

For the package’s version-by-version history, see RELEASE_NOTES.md. The supplied context does not provide a complete per-version changelog for this extension.

Plus additions and intentional differences

Addition or differenceWhy it matters for your workflow
Integrated H3 refinementReplaces a longer split/upscale/recombine/second-sampler chain.
Continuum refinement stateRetains chunk-specific model options and conditioning.
Sequential refined-prefix carryConnects later chunks to the preceding refined output.
Experimental handoff ProviderEnables compatible progressive samplers to request learned enlargement internally.
Dual-axis alignment with aspect-ratio preservationKeeps both dimensions valid while retaining proportion control.
Optional offload, default offLets you choose between reclaiming upscaler memory and avoiding repeated transfers.
Full-sequence 3D processingAvoids differences introduced by splitting temporal convolutions and normalization across partial windows.
Private-copy normalizationProtects the source latent while avoiding additional full-size arithmetic temporaries.

The Provider also exposes a specialized H3 patch-lattice transfer for consumers that need exact patch-coordinate matching. Ordinary node and Provider operation retain the trained half-pixel interpolation behavior; this is not an additional artist-facing resize mode.

See the transfer-lattice explanation for the advanced details.

Troubleshooting Comfyui_Minimax_h3_latent_Upscaler-Plus

The model is missing from the dropdown

  1. Confirm the checkpoint is a .safetensors or .pth file.
  2. Check that it is directly inside:
    ComfyUI/models/latent_upscale_models/
    
  3. Do not place it inside a nested subfolder: this fork scans the folder non-recursively.
  4. Restart ComfyUI and check model_name again.

A missing-weights or architecture error appears

  1. Identify whether you selected the 2D or 3D node.
  2. Use a 2D-layout checkpoint for 2D.
  3. Use a documented 3D checkpoint for 3D, Refine, or Provider.
  4. If following newer upstream instructions, verify that the checkpoint architecture is supported by this fork.

Changing precision does not make an incompatible architecture compatible.

The plain upscaler rejects an H3 latent

  1. Check whether the input is a joint audio-video latent.
  2. For plain 2D or 3D enlargement, separate it with LTXVSeparateAVLatent.
  3. Connect only the video branch to the upscaler.
  4. Recombine audio afterwards if your next stage needs joint AV input.

Alternatively, use the Refine node with the appropriate joint or split input pattern.

Refinement rejects the sigma schedule

  1. Inspect the first sigma.
  2. Ensure it satisfies 0 ≤ sigmas[0] < 1.
  3. Replace a full-generation schedule with a partial-denoise schedule.
  4. Remove manual pre-noising or DisableNoise stages copied from another package.

An empty SIGMAS input intentionally skips sampling and returns the enlarged latent.

The output size differs from the requested dimensions

  1. Check the selected sizing mode.
  2. Confirm you are editing the active controls for that mode.
  3. Check align and the combined 16-pixel H3 requirement.
  4. Check whether keep_proportion is enabled.

The node may choose nearby valid dimensions instead of the exact requested numbers. A target smaller than the source on either axis is rejected.

GPU memory runs out

  1. Determine whether the failure happens during learned enlargement or the later H3 pass.
  2. Enable offload_after_upscale to reclaim the learned network’s GPU memory before refinement.
  3. Reduce the target resolution if H3 itself cannot fit.
  4. Test a shorter supplied sequence to assess the memory cost of full-sequence enlargement.
  5. Benchmark the revised workflow on your hardware.

This fork has no temporal-chunking switch for the 3D network. Offload cannot make an otherwise oversized target-resolution H3 pass fit by itself.

A shorter refinement schedule can reduce processing time, but should not be relied upon to solve peak-memory limits.

Audio changes unexpectedly

  1. Set lock_audio=true.
  2. Verify joint-versus-split AV wiring.
  3. Confirm you are using this package’s Refine node rather than another package’s similarly named node.

With audio locked, the node restores pass-1 audio exactly after refinement.

Continuum reports missing or invalid refinement state

  1. Connect video_latents, audio_latents, and refine_state from the same Continuum sampler.
  2. Do not expect native model or conditioning inputs to override a connected state.
  3. Disable Run Storage or regenerate from chunk 1 if stored chunks were reused.
  4. Keep video geometry identical across chunks when refined-prefix carry is required.

A continuation join still has a visible defect

Protected latent continuity does not guarantee every decoded join will be visually perfect.

  1. Confirm that the expected denoise masks reach the Refine node.
  2. Confirm that all chunks use matching geometry.
  3. Inspect the decoded result to distinguish content changes from brightness shifts or decoder-window boundaries.
  4. Consult the companion documentation for the relevant issue.

For example, Continuum Decode Context addresses a separate temporal VAE decoder-window problem. It is not a replacement for correct sampler-time masks or refined-prefix carry.

Frequently asked questions

Does this work on ordinary images or latents from other models?
It targets MiniMax H3’s 24-channel video latent format. The plain nodes also accept the documented single-frame, four-dimensional form. It is not a general-purpose latent upscaler for unrelated models.

Does it add frames or change playback speed?
No. It enlarges width and height while preserving the latent time dimension.

Can I decode immediately after the plain upscaler?
Yes, using the appropriate video decode path. You can also add refinement before decoding.

Do I need Continuum, Flow, VDN, or Sol for basic enlargement?
No. They are relevant to their respective optional integrations. Follow each companion’s requirements when using those workflows.

Why does the Provider error when CUDA is unavailable?
Unlike the plain and Refine nodes, it intentionally does not switch devices silently.

Are published neural-upscaling speedups guaranteed here?
No. Benchmarks from other latent-upscaling projects, model families, or newer upstream checkpoints are not measurements of this fork. Quality, speed, and peak VRAM depend on your actual workflow.

Learn More about Comfyui_Minimax_h3_latent_Upscaler-Plus

Start with examples and package documentation

Explore optional H3 workflows

  • H3 Continuum-Plus — long-form generation, chunked continuation, and reference/audio workflows.
  • Flow-Aligned Regenerate — trajectory-guided refinement and progressive resolution handoff.
  • Flow workflow examples — loadable graphs for the companion handoff interfaces.
  • VDN-H3-Plus — the partitioned-transport companion required by Flow’s recommended Native Source Continuation workflow.
  • Sol-H3 — optional H3 runtime and attention optimization with hardware-specific requirements.
  • Spectrum MiniMax H3 — optional approximate sampling acceleration with its own quality and compatibility considerations.

Understand the underlying approach

For quality comparisons, keep the seed, prompt, references, model, sampler, schedule, duration, and geometry consistent. Judge the decoded video and audio, not only previews or numerical metrics. The package’s automated tests validate workflow contracts without loading trained upscaler weights, so real-media testing remains essential for your final settings.

Comfyui_Minimax_h3_latent_Upscaler-Plus Related Nodes

RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

Comfyui_Minimax_h3_latent_Upscaler-Plus detailed guide | ComfyUI