Tessera: Tiled 4K and 8K Video Upscaling for MiniMax H3

H3 is good at short clips at 544p and expensive above that. The existing routes to higher resolution either re-generate the frame at a bigger size and accept a slower, less stable pass, or upscale pixels and lose detail. Tessera takes a third route: keep the source clip as the reference the model already understands, upscale the picture with a neutral resampler, and let H3 re-render each tile of that plate under exact local conditioning.

The pack ships as plain ComfyUI nodes with no extra dependencies, version 1.0.0, and its pyproject.toml carries a [tool.comfy] block (DisplayName = "Tessera", PublisherId = "hashu786") for Comfy Registry publishing.

Source clip at 544p	3840x2176 render from the project's promo video

Tiles anchored to the plate, not to each other

The obvious way to refine a big latent in pieces is to walk the tiles in order and let each one inherit its neighbours' finished border. Tessera's author measured why that fails with H3: registration drift compounds along a row, at +1.5, -2.1, -9.3 and -15.5 px across four tiles, because every tile is being conditioned on the previous tile's guess instead of on the source.

Tessera reverses the dependency. Each tile is denoised against its own crops of the same ground truth:

• DiT references are cropped to the tile window and mapped onto that window's latent grid, so the video reference and the optional image reference show the tile's patch of the frame, not the whole shot.
• Text is re-encoded from the tile's own crop when a clip input is wired. Without it, the stock reference node hands Qwen the whole frame and every tile is told about a subject it may not contain, which the notes call the ghost-subject failure.
• Guides stay on the plate's exact grid, and the node fails fast if they do not match.

Tiles also share one global noise field rather than drawing per-tile noise, and strips along a seam are generated by both neighbours with a 32 px seam_regen band, then blended by weight-normalized accumulation. Two tiles that both saw a strip produce an exact render-to-render crossfade instead of a ghosted blend.

The schedule is one head step and two tail steps

The default sigmas are 1.0, 0.7, 0.4, 0.0: one step with the distilled turbo head, then two euler steps in the fine tail. The in-band guide is treated as a spectrum clamp, so it is noised only for the tail (guide_release 0.8) instead of for the whole run. The head decides structure under full evidence, the tail adds texture under freedom, and by the handoff enough signal is committed that content cannot move.

Measured on the author's reference clip, that combination gives +67% tile-local detail over the frozen-border baseline at near-baseline shimmer, and switching the identical schedule from LMS to euler gave +56% detail while cutting shimmer by about a third. Two head steps is worse, not better: it converges the state onto the soft guide and costs 21% detail, and a distilled turbo model stepped twice through mid sigmas emitted NaNs into the latent in one measured run.

Featureless tiles are skipped rather than sampled. A flat plate crop gives the model zero evidence and total freedom, and the author caught it painting the reference face into empty sky and smoke, worse once per-tile text re-encoding was on. flat_skip (default 4.0) keeps the plate in those windows and gives the sampling time back. The decision is made per tile and per chunk on source pixel energy, since two latent-space metrics were falsified in a row.

Streaming the parts that do not fit

At 4x, a 15 second clip is about 36 GB as a ComfyUI IMAGE in float32, per copy, and the plain graph holds three copies plus two whole-clip encodes. That OOMs on any GPU, which is why Tessera splits the work:

• Streamed Encode upscales and VAE-encodes the source in temporal windows on the H3 17-px block grid, with a 22-px warm-up re-encode per window that is discarded. On a validated 544p to 4K run the peak encode-side pixel buffer was about 5.2 GB, against 57.6 GB for the whole-clip copy that OOM'd the plain graph.
• Streamed Decode assembles the output through one streamed decode, with a disk-backed buffer above 4 GB. A 124-frame 8K canvas had previously died allocating 49.7 GB in the monolithic decode.
• A disk preflight runs before the first tile samples, because the decode's scratch need is knowable at plan time. One 8K sampling run had already spent 8 hours 49 minutes before failing to allocate a 67.6 GB buffer.
• Crash insurance: if the output stage fails anyway, the refined latent is saved as tessera_rescue_<timestamp>.latent and the graph still returns a latent, so LoadLatent plus the streamed decoder recovers the render without resampling.

Long clips in fast motion go through Temporal Dilate / Decimate, which raises the frame rate per span and re-times the output on the way back. The chunk windows are budgeted in real content seconds: dilation divides the content in every window, so the temporal window scales with the dilation factor to keep the same amount of motion structure per window. The planner also snaps every mid-span window start to a multiple of 5 latents, matching H3's own token timing of one head token then four frames per token, after a 15 second test showed a 17-px-frame flicker metronome through every misaligned chunk.

Measured runs

The author's reference run for the 544p to 4K path: a 15 second clip, 617 dilated frames, 18 windows, 24 tiles across 3 snapped chunks, 3 hours in total on one GPU. Frame-to-frame oscillation landed at 2.44% mean and 16.1% peak, against the same clip's 2x reference at 2.32% and 12.3%, with no 17-frame signature left in the autocorrelation.

Runs posted in the Banodoco Discord on the day after release, from people who were not the author:

• LDWorks David, RTX 6000 Pro with BF16 weights: 121 frames, 2K to 4K, 84 refine steps at about 32 s/step, 44 minutes to reach 93%.
• seitanism: 1344x768, 362 frames, temporally dilated to 583 frames and rendered at 2688x1536 in 46:58; a second clip from 1920x1088 to 3840x2176 in 53:08; a third with a Qwen-Image 2.1 still as the frame anchor in 27:48. His read: it does not fix all motion artifacts, but it holds up.
• mdkb, on a 12 GB RTX 3060, tested it against his own 20 minute budget and asked for a low-VRAM recipe. The author's answer was that one is still to come: the shipped defaults target high-VRAM cards.

ComfyUI usage

Install by cloning the repository into ComfyUI/custom_nodes/. The startup console prints [Tessera] loaded 9 node(s) when everything registered.

The bundled workflow wires the source clip as the H3 reference, a Lanczos plate at the chosen scale, an optional Qwen-Image 2.1 first-frame anchor, and the LoRA pair the author uses as a house recipe (the LMS detail LoRA from Alissonerdx's H3 pack and a 3-step turbo LoRA). It targets 4x on a 544p source, ending at 3840x2176.

The Tile Plan node in the promo video: grid, chunks and predicted cost before a run.

Models used by the example: MiniMax H3 ref2va (the pruned int8 build in the author's setup), the H3 video and audio VAEs, the Qwen3-VL text encoder, plus the optional Qwen-Image 2.1 checkpoint with its turbo LoRA and texture-fix VAE for the anchor still. The workflow also expects the SAM3 and KJ node packs for the optional hero mask and preview nodes.

Limits worth knowing

• The example is wired for one target. The expected output size and the scale factor are separate widgets; both have to match the clip you load. One Discord tester ran the shipped workflow on a different clip expecting 2x and got a 4K canvas that he judged worse than his source.
• The still anchor is a 2x tool. At 4x and above the notes recommend leaving it unplugged and letting the model render the head, because the splice crossfades between two different renderings of the same texture.
• Source shimmer is inherited. A low-res source whose own fine band churns upscales into magnified swimming: refinement lifts coherence toward roughly 0.75 and cannot go past it.
• Scene cuts are advisory. The cut oracle prints the frames it found and recommends splitting the clip there; short shots inside one window cannot satisfy both the head-timing rule and the content-time budget.
• Second hops enter at reduced sigma, for example 1.0, 0.923, 0.55, 0.0, and the second hop's plate should be the first hop's output, not a re-softened intermediate.

Availability

• hashu786/ComfyUI-Tessera on GitHub, with example_workflows/tessera_upscaler.json and the full engineering notes in docs/LAWS.md
• pyproject.toml carries the [tool.comfy] block for the Comfy Registry (DisplayName = "Tessera"); at scan time the package was not yet listed there, so install it from the repository
• Reference frames in this article are frames from the project's promo video, which compares the 544p source against the 4x render