@@ -512,8 +512,10 @@ namespace sd::backend_fit {
         } else if (tiling_params.rel_size_x > 0.f && tiling_params.rel_size_x <= 1.f &&
                    tiling_params.rel_size_y > 0.f && tiling_params.rel_size_y <= 1.f &&
                    std::max(tiling_params.rel_size_x, tiling_params.rel_size_y) > min_rel_size) {
-            tiling_params.rel_size_x = std::max(tiling_params.rel_size_x * 0.5f, min_rel_size);
-            tiling_params.rel_size_y = std::max(tiling_params.rel_size_y * 0.5f, min_rel_size);
+            // An axis already below the floor keeps its size: clamping it up would grow the tile that just failed.
+            auto shrink              = [&](float rel) { return rel > min_rel_size ? std::max(rel * 0.5f, min_rel_size) : rel; };
+            tiling_params.rel_size_x = shrink(tiling_params.rel_size_x);
+            tiling_params.rel_size_y = shrink(tiling_params.rel_size_y);
             if (tiling_params.target_overlap <= 0.f) {
                 tiling_params.target_overlap = 0.5f;
             }
 
@@ -62,8 +62,8 @@ int sd_tiling_seam_safe_tile_size(int small_dim, int tile_size, float tile_overl
     // sd_tiling_calc_tiles lets the real overlap fall well below the target for some sizes. The worst case is a
     // tile a little over half of the axis (e.g. round(dim / 2)): it falls back to two tiles overlapping by
     // 2 * tile_size - small_dim, which is 0 or 1 latent, so the cross-fade has nothing to blend over and the tile
-    // edge shows as a line. Pick the nearest tile size (smaller first, so memory use never grows unless nothing
-    // smaller works) whose tiles overlap by at least half the target and never by less than 2 latents.
+    // edge shows as a line. Pick the nearest tile size (smaller first; a larger one only up to twice the request,
+    // so an explicitly small tile cannot balloon) whose tiles overlap by at least half the target and by 2+ latents.
     const int min_tile_size = 4;
     if (tile_overlap_factor <= 0.f || tile_size >= small_dim) {
         return tile_size;
@@ -81,7 +81,7 @@ int sd_tiling_seam_safe_tile_size(int small_dim, int tile_size, float tile_overl
             return size;
         }
     }
-    for (int size = tile_size + 1; size < small_dim; ++size) {
+    for (int size = tile_size + 1; size < small_dim && size <= 2 * tile_size; ++size) {
         if (overlaps_enough(size)) {
             return size;
         }
Original file line number	Diff line number	Diff line change
`@@ -62,8 +62,8 @@ int sd_tiling_seam_safe_tile_size(int small_dim, int tile_size, float tile_overl`
`62`	`62`	`// sd_tiling_calc_tiles lets the real overlap fall well below the target for some sizes. The worst case is a`
`63`	`63`	`// tile a little over half of the axis (e.g. round(dim / 2)): it falls back to two tiles overlapping by`
`64`	`64`	`// 2 * tile_size - small_dim, which is 0 or 1 latent, so the cross-fade has nothing to blend over and the tile`
`65`		`- // edge shows as a line. Pick the nearest tile size (smaller first, so memory use never grows unless nothing`
`66`		`- // smaller works) whose tiles overlap by at least half the target and never by less than 2 latents.`
	`65`	`+ // edge shows as a line. Pick the nearest tile size (smaller first; a larger one only up to twice the request,`
	`66`	`+ // so an explicitly small tile cannot balloon) whose tiles overlap by at least half the target and by 2+ latents.`
`67`	`67`	`const int min_tile_size = 4;`
`68`	`68`	`if (tile_overlap_factor <= 0.f \|\| tile_size >= small_dim) {`
`69`	`69`	`return tile_size;`
`@@ -81,7 +81,7 @@ int sd_tiling_seam_safe_tile_size(int small_dim, int tile_size, float tile_overl`
`81`	`81`	`return size;`
`82`	`82`	`}`
`83`	`83`	`}`
`84`		`- for (int size = tile_size + 1; size < small_dim; ++size) {`
	`84`	`+ for (int size = tile_size + 1; size < small_dim && size <= 2 * tile_size; ++size) {`
`85`	`85`	`if (overlaps_enough(size)) {`
`86`	`86`	`return size;`
`87`	`87`	`}`