ComfyUI-32GPU-Video-Upscale Introduction
ComfyUI-32GPU-Video-Upscale adds nodes for spreading image and video-frame upscaling across multiple graphics cards in ComfyUI. If you have a long video or a large batch of images, it can divide the frames into smaller groups, send those groups to different GPUs, and bring the results back together afterward.
The extension supports selecting GPU IDs from 0 to 31, for a maximum of 32 GPUs. It works with NVIDIA CUDA and AMD ROCm devices when PyTorch can see them. You can build separate upscaling branches yourself or use a single node to distribute a batch across a list of GPUs.
The main benefit is parallel processing: instead of asking one GPU to upscale every frame in turn, you can give different GPUs different frames to work on. This may reduce processing time when multiple compatible GPUs are available. It does not turn several GPUs into one larger GPU for upscaling a single frame.
How ComfyUI-32GPU-Video-Upscale Works
A video workflow handles its frames as a batch of images. Think of that batch as a stack of pictures waiting to be enlarged:
- Split the stack.
Split Image Batchdivides the frames into smaller groups. - Assign the work. Each upscaling branch uses a chosen GPU to process its group with an upscale model.
- Put the results back in order.
Merge Image Batchconcatenates the processed groups. The resulting frames can then continue through a video-creation workflow.
For example, with four available GPUs, you can split a video’s frames into four parts and assign one part to each GPU. The separate branches can overlap in time because the GPU-specific upscale node supports asynchronous execution. For this to work as intended, your ComfyUI version needs async node support.
You can also use Parallel Upscale (Multi-GPU) to distribute an image batch from one node rather than constructing the separate branches yourself.
ComfyUI-32GPU-Video-Upscale Features
| Node | What it does | When you might use it |
|---|---|---|
| GPU Init | Initializes the GPU selected by gpu_id and outputs a Start connection. Valid IDs are 0–31. | Use it to select a card for a GPU-specific upscaling branch. |
| Upscale Image (Model + Start) | Upscales images using a selected model on the GPU chosen for its branch. It is similar to ComfyUI’s Upscale Image (using Model) node, with GPU selection through the Start connection. | Use separate branches when you want direct control over which GPU processes each group of images. |
| Split Image Batch | Divides a batch of frames into 1–8 parts. | Set num_parts=4 to prepare four groups for four upscaling branches. |
| Merge Image Batch | Concatenates processed parts back in order. | Rejoin separately upscaled frame groups before the next stage of your video workflow. |
| Parallel Upscale (Multi-GPU) | Distributes a batch across GPUs selected in a gpu_ids list, such as 0,1,2,3. | Choose this when you prefer a single-node approach to distributing the work. |
Example: Upscale video frames on four GPUs
An example workflow is available at example_workflows/32gpu_video_upscale.json. The general pattern is:
Load Video → Get Video Components → Split Image Batch (num_parts=4)
├─ Upscale on GPU 0 ─┐
├─ Upscale on GPU 1 ─┤
├─ Upscale on GPU 2 ─┤
└─ Upscale on GPU 3 ─┴→ Rejoin frames
→ Create Video → Save Video
Select an upscale model for the upscaling nodes, then give each branch a different available gpu_id. Upscale models are stored in ComfyUI’s models/upscale_models/ directory. Once the video and model are selected and the branches are connected, queue the workflow.
Split Image Batch provides up to eight outputs. If you have more than eight GPUs, you can split the batch in stages:
- 8 GPUs: Split into 8 parts.
- 16 GPUs: Split into 2 parts, then split each part into 8.
- 32 GPUs: Split into 4 parts, then split each part into 8.
Example: Work with images on two GPUs
For an image-only starting point, see example_workflows/two_gpu_image_upscale.json. It shows separate GPU-specific branches:
GPU Init (0) ─Start─► Upscale (Model + Start) ─► Save
GPU Init (1) ─Start─► Upscale (Model + Start) ─► Save
This approach lets you choose where each branch runs. If you are processing a batch that you want to divide and bring back together, use the split-and-merge nodes or the parallel upscale node.
ComfyUI-32GPU-Video-Upscale Models
The extension does not provide its own upscale models. It uses models available through ComfyUI’s upscaling setup; the author mentions ESRGAN and UltraSharp as examples. Place a compatible model in models/upscale_models/ and select it in the upscale workflow.
The model determines the visual character of the enlargement, while this extension determines which GPU processes the work. You can try different available models to see which treatment suits your images or video frames. The provided information does not specify particular model versions or recommend settings for individual models.
Troubleshooting ComfyUI-32GPU-Video-Upscale
More GPUs are available, but processing is not faster
- Check that PyTorch sees at least two GPUs. The extension’s stated requirement for a real multi-GPU speedup is
torch.cuda.device_count() >= 2. - Confirm that separate branches use different
gpu_idvalues, or thatParallel Upscale (Multi-GPU)lists multiple available GPU IDs. - If using separate branches, check that the frames are actually split between them.
- Use a recent ComfyUI version with async node support so the
Start→ upscale branches can overlap.
A selected GPU is not available
- Check that the
gpu_idrefers to a device visible to PyTorch. The supported ID range is 0–31, but an ID is usable only if that GPU is available to the running ComfyUI process. - Do not change
CUDA_VISIBLE_DEVICESorHIP_VISIBLE_DEVICESafter ComfyUI has started. If you need to change which devices are visible, make that change before starting ComfyUI again.
A model is missing from the upscale workflow
- Check that your upscale model is in
models/upscale_models/. - Select that model in the relevant upscale node before queuing the workflow.
Frequently asked questions
Can I use this with just one GPU?
You can select a single GPU, but the stated benefit of parallel multi-GPU processing requires at least two devices visible to PyTorch.
Does it work with NVIDIA and AMD GPUs?
The extension supports NVIDIA CUDA and AMD ROCm when PyTorch can see the devices.
Do I need 32 GPUs?
No. Two-GPU image and four-GPU video examples are provided. The 32-GPU figure is the maximum supported GPU ID range, not a requirement.
Does it include ESRGAN or UltraSharp?
No. Those are examples of upscale models you can use with the workflow, not models supplied by the extension.
Learn More about ComfyUI-32GPU-Video-Upscale
- ComfyUI: Learn about the node-based environment in which this extension runs.
- Video upscale example workflow: A starting point for distributing video frames across GPUs.
- Two-GPU image example workflow: A smaller example for understanding GPU-specific branches.
- MIT license: The extension’s license.
