BluePixel-Turbo: vivo’s Open 4K Image Editor in 4 Steps (ComfyUI Setup, VRAM, Licence)

Phone maker vivo has released BluePixel-Turbo, an open-weights image editor that works at native 4K (4096 x 4096) in just 4 steps. You give it a photo and a plain-English instruction like “make the sky sunset orange”, and it edits the full-resolution image directly, with no separate upscaling pass. It is built on FLUX.2 [klein] 9B with a very aggressive autoencoder, and a community ComfyUI pack already exists. This guide covers what was released, how good it really is according to vivo’s own paper, the exact files and ComfyUI folders, the hardware you need, and the licence question that most early posts get wrong.

What Is BluePixel-Turbo?

BluePixel is vivo’s research project on “native 4K agentic image editing”, described in the paper BluePixel: Toward Native 4K Agentic Image Editing (arXiv 2610.19882) by a team from vivo, Nanjing University and Shanghai Jiao Tong University. The full system has two parts: a 4K editing model, and an agent that breaks down requests, routes them to tools (LUT colour grading, effects, text overlays) and checks its own results with a reward model before showing you anything.

Only the editing model is public. BluePixel-Turbo is the 4-step distilled version of it. vivo open-sourced the inference code on 13 October 2026 and the weights followed on Hugging Face. On 3 November 2026 the transformer was swapped for a newer checkpoint (ckpt35), which the model card describes as an intermediate checkpoint that does not yet include the final post-training stage. So this is a release that is still moving, and quality may improve again.

Why does it matter? Most open image editors work around 1 megapixel. If you edit a 24 MP phone photo with them, you either downscale it and lose detail, or you run an upscaler afterwards that can invent textures. BluePixel-Turbo edits the 4K image in one go, and its training puts a lot of weight on leaving the parts you didn’t ask to change untouched. That is exactly what a phone maker cares about for a gallery app, and it is useful for anyone retouching high-resolution photos locally.

How It Edits 4K in Four Steps

You don’t need the maths to use it, but two design choices explain both its strengths and its quirks.

1. A 64x autoencoder keeps 4K cheap

A normal FLUX-style VAE shrinks an image 8x on each side. BluePixel swaps it for NVIDIA’s DCAE-F64, which shrinks it 64x. According to the paper, that keeps the number of tokens for a 4K edit roughly at the level of a 1K edit. In plain terms: the transformer does about the same amount of work at 4K as other models do at 1K. vivo adapted the model to the new autoencoder step by step (8x, then 32x, then 64x) over about four days on 32 accelerators with around 200K samples.

The side effect: you cannot mix BluePixel’s latents with a standard FLUX.2 VAE or a normal “Empty Latent Image” node. Everything has to go through the DCAE-F64 file that ships with it.

2. Distillation that anchors the untouched areas

The teacher model needed 50 steps. vivo distilled it to 4 with a method they call source-anchored target projection (SATP), which pins the parts of the image you did not mention to the source photo. Before that, the model went through supervised fine-tuning, a continual-learning stage for rare edit types (hairstyles, expressions, poses, photo effects) and two rounds of reinforcement learning for looks and instruction-following. The result is about 4x faster than the teacher, with background consistency reported as preserved.

Benchmarks: Where It Wins and Where It Doesn’t

All numbers below come from vivo’s paper and project page, so treat them as vendor-reported. Also note that vivo reports them for “BluePixel”, not specifically for the Turbo checkpoint, and that BluePixel used prompt rewriting while the other models each got a single attempt.

VINS-4KEval++ (vivo’s own 4K benchmark, scored by vivo’s reward model)

The paper itself admits the 0.02 lead over Nano Banana Pro is within seed noise. The real story is the “unedited areas kept” column: only GPT Image 2 does better at leaving the rest of your photo alone.

ImgEdit-Bench (public, 1-5 scale)

So on the general 1K-style benchmark BluePixel is mid-table. It is first in the Hybrid (4.59) and Action (4.93) categories and tied first on Add, but weaker on Extract and Style. Its weakest category in the 4K test is camera viewpoint changes (7.55), and text editing scored 7.87. In short: it is a specialist for high-resolution retouching, not a general replacement for Qwen-Image-Edit.

Every File, Size and ComfyUI Folder

For ComfyUI, use the converted pack t8star/BluePixel-Comfy. It splits the model into three single files (28.19 GB in total) that the community node pack loads. Put them here:

Download links (direct): https://huggingface.co/t8star/BluePixel-Comfy/resolve/main/diffusion_models/bluepixel_turbo_int8_convrot.safetensors, .../text_encoders/bluepixel_qwen3_8b_original.safetensors and .../vae/bluepixel_dcae_f64.safetensors. SHA256 checksums are in checksums.json in the same repo. If you are unsure where a folder lives in your install, our ComfyUI model folders cheat sheet lists every one for the portable, desktop and manual installs.

The INT8 file is a lossy conversion, so the packager is clear it is not identical to the BF16 original. If you want the untouched weights, the official repo openvivo/BluePixel-Turbo has the FP32 Diffusers folder (about 36.3 GB for the transformer plus the text encoder shards), but that folder is for Python, not for ComfyUI loaders.

How Much VRAM and RAM You Need

Neither vivo nor the ComfyUI packager publishes a VRAM figure, and the packager warns that download size is not a VRAM number. So the table below is my estimate from the file sizes and the architecture, not a measured result. The base FLUX.2 [klein] 9B model card lists about 29 GB for the full-precision stack, which is the ceiling we are working down from.

Why 16 GB is plausible: the INT8 diffusion model is 9.09 GB, and thanks to the 64x autoencoder a 4K edit has about as many tokens as a 1K edit on other models. The heavy part is the Qwen3-8B encoder, which ComfyUI runs once per prompt and then moves to system RAM. Budget about 30 GB of free disk space too. If you are deciding on a GPU upgrade, see how much VRAM you need for AI, and RTX 50 owners should check our ComfyUI on RTX 50 setup guide first, because the INT8 path depends on a correct PyTorch and CUDA build.

Step-by-Step: BluePixel-Turbo in ComfyUI

The node pack is Comfyui-BluePixel-T8 by T8mars (registry name bluepixel-t8, 20 nodes). It needs ComfyUI 0.43.0 or newer, Python 3.10+, and Diffusers 0.40+.

1. Update ComfyUI to 0.43.0 or later (Manager > Update ComfyUI, or git pull in the ComfyUI folder for manual installs).
2. Install the node pack. Easiest: ComfyUI Manager > Custom Nodes Manager > search BluePixel T8 > Install. Manual install:

   cd ComfyUI/custom_nodes
   git clone https://github.com/T8mars/Comfyui-BluePixel-T8.git
   cd Comfyui-BluePixel-T8
   python -m pip install -r requirements.txt

   Run pip with the same Python that runs ComfyUI. On the Windows portable build that is ..\..\..\python_embeded\python.exe -m pip install -r requirements.txt. The pack ends up in ComfyUI/custom_nodes/Comfyui-BluePixel-T8/.

3. Download the three model files from the table above into ComfyUI/models/diffusion_models/, ComfyUI/models/text_encoders/ and ComfyUI/models/vae/.
4. Restart ComfyUI fully (close the console, not just the browser tab).
5. Load an example workflow. The repo ships 8 workflows. Start with 02_edit_1k_preview.json to test quickly, then move to 01_edit_4k_int8_convrot.json for full 4096 x 4096 output. Drag the JSON onto the canvas or press Ctrl+O.
6. Pick your files in the BluePixel Loader node. It outputs standard MODEL, CLIP, VAE and CONDITIONING connections, and sampling runs through the normal SamplerCustomAdvanced node.
7. Load your photo in the Load Image node and type one clear instruction in English.
8. Keep the defaults: 4 steps, CFG 3. Fix the seed while you iterate on wording, then try a few seeds.
9. Queue and save. Expect the first run to be slow while the models load into memory.

The pack also includes workflows for keeping the aspect ratio, multiple reference images, seed batches, resumable JSONL batch runs, and an experimental text-to-image mode with no input photo. If you are new to custom node installs, our must-have ComfyUI custom nodes guide walks through the Manager in detail.

Run It With vivo’s Python Pipeline

If you prefer Python, or want the original (non-INT8) weights, vivo’s quick start is short. You need a CUDA GPU with BF16 support and plenty of memory (my estimate is 40 GB+ without offload, since the BF16 transformer and the 8B encoder are both large).

git clone https://github.com/vivo/BluePixel.git
cd BluePixel
pip install -r requirements.txt
pip install --upgrade diffusers huggingface_hub

import torch
from PIL import Image
from huggingface_hub import snapshot_download
from vins_infer import load_pipeline

model_dir = snapshot_download("openvivo/BluePixel-Turbo")
pipe = load_pipeline(model_dir=model_dir, device="cuda:0",
                     vae_tiling=False, lora_scale=None,
                     shift=0.0, mu_mode="empirical")

image = Image.open("input.jpg").convert("RGB")
result = pipe(image=image,
              instruction="Make the sky sunset orange and add warm light.",
              num_inference_steps=4, guidance_scale=3.0,
              target_pixels=4096 * 4096,
              generator=torch.Generator(device="cuda:0").manual_seed(42)).images[0]
result.save("output.png")

Set vae_tiling=True if the decode step runs out of memory. Hugging Face also shows a generic DiffusionPipeline snippet on the model page, but vivo’s documented path is vins_infer.load_pipeline, so use that.

Writing Good Edit Instructions

• One sentence, one goal. “Replace the grey sky with a golden sunset” beats a paragraph. The model was trained on direct instructions.
• Say what to keep. “Change her jacket to red, keep the face and background the same” plays to its strength.
• Use its trained skills: hairstyles (vivo trained 26 hairstyle templates), expressions, poses and global photo effects are where vivo spent extra training.
• Avoid big camera moves. “Show this from above” is its weakest category in vivo’s own test.
• Text edits need checking. Changing words on signs works sometimes, but scored lower than other edit types.
• English only. The model card says other languages are not supported.

BluePixel-Turbo vs Other Local Image Editors

Which to pick: for everyday edits on a 12-16 GB card, Qwen-Image-Edit is still the safe choice, and our Qwen Image Edit 2509 vs 2511 vs 2512 vs 2.1 comparison helps you choose a version. Reach for BluePixel-Turbo when you have a large photo (product shots, landscapes, portraits from a modern phone) and want a local edit at full resolution without an upscaler. For commercial work, use the Apache-licensed Qwen-Image-Edit-2511 instead.

Troubleshooting BluePixel-Turbo in ComfyUI

These are the problems specific to BluePixel-Turbo and the BluePixel T8 node pack, taken from the pack’s release notes and the requirements on the model cards. Most of them are fixed simply by updating the pack, so check your version first (ComfyUI Manager shows it next to “Comfyui-BluePixel-T8”).

Attention mask dtype error in BluePixel TextEncode

Symptom: the run stops at the BluePixel TextEncode node with a traceback ending in the pack’s reference_sdpa function, complaining that the attention mask dtype does not match the query (a BF16 mask against an FP32 query). It shows up mainly on cloud GPUs and backends that promote Q/K/V to FP32.

Fix: update the pack to v0.1.11 or newer (“Attention dtype compatibility”), which aligns the mask to the query dtype and retries once with an FP32 mask. Fully restart ComfyUI afterwards; a browser refresh is not enough. No model re-download is needed.

“Batch validation” rejects a model you did not change

Symptom: the pack refuses to run, saying the model or CLIP failed validation, after you put any native ComfyUI node that clones MODEL/CLIP (for example a model-sampling or LoRA node) between the BluePixel Loader and the sampler.

Fix: update to v0.1.8+. Older versions lost the artifact identity marker on native clones. If you still see the error on a current version, the file really differs from what the pack expects: re-check the file name, precision and hash (see “Corrupt download” below).

Model file not read correctly on Windows

Symptom: loading fails or behaves oddly when the file extension is upper or mixed case, such as .SAFETENSORS or .Sft (common after downloading with some managers on Windows).

Fix: update to v0.1.8+, or simply rename the files to lowercase .safetensors.

Node pack fails to import (red nodes, “BluePixel Loader” missing)

The pack needs ComfyUI 0.43.0+, Python 3.10+, Diffusers 0.40+ and a working comfy-kitchen CUDA setup. The usual cause is Diffusers installed into a different Python than ComfyUI uses. Check with ComfyUI’s own Python:

# portable Windows build (run inside the ComfyUI_windows_portable folder)
python_embeded\python.exe -c "import diffusers; print(diffusers.__version__)"
python_embeded\python.exe -m pip install -U "diffusers>=0.40"

# venv / Linux install
python -c "import diffusers; print(diffusers.__version__)"
pip install -U "diffusers>=0.40"

Then update ComfyUI itself past 0.43.0 and restart.

Black, noisy or garbled output

BluePixel uses DCAE-F64, an autoencoder with 64x spatial compression. It cannot be swapped for a normal FLUX.2 VAE, and a standard Empty Latent Image node produces the wrong latent size. Load bluepixel_dcae_f64.safetensors (2.71 GB, FP32) from ComfyUI/models/vae/ through the BluePixel Loader node, and use the latent produced by the pack’s own nodes or example workflows.

Corrupt or incomplete download

If loading crashes or validation fails, compare file sizes with the model card: bluepixel_turbo_int8_convrot.safetensors 9.09 GB, bluepixel_qwen3_8b_original.safetensors 16.39 GB, bluepixel_dcae_f64.safetensors 2.71 GB. For a full check, compare SHA256 hashes against checksums.json in the t8star/BluePixel-Comfy repo:

# Windows
certutil -hashfile bluepixel_turbo_int8_convrot.safetensors SHA256
# Linux / macOS
sha256sum bluepixel_turbo_int8_convrot.safetensors

Out of memory at 4K

The 16.39 GB BF16 text encoder alone exceeds a 16 GB card, so ComfyUI must offload it to system RAM; keep at least 32 GB of RAM free. Turn on VAE tiling (off by default upstream, and documented as the way to cut autoencoder memory), test with the 1K preview workflow first, and close other GPU apps before running the 4K editing workflow.

Output size is slightly different from the input

Expected behaviour: BluePixel keeps the aspect ratio approximately and rounds both sides to multiples of 64. Crop or resize your input to multiples of 64 first if you need pixel-exact dimensions for compositing.

The instruction is ignored or the edit changes too much

BluePixel is trained for English instructions only; prompts in other languages are often ignored. Keep to the recommended 4 steps and CFG 3, describe one change per pass, and add “keep everything else unchanged”. Raising steps or CFG does not improve a 4-step distilled model.

Your own INT8 conversion is huge or slow

Pack versions before v0.1.7 could write a floating-point file labelled as INT8 when ConvRot groups were invalid. Update before converting, or use the ready-made bluepixel_turbo_int8_convrot.safetensors.

Licence and Limits

This is the part to read carefully. vivo’s GitHub repo and the model card say Apache 2.0, and the repo also contains an OpenAtom model licence. But the model is built from FLUX.2 [klein] 9B, which Black Forest Labs releases under the FLUX Non-Commercial License (only the 4B klein models are Apache 2.0). The Hugging Face metadata for BluePixel-Turbo is tagged flux-non-commercial-license, and the ComfyUI repack states plainly that the diffusion weights fall under the FLUX non-commercial terms and that the upstream Apache label does not override them. The Qwen3 encoder and DCAE parts are Apache 2.0.

My reading: use it for personal projects, learning and research. Do not use it for client work or a paid product unless you get a commercial licence from Black Forest Labs. I am not a lawyer, so check the LICENSE, NOTICE and the BFL licence yourself for anything serious.

Other limits: English instructions only, the current checkpoint is intermediate, vivo’s agent and reward model are not released, the 8.7 s speed is for a Chinese Kunlunxin accelerator (a desktop CUDA GPU will differ), and the INT8 ComfyUI version is a lossy conversion.

My Take

BluePixel-Turbo is not the best open editor overall, and vivo’s paper is honest about that. What it does differently is more interesting: it treats resolution as the main problem. Most local editing still means “edit at 1 MP, then upscale and hope”, and the 64x autoencoder trick shows you can skip that. I also like that the training focuses on not touching what you didn’t ask for, because that is the number-one complaint with AI photo edits. The licence confusion and the missing VRAM numbers keep me from calling it ready for production. For hobbyists with a 24 GB card it is well worth a try today, and if someone ships a GGUF build or a final checkpoint, it could become the go-to tool for high-resolution local retouching.

Frequently Asked Questions

Is BluePixel-Turbo free to use?

The weights are free to download, but the model derives from FLUX.2 [klein] 9B, which is non-commercial. Personal and research use is fine; commercial use needs a licence from Black Forest Labs.

Can BluePixel-Turbo generate images from text?

It is built for editing an input photo. The ComfyUI pack includes an experimental text-to-image workflow with no reference image, but that is not what it was trained and tested for.

Does it run on a 16 GB GPU?

There is no official figure. Based on the 9.09 GB INT8 model and text-encoder offloading, it should run on 16 GB with about 64 GB of system RAM, starting with the 1K preview workflow. This is an estimate, not a test.

Is there a GGUF version?

Not at the time of writing. The ComfyUI option is the INT8 ConvRot repack (t8star/BluePixel-Comfy).

Why can’t I use my normal FLUX.2 VAE?

BluePixel uses DCAE-F64, which compresses images 64x instead of 8x. Its latents have a different shape, so only bluepixel_dcae_f64.safetensors works.

Is BluePixel-Turbo better than Qwen-Image-Edit?

Not overall. On ImgEdit-Bench, Qwen-Image-Edit-2511 scores 4.51 versus BluePixel’s 4.32. BluePixel’s advantage is native 4K output and keeping unedited areas intact.

Is there an online demo?

vivo’s project page lists a demo at bluepixel.vivo.com.cn, and Hugging Face shows a community Spaces thread. Availability outside China may vary.

What settings should I use?

4 steps, guidance (CFG) 3.0, target 4096 x 4096 pixels. Leave the shift at the workflow default and fix the seed while you refine your instruction.

Sources

• Hugging Face: openvivo/BluePixel-Turbo model card
• vivo: BluePixel project page
• arXiv 2610.19882: BluePixel: Toward Native 4K Agentic Image Editing
• GitHub: vivo/BluePixel
• GitHub: T8mars/Comfyui-BluePixel-T8 (ComfyUI nodes)
• Hugging Face: t8star/BluePixel-Comfy (ComfyUI files)
• GitHub: BluePixel T8 release notes (v0.1.6 to v0.1.11 fixes)
• Hugging Face: FLUX.2 [klein] 9B (base model and licence)
• ComfyUI Wiki: BluePixel-Turbo news