Three Routes to 4K From a 960-Pixel Render, and What Each One Actually Adds
A Japanese builder renders photoreal clips at 960×544 and finishes them at 3840×2176 with a single upscale pass. Three measured routes to high resolution (direct generation, latent upscale with resampling, post-hoc restoration) differ by 2.3x in time and by the kind of detail they invent.
AI-assisted draft. Reviewed and edited by the Phosphene team before publication.
On this page

Every photoreal clip fails in one of two places. Either the face drifts somewhere between the third and fifth second, or the take looks fine until you play it full screen and the whole thing is soft. Rendering bigger is the obvious answer to both, and it is the answer that costs the most.
On 19 November, a Japanese ComfyUI builder who publishes as Ai-Hakase released a workflow that splits the job instead of scaling it up. Render at 960×544, where a photoreal-tuned model gets to concentrate on motion and identity, apply a temporal correction that suppresses flicker and small face misalignment, then hand the clip to a one-step upscaler that takes the 16:9 frame to 3840×2176. That is UHD plus sixteen rows, so delivery at exactly 3840×2160 still needs a 16-pixel vertical crop. Most of the note sits behind a paid membership, so the downloadable graph is not the useful part. The split is.
Once you accept that render resolution and delivery resolution are two separate decisions, the real question is which of the three routes to high resolution you take per shot. They are not interchangeable. They cost different amounts and they add different kinds of detail, and only one of them can be trusted with a frame that has to carry readable text.
Two walls, not one
The drift problem is temporal. A video model decides identity and motion at the sampling stage, and every extra pixel of output resolution gives that stage more to keep consistent across 124 or 149 frames. Asking for 2560×1440 directly from a model that is comfortable at 768p costs time and gives the model more chances to lose the face.
The second wall is arithmetic. Sampling scales with token count, not with file size, and the curve is steep. KOBO Lab measured it on an RTX 5090 with a five second, 124 frame shot, the same prompt and the same seed: generating 2K directly took 1,138 seconds. Rendering at 768p first, upscaling in latent space, resampling three steps and decoding came to 503 seconds, for the same nominal output size.
That 2.3x is the honest argument for not rendering at delivery resolution. The catch is reproducibility: even with an identical seed, the two-stage run produced a different composition from the direct 2K render, so treat the second pass as a new roll rather than a faithful enlargement.
Route one: ask for the big frame directly
Direct generation is the simplest route and the one to keep for short, low-risk inserts. A product macro of three seconds, a locked-off background plate, a texture pass. It has one advantage no upscaler can match: everything in the frame was decided by the same model at the same time, so the grain, the depth of field and the light all agree with each other.
What it costs is the wall above. On KOBO Lab's card, a direct 2K render of a five second shot took 1,138 seconds against 503 for the two-stage route, and on a 16 GB card you may not get the frame at all. The other thing you give up is the cheap retry. Rerendering a four second shot at 4K to fix a blink is a different financial decision from rerendering it at 960×544. The per-shot arithmetic in the cost curve for local video is worth reading before you commit a scene to direct high-resolution renders.
Route two: upscale the latent, then resample
This is the route that has quietly become the default for MiniMax H3 work in ComfyUI, because it stays inside the model. ComfyUI core gained a latent upscale node on 28 October 2026, and the H3 latent upscaler weights weigh about 690 MB. The upscale itself is nearly free: KOBO Lab measured 1.5 seconds for it.
The expensive part is what comes after. You resample the enlarged latent for a few steps at a low denoise, and that resample is where the detail gets rebuilt. It took about 129 seconds per step on their card and accounted for roughly 77 percent of the whole run. Three steps at denoise 0.30 was their recommendation. At 0.44 the picture's content changed, which is the boundary you are looking for: the resample amplifies whatever the model already wanted to draw, and past a certain denoise it starts drawing new things instead.
Two consequences follow. Audio passes through the latent upscale untouched, but the resample regenerates it, so if you liked the first-pass sound you have to splice the original audio back in, which is the same ordering rule that makes the audio-last refine workflow work. And the resample is a second sampling pass, so it can still drift. It drifts less than a direct 2K render because it starts from a decided image, but it is not a pass-through.
The strongest thing about route two is that the added detail is the model's own. If you need skin texture that belongs to the character rather than texture that a restoration network thought looked plausible, this is the route.
Route three: a restoration pass after the fact
The third route ignores the generator entirely. You render at whatever size you like, then run a separate upscaler over the finished clip.
SeedVR2, the one-step diffusion restoration model from ByteDance Seed that ships natively in ComfyUI, is the clearest example of the category. ByteDance describes it as conservative upscaling, meaning it is trained to preserve the original structure rather than to reimagine it, and it runs in a single forward pass. RelayVSR takes a different tack: a large model builds reference information from keyframes at intervals, and a light decoder reconstructs every frame from that plus the source. Both are built so that VRAM does not grow with clip length the way it does during sampling.
The numbers are small. Ai-Hakase cites the upscaler developer's own figure: 149 frames at 960×480 to 3840×1920 in 36 seconds on an RTX 4090, with the caveat that GPU and settings move it. Separately, ComfyLab measured RelayVSR on an RTX 4070 Ti SUPER with 16 GB: a 0.5 megapixel, five second H3 clip went to 1920×1088 in about 28 seconds at 2x, and to 3840×2176 in about 53 seconds at 4x. A one megapixel clip reached 5504×3072 in about 98 seconds before being scaled down to 4K for delivery.
Those are different models on different cards, so do not line them up as a benchmark. What they agree on is the shape of the cost: tens of seconds for a 4x pass, on hardware that would choke on a 4K sample.
The other thing route three gives you is reach. Because the upscaler never sees a prompt, it works on footage the model did not generate. Home video, an old phone clip, a locked-off plate shot on a real camera. Ai-Hakase ships a second, upscale-only graph for exactly that, and it is the single most practical idea in the post.
The pass invents detail, and that is the risk
A restoration upscaler does not recover what the source lost. It paints something that could have been there.
The Japanese builder says it plainly: faces and text can come out looking slightly different from the original clip, because the model is drawing detail, not measuring it. ComfyLab found the same thing from the other direction, noting that RelayVSR sharpens blurry lettering and fine fabric patterns nicely but can over-emphasize wrinkles and shadows on a face. RelayVSR also exposes a detail strength parameter, where 1.0 uses all generated detail and 0 falls back to a plain bicubic enlargement. That slider is an honest admission of what the pass is doing.
So the QC checklist changes. At delivery size, zoom to 100 percent and look at eyes, teeth, hands, small jewelry, hair edges and every piece of signage in frame. If a frame carries a product label, a license plate or a subtitle, do not put it through route three. Render it bigger, or shoot the plate clean and composite it afterward. The line between finishing and inventing is the subject of where invented detail stops being a photograph, and this is the same line viewed from the finishing end.
The single-shot rule
This is the rule that costs people a day if they learn it late. The temporal correction and the upscaler both work on continuity across frames. Give them a file with a hard cut in the middle and the correction carries the previous scene's flicker across the boundary, so the first second of scene two inherits the problem you just fixed in scene one.
One shot per file. Not one scene, not one sequence. Cut at the cut before you finish, and reassemble after. That also makes the finishing step cheaper to rerun, because a bad upscale on shot four does not force you to reprocess shots one through three. If your edit already runs in shots, as it should, this costs you an export step and nothing else.
Picking a route per shot
Ask what is wrong before asking what is cheap.
If motion, identity or performance is wrong, no upscaler helps. A melted face upscaled 4x is a sharp melted face. Go back to the generation stage, drop the resolution, and use the extra speed to take more attempts. The grading questions in the seven axes for live-action output are designed to catch this before you spend finishing time on a dead take.
If the motion is right and the frame is merely soft, route three is the cheapest finish: tens of seconds for the upscale pass, against a resample stage that KOBO Lab measured at roughly 129 seconds per step.
If the motion is right but the material needs rebuilding, meaning skin, cloth or glass texture has to be re-derived rather than sharpened, route two is the tool. It costs a resample, and it keeps the detail inside the model.
If the frame must carry exact text or an exact product surface, none of the three routes is safe at 4x. Render at delivery size, accept the cost, or composite the critical region.
The honest limits
This is one builder's workflow, published with the graph gated, so the structure is verifiable and the exact node chain is not. The 36 second figure is the upscaler developer's, repeated by the author with a caveat, not a measurement the author ran.
KOBO Lab's numbers come from a single seed on a 5090 with a Turbo LoRA at eight steps, and their own note points out that direct generation and two-stage generation produce different compositions from the same seed, which limits how far you can push a like-for-like comparison. ComfyLab's RelayVSR numbers are one 16 GB card, and the same author reports that SeedVR2 at 2x failed on that machine while RelayVSR did not. Card-specific failures are part of the real cost of route three.
Worth knowing before you build a pipeline on H3: MiniMax's license for the model excludes the EU, the UK, South Korea and the United States, per KOBO Lab's summary. Route three does not fix a licensing problem.
What survives all of that is the habit. Treat resolution as two decisions, pick the finishing route by the failure you are actually looking at, and check every face and every sign at 100 percent before you call a shot done.
Sources
- Photoreal-stable model plus 4x upscale: a ComfyUI and MiniMax workflow that suppresses face drift and flicker, then finishes in one step (Japanese original, Ai-Hakase)
- SeedVR2: image and video upscaling in ComfyUI (official ComfyUI documentation, one-step diffusion restoration)
- How to bring MiniMax H3 to 2K: latent upscaling in ComfyUI core, measured on an RTX 5090 (Japanese, KOBO Lab)
- Fast video upscaling with RelayVSR 2x and 4x, measured on an RTX 4070 Ti SUPER (Japanese, ComfyLab)