PixelDiT Generate

This is the node that drops the whole latent space. PixelDiT Generate runs NVIDIA's PixelDiT text-to-image model directly in RGB pixel space - no VAE encode, no latent, no VAE Decode anywhere in the chain. Type a prompt, pick a resolution, get an IMAGE. That's it.

Why does that matter? Every mainstream model since SD1.5 generates inside a compressed latent and then decodes, and the encode/decode round-trip is lossy. Pixel-space generation skips that entirely - what the transformer operates on is what you see. The reason everyone doesn't do this is that pixel-space compute scales with pixel count, which is why this node lives at ~1 megapixel rather than offering 4K. It's a different trade, not a free upgrade.

There's a bigger asterisk than the resolution, though: the NVIDIA weights ship under the NSCLv1 license, which limits them to non-commercial research and evaluation. Node code is MIT, but the model itself is not for commercial work. Read that license before you build a product on it.

How it works

PixelDiT Generate loads a pixeldit_1300m_1024px diffusion model and NVIDIA's Gemma 2 2B text encoder (both auto-downloaded from Comfy-Org/PixelDiT on first run), runs the sampler, and outputs pixels. model_precision chooses bf16 (BF16 diffusion + BF16 Gemma) or fp8 (MXFP8 diffusion + FP8 Gemma) - bf16 is the quality pick, fp8 if VRAM is tight. Because it's pixel-space, the output is a real IMAGE immediately; there is no latent to decode and no VAE Decode node waiting at the end. This trips people up exactly once: they look for the missing decode step and assume the workflow is broken.

The inputs that matter

• prompt - the thing you want. Also has a negative_prompt that defaults to NVIDIA's recommended quality exclusions (low quality, worst quality, over-saturated, blurry, deformed, watermark), which you can clear if you prefer no negatives.
• resolution - eight ~1-megapixel presets from 1024x1024 square through portrait, widescreen and 1568x672 ultrawide. Bigger isn't a quality lever here; it's just more pixels to pay for.
• steps - default 30, matching the official ComfyUI PixelDiT workflow. Lowering it much below that degrades fast.
• cfg_scale - default 4.0. This is a real CFG value, unlike the 1.0 you run for PiD decode.
• sampler_name / scheduler - defaults er_sde / simple, which is what NVIDIA's reference workflow uses. There's a full sampler menu if you want to experiment, but the defaults are the tested path.
• seed - for reproducible runs.

It also exposes unload_comfy_before_generation and aggressive_cleanup (both on by default), which free other models' VRAM before the generator loads - helpful since this node is not light.

The whole workflow

PiD Text Prompt -> PixelDiT Generate -> Save Image

Yes, that's the entire graph. If you want a caption on top, PiD Text Prompt gives you text for this node and caption for anything else that wants one.

Setup and gotchas

This is part of the ComfyUI-PiD pack, so install once:

cd ComfyUI/custom_nodes
git clone https://github.com/Merserk/ComfyUI-PiD.git
cd ComfyUI-PiD
python -m pip install -r requirements.txt

or via ComfyUI Manager (search "ComfyUI-PiD"), then restart. This node specifically requires ComfyUI 0.28.0 or newer - older builds simply don't have the native PixelDiT support it calls. If it errors on load, update ComfyUI first, before you start hunting through your custom node list.

Where people get burned: treating it as a drop-in SD replacement (it's ~1MP and slower per image than latent models, which is the structural pixel-space tax, not a bug), and forgetting the NSCLv1 license if they plan to sell output. Within those limits it's a clean, self-contained generator - arguably the easiest node in the pack to just run.