How Much To Run AI
Open weights

Pruna P-H3-Image: ComfyUI Setup, VRAM and Image Costs

Pruna P-H3-Image is an eight-step image-generation and editing pipeline derived from MiniMax H3. It produces single images and can edit one image using up to seven more as references. Choose the native ComfyUI quantized components for desktop hardware, or the Diffusers pipeline for Python. The smallest documented ComfyUI set peaks near 21GB VRAM at 8MP; budget disk space for the prompt upsampler separately.

Content reviewed:

Pruna ComfyUI 8MP base-set peaks: w4a8 21 GB, int8 31 GB, bf16 56 GB. The prompt upsampler downloads separately.
Pruna-reported ComfyUI base-set measurements at 8MP. The recommended bf16 prompt upsampler adds 19.3GB on disk and runs before image generation.

Use this model

Official model repository

Local tools and guides

Choose a first image task

  • Generate an 8MP image from a detailed prompt or a short request expanded by the supplied upsampler.
  • Edit one image while preserving its subject and composition.
  • Combine a target image with up to seven visual references.

Which P-H3-Image package should you use?

Pruna publishes a standalone Diffusers pipeline and a companion ComfyUI repository with native component files in bf16, int8 and w4a8. These are two ways to run the same image release. The transformer is listed as 33.1B parameters, with separate text-encoding, VAE and prompt-expansion components; the small quantized download is not the size of the entire original pipeline.

For a 24GB GPU, start by evaluating the ComfyUI w4a8 set. For a 32GB GPU, int8 is another documented option, although its approximately 31GB peak leaves little margin. Extra references and a different workflow can change the peak. The card lists compatible quantized kernels for NVIDIA Ampere or newer and AMD RDNA3/4; check your ComfyUI and backend before downloading.

If you already have a MiniMax H3 FL2VA ComfyUI setup, Pruna also supplies a separate 2GB image LoRA and matching workflows. Apply it with the documented model-only loader at strength 1.0. That route reuses your H3 components; it is distinct from downloading the standalone P-H3-Image transformer. The image release generates neither video nor audio.

MiniMax’s official MiniMax-H3-Image is a separate six-step image checkpoint with up to 16 reference images and its own API. P-H3-Image uses an eight-step Pruna workflow to edit one image with up to seven additional reference images. Choose the files and template together; do not apply the official model’s reference limit or timing to this Pruna pipeline.

P-H3-Image VRAM and complete download budget

Pruna’s ComfyUI table measures the model, text encoder and VAE together at 8MP. It lists the prompt upsampler separately. With the recommended bf16 upsampler, add a 19.3GB download to any of the base sets below; the approximate w4a8 total becomes 39.3GB rather than 20GB.

The upsampler runs before image generation. With staged unloading, ComfyUI can evict it from VRAM before the image components need the memory, so the phase peaks are not simply added. A workflow that retains the upsampler can use more VRAM. Pruna’s separate L40S measurement puts the bf16 prompt upsampler alone at about 21GB peak VRAM. The table below measures the image base set (transformer, text encoder and VAE), excluding that upsampler: w4a8 peaks at 21GB and int8 at 31GB. The card does not specify a complete system-RAM minimum; leave room for offloaded components, inputs and the application.

Pruna says int8 preserves results close to bf16 in its examples, while w4a8 can change fine details and composition. Choose precision with the outputs you need to retain, rather than treating all three formats as visually identical.

ComfyUI base setDownload, excluding upsamplerReported peak at 8MP
bf1655 GB56 GB
int830 GB31 GB
w4a8 + int8 VAE20 GB21 GB

Generate a first image in ComfyUI

ComfyUI v0.44.0 includes native P-H3-Image support. Update an older installation to v0.44.0 or later before opening the supplied workflows; an older backend may lack the conditioning node even when the files are in the right folders. No custom nodes are required for the published workflows.

Install the Hugging Face CLI in your environment. From the parent directory containing your ComfyUI folder, run the download below; it selects the w4a8 transformer and text encoder, int8 VAE and recommended bf16 prompt upsampler. Import p-h3-image_text_to_image.json from the repository’s workflows folder, select those exact files in its loaders and keep the supplied eight-step schedule.

Begin with one short request, such as a documentary photograph of a ceramic cup on a wooden kitchen table in morning light. Leave the prompt upsampler enabled for that first run. Queue the workflow and inspect the saved image, expanded prompt and peak memory before raising resolution or adding reference inputs.

Desktop ComfyUI files; about 39.3GB including the bf16 prompt upsampler
python -m pip install -U huggingface_hub
hf download PrunaAI/P-H3-Image-Comfy \
  --include "diffusion_models/p-h3-image_w4a8.safetensors" \
            "text_encoders/p-h3-image_text_encoder_w4a8.safetensors" \
            "text_encoders/p-h3-image_prompt_upsampler_bf16.safetensors" \
            "vae/p-h3-image_vae_int8_convrot.safetensors" \
  --local-dir ComfyUI/models

Edit one image with up to seven references

Import p-h3-image_edit.json for editing. Picture 1 is the image being changed; Pictures 2 through 8 provide references. Describe what should change and what should remain: for example, give the woman in Picture 1 the hat from Picture 2 while keeping her face, pose and background.

The upsampler turns a short instruction into the detailed edit prompt expected by the model. Inspect that expanded prompt when the result changes too much. If you bypass the upsampler, write the target object, finished appearance and preserved details yourself. Short quoted text is more reliable than paragraphs of small lettering.

Pruna recommends 8MP for text-to-image and 4MP or 8MP for edits. An 8MP square is 2912×2912; an 8MP landscape is 3872×2176. In the Python pipeline, an edit without explicit dimensions scales Picture 1 to at least 4MP, with sides rounded to multiples of 32. Lower-resolution generations can show more face, hand and small-detail artifacts.

Use the Diffusers pipeline on a larger GPU

For Python automation, the model card installs Diffusers from its GitHub repository, plus transformers, accelerate, torch and pillow. The example below follows its ModularPipeline path. It loads bf16 components and moves the complete pipeline to CUDA, so it is intended for a much larger GPU than the quantized ComfyUI route.

With automatic CPU offload, Pruna reports roughly 76GB peak GPU memory at 8MP on an 80GB H100. Offloading changes where components live and can change elapsed time; it does not make the full bf16 Python example a documented 24GB recipe.

Official Python path; install the model card’s current dependencies first
import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("PrunaAI/P-H3-Image")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")
image = pipe(
    prompt="A documentary photograph of a ceramic cup on a wooden kitchen table in morning light.",
    height=2496, width=3360,
    output="images",
)[0]
image.save("cup.png")

How long does an image take, and what does it cost?

On one B200, bf16, batch size one and 8MP, without compilation or offload, Pruna reports about nine seconds for the image stage. Prompt expansion adds six to eleven seconds and brings the resident pipeline to about 101GB. The nine-second headline therefore does not describe a complete short-prompt request.

For ComfyUI on an L40S 48GB, Pruna reports 6.3 seconds for a 2048×2048 w4a8 image versus 19 seconds with bf16 offloading. The upsampler has separate L40S timings: about seven seconds for bf16, thirteen for int8 and eleven for w4a8. Those figures come from different stated stages; measure your whole queue, loading and disk writes when sizing a service.

For an illustrative rental at $2 per hour, a complete 30-second attempt costs about $0.0167. Three attempts per retained image cost $0.05 before loading, idle time and storage. This is a budget example, not a Pruna customer price or a measured 24GB GPU result.

In a November 6 first-shot comparison, Reddit author AxonkaiLab shows four prompts across P-H3, FLUX3-Klein, MOSS and Krea2-Raw using a custom Comfy backend without upscaling or inpainting. The post does not state the GPU, precision or revision, so it is useful for inspecting examples, not for a hardware or speed ranking.

What did a desktop test reveal about the upsampler?

KOBO Lab’s November 4 test, updated November 7, uses Windows 11, an RTX 5090 32GB, 128GB RAM and ComfyUI 0.44.0. For 2912×2912, eight-step images, its warmed w4a8 run without prompt expansion takes 11.0 seconds with 20.8GB peak VRAM. Keeping the bf16 upsampler resident alongside the w4a8 image base set raises that combined workflow’s peak to about 31GB; this is distinct from the int8 base set’s own 31GB peak. The reported 11.4-second image time with expansion reuses an unchanged prompt; it is not evidence that writing a new expanded prompt costs only 0.4 seconds.

The author separately reports about three seconds for resident bf16 prompt expansion and 90–200 seconds when first loading from a USB hard drive. These are different stages from a warm saved-image time. Two-input hat edits take about 21.5 seconds in three reported successful seeds; other face edits vary by seed. For a 24GB card, keep unloading/offload behavior in the workflow rather than assuming a resident-upsample run fits the 21GB base-set figure.

Check the license and choose an image workflow

P-H3-Image weights use the MiniMax H3 Community License. Its standard grant excludes the United States, European Union, United Kingdom and South Korea without separate authorization from MiniMax. Commercial product or service interfaces must prominently display MiniMax H3; the agreement also encourages a Powered by MiniMax H3 notice. The Apache-2.0 licenses of the Qwen-derived auxiliary components do not replace the weight license.

Choose this pipeline when local high-resolution generation or multi-reference editing fits your hardware and license. Compare Qwen Image for another local editing workflow, and GPT Image 2.6 when you prefer a hosted image service. Compare total attempts, resolution, reference handling and final image quality before committing a batch.

Before you use it

  • Dense text, hands and small faces can require correction; evaluate the final output at its intended display size.
  • The reported 21GB ComfyUI peak is a particular 8MP component setup; it does not include a documented whole-system RAM minimum.

How to get started

Check the weight license, select the precision that leaves GPU headroom, then run the matching official ComfyUI workflow with the upsampler enabled.

Sources

Sources (10)

Calculators