📐 Krea 2 Tiled Diffusion

Krea 2 is a hard model to upscale the classic way. The usual tiled trick is ControlNet Tile feeding the source into a KSampler per tile, and on a CFG-1, vision-language DiT that whole approach barely applies - there's no ControlNet Tile for it, and even if there were, tiles forget where they sit on the big canvas. This node is the fix for that specific problem: a Krea 2–native tiled diffusion upscaler from the FiL_Design_ImageMind pack. The clever part is that each tile is conditioned on the crop of your source image that it actually covers, with RoPE position offsets so the model knows the tile's real coordinates on the output canvas. You get back a multi-thousand-pixel image that holds the original's identity instead of drifting into a dozen different paintings.

The name is a bit of a lie in a good way - despite the pack being full of LLM/vision-API nodes, this one is pure local diffusion. No API key, no provider. What it does need is the whole Krea 2 stack: the model checkpoint, the Qwen3-VL text encoder, and the Qwen-Image VAE (~250MB). If you're missing any of those three, it won't behave - that "broken model" report on r/StableDiffusion was usually someone skipping the encoder.

How it actually works

Under the hood (the pack's common/krea2_engine.py) it's a real pipeline, not a wrapper. Your image is scaled by upscale_factor - through an optional AI upscale model like DAT-2 if you plug one into the upscale_model socket, plain resize otherwise. That scaled version is VAE-encoded into the target latent, split into an overlapping tile grid, then each sampling step denoises the tiles separately and fuses them under raised-cosine feathering weights so seams don't show.

Two things stop the tiles from diverging - the failure mode that makes naive tiled diffusion look like a quilt:

• Per-tile vision conditioning. Krea 2's text encoder is a vision-language model, and the node exploits it: each tile is conditioned with a crop of the source covering that tile's area, plus your prompt. vision_weight (default 1.4) is the attention weight those image tokens get. No ControlNet Tile needed - the model literally sees the source.
• RoPE canvas coordinates. A model patch shifts each tile's position IDs to its true offset on the output canvas. Without it, tiles treated as top-left repeat artifacts across the grid.

After sampling it decodes and runs the polish pass: texture_injection re-adds high-frequency microtexture (pores, hair, fabric weave) from the source, masked by a Sobel edge map so it boosts detail along real edges without smearing noise onto flat skin. color_match finishes it - luminance transfers the source's chroma while keeping your generated luminance; wavelet splices in the source's low frequencies.

The knobs that matter

Defaults are honestly sensible; change a handful.

• denoise - 0.20–0.25 for a faithful upscale, which is why the default is 0.22. Push past 0.35 and you're not upscaling anymore, you're reimagining.
• steps - 8, which is optimal for Krea 2 Turbo's distilled timesteps. CFG is fixed at 1.0, sampler euler - this is a Turbo-shaped node.
• tile_grid - auto picks the smallest grid that keeps tiles under ~1024px, which is the right starting point. Drop to 1x1 if you're gentle, or go up to 4x4 for monster canvases and pay in time.
• identity_lora_name - picks from your LoRA folder if you want to hold a character across the upscale.

Outputs are image (the finished upscale) and latent (the denoised latents, if you want to keep sampling). Save the image, done.

Installing it

ComfyUI Manager → search FiL_Design_ImageMind, or:

cd ComfyUI/custom_nodes
git clone https://github.com/FiL-Design-Ai/FiL_Design_ImageMind.git
pip install -r FiL_Design_ImageMind/requirements.txt

Dependencies are light - requests, aiohttp, Pillow, numpy, pydantic - no heavy wheels. The real download is the Krea 2 model files themselves. You need ComfyUI 0.3.60+ (the pack targets the V3 node API); the node lives under 🎨 FiL Design → 🖼️ Image.

Where people get burned

• Connect an image or a latent - the node raises ValueError otherwise. The image input is optional only because latent is an alternative, not because you can skip both.
• Vision-less conditioning. If your clip lacks the vision-encoding path (a plain FLUX text encoder, say), the node silently falls back to text-only encoding and faithfulness drops. Use the Qwen3-VL/Krea2 clip.
• tile_batch_size only helps in that fallback path. With per-tile vision conditioning active the code evaluates tiles one at a time per step, so cranking it to 8 won't speed up a Krea 2 upscale.
• 4x4 grids are slow. Sixteen tiles, each through a multi-billion-parameter DiT per step. Krea 2 is a big model - run the FP8 conversions if you're under ~24GB - and every tile is a full forward pass, so monster grids are a go-make-tea operation.