Painter Bernini Upscale

Bernini is ByteDance's video editing model built on Wan 2.2 - the one the community crowned "NEW KING for local" and then immediately pointed out was mute. It has no audio, no first-frame/last-frame, and it eats compute like a Wan generation at double the frame count, because the source video you're editing is part of the model's input. PainterBerniniUpscale is the node that builds that input: it takes your low-res video or image, upscales it to your target resolution, VAE-encodes it into a latent, and stuffs the conditioning with the references Bernini needs. It's the front half of basically every Bernini edit graph.

What it is

A conditioning/latent builder, not a sampler. You'll find it in the PainterNodes/Bernini category, and it sits between your input footage and the KSampler: feed it the thing you want upscaled, the prompt conditioning from your text encoder, and a VAE, and it hands back a latent plus positive/negative conditioning plus the resolved width and height.

How it works

The core move is simple: it resizes low_res_video up to your width/height (nearest-exact, so no invented detail - this is the "more pixels" side of upscaling, not a hallucinating upscaler), then runs it through the VAE into a latent. The interesting part is the optional inputs. Wire in source_video and Bernini treats it as footage to edit or restyle; reference_video becomes a clip to insert into it; and the reference_images autogrow input (up to 8) injects each image as an in-context token - the same multi-reference trick that made Bernini's character consistency across cuts a headline feature. ref_max_size caps how big references get downscaled before they're fed in.

Two outputs worth wiring explicitly: the width and height ints, which you feed into your sampler's resolution so everything stays consistent - and the returned conditioning, which carries the whole reference context to the denoise pass.

The inputs you'll actually touch

• low_res_video - the low-res footage or image to upscale (required).
• width / height - target size, defaults 1536×864, stepped by 16. Bernini is heavy; don't go past what your card can sample.
• length - frame count, default 81, stepped by 4.
• positive / negative - your prompt conditioning, wired through from the CLIP/text encode stage.
• source_video / reference_video / reference_images - the optional edit context. This is where Bernini earns its keep; without them the node is just an upscale-and-encode.

Install

Part of the PainterNodes pack. In ComfyUI Manager, search "PainterNodes" and install, or:

cd ComfyUI/custom_nodes
git clone https://github.com/princepainter/ComfyUI-PainterNodes
cd ComfyUI-PainterNodes
pip install -r requirements.txt

Restart ComfyUI after. The pack's own deps are just soundfile and numpy - the Bernini weights themselves you get separately (Kijai's fp8 conversions live under Kijai/WanVideo_comfy_fp8_scaled, and are the sane download). The pack's workflows/ folder has a bernini+ltx2.3.json example showing the full pipeline - that's the reference graph to copy.

Common issues

• Slow, and I mean slow. That's Bernini, not the node. Because the edited source video is part of the model input, a 121-frame request processes roughly twice the compute of plain Wan. Kijai's Wan Chunk FeedForward and memory-efficient attention nodes in KJNodes are the usual mitigation; plan for minutes, not seconds.
• No sound in the output. Correct - Bernini has no native audio. The usual move (and this pack's own workflows/bernini+ltx2.3.json) is to run the Bernini render, then dub it with an LTX 2.3 audio pass. That's exactly what this pack's LTX2Vomni node is for.
• Wrong VAE gives washed-out garbage. Use the Bernini/Wan VAE that matches your checkpoint, or the encode/decode cycle will shift colors and flatten contrast.

If you're editing video locally in 2026, Bernini is the reason, and this is the node that gets your footage into it.