UltraPixel Process

UltraPixel Process is where the pack earns its keep. Feed it the model wire from UltraPixel Load, type a prompt, pick a size, and it writes an image at 2048×2048 by default - and up to 4096×4096 if your GPU can take it. No upscaling pass, no img2img, no second-stage detail add. That's the entire pitch, and it's why this node is interesting: it sidesteps the whole "generate small, then upscale" dance and just renders big.

How it works

The generation runs Stable Cascade's three-stage pipeline in one node. Stage C is the text-to-latent pass (the part that actually talks to your prompt), then stage B and stage A decode that latent back to full pixels. Everything here is fixed internally - DDPM sampler, no sampler picker, no scheduler menu. What you control per stage is steps and CFG, and the defaults are sensible: stage_c_steps 20 with stage_c_cfg 4.0 for the text pass, stage_b_steps 10 with stage_b_cfg 1.1 for the decoder. Don't crank that stage_b CFG; it's a decoding stage and high guidance there just makes things weird.

The inputs a beginner actually touches:

• height / width - INT, 512 to 5120 in steps of 256. Multiples of 256 only, which matches the model's expected grid. The README's VRAM table is your real guide here: about 2048² on a 10 GB card, 3072² on 12 GB, 4096² on 16 GB.
• seed - standard, for reproducing a result.
• dtype - bf16 or fp32. bf16 is the default you want; it's what makes the higher resolutions fit at all. Switch to fp32 only if your card doesn't support bf16 (pre-Ampere) or you're chasing maximum fidelity and have headroom.
• stage_a_tiled - true / false. Turning this on tiles the stage A decode and is your first lever when you're bumping into VRAM at the chosen size.
• prompt - multiline, and the only real "creative" input. No negative prompt here, which is normal for this architecture.

The outputs are image (your render) and edge_preview (more on that below). Wire image to a Preview/Save node and you're done.

ControlNet, the useful extra

The pack ships a canny ControlNet, and it's dead simple: attach any IMAGE (from a standard Load Image node) to the optional controlnet_image input. The node runs its own canny edge detection internally, conditions on those edges, and the controlnet_weight (default 0.7, range 0.01–10) scales how hard it holds. That's the whole control story - no preprocessor choice, no other ControlNet types, just canny. The edge_preview output is exactly what the model sees: the detected edges. Plug it into a preview node once to confirm your reference image is producing useful structure before you burn a five-minute generation.

Reality check

A full 4096×4096 render takes around five minutes on a 4090, per the project's own numbers, so this is a wait-and-read-something node, not an interactive toy. Community interest in UltraPixel peaked hard in mid-2024 and then went quiet - it still works, but treat it as a niche curiosity and don't expect updates. The most common failure is the boring one: VRAM exhaustion, which the README's size table exists to prevent. Drop the resolution, flip stage_a_tiled on, and keep dtype at bf16 before you start blaming the node.

Installing it

Same pack as UltraPixel Load, so the steps are identical: install ComfyUI-UltraPixel via ComfyUI Manager (search "UltraPixel") or clone it into custom_nodes, then pip install -r requirements.txt from inside your ComfyUI venv. The heavy dependency list (insightface, onnxruntime, kornia, a couple of git-URL packages) is where installs tend to die - on Windows, insightface especially. First queue of the Load node downloads ~10 GB of models into ComfyUI/models/ultrapixel, and there was once a download bug with stage_b_lite_bf16.safetensors; if a download stalls, update the pack and re-run.