BennyDaBall/Fibo-2.0-dev-NVFP4

Fibo 2.0 Dev NVFP4 for ComfyUI

Follow me on X @BennyDaBall_OG !

This is an independent NVFP4 quantization of Fibo 2.0 Dev. BRIA AI created the original model. I converted Comfy-Org's ComfyUI repack and packaged the quantized weights and the validation here. This is not a new base model or an official BRIA release.

One file. 7.27 GB. 2.5x faster than bf16 on an RTX 5090, and faster and smaller than the int8 build too.

Want to edit images instead? That's the sibling repo: BennyDaBall/Fibo-2.0-edit-turbo-NVFP4, 4-step edits in about 1.6 seconds.

As far as I can tell, this is the first NVFP4 build of Fibo 2.0 anywhere, and it drops into ComfyUI with no custom nodes, no runtime patch and no GGUF loader. Load Diffusion Model, pick the file, hit Run.

Model Metadata

Key	Value
License	CC BY-NC 4.0, non-commercial (same as the source weights)
Base Model	briaai/Fibo-2.0-dev (via Comfy-Org/Fibo-2.0)
Architecture	8B single-stream DiT, 44 blocks + Perceiver, Qwen3-VL-4B text encoder (unchanged), FLUX.2 VAE (unchanged)
Format	Mixed-precision NVFP4: ComfyUI native NVFP4 + 8-bit + bf16, per-layer comfy_quant metadata
File	fibo2_dev_nvfp4.safetensors, 7.27 GB
Tested on	RTX 5090, ComfyUI 0.42.3 + native Fibo 2.0 support (Comfy-Org/ComfyUI#17240, merged 2026-10-21), comfy-kitchen 0.2.39, PyTorch 2.14 cu130
sha256	a731576379f31f8a57a943c793e794b24bfa609d96af13434da6d3bc23dab8a0

---

What is Fibo 2.0, and why should you care?

Fibo 2.0 is BRIA's new 8B image model, and it does two things in one set of weights: text-to-image and instruction editing. Its party trick is control. It was trained on long structured JSON captions (BRIA calls the format VGL), where lighting, camera, composition and every object are separate fields, so you can change one thing without the whole scene drifting. On top of that it got a big upgrade in text rendering, texture and anatomy. On release day it sat #2 among open-weights text-to-image models (and #1 in editing) on the Artificial Analysis arena.

The catch: the bf16 model is 16.45 GB and takes about 40 seconds per 1024x1024 image (50 steps, CFG 5) on a 5090. This build gets that down to 7.27 GB and under 16 seconds, and every test string still comes out spelled right.

Every image above was rendered with this NVFP4 file at about 1 megapixel, 50 steps, CFG 5, BRIA's text-to-image negative, best of 2 seeds, no upscaling, no inpainting, no touch-ups. Full-resolution PNGs are in images/hero.

---

The Numbers

Same machine, same graph (core nodes only: Load Diffusion Model, Load CLIP fibo2, TextEncodeFibo2, KSampler euler / simple, 50 steps, CFG 5, VAE Decode). Speed is ComfyUI's own execution time per image, median of 4-6 warm runs with a fresh seed every run. Peak VRAM is the whole GPU (bf16 text encoder, VAE and my desktop included).

Model	File	s/img 1024x1024	s/img 1920x1088	Peak VRAM (1024)
bf16 (Comfy-Org)	16.45 GB	39.78	84.94	27.9 GB
int8 ConvRot (Comfy-Org)	8.41 GB	16.86	36.03	21.3 GB
NVFP4 (this repo)	7.27 GB	15.68	33.93	20.3 GB

So: 2.5x faster than bf16, 7% faster than int8, 56% smaller than bf16, 14% smaller than int8.

How close is it to the original? Same prompt, same seed, measured against bf16 on 16 prompts x 2 seeds (5 typography and signage scenes, hands and a dancer, knit / skin / moss textures, two product shots, a counting-and-position prompt, a watercolor and a 1920x1088 night market). Lower LPIPS = closer to bf16.

Model	LPIPS	SSIM	PSNR	Color shift (R, G, B)
int8 ConvRot (Comfy-Org)	0.047	0.929	27.6 dB	-0.2, -0.2, -0.3
NVFP4 (this repo)	0.098	0.869	23.4 dB	-0.6, -0.5, -0.7
NVFP4 wherever the runtime allows (GPTQ, 8-bit only where forced; 16 images)	0.124	0.841	21.7 dB	up to -7 on one image

That last row is the "just go FP4 everywhere" build, and it's why the mix below exists.

Text check. Every string in the text prompts (25 per seed: shop signs, a chalkboard menu with prices, a poster, a book cover, a tea tin with a net-weight line, street signs, a watch dial and three night-market signs) was read back letter by letter by a reader that didn't know which image came from which model:

Model	Strings correct
NVFP4 (this repo)	50/50 (2 seeds)
bf16	50/50 (2 seeds)
int8 ConvRot	25/25 (1 seed)

The only nit: in one of the 50, a price came out as "$4,25" instead of "$4.25". Letters and digits were right every time.

---

Same prompts, same seeds

bf16 on the left, this NVFP4 on the right. Same prompt, same seed, same everything.

And because Fibo 2.0 Dev is also an editing model, the edit path works too (reference image in, instruction in, same seed):

Honest take: same-seed images can land a little differently in layout (a pose shifts, a street sign moves or shows up twice), but color, contrast, detail and text hold up, and there's no tint. Comfy-Org's int8 is still closer to bf16 pixel for pixel. This one trades a slice of that for speed and size.

---

Quick Start

1. Download fibo2_dev_nvfp4.safetensors into ComfyUI/models/diffusion_models/.
2. Grab the text encoder and VAE from Comfy-Org/Fibo-2.0: text_encoders/qwen3vl_4b_bf16.safetensors and vae/flux2-vae.safetensors.
3. Build the graph from core nodes: Load Diffusion Model (this file, weight_dtype default) and Load CLIP (qwen3vl_4b_bf16, type fibo2) into TextEncodeFibo2, then KSampler and VAE Decode. TextEncodeFibo2 hands you the positive, the negative and the empty latent in one node.
4. Run.

Requirements:

• ComfyUI with native Fibo 2.0 support. It was merged on 2026-10-21 (Comfy-Org/ComfyUI#17240), so update to the latest ComfyUI (nightly / master until the next release ships it). I tested v0.42.3 with that change applied.
• An RTX 50-series / Blackwell GPU for native FP4. On older cards ComfyUI falls back to dequantizing the FP4 layers. It works, it's just slow. Grab Comfy-Org's int8 file instead if that's you.

Verified settings (BRIA's recommended settings for Dev):

UNET: fibo2_dev_nvfp4.safetensors (weight_dtype default)
Text Encoder: qwen3vl_4b_bf16.safetensors (type fibo2)
VAE: flux2-vae.safetensors
Steps: 50
CFG: 5
Sampler: euler
Scheduler: simple
Size: about 1 megapixel (1024x1024, 1424x800, 1248x832, ...)
Negative: BRIA's NEGATIVE_T2I caption from the Fibo 2.0 Dev model card (an empty negative also works)

Prompts: Fibo 2.0 was trained on structured JSON captions. Plain text works, but long VGL-style JSON is where it really shines. BRIA's bria-vgl turns a short prompt into one, or write the JSON yourself (short_description, objects, lighting, aesthetics, photographic_characteristics, style_medium, text_render, ...). Every string you want in the image goes in text_render.

---

Under the Hood: what's actually in the file?

Layers	Format	Why
attention.qkv + feed_forward.w13 in 24 of the 44 blocks (0, 5-24, 27, 32, 33), 48 layers	NVFP4, GPTQ-rounded	The biggest matmuls in the blocks where 4-bit holds up, so they get the fast Blackwell FP4 tensor cores
attention.qkv + feed_forward.w13 in the 20 most sensitive blocks (1-4, 25, 26, 28-31, 34-43)	8-bit (int8 ConvRot)	Measured: these blocks, and block 43 above all, carry most of the 4-bit damage
attention.out and feed_forward.w2 in all 44 blocks	8-bit (int8 ConvRot)	out is the cheapest big accuracy win; w2 is faster in 8-bit (see "the SwiGLU tax")
Perceiver, noise refiner, the 5 text cross-attention blocks	8-bit (int8 ConvRot)	Small, feed every block, and the text cross-attention can't run FP4 in stock ComfyUI (see below)
adaLN modulations, embedders, final layer (51 layers)	bf16	Tiny, not worth a single bit of risk

• NVFP4 layers are ComfyUI's native format: 4-bit e2m1 weights, one e4m3 scale per 16 weights, one fp32 scale per tensor, activations quantized on the fly (W4A4). Nothing extra stored, no calibration scales.
• Every block carries the same attention setting as the int8 build (int8 attention on blocks 0-39, bf16 on the last four).

How we got here

1. The obvious recipe crashed. "FP4 everything" dies on the first step: the text cross-attention layers read a non-contiguous slice of the text features, and ComfyUI's FP4 quantizer refuses non-contiguous input. Those layers only see a few hundred text tokens, so they stay 8-bit.
2. The SwiGLU tax. Fibo's feed-forward runs SwiGLU in front of w2. The int8 kernels fuse it into the quantize step, the FP4 path runs it as separate little kernels. FP4 matmuls are fast, but w2 is faster in 8-bit, so it stays there.
3. The problem wasn't the weights. Replaying the exact bf16 denoiser inputs through the quantized model showed the weights are the easy part: GPTQ (Hessians from 24 calibration prompts I never tested on, both CFG branches, 9 of the 50 steps) cuts each layer's output error 5-60x versus plain rounding. What's left is the 4-bit activations, and CFG 5 amplifies them. SmoothQuant didn't help.
4. So I bought it back where it's cheapest. I scanned the model one block and one layer family at a time. attention.out gives the most accuracy per millisecond, block 43 matters more than any five other blocks, and the rest of the error is spread thin. The final mix keeps FP4 where it pays for itself and 8-bit where it doesn't, and stays faster and smaller than int8.
5. Checked it like I meant it. File read back against the converter's own math, loaded through the stock loader, server and in-process renders match, speed raced against bf16 and int8, A/B'd on 32 images, text read back blind on 50 strings, and an edit test.

---

Verification & Proof

• Speed: ComfyUI execution timestamps, median of 4-6 warm runs per model, fresh seeds, back-to-back on the same machine.
• Quality: LPIPS / SSIM / PSNR / color shift against same-seed bf16, 16 prompts x 2 seeds at their native sizes (832x1248 up to 1920x1088).
• Text: blind letter-by-letter read of every target string, scored by edit distance over letters and digits.
• Prompts used for tuning and prompts used for testing never overlap.

---

Limitations

• Mixed precision, not FP4 everywhere. The FP4 share is the part that helps on Blackwell without hurting the picture.
• Tuned and tested on text-to-image. The edit path works (see above), but I only smoke-tested it.
• Not tested with LoRAs. Heads up: ComfyUI requantizes FP4 layers when it patches a LoRA onto them.
• My numbers are from one RTX 5090. Other Blackwell cards should see the same ranking, not necessarily the same seconds.
• Diffusion is still diffusion. A good file won't save a bad seed.

---

License

The model weights are © BRIA AI and licensed under Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0). Non-commercial use only. Commercial use requires a separate agreement with BRIA AI: https://platform.bria.ai/licensing/pricing?model=fibo-2

This quantized file is a derivative of those weights (requantized and repackaged as described above) and carries the same license. Provided as is, without warranties of any kind.

Acknowledgements

• BRIA AI for Fibo 2.0 (briaai/Fibo-2.0-dev), trained on fully licensed data.
• Comfy-Org for the ComfyUI repack (bf16 and int8 ConvRot) this build is made from (Comfy-Org/Fibo-2.0), and kijai for native Fibo 2.0 support in ComfyUI.
• comfy-kitchen for the NVFP4 and int8 runtimes, and the GPTQ authors (Frantar et al.) for the rounding trick.
• My local power utility provider, for once again sustaining the research grid.

Not affiliated with BRIA AI or Comfy-Org.

@article{gutflaish2025generating,
  title={Generating an Image From 1,000 Words: Enhancing Text-To-Image With Structured Captions},
  author={Gutflaish, Eyal and Kachlon, Eliran and Zisman, Hezi and Hacham, Tal and Sarid, Nimrod and Visheratin, Alexander and Huberman, Saar and Davidi, Gal and Bukchin, Guy and Goldberg, Kfir and others},
  journal={arXiv preprint arXiv:2511.06876},
  year={2025}
}

Quantized & tested locally with care by BennyDaBall.

Follow me on X @BennyDaBall_OG !