How greenzorro/comfyui-workflow-upscaler works
1. What this repo is
- This is not an application codebase; it is a collection of ComfyUI workflow definitions for image upscaling.
- The core deliverables are four JSON workflow graphs plus documentation and example images.
2. Primary repository boundary
- The repo itself holds only the workflow specs and usage guidance.
- Actual execution happens in an external ComfyUI runtime with the required custom nodes and model files installed.
3. Main workflow artifacts
- upscaler-sharpen.json: a lightweight, non-diffusion upscaler focused on sharpening/detail recovery.
- upscaler-creative.json: an SDXL-based creative upscaler that can alter or enrich image content.
- upscaler-ultra-sharp.json: a Flux Dev–based workflow optimized for stronger fidelity and resolution enhancement.
- upscaler-mad-mode.json: a chained workflow that combines the Flux-based and SDXL-based approaches.
4. Functional architecture of the workflows
- All workflows start from an input image and end with an upscaled output image.
- They differ mainly in how much they preserve the source versus how much they regenerate detail:
- Sharpen = preserve composition, improve crispness.
- Creative = preserve composition with controlled AI reinterpretation.
- Ultra sharp = maximize high-resolution detail using Flux Dev.
- Mad mode = sequential combination for maximum detail and creativity.
5. Shared processing pattern
- The workflows likely follow a common ComfyUI graph shape:
- load source image
- resize / upscale or latent preparation
- apply model-driven enhancement
- optionally apply ControlNet and/or LoRA conditioning
- decode and save final image
- The “creative” variants use low denoise / conditioning strength to keep the original composition while allowing detail synthesis.
6. Model and asset boundaries
- The repo does not ship models; it assumes external model placement in standard ComfyUI folders such as:
- unet
- checkpoints
- clip
- vae
- controlnet
- upscale_models
- embeddings
- loras
- This makes the workflows portable, but dependent on the exact model versions listed in the README.
7. Custom node dependency layer
- Several workflows depend on third-party ComfyUI extensions:
- ComfyUI_Essentials
- ComfyUI-Easy-Use
- ComfyUI-Anyline
- ComfyUI_UltimateSDUpscale
- Comfyui_TTP_Toolset
- These nodes form the “middle layer” between the graph definitions and the base ComfyUI engine.
8. Modeling/conditioning strategy
- The creative workflows rely on a stack of conditioning components:
- SDXL / DreamShaper XL Lightning for generation
- Anyline / MistoLine ControlNet for structural guidance
- LoRA for detail injection
- negative embedding to steer away from unwanted artifacts
- This is why the creative workflow can change fine-grained content while still keeping the overall image recognizably aligned.
9. Execution environments
- The repo is designed to run:
- locally in ComfyUI
- or in preconfigured cloud notebooks on Kaggle and Colab
- That means infrastructure is external to the repo; the workflow JSON is the portable unit, not the compute environment.
10. Documentation and examples
- The examples/ folder and embedded screenshots demonstrate expected output behavior, especially for the creative workflow.
- The README functions as the operational guide: it maps each workflow to required models, custom nodes, and expected tradeoffs.
11. External service dependencies
- Model downloads are sourced from Hugging Face, Civitai, and Liblib.
- Those services are part of the supply chain for the workflows, but not runtime dependencies once models are installed.
12. How to draw the architecture
- Diagram this as a workflow repository feeding a ComfyUI execution environment.
- Show the input image flowing into one of four workflow graphs, each graph depending on:
- ComfyUI core
- custom nodes
- externally stored models
- Then show the final image output, with the “mad mode” graph explicitly represented as a composition of the Flux-based and SDXL-based upscaling stages.
Main entry points: upscaler-creative.json Creative · upscaler-ultra-sharp.json Ultra sharp · upscaler-mad-mode.json Mad mode · upscaler-sharpen.json Sharpen
Components 20
Repository
Portable workflow specs, docs, and examples.
- Workflow repo · Repository boundary containing ComfyUI workflow definitions rather than application code.
Workflows
Four ComfyUI upscaling graphs with different fidelity and creativity tradeoffs.
- Sharpen · Lightweight upscaler focused on crispness and detail recovery with minimal regeneration.
upscaler-sharpen.json - Creative · SDXL-based upscaler that preserves composition while allowing controlled reinterpretation.
upscaler-creative.json - Ultra sharp · Flux Dev-based upscaler tuned for higher fidelity and strong resolution enhancement.
upscaler-ultra-sharp.json - Mad mode · Chained workflow combining Flux-based and SDXL-based upscaling stages.
upscaler-mad-mode.json - Flux stage · Flux Dev-based enhancement stage used by the ultra-sharp and mad-mode workflows.
- SDXL stage · SDXL-based generation and refinement stage used by the creative and mad-mode workflows.
ComfyUI Runtime
External execution environment plus custom nodes and model assets.
- Input image · Starting image fed into each workflow graph.
- Output image · Final saved image produced by the workflows.
- ComfyUI core · External runtime that executes the workflow graphs.
- Custom nodes · Third-party ComfyUI extensions used as graph building blocks and operators.
- ControlNet · Structural guidance used by creative workflows to preserve image alignment.
- LoRA · Detail-injection adapters used to enrich output texture and style.
- Negative emb · Embedding used to suppress unwanted artifacts during creative generation.
- Kaggle/Colab · Optional preconfigured notebook environments for running the workflows outside local ComfyUI.
External Assets
Models, LoRAs, embeddings, and source image supply chain.
- Model store · Externally installed checkpoints, UNet, VAE, ControlNet, LoRA, embeddings, and upscale models.
- Model sources · Hugging Face, Civitai, and Liblib as the supply chain for required model files.
Connections 34
- Workflow repo → README: documented by · Repository usage and dependency guidance.
- Workflow repo → 中文 README: localized by · Chinese documentation companion.
- Workflow repo → Examples: demonstrated by · Sample outputs illustrate workflow behavior.
- Workflow repo → Sharpen: contains · Non-diffusion sharpening workflow.
- Workflow repo → Creative: contains · SDXL creative upscaling workflow.
- Workflow repo → Ultra sharp: contains · Flux Dev-based high-fidelity upscaling workflow.
- Workflow repo → Mad mode: contains · Chained combined workflow.
- Input image → Sharpen: feeds · Source image enters the workflow.
- Input image → Creative: feeds · Source image enters the workflow.
- Input image → Ultra sharp: feeds · Source image enters the workflow.
- Input image → Mad mode: feeds · Source image enters the chained workflow.
- Sharpen → Output image: produces · Sharpened upscale result.
- Creative → Output image: produces · Creatively enhanced upscale result.
- Ultra sharp → Output image: produces · High-fidelity upscale result.
- Mad mode → Output image: produces · Final chained upscale result.
- Creative → SDXL stage: uses · SDXL-based enhancement path.
- Ultra sharp → Flux stage: uses · Flux Dev-based enhancement path.
- Mad mode → Flux stage: starts with · First stage in the chained workflow.
- Flux stage → SDXL stage: hands off to · Mad mode composes Flux then SDXL.
- SDXL stage → Output image: finishes as · Final pass in the chained workflow.
- Creative → ControlNet: conditions on · Structural guidance for composition preservation.
- Creative → LoRA: adapts with · Detail/style injection during creative upscaling.
- Creative → Negative emb: steered by · Artifact suppression and output cleanup.
- Sharpen → Custom nodes: depends on · Uses ComfyUI extensions for specialized upscaling operations.
- Creative → Custom nodes: depends on · Uses extension nodes for conditioning and enhancement.
- Ultra sharp → Custom nodes: depends on · Uses extension nodes for Flux-based processing.
- Mad mode → Custom nodes: depends on · Uses both workflow stages and extension nodes.
- Custom nodes → ComfyUI core: extends · Bridges workflow JSON into the ComfyUI engine.
- ComfyUI core → Model store: loads · Runtime reads checkpoints, VAE, ControlNet, LoRA, embeddings, and upscale models.
- Model store → Model sources: sourced from · External model supply chain.
- Kaggle/Colab → ComfyUI core: hosts · Optional execution environments for running ComfyUI.
- README → Model store: specifies · Documents required model placement and versions.
- README → Custom nodes: specifies · Documents required custom node extensions.
- Examples → Creative: illustrates · Example outputs are especially relevant to creative mode.