FunUI Load Latent Upscaler:
FunUILatentUpscalerLoader, displayed as “FunUI Load Latent Upscaler” in the FunUI/Latent category, loads learned models for enlarging latent representations—the compressed working data used during image or video generation, before decoding into visible frames. Its main purpose is to support latent upscalers that ComfyUI’s own loader does not recognize, including supported convolution-based H3 upscalers. It reads a selected model’s saved weights and asks the installed FunUI model modules to recognize and construct the appropriate upscaler, using the first module that succeeds. In a second-pass workflow, this provides the learned upscaling component for either retaining a larger latent resolution or sharpening through an upscale-and-reduce operation before another sampling pass. The loader itself does not resize latents, generate detail, or run sampling; those operations happen in downstream nodes. Compatibility depends on the installed model modules, and the supplied implementation explicitly does not support the newer attention-based H3 upscaler.
FunUI Load Latent Upscaler Input Parameters:
upscaler_name
Required selection parameter of type COMBO that chooses the latent upscaler weight file to load. Its options are populated dynamically by upscaler_files(), so the available filenames depend on your installation; the supplied source does not list individual options, identify the underlying model folder, or specify an explicit default. Numeric minimum and maximum values do not apply. The node resolves the selected filename to a full path, reads its weights using ComfyUI’s safe-loading mechanism, and passes those weights to the installed FunUI latent-upscaler providers until one recognizes them. Your selection therefore determines both which learned upscaling model becomes available and whether loading succeeds. A filename appearing in the dropdown does not guarantee that an installed provider supports its architecture. Choose a model intended for your latent format and supported by your installed FunUI model module, rather than assuming that any image upscaler or latent upscaler is interchangeable.
FunUI Load Latent Upscaler Output Parameters:
upscaler
An output of type LATENT_UPSCALE_MODEL containing the loaded model object returned by the first installed FunUI provider that recognizes the selected weights. This is a reusable upscaling component, not an enlarged latent, an image, or a video. Connect it to a compatible downstream operation, such as the upscaler input of FunUILatentResample, to perform the actual latent processing. FunUI’s supplied resampling runner expects the model, or its wrapped model module, to provide a callable funui_latent_upscale operation. The output does not specify a scale factor or sharpening mode; those choices belong to the downstream resampling node. If no installed provider recognizes the selected file, execution raises an error instead of producing this output.
FunUI Load Latent Upscaler Usage Tips:
- Connect this node’s
upscaleroutput to FunUILatentResample for between-pass processing. A typical workflow is first sampler → FunUILatentResample → second sampler, with this loader supplying the resampling model. - For H3 workflows, use a supported older convolution-based H3 upscaler. The provided implementation explicitly rejects the newer attention-based H3 format and recommends the older architecture.
- Configure the operation and scale in FunUILatentResample, not in this loader. The supplied H3 pipeline demonstrates
operation="sharpen"withscale=2.0; treat this as a documented workflow example rather than a loader default or a universal recommendation. - Choose sharpening when you want an upscale-and-reduce operation before another sampling pass, or upscaling when you want to retain the larger latent dimensions. The second sampler performs the subsequent refinement; loading the model alone does not change your result.
- When resizing latents with associated conditioning, pass the relevant positive and negative conditioning through FunUILatentResample and use its updated conditioning for the second sampler. The supplied context notes that H3 anchor conditioning is tied to the latent grid and may otherwise be rejected after a size change.
- If your model is a Lightricks or Hunyuan latent upscaler, use ComfyUI’s own “Load Latent Upscale Model” as directed by this loader’s error message. Also use the corresponding compatible processing node; the supplied FunUI runner specifically points to ComfyUI’s LTXV Latent Upsampler for Lightricks models.
- If a valid model is not recognized, check that the FunUI model module supporting its architecture is installed and enabled. This loader relies on registered providers rather than supporting every latent-upscaler architecture by itself.
FunUI Load Latent Upscaler Common Errors and Solutions:
“[filename] is not an upscaler any installed model module can load.”
- Explanation: The file was read, but none of the registered FunUI latent-upscaler providers accepted its weights. Possible causes include an unsupported architecture, a missing supporting model module, or selecting a file that is not a compatible latent upscaler.
- Solution: Confirm the model’s intended architecture and purpose, then select a supported latent upscaler. Check that the corresponding FunUI model module is installed and enabled. For Lightricks or Hunyuan models, follow the message’s recommendation to use ComfyUI’s own loader.
“It looks like the newer attention-based H3 upscaler, which FunUI cannot build yet: use an older convolution-based H3 upscaler.”
- Explanation: After all providers fail to recognize the file, the loader checks whether any weight names begin with
base.. If they do, it adds this diagnostic to the unsupported-model error. The wording indicates a likely architecture match, not a guaranteed identification. - Solution: Select an older convolution-based H3 upscaler supported by your installed FunUI version. Renaming the file will not resolve the issue because the check examines its contents.
“If it is Lightricks' or Hunyuan's, ComfyUI's own Load Latent Upscale Model loads it.”
- Explanation: This is guidance appended to the unsupported-model error, rather than a separate failure. It explains that some latent upscalers belong with ComfyUI’s built-in loader instead of this FunUI loader.
- Solution: Replace this loader with ComfyUI’s “Load Latent Upscale Model” for the indicated model family and connect it to a compatible processing node. For Lightricks models, the supplied context specifically identifies LTXV Latent Upsampler.
Selected model file cannot be found
- Explanation: The node resolves the selected filename with
get_full_path_or_raisebefore reading the weights. If the file has been moved, deleted, renamed, or is no longer available through the configured model paths, execution can fail at this stage. The exact error text depends on ComfyUI. - Solution: Check that the selected file still exists and is accessible in the model location used by your installation. Restore or reselect it, refresh the available choices, and restart ComfyUI if necessary.
Model weights cannot be read or loaded safely
- Explanation: The node reads the file with
comfy.utils.load_torch_fileusingsafe_load=True. A damaged or incomplete download, an incompatible file format, or a file-access problem can cause an exception before architecture recognition begins. The supplied class does not define a fixed message for these failures. - Solution: Read the underlying ComfyUI error for details, verify that the download is complete and in a supported weights format, and check file permissions. If necessary, download a fresh copy from a trusted source rather than disabling safe loading.
“this upscaler does not say how to run itself on a latent (no funui_latent_upscale). ComfyUI's LTXV Latent Upsampler node runs Lightricks' one.”
- Explanation: This is a downstream execution error from FunUI’s upscaler runner, not an error raised directly by the loader. It means the connected model does not expose the operation that FunUI expects for processing latents.
- Solution: Use an upscaler supported by the FunUI model provider and resampling workflow. For a Lightricks model, use ComfyUI’s LTXV Latent Upsampler instead of attempting to run it through this FunUI execution path.
