# ComfyUI TTP Toolset: tiling an image around the things that need detail > A set of ComfyUI custom nodes for upscaling, and the interesting one is Smart Tile 2.0, which replaces a uniform grid with variable-size tiles laid out around the structure of the image, a face or a pair of hands, processes one tile at a time through the sampler, and assembles the result back with masks, feathering and a priority order. **TTPlanetPig/Comfyui_TTP_Toolset** — for tile the image for advanced control or modification - Repository: https://github.com/TTPlanetPig/Comfyui_TTP_Toolset - Stars: 1,044 · Forks: 43 - Language: Python - License: MIT - Published: 2026-10-19 · Updated: 2026-10-19 · Language: en - Canonical page: https://hysenlabs.com/projects/ttplanetpig-comfyui-ttp-toolset ## What the toolset actually contains The ComfyUI TTP Toolset is a collection of tiled upscale, Smart Tile, video sampler, coordinate and conditioning helper nodes, and the README is organised as a table of feature blocks with a status column for each. Smart Tile 2.0 is the current main feature, described as an object-aware variable-size tile workflow for detail img2img upscale. TTP Tile 1.0 is the legacy workflow, fixed-grid image tiling and assembly for classic upscale workflows. The coordinate and conditioning utilities are helper nodes for coordinate splitting, condition batching and condition merging. The LTX workflow examples are example workflows for first and last frame and middle-frame control. And TeaCache for Hunyuan Video is an extra tool for faster Hunyuan Video sampling. So the toolset is not one feature but a small shelf of them, and the shelf is what the documentation calls it: a set of nodes rather than a workflow. The example workflows in the `examples/` directory are the other half of the deliverable, and they include a Flux 8 megapixel upscale, an LTX first and last frame workflow, a Hunyuan Video TeaCache sampler, a smart tile example with a Qwen and SAM loop, and a Krea edit example. The package metadata describes the intent in one long sentence: a workflow for a simple logic amazing upscale node for DIT models, common use for Flux, Hunyuan and SD3, which can tile the initial image into pieces and then use an image-interrogator to get each tile's prompts for a more accurate upscale, with the condition properly handled and the hallucination significantly eliminated. That last clause is the design goal stated plainly. Tiling an image and running img2img over each piece tends to invent detail that was not in the original, and the tile-by-tile prompting is the attempt to reduce that, by giving each region the prompt that actually describes it. ## Smart Tile: variable-size tiles laid out around structure The difference between Smart Tile and a grid is the whole product, and the README states it directly: instead of cutting every image into equal squares, it lets you build variable-size tiles around visual structure, naming face, eyes, hands, text, subject, clothing, foreground details and background and context regions. So the tile plan is a description of the image, and a face gets a small tile and the background gets a large one. The list of problems it solves makes the reasoning concrete. It avoids cutting important objects through the middle when a simple grid would split a face, a hand or text. It allows different tile sizes, so a face tile can be small and high detail while the background stays large. It sends one tile at a time through img2img, so the number of tiles can be 4, 8, 16, or anything produced by the editor. It keeps high-detail focus tiles visible during assembly with priority, layer and semantic ranking. And it supports mask-aware pasteback, soft detail overlay, final-only assembly and a black-base canvas mode. That is the design in a sentence: the detail budget is spent where the detail is. The workflow it fits is described as one where small areas need more detail than the full image, which is what happens when a source image is small and the output is large, and where a single img2img pass over the whole image has no resolution to spend on a face. And the assembly step is where the work is: the processed tiles are pasted back with feathering, masks, color correction, priority, optional GPU paste and optional alignment, so that the seams between a small face tile and a large background tile are not visible. ## The editor and the layout that lives in a hidden widget The entry point is the `TTP Smart Tile Interactive Crop` node, which the README calls the recommended starting point. It can load an image the way ComfyUI's official Load Image does, or receive a connected `source_image`. The editor stores the current layout in a hidden `layout_json` widget, and the reason for that is stated: so the workflow keeps the tile plan. That is a small design decision with a large consequence, because a layout that only lives in the editor session is a layout that has to be redone every time, and a layout that is saved into the workflow is a layout that travels with the pipeline. The editor actions are the vocabulary for building that plan. `Replace grid` replaces the whole layout with an even grid. `Grid in T#` subdivides the selected tile without rebuilding the whole layout. `Show masks` and `Hide masks` toggle a coloured overlay for tile object masks. `Stitch mask` and `Raw masks` preview the hardened and feathered replace-paste mask shape without changing the saved masks. `Mask to Tile` turns painted regions into object tiles. `Merge masks` shift, cmd or ctrl selects multiple tiles and unions their cropped object masks back onto the selected tiles. `Merge tiles` does the same selection and replaces them with one larger tile, with existing masks unioned into the merged tile when available. `Refresh masks` re-crops the inherited masks to the current tile boxes after manual edits. `Fill gaps` adds background tiles for uncovered areas. `Auto Tile` runs SAM3.1 or QwenVL3 detection and writes the detected layout back into the editor. `Auto SAM` runs SAM3.1 detection and keeps only the detected object tiles without automatic gap filling. The subdivision rules are also documented. When you subdivide a masked tile with `Grid in`, the Mask mode can crop the original object mask into the child tiles or skip empty mask children, and the child tiles keep a parent mask source, which is what lets `Refresh masks` update them after a manual edit. ## Sixteen nodes and a loop that replaces a duplicated sampler chain The core node table is the reference for the whole thing, and it is worth reading as a pipeline rather than as a list. `TTP Smart Tile Interactive Crop` loads or connects an image and creates the manual, painted or automatic tiles, outputting a variable-size `tile_set`. `TTP Smart Tile Set Preview` previews a tile set as a contact sheet or one selected tile. `TTP QwenVL3 Local Loader` loads a local QwenVL tagging model from `ComfyUI/models/text_encoders`. `TTP Smart Tile QwenVL Prompt Set Builder` generates per-tile prompts before the loop. `TTP Smart Tile Prompt Override` filters selected tiles and replaces, prepends, appends or finds and replaces in the per-tile prompts before sampling. `TTP Smart Tile Composite Override` sets the composite mode, replace shape, layer, priority, occlusion priority, blend and importance before assembly. `TTP Smart Tile Stack Order` puts tiles such as `T1,T3,T2` at the front in that order, leaving unlisted tiles behind. `TTP Smart Tile Semantic Rank` classifies tiles and writes recommended layer, priority, scale weight and composite metadata. The loop is the fourth pair of nodes. `TTP Smart Tile Loop Source` outputs one tile at a time for the VAE Encode, sampler and VAE Decode, and `TTP Smart Tile Loop Collect` collects each processed tile back into the same tile set. The README is explicit that these two should be used instead of manually duplicating sampler chains: the loop source outputs the current tile image and the current tile prompt, and after the sampler finishes, the loop collect stores the result and advances to the next tile. The rest of the table closes the loop. `TTP Smart Tile Image Upscale Prep` optionally upscales or resizes each tile before sampling, with a megapixel cap. `TTP Smart Tile Output Size Estimate` estimates the final output scale and resolution from the processed tile sizes. `TTP Smart Tile Assemble` pastes the processed tiles back with feathering, masks, color correction, priority, optional GPU paste and optional alignment. And `TTP Smart Tile Save Final Image` saves only the final completed loop result and embeds the workflow metadata. The recommended order of those nodes is in the README as a plain text diagram, and it is the clearest statement of the intended pipeline: ```text TTP Smart Tile Interactive Crop -> TTP Smart Tile QwenVL Prompt Set Builder (optional) -> TTP Smart Tile Prompt Override (optional) -> TTP Smart Tile Composite Override (optional) -> TTP Smart Tile Semantic Rank (optional) -> TTP Smart Tile Loop Source -> VAE Encode / Sampler / VAE Decode -> TTP Smart Tile Loop Collect -> TTP Smart Tile Semantic Rank (optional final refresh) -> TTP Smart Tile Stack Order (optional final manual order) -> TTP Smart Tile Output Size Estimate (optional) -> TTP Smart Tile Assemble -> TTP Smart Tile Save Final Image ``` Note how many of the steps are optional and how the two ranking and ordering steps appear twice, once before the loop and once after it. The first pass ranks the tiles for the sampling stage, and the second pass ranks them for the assembly, which is the difference between a tile that is important to the sampler and a tile that is important to the final composite. ## Automatic tiling with SAM3.1 and a local QwenVL model Two of the editor actions run models, and they do it in a way that keeps the layout in the editor rather than replacing it. `Auto Tile` runs SAM3.1 or QwenVL3 detection and writes the detected layout back into the editor, so the detections become an editable starting point rather than a fixed answer. `Auto SAM` runs SAM3.1 detection and keeps only the detected object tiles, without automatic gap filling, which is the variant for somebody who wants the objects and nothing else. The QwenVL side is a local model. `TTP QwenVL3 Local Loader` loads a local QwenVL tagging model from `ComfyUI/models/text_encoders`, and `TTP Smart Tile QwenVL Prompt Set Builder` generates the per-tile prompts from those tags. So the model runs on the machine, the tags are the input to the prompt builder, and the prompts are then editable per tile through the override node. That chain is what connects the two halves of the tool. The detection half answers what is in the image and where, and the tagging half answers what to say about each region, and the per-tile prompt override is where a human corrects either. The remaining example workflows show the toolset used in the other directions, with a TeaCache sampler for Hunyuan Video, the LTX first and last frame and middle-frame control workflows, and the LTX control implementation living in its own module in the repository, `LTXVFirstLastFrameControl_TTP.py`, next to the main `TTP_toolsets.py`. ## Packaged for the Comfy Registry, with a version number that moves on its own The packaging is small and the metadata is what a ComfyUI custom node pack needs. The project metadata names the package `comfyui_ttp_toolset`, version 1.0.5, with the licence read from the `LICENSE` file, and it carries a `[tool.comfy]` section with a `PublisherId` of `ttplanet`, a `DisplayName` of `Comfyui_TTP_Toolset` and an icon. The comment beside the URLs records that this is used by the Comfy Registry, so a node pack published there is discoverable by ComfyUI users the way a published package is discoverable on PyPI. The releases and the package version tell two different stories, and the difference is worth noting. The GitHub releases are V1.0.3 and V1.0.3fix, both from 2026-01-08, and v1.0.2 from 2025-04-20, while the package metadata says 1.0.5. The last push was on 2026-09-14, and the project is not archived, so the work is continuing between releases and the version in the metadata moves with it. The repository layout is what a ComfyUI node pack looks like. There is `TTP_toolsets.py` with the main node implementations, `LTXVFirstLastFrameControl_TTP.py` for the LTX frame control, an `__init__.py` for the ComfyUI entry point, a `web/` directory for the custom editor interface, a `scripts/` directory, a `docs/` directory with the pipeline diagrams referenced from the README, and the `examples/` directory holding the example workflows as JSON and the example outputs as images. ## Where this toolset is the wrong tool The limits here are a matter of proportion, and the toolset itself hints at them by keeping a legacy grid workflow around. The first is that the cost is per tile. Every tile is a pass through the sampler, and the node list includes an upscale prep step with a megapixel cap precisely because a large tile at high resolution is expensive. A grid of sixteen tiles on a 4 megapixel source is sixteen generations, and the whole point of the tool is that the tiles should be fewer and better aimed, which means the layout work is not optional overhead but the thing that makes the cost acceptable. The second is the interactive part. The recommended entry point is an editor node, and the automatic detection is a starting point for a human to correct rather than a finished plan. So the workflow is not reproducible in the way a fixed grid is: the layout lives in a hidden widget inside the saved workflow, and the corrections a person makes are corrections to that widget. For a pipeline that has to run the same way on a hundred images, that is a real constraint, and it is the kind of thing to check before building a production path on it. The third is that the toolset is a shelf. There are five feature blocks, and the coordinate and conditioning helpers and the LTX examples and the TeaCache sampler are tools for particular workflows rather than parts of a coherent whole. A user who wants one of them gets it, and a user who wants a general upscaler gets a node pack with a lot of options. The alternative, for somebody whose problem is that a grid cuts a face in half, is the legacy TTP Tile 1.0 fixed grid with a mask, or a plain tiled img2img workflow assembled by hand in ComfyUI. The difference in approach is that this toolset moves the layout from a geometric grid to a semantic description of the image, and the price is the editor session, the per-tile prompts and the fourteen nodes that express the assembly. For an image with a face and a line of text, that price is worth paying. For an image of a landscape, it is not, and the fixed grid is the right answer. ## Conclusion The TTP Toolset fits a ComfyUI user who upscales with img2img and keeps cutting a face or a line of text in half with an even grid, and who is prepared to lay out tiles by hand or with a detector. It is the wrong tool for a plain upscale where a grid is enough, because the cost of the tool is the layout work, the prompt per tile and the assembly settings, and it is the wrong choice for a team that needs reproducible output, since the editor stores the layout in a hidden widget and the tiles come out of an interactive session. Before adopting it, look at the example workflows in the `examples/` directory, since they show the whole loop wired up, and check the node count against the number of tiles your images actually produce, because every tile is another pass through the sampler. ## FAQ ### What does the ComfyUI TTP Toolset do? It is a set of ComfyUI nodes for tiled upscale, Smart Tile, video sampling and coordinate and conditioning helpers. Its main feature is Smart Tile 2.0, an object-aware tiled img2img workflow with automatic layout, per-tile prompts, loop processing, semantic priority, mask-aware assembly and final-only saving. ### How do I choose the tiles in the Smart Tile editor? With the TTP Smart Tile Interactive Crop node, which can load an image like ComfyUI's Load Image or take a connected source_image. The editor actions include Replace grid, Grid in, Show and Hide masks, Mask to Tile, Merge masks, Merge tiles, Refresh masks, Fill gaps and Auto Tile, and the layout is stored in a hidden layout_json widget so the workflow keeps the tile plan. ### What do TTP Smart Tile Loop Source and Loop Collect do? The loop source outputs one tile at a time, as an image and a prompt, for the VAE Encode, sampler and VAE Decode chain, and the loop collect stores each processed tile back into the same tile set, so the sampler chain does not have to be duplicated by hand. ### How are the tiles detected automatically? The Auto Tile action runs SAM3.1 or QwenVL3 detection and writes the detected layout back into the editor, and Auto SAM runs SAM3.1 detection and keeps only the detected object tiles without automatic gap filling. The QwenVL model is loaded locally from ComfyUI/models/text_encoders. ## Sources - [Issues](https://github.com/TTPlanetPig/Comfyui_TTP_Toolset/issues) - [License: MIT](https://github.com/TTPlanetPig/Comfyui_TTP_Toolset/blob/main/LICENSE) - [README](https://github.com/TTPlanetPig/Comfyui_TTP_Toolset/blob/main/README.md) - [Releases](https://github.com/TTPlanetPig/Comfyui_TTP_Toolset/releases) - [TTPlanetPig/Comfyui_TTP_Toolset on GitHub](https://github.com/TTPlanetPig/Comfyui_TTP_Toolset) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ttplanetpig-comfyui-ttp-toolset