10:11
ComfyUI
The video shares two downloadable ComfyUI workflows that use a Flux.1 Depth ControlNet model to upscale images locally, arguing this adds real detail (not just size) to low-quality or compressed source images, while conceding the local GGUF-based result is currently weaker and more VRAM-constrained than Black Forest Labs' online demo.
The video demonstrates local upscaling with ComfyUI using a Flux.1 Depth ControlNet workflow, with two downloadable workflow files linked below the video.
Upscaling here means adding real detail to a low-quality/compressed image, not simply enlarging it — shown on a portrait, a photo, and an old Midjourney image.
Pipeline: load image → latent (Lanczos-style) upscale by a chosen scale factor (creator uses 5) → VAE Encode → K Sampler, while the original (non-latent) image is separately fed into the Apply ControlNet node.
Choosing the upscale scale factor is a size/quality/hardware tradeoff: too small loses detail, too large may exceed the GPU's capability.
Model stack: VAE = ae.safetensors, a Dual CLIP Loader with CLIP L plus T5 XXL FP16 (the video states the FP8 'eight' version gives lower detail quality), and a Flux.1 Depth GGUF UNet model.
GGUF quantization tradeoff: the higher-quality Q8 model caused VRAM overload/crashes and only finished every second or third run, so the video uses Q5 instead for reliability.
A LoRA (the 'flux aesthetic amateur photo' LoRA from Civitai) is applied to both the model and CLIP outputs for added flexibility; a 'realist LoRA' (ComfyUI-converted, from XLabs-AI) is offered as an alternative, and other LoRAs can be swapped depending on the target look.
Prompting: a detailed positive-prompt description of everything visible in the source image is written by hand rather than via an auto-captioner (e.g. WD14), feeding into CLIP Text Encode → a Flux Guidance node set to 3.5; the negative prompt stays empty.
Unlike the online Flux ControlNet demo, which needs no prompt at all, this local workflow requires a written prompt to get good upscaled detail.
ControlNet setup: Apply ControlNet takes the original image, the Flux.1 Depth ControlNet Upscaler model (downloaded from jasperai's Hugging Face repo as 'diffusion_pytorch_model.safetensors' and renamed), and a VAE, then routes positive/negative conditioning into the K Sampler alongside the upscaled-and-encoded latent.
Sampler settings: 35 steps (28 also usable) trade render time against quality; the Euler sampler with the normal scheduler is described as fast and giving a smooth result; ControlNet strength and end-percentage are further tunable parameters balancing the Flux model's 'freedom' against the ControlNet's control.
The final image comes from a VAE Decode node after the K Sampler.
Model folder placement: GGUF UNet models go in a manually created 'unet' folder inside ComfyUI's models directory; LoRAs go in the loras folder; the ControlNet model goes in the controlnet folder; CLIP/T5 files go in the usual clip location; the VAE goes in the vae folder.
The creator states the local result is currently weaker/grainier than the official online demo and expects it to improve, and notes the workflow includes no face-fixing, so flaws already present in the source image (e.g., an early Midjourney face) are not corrected.
ComfyUI — The node-based Stable Diffusion/Flux interface the video uses to build and run the entire upscaling graph. Apply: Load one of the two provided workflow files into ComfyUI and place each referenced model in its correct models subfolder before running it.
Flux.1 (Flux) — The underlying diffusion model family whose depth-ControlNet variant is repurposed here for upscaling rather than fresh generation. Apply: Use a Flux.1 depth GGUF UNet checkpoint as the base model, loaded via a GGUF UNet loader node.
ControlNet (Apply ControlNet) — A conditioning mechanism that feeds the original, non-latent input image plus a dedicated ControlNet model into the sampler to guide the upscale toward the source image's structure. Apply: Wire the original image, the Flux.1 Depth ControlNet Upscaler model, and the VAE into an Apply ControlNet node, and tune its strength and end-percentage to balance fidelity to the source against freedom for the Flux model.
Flux.1 Depth ControlNet Upscaler (jasperai) — A specific ControlNet checkpoint, downloaded from jasperai's Hugging Face repo as 'diffusion_pytorch_model.safetensors' and renamed, built for depth-guided upscaling with Flux. Apply: Download it, rename it to identify it as the Flux depth ControlNet upscaler, place it in ComfyUI's models/controlnet folder, and load it in the ControlNet loader node.
GGUF quantization (Q5 vs Q8) — A compressed model file format offered at different quantization levels that trade file size and VRAM use against output quality. Apply: Choose Q5 for more reliable local runs on limited VRAM, or Q8 for higher quality only if the GPU can handle the extra VRAM load without crashing.
Dual CLIP Loader — A ComfyUI node that loads two text-encoder models together — here CLIP L and T5 XXL FP16 — needed for Flux prompting. Apply: Load both CLIP L and the FP16 (not FP8) version of T5 XXL to preserve output detail quality.
T5 XXL FP16 — The larger, higher-precision variant of the T5 XXL text encoder that Flux relies on for prompt understanding. Apply: Use the FP16 version rather than the FP8 ('eight') version, since the video states FP8 yields less detail in the upscaled output.
LoRA — A lightweight fine-tuning adapter applied to the base model and CLIP to shift the output's style or character. Apply: Route the model and CLIP through a LoRA loader before the rest of the graph to add stylistic flexibility suited to the target image.
Flux Aesthetic Amateur Photo LoRA — A specific Civitai-hosted LoRA the creator applies in this workflow to push results toward an amateur-photo aesthetic. Apply: Download it from Civitai, place it in ComfyUI's models/loras folder, and apply it to both the model and CLIP outputs ahead of the text encoder.
Realist LoRA (XLabs-AI, ComfyUI-converted) — An alternative LoRA, converted for ComfyUI from XLabs-AI, offered as a swap-in for a more realistic look. Apply: Substitute it in the same LoRA-loader slot in place of the aesthetic-amateur-photo LoRA depending on the desired output style.
Lanczos-style latent upscale — The upscaling node used to enlarge the input image before VAE-encoding it into a latent, at a chosen scale factor (5x in the video). Apply: Set the scale factor to balance added detail against latent size and GPU capacity — too small loses detail, too large may exceed VRAM.
VAE Encode / VAE Decode — The nodes that convert between pixel-space images and the latent space the sampler operates in, using the ae.safetensors VAE. Apply: Encode the upscaled image into a latent before the K Sampler, then decode the sampler's output latent back into the final pixel image afterward.
CLIP Text Encode (positive/negative prompt) — The node that turns a written text description into sampler conditioning; here the negative prompt is left empty. Apply: Hand-write a detailed positive-prompt description of everything visible in the source image, rather than auto-captioning, to steer the added detail.
Flux Guidance node — A node that sets the guidance-scale value (3.5 in the video) applied to the positive conditioning before the sampler. Apply: Insert it between CLIP Text Encode and the sampler's positive input, using a value around 3.5.
K Sampler (Euler sampler / normal scheduler) — The core denoising node; the video specifies the Euler sampler with the normal scheduler and 35 (or 28) steps. Apply: Set steps between 28 and 35 as a speed/quality tradeoff, and choose the Euler sampler with the normal scheduler for a quick, smooth result.
UNet Loader (GGUF) — The ComfyUI node used to load GGUF-quantized UNet checkpoints — here the Flux.1 depth Q5 GGUF model. Apply: Place the GGUF UNet file in a manually created 'unet' folder inside ComfyUI's models directory and load it with the GGUF UNet loader node.
WD14 / CLIP interrogator — An automated image-captioning tool the video mentions as an alternative way to generate the positive prompt instead of writing it by hand. Apply: Run the source image through WD14 or a similar interrogator to auto-generate a descriptive prompt if manual prompting isn't preferred.
The creator openly concedes that SDXL plus the Ultimate SD Upscaler currently outperforms this Flux ControlNet method, framing the video as exploratory rather than a recommended best practice.
Higher quantization is not straightforwardly better in practice: the Q8 GGUF model produced higher quality but caused VRAM overload that made renders fail intermittently, illustrating a real hardware-constrained quality/reliability tradeoff that pushed the creator to the lower Q5 quant.
The prompting requirement differs sharply between the hosted and local versions of the same technique — the online demo needs no text prompt at all, while the local ComfyUI graph requires a detailed hand-written description to get comparable detail.
The video explicitly flags a subtle graph-reading trap: the original image feeds directly into the Apply ControlNet node, not through the latent/upscale chain — a distinction the creator calls out as 'pretty big difference' because it's easy to assume the ControlNet uses the same latent path as the sampler.
«I show you how to upscale Goods on local hardware as you should but some of you are going to cry cuz this is about comy UI»
— 00:00
«and to be honest you probably can do it better with sdxl and the ultimate upscaler but we're going to still look into the control net app scale for flux»
— 01:50
«it is really important here to think about how much you want to upscale this this is not improving anything this is just making the bigger picture»
— 02:28
«but with the Q8 model my comi kind of crashed had a kind of like vram overload so it didn't always work»
— 03:50
«for the positive prompt here you want to write a description of everything you see in the image the more you describe this the better the upscaling can get the details»
— 05:31
«it looks pretty good it has some problem it's not as super good as the online demo to be honest so I think this is going to improve in the future»
— 07:57
«you can see down here with the fur it looks kind of furry but also has this kind of graininess in it not completely looking like hair»
— 08:06
Reception
Viewers appreciate the creator's detailed tutorial and opening poem, but widespread technical issues, performance limitations, and hardware incompatibilities create significant frustration with implementing the workflow.
The video is a self-critical, node-by-node technical walkthrough of a specific ComfyUI Flux ControlNet upscaling graph — it explicitly frames the technique as still rough (weaker than the online demo, VRAM-heavy at higher quantization, no face-fixing) rather than presenting it as a finished best-practice solution.
10:11