Tiled Image Generator

When you look at an 11,519 × 7,936 pixel AI image, the assumption is someone welded crops together for weeks. Roope Rainisto's The Swimming Hall - the piece that went through Christie's "Augmented Intelligence" auction in early 2025 - was built smarter: he wrote 24 small prompts, one per region of the frame, and stitched them into one seamless canvas. That's the Brenizer method applied to image generation, and TiledImageGenerator is the turnkey version of it. A single prompt targets the whole image; tile-specific prompts let each region of the composition get its own generative pass, directed by a model that already imagined the whole. This is the node for Where's-Waldo-scale detail - dense crowds, city blocks, giant interior scenes - where one prompt just melts into mush.

Mechanically it's a familiar KSampler wearing a different hat. You wire the same model, CLIP, VAE, sampler, scheduler, steps, and CFG you always do, plus one unusual thing: a JSON blob of per-tile prompts. The node then generates each tile with its own prompt, with each tile after the first starting from its already-generated neighbor's overlapping edge, and feathers the results into one big canvas.

The centerpiece input is json_tile_prompts (a multiline string). The format is a JSON array where each object has a 1-indexed position (x is column, y is row) and a self-contained prompt. It must contain exactly grid_width × grid_height objects or the node will refuse. Tiles process left-to-right, top-to-bottom, and each increments the base seed by one so neighbors stay distinct but deterministic.

The few inputs a beginner actually sets:

• grid_width / grid_height (default 4×6, up to 16×16). At 1024² tiles that's a 4K×6K image - mind your VRAM before you push 8×8.
• tile_width / tile_height (default 1024), and overlap_percent (default 0.15; 15–25% is the sweet spot for hiding seams).
• global_positive / global_negative - appended to every tile at generation time. Put your style tokens, medium, and lighting register here; repeating them in each tile prompt doubles them and wastes context.
• seamlessX / seamlessY - wrap the last row/column into the first, for tiling textures and repeating patterns.
• control_strength (default 0.7) - how hard the coherence signal pulls.

The subtle part is coherence, and it's where most people get burned. For SDXL or Flux, wire a tile/inpaint ControlNet into the optional controlnet input. If it's an SDXL Union model (ControlNet++), it does nothing until you set its control type - insert SetUnionControlNetType, set it to tile or repaint, and only then does the neighbor-pixel conditioning kick in. Skip that and you get a checkerboard of independent tiles. For z-image Turbo or Qwen, the path is different: load a DiffSynth/Fun inpaint model (e.g. Z-Image-Turbo-Fun-Controlnet-Union 2.1) with ModelPatchLoader and connect it to the model_patch input instead. With neither wired, the node happily falls back to independent per-tile generation - seams and all.

Outputs are composite_image (the stitched result) and individual_tiles (every tile as a batch). Wire composite into a PreviewImage or SaveImage and you're done.

Install is boring in the good way: no pip deps beyond numpy/Pillow/torch, and no model downloads beyond the checkpoint and ControlNet you already use.

cd ComfyUI/custom_nodes
git clone https://github.com/rickyars/comfyui-llm-tile.git

Restart ComfyUI (or search "Tiled Image Generator" in ComfyUI Manager). The common failure modes are JSON errors - trailing commas, 0-indexed positions, wrong object count - plus the Union control type not being set. Start with a 2×3 grid, prove the seams, then scale up. The README ships an LLM prompt template that's genuinely good: tell the model to imagine the finished image first, then describe each tile, 30–80 words per tile, raw JSON out. Paste that output straight into json_tile_prompts.