Upscaling a MiniMax H3 clip to 4K usually ends the same way: an out-of-memory error at the VAE encode. Tessera is a new ComfyUI node pack built to get past that wall.
It refines your clip tile by tile and window by window, so the full 4K or 8K video never sits in memory at once. The trade-off is time: real 4K renders take from about 30 minutes to several hours.
This guide covers what Tessera does, how to install it, the exact model files, the settings that matter, honest timings from early users, and when a lighter upscaler is the better pick.
- What: ComfyUI-Tessera by hashu786 (released 30 October 2026, MIT licence). A tiled, streamed refiner that upscales MiniMax H3 clips to 2K, 4K or 8K.
- Install:
git clone https://github.com/hashu786/ComfyUI-TesseraintoComfyUI/custom_nodes/. No extra pip packages. - Models: MiniMax H3 ref2va + H3 video/audio VAEs + Qwen3-VL text encoder, plus Alissonerdx’s LMS detail LoRA. Qwen-Image 2.1 and SAM3 are optional.
- Key trick: Streamed Encode peaked at about 5.2 GB where a whole-clip copy needed 57.6 GB.
- Speed: about 27-53 minutes for 2K/4K test clips on big cards; one 15-second 544p-to-4K job took about 3 hours. No finished 8K timing yet.
- 16 GB users: set the tile presets to
low_vram, run Tile Plan first, and start at 2x. A tested low-VRAM recipe is still “to come” from the author.
What Is Tessera?
Tessera is a ComfyUI custom node pack from developer hashu786, version 1.0.0. It is described as a production video upscaler built on MiniMax H3.
It does not use a separate upscaling network. Instead it takes a simple Lanczos-enlarged copy of your clip and lets MiniMax H3 itself re-draw the detail, one tile and one time-window at a time.
That makes it a generative upscaler. It can add real texture to skin, fabric and foliage, but it can also invent detail, which is why the pack includes “anti-hallucination” tile skipping.
Note: Tessera is built for MiniMax H3 clips. The docs do not say whether it works on footage from other models, and the example workflow uses the source clip as the H3 reference.
How Tessera Avoids Out-of-Memory Errors
A 15-second clip upscaled 4x is huge. As a float32 image batch it is about 36 GB per copy, and a normal ComfyUI graph keeps several copies alive.
Tessera changes three things:
- Streamed encode and decode: the clip is encoded and decoded in temporal windows, so the full-resolution pixels never sit in RAM at once. The author measured a 5.2 GB peak against 57.6 GB for the whole-clip copy.
- Spatial tiles with seam repair: each frame is split into tiles, and a 32-pixel band along each seam is regenerated so joins do not show.
- Temporal chunks: long clips are refined in chunks aligned to H3’s latent grid, with a short warm-up re-encode per window to keep motion consistent.
If the final decode crashes, the refined latent is saved as tessera_rescue_*.latent, so you can recover hours of work without sampling again.
How to Install ComfyUI-Tessera
At launch the pack was not yet in the Comfy Registry, so install it with git.
- Open a terminal in your custom nodes folder.
cd ComfyUI/custom_nodes - Clone the repo.
git clone https://github.com/hashu786/ComfyUI-TesseraThe pack lands in
ComfyUI/custom_nodes/ComfyUI-Tessera/. - Restart ComfyUI. No
pip installis needed. The console should print[Tessera] loaded 9 node(s). - Install the helper packs the example workflow uses: ComfyUI-KJNodes for preview nodes, and a SAM3 node pack only if you want the optional hero-subject mask.
- Open the example: drag
ComfyUI/custom_nodes/ComfyUI-Tessera/example_workflows/tessera_upscaler.jsononto the canvas.
Tip: on the Windows portable build, run the git command inside ComfyUI_windows_portable\ComfyUI\custom_nodes. My must-have custom nodes guide explains Manager installs vs git installs.
Model Files You Need (and Where They Go)
Tessera uses your existing MiniMax H3 setup. If you already make H3 videos, you probably have most of these.
| Model | Role | Folder |
|---|---|---|
| MiniMax H3 ref2va diffusion model (the author used a pruned int8 build) | Re-draws detail | ComfyUI/models/diffusion_models/ |
H3 video VAE, e.g. minimax_h3_video_vae_int8_convrot.safetensors |
Encode/decode video | ComfyUI/models/vae/ |
H3 audio VAE, minimax_h3_audio_vae_fp32.safetensors |
Keeps the audio track | ComfyUI/models/vae/ |
Qwen3-VL text encoder, e.g. qwen3vl_4b_int4_convrot.safetensors + ClipProj |
Prompt conditioning | ComfyUI/models/text_encoders/ |
| LMS detail LoRA from Alissonerdx/Minimax-H3-ComfyUI | Sharpness, part of the default recipe | ComfyUI/models/loras/ |
| A 3-step H3 turbo LoRA | Fast head step | ComfyUI/models/loras/ |
| Qwen-Image 2.1 + turbo LoRA (optional) | Detailed first-frame anchor | diffusion_models/, loras/ |
| SAM3 (optional) | Hero-subject mask | Per the SAM3 node pack |
The core H3 files are linked from Comfy’s MiniMax H3 page. My MiniMax H3 ComfyUI hub lists every file, size and folder in one place.
The Tessera Nodes Explained
| Node | What it does |
|---|---|
| Tessera Tile Plan | Dry run. Shows the tile grid, chunk layout and cost before you spend GPU time. |
| Tessera Streamed Encode | Builds the upscaled plate latent and guide conditioning in windows. Replaces the encode chain that runs out of memory at 4x. |
| Tessera Refine | The tiled sampler: per-tile conditioning, temporal chunks, hero tiles, flat-tile skipping and crash-safe output. |
| Tessera Streamed Decode | Decodes in windows. Also loads rescued latents. |
| Tessera Guide Anchor | Splices a detailed still image into the guide’s fine detail band. |
| Tessera Temporal Dilate / Decimate | Adds frames for fast action spans, then re-times exactly on output. |
| Tessera Guide Grain | Adds matched grain to the guide. |
| Tessera Extra Options | Expert settings with tested defaults. |
Running the Example Workflow Step by Step
- Load your clip in the LoadVideo node of
tessera_upscaler.json. - Set the scale factor and output size. They must match the clip you loaded; the example is wired for one target.
- Point the model loaders at your H3 ref2va model, VAEs, text encoder and LoRAs.
- Queue Tessera Tile Plan only (mute the rest) and read the grid, chunk count and cost estimate.
- Unmute and run the full graph. Keep the default sigmas for the first try.
- If the decode fails, load the
tessera_rescue_*.latentfile with LoadLatent and send it to Tessera Streamed Decode.
Warning: split long clips at scene cuts before you start. Tessera only flags cuts as advisory, and refining across a hard cut can smear the two shots together.
Settings That Matter
| Setting | Default | What it does |
|---|---|---|
| Sigmas | 1.0, 0.7, 0.4, 0.0 |
One turbo head step, then two euler tail steps |
| Second-hop sigmas | e.g. 1.0, 0.923, 0.55, 0.0 |
Lighter pass for repeat hops |
guide_release |
0.8 | How long the guide steers sampling |
flat_skip |
4.0 | Skips featureless tiles (sky, smoke); 0 disables |
seam_regen |
32 px | Overlap band regenerated along tile seams |
spatial_tile / temporal_tile |
high_vram |
Switch to low_vram on smaller cards |
motion_release_floor |
– | Set to 0.3 when you use a still anchor |
- At 2x: feed a detailed still to Guide Anchor (Qwen-Image 2.1 works well).
- At 4x and above: leave the anchor unplugged, as the author recommends.
- Shimmer: flicker in the source carries over. Tessera can raise coherence to about 0.75 but not beyond.
Real Render Times and VRAM
The author gives no minimum VRAM, and the shipped defaults target high-VRAM cards. These are the numbers reported so far:
| Job | Hardware | Time |
|---|---|---|
| 15 s clip, 544p to 4K (617 dilated frames, 18 windows, 24 tiles) | One GPU (author) | about 3 hours |
| 121 frames, 2K to 4K, BF16 | RTX 6000 Pro | about 32 s/step; 44 min to reach 93% |
| 1344×768 to 2688×1536 | user report | 46:58 |
| 1920×1088 to 3840×2176 | user report | 53:08 |
| 2x with a Qwen-Image 2.1 anchor | user report | 27:48 |
| 8K attempt | user report | failed after 8 h 49 min on a 67.6 GB buffer |
The 8K row is the honest headline: 8K is possible on paper, but no one has posted a finished 8K render with a timing yet.
Using Tessera on 12-16 GB GPUs
A 12 GB RTX 3060 owner asked for a low-VRAM recipe, and the author said one is coming. Until then, this is the safest approach on a 16 GB card like an RTX 5080:
- Use small H3 files: a pruned int8 or W4A8 ref2va model and the Qwen3-VL 4B INT4 encoder.
- Switch both tile presets to
low_vram. - Start at 2x on a short (3-5 second) clip and check the Tile Plan cost.
- Keep 64 GB+ system RAM and fast SSD space for the rescue latents.
- Launch ComfyUI with memory-friendly flags; see my ComfyUI command line arguments guide.
If H3 itself already struggles on your card, fix that first with my MiniMax H3 out of memory guide.
Tessera vs Latent Upscaler vs SeedVR2
| Tool | Target | Speed | Best for |
|---|---|---|---|
| Tessera | 2K, 4K, 8K | Slow (30 min to hours) | Final hero shots that need real 4K texture |
| H3 latent upscaler + Sol VAE | 2K, 4K | Fast | Quick 2K/4K inside the H3 graph |
| SeedVR2 + RIFE | 1080p, 60 fps | Medium | Social media clips, smooth motion |
No one has published a side-by-side of Tessera and SeedVR2 yet, so pick by target size and time budget.
Troubleshooting
Tessera nodes are missing or red
Check the console for [Tessera] loaded 9 node(s). If it is missing, confirm the folder is ComfyUI/custom_nodes/ComfyUI-Tessera/ and restart. Red KJ or SAM3 nodes mean those helper packs are not installed.
Size mismatch errors
The example graph is wired for one target. Set the scale factor and output size to match the clip you loaded.
Out of memory during Refine
Switch spatial_tile and temporal_tile to low_vram, lower the scale to 2x and rerun Tile Plan. My CUDA out of memory guide covers system-level fixes.
Crash at the final decode
Do not re-run the whole job. Load tessera_rescue_*.latent with LoadLatent and feed it to Tessera Streamed Decode.
Odd details or melting at 4x
Unplug the Guide Anchor at 4x and above. Keep flat_skip on so empty sky and smoke are not “invented”.
Flicker or shimmer remains
Tessera cannot fully remove shimmer that exists in the source. Generate a cleaner base clip or split at scene cuts.
My Take
Tessera solves a real problem. The streamed encode alone turns a 57 GB memory spike into about 5 GB, and that is what finally makes 4K H3 output possible on one card.
It is not a quick upscaler, though. For most clips I would still finish with the latent upscaler or SeedVR2, and save Tessera for the one shot that has to look perfect at 4K.
16 GB users should wait for the promised low-VRAM recipe before planning long jobs, and test on short clips first.
FAQ
What is Tessera in ComfyUI?
A free MIT-licensed node pack by hashu786 that upscales MiniMax H3 videos to 2K, 4K or 8K by refining them tile by tile with H3 itself.
How do I install Tessera?
Run git clone https://github.com/hashu786/ComfyUI-Tessera inside ComfyUI/custom_nodes and restart. It needs no extra Python packages.
Does Tessera work with Wan or LTX videos?
The pack is built on MiniMax H3 and the docs only cover H3. You can feed it other footage as the reference, but there are no published results for that.
How long does a 4K upscale take?
Reported runs took about 27-53 minutes for short 2K and 4K clips, and about 3 hours for a 15-second 544p-to-4K job.
Can Tessera run on a 16 GB GPU?
It is designed for one consumer GPU, but defaults target high VRAM. Use the low_vram tile presets, small H3 files and 2x first; an official low-VRAM recipe is still coming.
Can Tessera really make 8K video?
It supports 8K targets, but no finished 8K render time has been published, and one 8K attempt failed after almost nine hours.
What happens if Tessera crashes at the end?
The refined latent is saved as a rescue file. Load it with LoadLatent and run Tessera Streamed Decode to get your video back.