If you render an 8192 by 8192 image on Nvidia’s Pixel DiT by assembling four independently refined passes, you get one very specific artifact: the joins at x=4096 and y=4096 stay faintly visible. Straight-exposure and white-balance drift between tiles that were each refined on their own — every tiling pipeline lives with it, and most just blur the seams and call it done. seamingly-epic is a native Rust program built for exactly this: “8192x8192 (or higher) grid seamline removal for Nvidia Pixel DiT”, per the repo description. It treats the artifact as a linear algebra problem instead, and the commit history shows a person who found the right formulation in a single afternoon — after first building, verifying, and then replacing a more obvious one.

Tiles Are Nodes, Seams Are Edges

The method is the interesting part. Each tile is a node in a sparse graph; every measured shared boundary is an edge carrying a confidence weight and a robust log-linear RGB jump. The question becomes: what per-tile log gain makes every neighbor’s observation consistent? All boundaries are reconciled at once by a zero-mean weighted least-squares solve over the weighted graph Laplacian:

L_W g = b        where  L_W = B^T W B,   b = -B^T W d

The native engine never materializes that matrix. It pins the constant-gain nullspace with one temporary gauge anchor, solves each RGB channel with a matrix-free conjugate-gradient method under a Jacobi preconditioner, and recenters to zero mean. Storage and every graph iteration stay O(|V|+|E|), and one Laplacian multiplication communicates across exactly one shared boundary — so information travels through the graph the way it actually got there, along real adjacency paths and cycles, with no fictional diagonal or distant-pixel comparisons invented. The engine is bounded-memory by design, and disconnected seam graphs are guarded against up front rather than allowed to fabricate new joins.

The README has a line I keep coming back to: it behaves “much like sparse attention for an image grid.” The Laplacian solve carries valid relationships through every adjacency depth while the detailed evidence stays attached to the boundary that actually measured it. The result is a deterministic graph-and-wave optimization, not a learned model — run it twice, get the same output. In this orbit that’s a feature, not a compromise.

The Cloud That Didn’t Survive The Afternoon

The history contains an architectural pivot that’s easy to miss if you only read the finished README. At 14:38 on August 23 the project documented its first complete solution: the full-image Laplacian correction cloud — a whole-image Poisson-style field that spreads the correction everywhere. A production verification pass completed an hour later, at 14:45. The system worked. It was also, apparently, the wrong shape.

At 16:42 — two hours and a bundled ComfyUI workflow later — the commit log says it plainly: “Replace global cloud with midpoint-anchored seam waves”, with the Comfy diagnostics realigned to match in the same minute. The final method keeps the solved tile values but stops broadcasting them: at each accepted seam, the residual step is split between the two endpoints, and each side is carried inward with a raised-cosine wave — full strength at the join, exactly zero at the center of each adjacent tile. No correction is broadcast across a quadrant; there is no image-wide exposure gauge and no Poisson cloud. The feathering distance is derived from the geometry, not tuned until the seam disappears and the detail dies with it.

That’s the difference between a tool that solves your seam and one that re-lights your image. The wave kernel, the incidence structure, and the Krylov machinery all get the full formal treatment in the README — and the fact that the abandoned cloud exists only in the commit log is how you know the final choice was made, not inherited.

When Photometry Is Not Enough

There are seams a photometric field cannot repair — places where overlapping PiD renders disagree about the geometry of an object, not just its exposure. For that case there’s strucfix, a second independent structural pass that takes two cross references: the 8192x4096 landscape render registered at (0, 2048) and the 4096x8192 portrait registered at (2048, 0). The command validates those dimensions and placements exactly and refuses to guess, resize, or geometrically align a reference — the commits show the references being matched to the canonical base and the cross-reference opacity being localized around the seams, because a structural hint that bleeds across the whole image is just a worse version of the original artifact. If only the exact cross intersection still wants alternate structural evidence, a third pass — centerfix — accepts one seam-free 4096x4096 center render. Same rule: the reference registers where the math says it goes, or it doesn’t run.

The ordinary invocation reflects how small the interface ended up:

seamingly-epic --x 4096 --y 4096 --in myfile.png --out fixed.png

Any number of comma-separated X and Y coordinates defines the tiles and every true shared boundary automatically. No grid dimensions, adjacency depth, sampling plan, or correction strength to supply. And the guarantees are explicit rather than implied: truecolor and smokemap behavior documented, exact-coordinate full-scan correction, source PNG encoding strength preserved on the way out, large-mask feathering hardened, and output tile ordering matched to McBoaty’s pipeline — so a corrected image drops into an existing 8K workflow without surprising anyone downstream.

For People Living In ComfyUI

The repo ships where this work actually happens: the exact SeamFix 2.1 workflow is bundled, native and tutorial-derived ComfyUI nodes land on day one, the complete tutorial repair path is documented, and /workflows/ carries a quick start for new users. The before/after pairs are hosted publicly on Hugging Face, because a seam-removal tool that has to be believed on faith is a seam-removal tool that failed. The final commit of the entire project, six days after everything else, is simply “Push Comfy Node” — the desktop tool mattered, but the people stitching 8K grids live in ComfyUI, and that’s where the last piece went.

Fifty-Eight Commits, Twenty-One Hours

The timeline, with the beats the flat list hides:

  • August 23, 08:18 UTC — first commit documents the architecture and source research; twenty-four minutes later the bounded-memory engine lands. By 08:59 the disconnected-graph guard, the ComfyUI nodes, hardened transports, and the first completed production verification checklist are all in. The midday is pure mathematics: sparse graph explanations, the global f64 seam influence field, highlight and transparent-sample fidelity, the Laplacian cloud, and a second verification pass. The afternoon pivots (SeamFix 2.1 bundle, PNG encoding strength, McBoaty ordering, cloud → midpoint-anchored waves at 16:42), and the evening builds the structural layer: registered cross repair at 17:34, localized reference opacity at 18:19, canonical-base matching at 19:18, registered center repair at 20:27. Twenty-eight commits.
  • August 24, 00:24 UTC — the GitHub repository itself is created (the LICENCE file lands at 00:31; the AGPL-3.0 provenance dates from this moment). Before/after images enter the README at 00:36. Then two overnight sessions of LaTeX bullying — six formatting commits at 00:52–01:02, eighteen more from 05:15 to 05:48 — fixing the wave function equations, removing the alpha function equation, correcting the reference-opacity expressions. The tool was done; the documentation was being held to the same standard as the code.
  • August 30, 08:04 UTC — “Push Comfy Node”.

Fifty-eight commits total, fifty-seven of them inside roughly twenty-one hours. Not a filter, not a model, just the right linear system — solved without allocating a single dense matrix, and revised once when the better answer showed up at 16:42.

github.com/CommanderTurtle/seamingly-epic

xkcd of the day, 8/23 - Archery Feat #3288

xkcd of the day

[rp as ai]