AtomicChat/P-H3-Image-GGUF

How to Run P-H3-Image Locally

Pruna AI's P-H3-Image, the 8-step image model built on MiniMax-H3, as GGUF for ComfyUI and stable-diffusion.cpp: quantized with per-tensor layouts from a sensitivity scan of this model and an importance matrix from its BF16 weights, and measured on one stand against Pruna's own ComfyUI files and every other P-H3-Image GGUF we found. The renders and measurements are public.

• Built by the team behind Atomic Chat, the app that runs open-weight models locally and offline.
• The image model from 9.0 to 21.7 GB on disk. It loads in ComfyUI v0.44.0 or newer through ComfyUI-GGUF's Unet Loader (GGUF), with Pruna's text encoder and VAE; see In ComfyUI.
• Closer to the original picture than the other files we measured: AD-Q5_K (13.3 GB) is 29% closer than Pruna's own w4a8 (13.4 GB), our Q8_0 34% closer than Pruna's int8_convrot (0.5 GB smaller than ours), and AD-Q4_K 18% closer than a Q4_K_M GGUF 1 GB larger.
• No uncensored version: the MiniMax H3 license forbids circumventing safety guardrails.

---

P-H3-Image is Pruna AI's text-to-image and editing model on MiniMax-H3's 33B transformer: 8 steps, no CFG, up to 8 megapixels, edits with up to eight images. Its AdaLN branches are already folded into a small table by Pruna, so the image model is about 20B weights (40.5 GB in BF16). This repo has that image model as GGUF. The text encoder, the VAE and the prompt upsampler stay Pruna's files, from PrunaAI/P-H3-Image-Comfy.

Pick a file

Every file rendered the same 40 upsampled captions from the same starting noise as the BF16 weights. Two numbers per file, both against BF16:

• Output error follows the BF16 path: at each of the 8 steps the file gets exactly the input the BF16 model got, and we measure how far its prediction lands (relative L2; 0 = identical). It is the stable number. An 8-step model like P-H3 changes the composition of the picture under any quantization, Pruna's own int8_convrot included, so two free renders can differ a lot even when a file is good.
• LPIPS is the picture you actually get, compared with the BF16 picture of the same caption and seed (lower is closer; vs. new seed puts it on a scale: 100% is how far BF16 moves when only the seed changes, LPIPS 0.586).

File	Size on disk	Bits per weight	Output error [95% CI]	LPIPS [95% CI]	vs. new seed
BF16 (Pruna's p-h3-image_bf16.safetensors)	40.47 GB	16	0	0	0%
Q8_0	21.68 GB	8.57	0.036 [0.033, 0.040]	0.117 [0.090, 0.147]	20%
AD-Q6_K	16.79 GB	6.64	0.062 [0.054, 0.070]	0.152 [0.123, 0.182]	26%
AD-Q5_K	13.28 GB	5.25	0.110 [0.097, 0.122]	0.225 [0.191, 0.261]	38%
AD-Q4_K	11.60 GB	4.59	0.156 [0.137, 0.175]	0.300 [0.269, 0.333]	51%
AD-Q3_K	8.98 GB	3.55	0.255 [0.236, 0.275]	0.390 [0.355, 0.424]	67%

• Q8_0 is the closest to the original. Pick it if it fits.
• AD-Q6_K keeps the picture: small details move.
• AD-Q5_K and AD-Q4_K keep the subject, the style and the lettering; composition and objects shift more.
• AD-Q3_K still draws clean pictures and text (see the grid), but it is often a different take on the caption.
• The names are nominal: an AD- file mixes types per tensor, so compare by size and bits per weight.
• The BF16 weights render deterministically here: a second BF16 render of the same caption and seed is LPIPS 0.0001 away, so every number above comes from quantization.
• ComfyUI loads only what fits and streams the rest, so a file larger than your GPU still runs, slower.

How these compare with other files

Every file below was downloaded and rendered here, with the same captions, seed, graph, ComfyUI build and GPU.

File	Size on disk	Output error	LPIPS	Ours
Pruna int8_convrot	21.21 GB	0.055	0.137	Q8_0, 0.5 GB larger: 0.036 / 0.117, 34% closer
vantagewithai Q6_K	17.58 GB	0.065	0.177	AD-Q6_K, 16.79 GB: 0.062 / 0.152
vantagewithai Q5_K_M	15.03 GB	0.113	0.248	AD-Q5_K, 13.28 GB: 0.110 / 0.225
Pruna w4a8	13.36 GB	0.155	0.283	AD-Q5_K, 13.28 GB: 0.110 / 0.225, 29% closer
vantagewithai Q4_K_M	12.62 GB	0.190	0.343	AD-Q4_K, 11.60 GB: 0.156 / 0.300, 18% closer
vantagewithai Q3_K_M	10.06 GB	0.356	0.479	AD-Q3_K, 8.98 GB: 0.255 / 0.390, 28% closer

• vantagewithai's files are the plain types (all blocks at one type): they measure the same as the plain Q6_K/Q5_K/Q4_K we built (0.064 / 0.113 / 0.191).
• Pruna's int8_convrot and w4a8 need ComfyUI's own quantized kernels; ours load through ComfyUI-GGUF. The error column compares the pictures, not the speed.
• "% closer" is the output error, the stable number; the LPIPS difference points the same way at every size (9–21%), with wider intervals.

What AD- changes

AD- means Atomic Dynamic: the type is chosen per tensor group from a sensitivity scan of this model, and the file is quantized with an importance matrix collected on the BF16 weights from 12 upsampled captions that share no request with the evaluation set.

• Where the bits go. The scan put one group at a time at Q2_K over Q8_0. Blocks 30–39 were the most sensitive, then 40–49; blocks 0–19 and the token refiner the least. Per GB saved, the attention output projection costs the most, then qkv; the two MLP projections the least.
• The layout does the work. On its own the importance matrix moved the plain Q4_K from 0.191 to 0.178 and Q3_K from 0.338 to 0.326; the layouts take the same sizes to 0.156 and 0.255.
• A MiniMax-H3 recipe does not carry over. Unsloth's per-tensor recipe for their MiniMax-H3 files (attention at Q5_K and the MLP at Q2_K; or all blocks at Q2_K with the last ten at Q5_K), applied by us to these weights, measured worse than the plain Q3_K (0.393 at 9.85 GB, 0.509 at 8.35 GB). P-H3's fine-tune moved where it is sensitive. That is a statement about the recipe on P-H3, not about Unsloth's MiniMax-H3 files.
• Kept out of quantization in every file: the AdaLN table and projections (F32), the norms (BF16; ComfyUI-GGUF cannot read quantized 1-D tensors), the patch and output layers (F32) and condition_proj (BF16).
• The exact rules and the per-tensor type map of each file are in the metrics repo (logs/convert-*.log, layouts/). AD-Q5_K is the row AD-Q5_K-S there.

In ComfyUI

1. ComfyUI v0.44.0 or newer (P-H3-Image support, Comfy-Org/ComfyUI#17506) and ComfyUI-GGUF.
2. Image model: one of these files in models/unet/, loaded with Unet Loader (GGUF).
3. Text encoder and VAE: from PrunaAI/P-H3-Image-Comfy: text_encoders/p-h3-image_text_encoder_bf16.safetensors (or its int8_convrot/w4a8) with Load CLIP, type minimax, and vae/p-h3-image_vae_bf16.safetensors with Load VAE.
4. Graph: start from Pruna's workflows/p-h3-image_text_to_image.json in that repo and put Unet Loader (GGUF) in place of Load Diffusion Model. Pruna's graph runs the prompt upsampler first; keep it, the model is trained on its long captions.

Measured with ComfyUI 2c75dc1b (v0.44.0) and ComfyUI-GGUF 6ea2651, at 1024×1024 (the model is at its best at 8 megapixels; we measured at 1 to keep 1,200 renders in a day).

In stable-diffusion.cpp

P-H3-Image support is in leejet/stable-diffusion.cpp#2270, not merged on 4 November. Built from that pull request (cfd7737), our files run with Pruna's encoder and VAE as they are:

sd-cli --diffusion-model P-H3-Image-AD-Q4_K.gguf \
  --llm p-h3-image_text_encoder_bf16.safetensors \
  --vae p-h3-image_vae_bf16.safetensors \
  -p "$(cat caption.txt)" -W 2048 -H 2048 --diffusion-fa -o out.png

The sampler uses the checkpoint's 8-step sigmas. sd.cpp renders the prompt as given: write a full caption, or run Pruna's prompt upsampler first. Atomic Chat does not run image models yet.

How it was measured

• Engine: ComfyUI v0.44.0 + ComfyUI-GGUF on one NVIDIA A100 40 GB, PyTorch 2.9.1 + CUDA 12.8.
• Graph: Pruna's text-to-image graph without the LoRA: P-H3 conditioning, MiniMaxH3SigmaShift(1, 1), euler, Pruna's 8 manual sigmas, 1024×1024, seed 42 (and 43 for the floor).
• Captions: 40 requests in five categories (photo, illustration, English text, Chinese text, several objects with attributes), each upsampled exactly as Pruna's diffusers pipeline does it (greedy, the text after </think>).
• Held constant: Pruna's BF16 text encoder and VAE, so the image model file is the only thing that changes.
• Output error: 16 of the captions × 8 steps, the BF16 inputs recorded once and replayed through each file.
• Not measured: edits, other resolutions and samplers, speed, aesthetics or prompt adherence as such.
• In the metrics repo: every render, the captions, the importance matrix, the scan, the per-tensor layout of every file and every log.

How these files were made

1. Pruna's diffusion_models/p-h3-image_bf16.safetensors from PrunaAI/P-H3-Image-Comfy.
2. Converted with sd-cli -M convert from stable-diffusion.cpp cfd7737 (PR #2270) with --tensor-type-rules and --imat-in; then general.architecture is written into the metadata so that ComfyUI-GGUF loads the file (the tensors are byte for byte the converter's).
3. The importance matrix comes from ComfyUI itself: a hook on every linear layer of the BF16 model while it rendered the calibration captions, written in stable-diffusion.cpp's format.

License

These files are a modified MiniMax H3 Work under the MiniMax H3 Community License Agreement; see NOTICE. MiniMax H3 is licensed under the MiniMax H3 Community License Agreement, Copyright © 2026 MiniMax. All Rights Reserved.

• The license is limited to its Applicable Territory: worldwide excluding the European Union, the United Kingdom, the Republic of Korea and the United States (section I.5). Read it before you use these files.
• Its Acceptable Use Policy (Exhibit A) applies to every use, including the ban on circumventing safety guardrails and on harming minors.
• Commercial products above US$20M yearly revenue need MiniMax's written authorization, and commercial products must display "MiniMax H3" (section IV).
• The base model is PrunaAI/P-H3-Image by Pruna AI. Quantized by AtomicChat; not affiliated with or endorsed by MiniMax or Pruna AI.