L2P Z-Image Generate

This is the half of the ggf-ltp-zimage pack that does the work. The loader next to it hands you a ready-built pipeline; this node takes that pipeline plus a prompt and returns a perfectly normal IMAGE tensor you can drop into a Preview or Save node. Nothing exotic about the wiring - the exotic part is what happens in between.

Because L2P Z-Image is a pixel-space model. Where every model since SD 1.5 diffuses in a compressed latent and lets a VAE decode the result, this one has no VAE at all. The transformer operates directly on pixels, so there's no encode/decode round-trip to accumulate loss across passes. That's the whole pitch of L2P (Latent-to-Pixel, from Nanjing University with Tencent Youtu Lab): instead of training a pixel-space model from scratch, they took Z-Image Base, froze the middle layers, and retrained only the shallow ones to output pixels. The checkpoint you're running is Base-derived, which matters more than the architecture trivia: treat it like Z-Image Base, not Turbo. Turbo's famous "8 steps, CFG 1" recipe does not apply here. The pack's defaults - 30 steps, CFG 2.0 - are in the right Base-ish ballpark (the community settled on 25–50 steps and CFG 3–5 for Base), and the negative prompt field does something.

Mechanically, the node calls the bundled diffsynth pipeline with a flow-matching scheduler, runs however many steps you asked for, and converts the PIL output straight into a 0–1 float IMAGE. A couple of details worth knowing: randomize_seed defaults to on, so every run rolls a fresh seed (flip it off when you're chasing one specific output), and the node flushes the CUDA cache before each generation so a long ComfyUI session doesn't slowly leak VRAM between runs.

The inputs that actually matter:

• prompt - multiline natural-language prose, closer to Flux than to Danbooru tags. The Qwen3-4B encoder is bilingual; community testing says Chinese prompts measurably improve adherence, but don't over-rotate on day one.
• negative_prompt - works here because this is Base-derived (on Turbo it would do nothing at CFG 1). The bundled workflow ships with bad quality, low quality, blurry, artefacts; that's a fine start.
• steps (default 30) and cfg_scale (default 2.0) - your first two knobs. Fewer steps for iteration, more for finals.
• width / height (256–4096, step 16) - stay in the model's native 1–2MP range; beyond ~2MP the quality starts falling apart.

The output is a single IMAGE, so it plugs into PreviewImage, SaveImage, or anything else that eats an image. The pack's starter workflow is exactly loader → generate → preview.

Install and models

Install the pack once (this node and the loader come together): clone it into custom_nodes and install its requirements, then restart ComfyUI. ComfyUI Manager can also find it by searching "ggf-ltp-zimage".

cd <ComfyUI>\custom_nodes
git clone https://github.com/gjnave/ggf-ltp-zimage.git
cd ggf-ltp-zimage
<ComfyUI>\venv\Scripts\python.exe -m pip install -r requirements.txt

You still need the model files - the repo has no weights. All three pieces (the ~20GB L2P checkpoint, the Qwen3-4B text encoder, and the Z-Image tokenizer) get selected in the loader's dropdowns; this node just consumes them. The README has exact hf download commands with the right renames.

The honest warning: it's slow

This is not a daily driver, and nobody should sell you on it as one. Pixel-space compute scales with pixel count, which is the entire reason latent diffusion was invented. The L2P checkpoint measures around 20GB, so most people are offloading on anything below a 40/50-series card, and the first community ComfyUI wrapper for L2P reported twenty-minute generations at 512×512 on an 8GB card. On a 12–16GB card you'll get minutes per image, not the ~30 seconds Turbo is known for. It's a fascinating "look, no VAE" research conversion - great for recursive editing experiments where avoiding the encode/decode cycle is the point, and a lesson in why the VAE exists in everything else.

If it looks like the node is hanging on first run, it isn't - that's the 20GB checkpoint loading upstream in the loader. Give it a minute, then watch it chew through steps.