ComfyUI_UltimateSDUpscale: tiled img2img upscaling inside ComfyUI
ComfyUI nodes for the Ultimate Stable Diffusion Upscale script by Coyote-A.
At a glance
- What is it?
- The ssitu/ComfyUI_UltimateSDUpscale nodes bring Coyote-A's Ultimate Stable Diffusion Upscale tiling method into ComfyUI, so large images are redrawn tile by tile instead of in one pass. The install paths are short and the parameter list is long, and the repository documents the parameters less than the original script does.
- Who is it for?
- Adopt it if you already run ComfyUI and want the Ultimate SD Upscale tiling method available as nodes, with example workflows and a node menu entry under image/upscaling. Skip it if you are not on ComfyUI, or if you need a single-pass upscaler rather than a tiled img2img pass.
- Can I use it commercially?
- Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
- Is it still maintained?
- Yes. The repository last received commits 88 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What tiled img2img upscaling solves, and for whom
A diffusion model is trained at a fixed image size. Feed it something much larger and the result degrades or the run does not fit in memory. The README states the point plainly: this approach improves the details commonly found on upscaled images while reducing hardware requirements and maintaining an image size that the diffusion model is trained on. So the target user is someone with a large image and a modest GPU, who wants the model to redraw detail rather than have a separate upscaler interpolate pixels.
The nodes implement the Ultimate Stable Diffusion Upscale script by Coyote-A, which was written for the Automatic1111 Web UI. If you have used that script, the parameter names should look familiar. If you have not, the repository points you at the original wiki for the parameter descriptions, which is a hint about where the documentation really lives.
How the nodes split an image and redraw it
The mechanism is image-to-image diffusion applied in tiles. Instead of one pass over the whole canvas, the image is divided into tiles, each tile goes through the diffusion process, and the results are reassembled. The repository layout reflects this: usdu_nodes.py holds the node definitions, usdu_utils.py holds the helpers, usdu_patch.py and crop_model_patch.py patch behaviour around model handling, and the repositories/ directory is declared in pyproject.toml as the location of the bundled ultimate_sd_upscale code, the part inherited from Coyote-A's script. The js/ directory holds the front-end side, including js/docs/, which is where the node documentation lives.
The practical consequence of tiling is that tile size, overlap and seam handling become the parameters you tune. The README does not describe them; it links to the original script's wiki FAQ for parameter descriptions and points at js/docs/ and the in-app info panel. Treat those two sources as the real manual.
Installing ComfyUI_UltimateSDUpscale with ComfyUI Manager, comfy-cli or git
The README gives four install routes. The shortest is ComfyUI Manager: install the manager, launch ComfyUI, open it, choose Custom Nodes Manager, search for "UltimateSDUpscale", install the node, and restart ComfyUI when prompted. The README says to select latest for the most up-to-date version.
The command-line route uses comfy-cli. Run this from a terminal once comfy-cli is installed:
comfy node install comfyui_ultimatesdupscaleIf you prefer git, start in ComfyUI/custom_nodes/ and clone the repository. Verify git is present first with `git -v`:
git clone https://github.com/ssitu/ComfyUI_UltimateSDUpscaleThe fourth route is a manual download: take a zip from the Comfy Registry page or the green Code button on GitHub, create a folder such as ComfyUI/custom_nodes/ComfyUI_UltimateSDUpscale, and extract into it. After any of these, restart ComfyUI and look for the nodes under image/upscaling in the node menu. The README also says example workflows appear in the Templates menu under the Extensions section, and in the example_workflows/ folder.
A first run: the node menu, the info panel and the example workflows
There is no script to run. The first real use is opening a workflow and inspecting a node. Right-click the relevant node and select the info icon to read its documentation in the application, which the README presents as an alternative to reading js/docs/ on disk. The README also says you can find the example workflows in the ComfyUI application under the Templates menu, by scrolling down the left sidebar to the Extensions section and selecting this repository, or by opening the files in example_workflows/ directly.
Because the README does not list the node parameters, the honest first step is to load an example workflow and read the node's inputs there rather than guess at them. The parameter descriptions the README points to are on the original script's wiki FAQ, not in this repository's README.
Where ComfyUI_UltimateSDUpscale is the wrong tool
Tiling is a trade-off, not a free win. The README frames the method as reducing hardware requirements and keeping the working size close to what the model was trained on, which is exactly why you pay for it in tile boundaries: overlapping regions and seam handling are inherent to the approach, and the repository's crop_model_patch.py and usdu_patch.py exist because model behaviour has to be adjusted around the tiling. If your image fits in a single pass at the model's native size, the tiling machinery adds work for no benefit.
It is also ComfyUI-only. The nodes are described as ComfyUI nodes for the script, and installation assumes a ComfyUI/custom_nodes/ directory. If you work in Automatic1111 or Forge, this repository is not the thing you install; the README links to Coyote-A's script for that. And if you want a fast non-diffusion upscale, a tiled img2img pass is the wrong category of tool entirely.
Ultimate SD Upscale versus single-pass latent upscaling
The alternative inside ComfyUI is the ordinary latent upscale plus a second sampler pass, which enlarges the latent and runs the sampler once over the whole image. It is simpler, has no tile parameters, and produces no seams because there is nothing to stitch. It also asks the sampler to work at a resolution the model was not trained on, which is the failure mode this project exists to avoid.
The difference is where the detail comes from. A single-pass latent upscale asks the model to invent structure at a scale it does not know well. Tiled img2img keeps each diffusion step near the training resolution and relies on overlap and blending between tiles. The README's own framing puts detail quality and hardware requirements on the tiling side of that comparison.
Maintenance, upgrade cost and the GPL-3.0 licence
The last push to the default branch was on 2026-06-22. The repository is not archived. There are no releases retrieved, and pyproject.toml declares version 1.7.2, so version tracking runs through the package metadata and the Comfy Registry rather than GitHub release tags. Upgrades come through whichever channel you installed from: ComfyUI Manager, comfy-cli, or a fresh clone or zip. If you installed by hand, updating means repeating the download and extraction step, and ComfyUI Manager's instruction to pick latest does not apply to you.
The licence is GPL-3.0, declared in pyproject.toml as a file reference to LICENSE. The bundled code under repositories/ultimate_sd_upscale/ comes from Coyote-A's script, which is also GPL-3.0. If you redistribute this node pack, or ship it inside a product, the GPL-3.0 obligations travel with it. That is a statement about the licence, not legal advice; read LICENSE and the original project's licence before you redistribute.
Editorial conclusion
Adopt it if you already run ComfyUI and want the Ultimate SD Upscale tiling method available as nodes, with example workflows and a node menu entry under image/upscaling. Skip it if you are not on ComfyUI, or if you need a single-pass upscaler rather than a tiled img2img pass. Before committing, check that the version ComfyUI Manager or comfy-cli offers matches what you expect, and open js/docs/ or the node info panel for the parameters, since the README only links to the original script's wiki for them.
Frequently asked questions
How do I install ComfyUI_UltimateSDUpscale?
The README gives four routes: ComfyUI Manager (search for "UltimateSDUpscale" under Custom Nodes Manager), comfy-cli with `comfy node install comfyui_ultimatesdupscale`, a git clone into ComfyUI/custom_nodes/, or a manual zip download extracted into a folder there. Restart ComfyUI afterwards.
Where do the ComfyUI_UltimateSDUpscale nodes appear in the node menu?
The README states the nodes can be found in the node menu under image/upscaling.
Where can I find ComfyUI_UltimateSDUpscale example workflows?
They are in the example_workflows/ folder, and the README says they also appear in the ComfyUI application under the Templates menu in the Extensions section of the left sidebar.
Where are the parameters of the Ultimate SD Upscale nodes documented?
The README points to js/docs/, to the node's info icon when you right-click it in the application, and to the original script's wiki FAQ for parameter descriptions. The README itself does not list them.
Community notes