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 > Minimax H3 Latent Upscaler (3D)

ComfyUI Node: Minimax H3 Latent Upscaler (3D)

Class Name

MinimaxH3LatentUpscaler3D

Category
video/MinimaxH3
Author
xmarre (Account age: 2627days)
Extension
Comfyui_Minimax_h3_latent_Upscaler-Plus
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

Minimax H3 Latent Upscaler (3D) Description

Upscales MiniMax H3 image and video latents with a learned 3D model and temporal context.

Minimax H3 Latent Upscaler (3D):

MinimaxH3LatentUpscaler3D enlarges MiniMax H3 image and video latents using a learned 3D upscaling model. Latents are the compact representations that a generation workflow works with before converting them into visible images or video. Rather than resizing decoded pixels, this node performs the enlargement in that compact space, using learned processing that includes temporal operations for video. It keeps the full video sequence together during processing, preserving the context used by its 3D and temporal layers instead of treating separate frame chunks as equivalent. It supports several ways to choose the target resolution, aligns the resulting dimensions to the H3 VAE grid, and can preserve the original proportions as closely as that alignment allows. This node performs the learned upscaling stage only; it does not include the separate low-sigma H3 refinement sampling pass provided by the companion refinement node.

Minimax H3 Latent Upscaler (3D) Input Parameters:

latent

Required input with interface type *, meaning the connector is not restricted to a single declared ComfyUI type. In practice, this node expects a latent dictionary containing a samples tensor, not a decoded image, arbitrary data, or a combined audio/video object that lacks the expected tensor structure. It accepts a four-dimensional image tensor arranged as batch, channels, height, width, or a five-dimensional video tensor arranged as batch, channels, time, height, width. An image is temporarily treated as a sequence with one frame for processing, then returned to its original number of dimensions. The spatial dimensions are interpreted using H3’s 16× VAE downsampling relationship, so you should supply latents compatible with the selected MiniMax H3 upscaler model. There is no default value, numerical range, or fixed option list.

model_name

Required COMBO selection identifying the learned MiniMax H3 upscaler model to use. Its options are populated dynamically by scan_models(), so the available names depend on the model files found in your installation rather than a fixed list included in the node definition. No explicit default is specified in the schema. You must install the appropriate upscaler model files in the latent_upscale_models directory and choose a valid entry. If the selected name starts with an opening parenthesis, the node treats it as a placeholder rather than a usable model and stops with an instruction to install the model files. Model compatibility matters because the node passes your latent tensor to the selected learned upscaler rather than performing a generic image resize.

mode

Required COMFY_DYNAMICCOMBO_V3 selection controlling how the desired pixel-space size is calculated; its available modes are UpscaleMode.SCALE_BY, UpscaleMode.TARGET_DIMENSIONS, and UpscaleMode.MEGAPIXELS. No explicit default mode is declared in the schema. In scale-by mode, the nested scale control has a default of 2.0, minimum of 1.0, maximum of 4.0, and step of 0.05; it multiplies both original pixel dimensions by the requested factor. In target-dimensions mode, nested width and height controls specify pixel dimensions: width defaults to 1280 and height to 704, and both have a minimum of 64, maximum of 4096, and step of 8. Those dimensions are requests rather than guaranteed final dimensions because alignment and aspect-ratio preservation are applied afterward. In megapixels mode, the nested megapixels control defaults to 1.0, with a minimum of 0.1, maximum of 8.0, and step of 0.1; the node defines one megapixel as 1024 × 1024 pixels and calculates dimensions from that area using the source aspect ratio. Target-dimensions and megapixels modes also calculate an effective scale from the average of the requested width and height ratios, which is supplied to the learned model before alignment adjustments.

align

Required INT control defining the requested pixel-space alignment grid, with a default of 32, minimum of 1, maximum of 512, and step of 1. Both final image axes are placed on a grid compatible with this value and H3’s 16× VAE grid, ensuring that the pixel dimensions can be represented by whole latent dimensions. This can change the final size from the exact size requested through mode. For example, requesting an alignment smaller than 16 does not remove the requirement for compatibility with the 16-pixel H3 grid. Larger alignment values impose a coarser set of possible dimensions and can therefore lead to a greater difference between your requested size and the actual result.

keep_proportion

Required BOOLEAN control with a default of True and options True or False. When enabled, the node tries to preserve the source aspect ratio as closely as the alignment grid permits, helping avoid unwanted stretching or compression of your composition. Because dimensions must still meet grid requirements, preservation is approximate rather than guaranteed to be mathematically exact. When disabled, the alignment calculation is not asked to preserve the original proportions, which is useful when you deliberately want a different frame shape in target-dimensions mode. Megapixels mode already calculates its initial target dimensions from the source aspect ratio, even when this setting is disabled.

device

Required COMBO control with options cuda and cpu, defaulting to cuda. This selects where the learned upscaling calculation runs: cuda uses an available CUDA-capable GPU, while cpu runs it on the processor. If you select cuda but CUDA is unavailable, the node automatically falls back to CPU rather than failing at this device-selection step. GPU processing is generally preferable for demanding video workloads, while CPU processing can be useful when CUDA is unavailable or GPU memory is limited, although it can be substantially slower. Regardless of the inference device, the upscaling call requests that the resulting tensor be returned on CPU.

precision

Required COMBO control with options fp32, fp16, and bf16, defaulting to fp16. This selects the numerical precision passed to the learned upscaler: fp32 uses full 32-bit floating-point precision, while fp16 and bf16 use two different 16-bit floating-point formats. Reduced precision can lower inference memory requirements on compatible hardware, but support and performance depend on your processor, GPU, and the operations used by the model. If you encounter precision-related failures, fp32 is a useful troubleshooting choice, particularly on CPU, although it can require more memory. After upscaling, the node converts the result back to the original input tensor’s data type, so the selected inference precision does not necessarily become the returned latent’s data type.

offload_after_upscale

Required BOOLEAN control with a default of False and options True or False. When enabled, it requests that the cached learned upscaler be moved to CPU after inference so that its GPU memory can be released for later workflow stages. When disabled, the model can remain available on the GPU for faster repeated upscaling runs when sufficient VRAM is available. Enable this when you need to make room for subsequent sampling or decoding, and leave it disabled when repeated upscaling speed is more important than releasing GPU memory. It is a post-inference memory-management setting, not a method for reducing the peak memory required while the upscaling operation itself is running.

Minimax H3 Latent Upscaler (3D) Output Parameters:

latent

The single output, named latent and declared with interface type *, contains the enlarged latent representation rather than a visible image or video. When upscaling runs, the returned value is a dictionary containing samples with the processed tensor on CPU, converted back to the original input data type. Four-dimensional image inputs return four-dimensional tensors, and five-dimensional video inputs retain their temporal dimension; the operation targets spatial resolution rather than increasing the number of frames. To interpret the spatial size in pixels, multiply the output latent width and height by the H3 downsampling factor of 16. If alignment produces the same latent dimensions as the source, the node returns the original latent dictionary unchanged and skips inference. Otherwise, it constructs a new dictionary containing only samples, so additional fields from the input dictionary are not automatically preserved. This is the result of the learned upscale stage, not an integrated H3 refinement result or a reconstructed combined audio/video state.

Minimax H3 Latent Upscaler (3D) Usage Tips:

  • Start with scale-by mode at scale = 2.0, align = 32, and keep_proportion = True for a straightforward enlargement that preserves your composition as closely as the grid allows.
  • Use target-dimensions mode when you have a delivery resolution in mind. Keep keep_proportion enabled if avoiding distortion matters more than matching both requested dimensions exactly; disable it only when changing the frame shape is intentional.
  • Use megapixels mode when you want a consistent approximate image area across different aspect ratios. Remember that megapixels = 1.0 means 1,048,576 pixels here, and alignment can change the final area.
  • Check the console message beginning with [MinimaxH3-3D] to confirm the actual latent and pixel dimensions. The reported scale is the effective scale calculated before alignment, not necessarily the exact ratio of the final aligned dimensions.
  • On a compatible CUDA GPU, begin with device = cuda and precision = fp16. If you encounter unsupported-operation or precision errors, test fp32; on CPU, fp32 is a practical compatibility-oriented starting point.
  • Enable offload_after_upscale when later stages need GPU memory. If the upscaling operation itself runs out of memory, reduce the requested size or the input sequence length instead, because post-inference offloading cannot resolve peak inference memory use.
  • Keep the full temporal context in mind when planning video workloads. The implementation processes the whole sequence together because its normalization and temporal layers make naive chunking non-equivalent; manually splitting a clip can change the result compared with processing it as one sequence.
  • Connect a compatible image or video latent tensor, not decoded frames or an arbitrary combined audio/video state. If your workflow needs integrated H3 low-sigma refinement or H3 Continuum audio/video handling, use the appropriate companion refinement or handoff workflow rather than assuming this node performs those steps.
  • Preserve any extra latent metadata separately if your downstream workflow needs it. A successful resize returns a new dictionary containing only samples, whereas a no-resize pass returns the original dictionary unchanged.

Minimax H3 Latent Upscaler (3D) Common Errors and Solutions:

Please place model files into the latent_upscale_models directory

  • Explanation: This exact error is raised when model_name starts with an opening parenthesis, indicating that the selection is a placeholder rather than a usable model entry.
  • Solution: Install the appropriate MiniMax H3 latent upscaler model files in the latent_upscale_models directory, refresh the available model list or restart ComfyUI if necessary, and select a valid model name.

This model only supports upscaling (effective scale >= 1.0).

  • Explanation: This exact error occurs when the calculated effective scale is below 1.0 and at least one aligned output axis is smaller than its corresponding input axis. Target-dimensions or megapixels settings can request a smaller size even though scale-by mode does not offer factors below 1.0.
  • Solution: Increase the requested dimensions or megapixel value, or use scale-by mode with a factor above 1.0. Use a separate resizing tool if your goal is to reduce resolution.

Unsupported mode: ...

  • Explanation: This exact message prefix is raised when the supplied mode does not match one of the three supported modes. It is more likely with a malformed API request, an incompatible saved workflow, or mismatched node versions than with normal interface selection.
  • Solution: Reselect a supported mode in the node interface and set its displayed controls. If you are calling the workflow through an API, verify that its dynamic mode data matches the installed node version.

KeyError: 'samples'

  • Explanation: The node directly reads latent["samples"]. A dictionary without that entry will fail because it does not contain the expected latent tensor.
  • Solution: Connect the latent result from a compatible upstream stage rather than an image, configuration dictionary, or unrelated data object.

AttributeError involving dtype, dim, or shape

  • Explanation: The value stored in samples must behave as a tensor. A missing tensor, nested container, or incompatible combined audio/video representation can fail when the node reads its data type, dimension count, or shape; the exact message depends on the supplied object.
  • Solution: Supply a standard compatible image or video latent tensor. For a combined H3 audio/video workflow, use the appropriate companion integration to provide the video latent rather than connecting an unsupported container directly.

not enough values to unpack / too many values to unpack

  • Explanation: The node expects a five-dimensional video tensor after optionally expanding a four-dimensional image tensor. Other tensor dimension counts can fail when it unpacks the tensor shape; exact wording varies with the number of dimensions.
  • Solution: Check that image samples are arranged as batch, channels, height, width and video samples as batch, channels, time, height, width. Use a compatible upstream latent source instead of manually reshaping data without confirming its layout.

CUDA out of memory

  • Explanation: This is a possible PyTorch runtime error, rather than a custom message defined by the node. The full video sequence and its upscaling calculations can exceed available GPU memory, especially with large resolutions, long clips, or large batches.
  • Solution: Lower the requested scale or resolution, reduce batch size, or generate a shorter source sequence. Close other GPU workloads, try a supported reduced precision, or use CPU if necessary. Enable offloading to help later stages, but do not expect it to reduce this operation’s peak memory needs.

Unsupported precision or device operation

  • Explanation: A possible runtime error may report that an operation is not implemented or supported for the selected floating-point format or device. The node offers fp16 and bf16, but their availability depends on the hardware and underlying model operations.
  • Solution: Retry with precision = fp32. If you selected CUDA, verify that your ComfyUI environment can use your GPU; otherwise, use CPU with a supported precision.

Model loading or tensor channel mismatch

  • Explanation: Possible runtime errors about missing files, incompatible weights, or unexpected channel counts can arise inside the model-loading or inference code. The supplied class does not define the exact messages, but selecting an incompatible model or supplying latents from a different model family can cause these failures.
  • Solution: Confirm that the selected file is a compatible MiniMax H3 learned latent upscaler, that it is installed completely, and that the input latents match its requirements. Do not assume that an unrestricted * connector guarantees compatibility with every latent format.

Minimax H3 Latent Upscaler (3D) Related Nodes

Go back to the extension to check out more related nodes.
Comfyui_Minimax_h3_latent_Upscaler-Plus
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.

Minimax H3 Latent Upscaler (3D)