ComfyUI Core Node Compatibility

ComfyUI Core Node Compatibility

Core Type System

Media Types

Type	Shape	Value Range	V3 Type
IMAGE	[B,H,W,C]	[0.0, 1.0]	io.Image
MASK	[B,H,W]	[0.0, 1.0]	io.Mask
LATENT	{"samples": [B,C,H,W]}	-	io.Latent
AUDIO	{"waveform": [B,C,T], "sample_rate": int}	-	io.Audio

Model Types

Type	Purpose	V3 Type
MODEL	Diffusion model (U-Net, DiT)	io.Model
CLIP	Text encoder model	io.Clip
VAE	Variational Autoencoder	io.Vae
CONTROL_NET	ControlNet model	io.ControlNet

Processing Types

Type	Purpose	V3 Type
CONDITIONING	CLIP conditioning data	io.Conditioning
SAMPLER	Sampling algorithm	io.Sampler
SIGMAS	Noise schedule [steps+1]	io.Sigmas
NOISE	Noise generator	io.Noise
GUIDER	Sampling guide (CFG)	io.Guider

Primitive Types

io.String, io.Int, io.Float, io.Boolean

Category Conventions

Standard Categories

• image/preprocessors - Canny, depth, pose
• image/postprocessing - Upscaling, enhancement
• image/transform - Resize, crop, rotate
• utils/string, utils/primitive, utils/logic, utils/math
• advanced/model, advanced/sampling, advanced/latent
• conditioning, loaders, sampling

Custom Categories

custom/yourname, tools/specific, integration/service

Tensor Format Conventions

Image Tensors

# ComfyUI: [B,H,W,C] (channels last)
# PyTorch: [B,C,H,W] (channels first)

# Conversion
pytorch_image = comfy_image.movedim(-1, 1)  # ComfyUI -> PyTorch
comfy_image = pytorch_image.movedim(1, -1)  # PyTorch -> ComfyUI

Latent Tensors

[B,C,H,W] inside {"samples": tensor} dict

Device Management

import comfy.model_management

device = comfy.model_management.get_torch_device()
intermediate = comfy.model_management.intermediate_device()

# Usage
tensor_gpu = tensor.to(device)       # Move to GPU
result = process(tensor_gpu)         # Process
result_cpu = result.to(intermediate) # Move back to free GPU

Common Pitfalls

Wrong Tensor Format

# WRONG: [B,C,H,W]
image_wrong = torch.randn(1, 3, 512, 512)

# CORRECT: [B,H,W,C]
image_correct = torch.randn(1, 512, 512, 3)

In-Place Model Modification

# WRONG
def process(model):
    model.something = new_value
    return model

# CORRECT
def process(model):
    m = model.clone()
    m.something = new_value
    return m

Memory Leaks

# WRONG: Keep on GPU
result = process_on_gpu(image.to(device))
return io.NodeOutput(result)

# CORRECT: Move back
result = process_on_gpu(image.to(device))
return io.NodeOutput(result.to(intermediate_device()))

Best Practices

1. Use standard types (IMAGE, MODEL, etc.)
2. Follow formats: [B,H,W,C] for images, [B,H,W] for masks
3. Normalize values: [0.0, 1.0]
4. Use standard categories
5. Validate inputs
6. Move to intermediate device after processing
7. Clone models before modification