---
title: How to Run MiniMax H3 Image Locally in ComfyUI (48 GB VRAM)
url: "https://goremy.ai/blog/articles/minimax-h3-image-comfyui-run-locally"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-17T10:40:11.220Z"
updated: "2026-11-17T10:40:11.220Z"
topic: Local AI
description: "Install MiniMax H3 Image in ComfyUI: which files to download, where they go, the roughly 48 GB of VRAM it used, and what a 16 MP image takes."
---

# How to Run MiniMax H3 Image Locally in ComfyUI (48 GB VRAM)

> Install MiniMax H3 Image in ComfyUI: which files to download, where they go, the roughly 48 GB of VRAM it used, and what a 16 MP image takes.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-17

## How do you run MiniMax H3 Image locally in ComfyUI?

Download the model files from the MiniMax-H3-Image page on Hugging Face (the diffusion transformer, the VAE and the MiniMax-H3 text encoder), place them in the matching folders inside your ComfyUI "models" directory, then load MiniMax's text-to-image or edit workflow and press run. You need a GPU with a lot of memory. In one hands-on test the model used close to 48 GB of VRAM and produced an image in about 10 to 15 seconds.

## TL;DR

- MiniMax H3 Image is an **open-weight 33B diffusion transformer** distilled to six sampling steps with no classifier-free guidance, so each image takes few passes.
- It generates about **16 megapixels natively** (4096x4096 for a square image) without an upscaler, and accepts **up to 16 reference images** for editing.
- In one local ComfyUI test it used **close to 48 GB of VRAM** and generated in roughly 10 to 15 seconds. An identity-preserving edit took about 40 seconds.
- The files add up to **well over 100 GB** on disk, because the text encoder alone is 66.7 GB.
- ComfyUI has an official tutorial and **two workflow templates** (text-to-image and edit), so you do not build the graph yourself.
- Big text, counting and layout, and edits that keep a scene intact worked well in testing. Small text, hands-and-feet-style anatomy and complex scenes still slipped.

## What is MiniMax H3 Image?

It is an image model from the MiniMax H3 family. One checkpoint handles both text-to-image (you describe a picture) and image editing (you give it one or more reference images and describe the change). The weights are open, so you can download and run them on your own machine instead of paying per image through an API.

The technical details from the model card:

- **Size:** a 33.1B-parameter diffusion transformer (DiT), 50 layers, weights in BF16.
- **Sampling:** distilled to 6 steps with no classifier-free guidance. Fewer steps is the main reason it is fast.
- **Resolution:** about 16 megapixels at every aspect ratio, from 4096x4096 (1:1) to 6272x2688 (21:9).
- **References:** up to 16 reference images.
- **Text encoder:** the Qwen3-VL text encoder from MiniMax-H3, unchanged.

## What hardware does it need?

Plan for a workstation or server-class GPU, not a gaming card. In the hands-on ComfyUI test, VRAM use was close to 48 GB. The presenter said you can reduce it by using fewer steps, but recommended staying with the default settings. Since the model is already distilled to six steps, treat that as a trade-off to test, not a free saving.

The files help explain why. The model card lists the transformer at 66.28 GB in BF16. That is larger than 48 GB, so ComfyUI's memory handling is likely moving parts of the model between system RAM and the GPU. The sources do not spell that out, so check the ComfyUI tutorial for current memory guidance and make sure your machine has plenty of system RAM too.

For comparison, the model card's server recipes (vLLM-Omni) list NVIDIA H200, RTX PRO 6000 Blackwell and AMD Instinct MI350X among the supported accelerators. That gives a sense of the class of hardware MiniMax is aiming at. If you do not own one, renting a GPU by the hour is the practical route for a trial.

Disk space matters as much as VRAM. Here are the components as listed on the model card:

| Component | What it does | Size |
| --- | --- | --- |
| `transformer/` | The diffusion transformer (BF16, with some layers in FP32) | 66.28 GB |
| `vae/` | Image VAE (variational autoencoder, turns the model's internal image into pixels) | 2.34 GB |
| `pdd_fused_heads.safetensors`, `pdd_config.json` | Per-step output heads and the sampling schedule | 12 MB |
| `tokenizer/`, `processor/` | Qwen3-VL tokenizer and processor | 23 MB |
| Text encoder (from MiniMax-H3, `text_encoder/`) | Reads your prompt | 66.7 GB |
| MiniMax-H3-Image-PE (optional) | Prompt expander, NVFP4 | 17.9 GB |

Add the first rows and you are at roughly 135 GB before the optional prompt expander. Free up the disk before you start.

## Which files do you download, and where do they go?

Start on the MiniMax-H3-Image page on Hugging Face and open the "Files" tab. In the hands-on test, the process was exactly that: open the model card, go to Files, and download each file by right-clicking the link and choosing "Save link as".

For each file, save it into the matching folder under your ComfyUI install's `models` directory. The VAE, for example, goes in the `vae` folder. The other components follow the same logic, using ComfyUI's usual folders (for example `diffusion_models` for the transformer and `text_encoders` for the text encoder). The presenter stressed following the folder structure from the model card and ComfyUI's instructions.

Two cautions:

1. **Match the ComfyUI tutorial.** The Hugging Face repo is laid out for tools like diffusers, SGLang and vLLM-Omni. ComfyUI's tutorial page for MiniMax H3 Image is the place to confirm exact file names and folders. I can't verify them from the model card alone.
2. **The text encoder is separate.** It lives in the MiniMax-H3 repository, not the Image repository. If you already have MiniMax-H3, you do not need to download it again.

If you prefer the command line, the model card gives these downloads into the Hugging Face cache (useful for the server tools, not required for ComfyUI):

```bash
hf download MiniMaxAI/MiniMax-H3-Image
hf download MiniMaxAI/MiniMax-H3 --include "text_encoder/*"
# optional prompt expander
hf download MiniMaxAI/MiniMax-H3-Image-PE
```

## How do you load the workflow and generate an image?

A ComfyUI "workflow" is the saved graph of nodes that wires the model, prompt and sampler together. You do not have to build one. The model card links two templates in ComfyUI's workflow_templates repository:

- `image_minimax_h3_image_t2i.json` for text-to-image
- `image_minimax_h3_image_edit.json` for image editing

The steps:

1. Update ComfyUI to a version that supports the model (the official Comfy tutorial states which).
2. Place the model files in their folders.
3. Open ComfyUI and load the template (drag the JSON onto the canvas, or use ComfyUI's template browser).
4. Check that each loader node points at the files you downloaded.
5. Type your prompt, set the image size, and press run.

For editing, add your reference image or images in the edit template. In the server API, the order of uploaded images defines `<Picture 1>`, `<Picture 2>` and so on in the prompt. Check the ComfyUI tutorial for how the edit template handles that.

Size notes from the model card: if you request a smaller image than the default minimum generation area (2048x2048), the API generates at the same aspect ratio on a larger canvas and resizes it back. That is an API setting. Do not assume ComfyUI behaves the same way.

## How fast is it, and how good are the results?

Speed, from the hands-on test: image generation took about 10 to 15 seconds. A multi-step edit that kept a person's face, hair and lipstick while changing the outfit and background took about 40 seconds. Those numbers come from one run on one setup, so your hardware will vary.

Quality, from the same set of tests:

| Test | What worked | What missed |
| --- | --- | --- |
| Neon sign, poster, crowd | Large sign and headline text came out clean | Small poster text garbled, crowd faces weak |
| Five boats, five fishermen | Count, diagonal layout and outfit colors correct | The requested painted name was missing |
| Replace a taxi with a tuk tuk | Pink and lime paint, rainy dusk, reflections kept | Lettering landed on the roof, not the side |
| Identity-preserving outfit edit | Face, curly hair, lipstick close to the original | Background looked a bit plasticky |
| Drone photo edit with gates | Perspective and depth held up, seasonal details added | Some shadow and sun-angle inconsistencies |
| Flat illustration to photo | Layout, horizon and lighting carried over well | Little to criticize here |
| Hand with city names on palm | Five fingers, names spelled correctly | The mitten outline was faint |

The presenter was most impressed by the illustration-to-photograph conversion and by the skin texture in a realistic portrait.

## Where does it fall short?

Several tests showed the usual weak spots of image models. A scene with a leaping elephant, fire trails and sparks had visible errors (the tree behind was weak). An over-and-under water shot had no clearly visible boat and a missing outrigger, and the school of fish looked flat. The reflections in one water scene looked slightly artificial.

So the honest summary: strong at following layout and keeping an edited scene coherent, still unreliable on small text and busy compositions. Plan to generate several options and pick one, as with any image model.

## What does this mean for you?

**If you are a designer or marketer:** local generation means no per-image fees and no uploading unreleased product shots to a third party. But you need serious hardware. If you do not own it, rent a GPU for a day, run your real use cases (product edits, ad variations, mockups) and decide with your own results. Read the model's license on Hugging Face before using output commercially. I have not summarized it here.

**If you are in IT or run a team:** the cost is mostly disk, VRAM and setup time. The ComfyUI workflow templates remove most of the setup. Check whether the hosted API or the Hailuo web app (both linked on the model card) are cheaper for your volume.

**If you are just curious:** try the hosted app first. Install locally only if you want control over the files, the seeds and the workflow.

## Can you build tools around your image workflow?

Running a model locally solves generation, not everything around it. A small team using a model like this still needs somewhere to collect image requests, track which version was approved, and keep the prompts that worked. Instead of juggling a spreadsheet, you can describe that tool to [Remy](https://goremy.ai) in plain English (a request form, an approval board, a shared prompt library) and get a deployed app with sign-in and a database. Remy's platform includes a catalog of image models, so you can also compare outputs inside the same app. Remy does not run your local ComfyUI setup, so treat it as the organizing layer.

## Frequently Asked Questions

### How much VRAM does MiniMax H3 Image need?

In the ComfyUI test, VRAM use was close to 48 GB. The model card lists the transformer at 66.28 GB in BF16, so expect heavy use of system memory as well. Check the ComfyUI tutorial for current guidance.

### How big is the full download?

The transformer (66.28 GB), VAE (2.34 GB) and text encoder (66.7 GB) come to roughly 135 GB, plus 17.9 GB if you add the optional prompt expander. The text encoder comes from the MiniMax-H3 repository.

### Can it edit existing images?

Yes. The same checkpoint handles text-to-image and editing with up to 16 reference images. Tests showed it swapping vehicles, changing outfits and backgrounds while keeping a face recognizable, and turning an illustration into a photograph.

### Is it better to use the API instead of running it locally?

It depends on volume and privacy. MiniMax offers an online API and apps for text-to-image and editing. Local use avoids per-image fees and keeps files on your machine, but requires expensive hardware and setup.
