GPUWorks Day-1 support for MiniMax-H3-Image! Real-world tested on RTX 4090 & H20

Deploy MiniMax-H3-Image on GPUWorks for text-to-image and reference-image editing: ~2.6s on 4 H20, 3.3s on 2 A100, 18s on one RTX 4090. Six tiers, OpenAI-compatible API.

Released Nov 14, 2026
Tag
Product Update

01 / CONTEXT

GPUWorks' inference templates have supported MiniMax-H3-Image since Day 1! After deployment, users can generate and edit images directly in the Playground, or call it through the OpenAI-compatible /v1/images API.

We prepared 6 tiers for different entry points, and benchmarked each on the RTX 4090, A100 80GB, and H20-3e:

  • A single 24 GB RTX 4090 is enough, producing each 2048×2048 image in about 18 seconds.

  • Two A100s: about 3.3 seconds.

  • Four H20s: about 2.6 seconds.

MiniMax-H3-Image is MiniMax's open-source text-to-image and reference-image editing model, built on the MiniMax-H3 DiT:

  • Composition: a 33.1B DiT (BF16), a 33.4B Qwen3-VL text encoder (BF16), and a 0.58B image VAE (FP32) — roughly 135 GB of weights in total.

  • Every image uses a fixed 6 steps; the model has undergone CFG distillation.

  • Editing accepts up to 9 reference images.

  • The native canvas is 2048²-level, with a maximum output of 4736×3552.

  • Upstream is served by vLLM-Omni; see the vLLM recipe.


    1.png

[MiniMax-H3-Image — generation time across different GPUs and tiers]

02 / TEST ENVIRONMENT

We used three hardware classes to cover scenarios from entry-level to high-performance. Two of them were cloud instances rented directly from GPUWorks' "Public Cloud" page — once rented, a one-click install of the agent brings them online as nodes within minutes.

ScenarioMachineVRAM per GPUHost RAMRuntime
Consumer GPU4 × RTX 4090 (cloud container)24 GB251 GBrunveil
Datacenter GPU2 × A100 SXM4 80GB (cloud container)80 GB976 GBrunveil
Large-VRAM inference GPU8 × H20-3e (local server, 4 used)141 GB2 TBDocker

Model: MiniMaxAI/MiniMax-H3-Image (68.7 GB) plus the text_encoder directory from MiniMaxAI/MiniMax-H3 (66.7 GB), both pinned to a fixed revision.

Image: vllm/vllm-omni:minimax-h3-image, released upstream with the model, including vLLM 0.33.0, vLLM-Omni, and PyTorch 2.14 + cu130.

03 / MODEL TEMPLATE

The template: two components, one rewrite

MiniMax-H3-Image's repository has no text encoder. Its model_index.json says "fetch the text_encoder from MiniMaxAI/MiniMax-H3 on Hugging Face." But GPUWorks starts the engine offline by default (HF_HUB_OFFLINE=1), and many nodes can't reach Hugging Face at all. So the template splits it into two components:

ComponentSourcePath inside container
Main model (DiT, VAE, PDD output head, tokenizer)MiniMaxAI/MiniMax-H3-Image/models/MiniMax-H3-Image
Text encoder (only this directory)text_encoder of MiniMaxAI/MiniMax-H3/models/MiniMax-H3

Download & mount: both components are downloaded and mounted into the container by the platform. Each component declares both a Hugging Face and a ModelScope source; nodes use whichever is faster to reach.

Pre-start rewrite: before engine startup, the template's pre-start script assembles a model directory under /tmp using symlinks and replaces the repo name in model_index.json with the mount path. vLLM-Omni sees a local directory and loads it directly, never touching the Hub.

Fixed revision: after release, the Hugging Face repo gained an additional set of diffusers-format weights, growing to about 204 GB — which vLLM-Omni doesn't use. The template pins the revision before those weights were added, and was verified file-by-file against the ModelScope version, with matching sha256 hashes.

04 / DEPLOYMENT OPTIONS

6 tiers

Tier parameters are taken from the vLLM recipe, then adjusted based on measured results for the supported GPU models and VRAM reservations:

PositioningTierApplies toGPU countMinimum requirement
Single GPU · per-layer offloadAmpere or newer, ≥ 22 GiB per GPU (4090, A100, L40S…)1One 80 GB GPU
Single GPU · text-encoder offloadAmpere or newer, ≥ 78 GiB per GPU1Two 80 GB GPUs
2-GPU TPAmpere or newer, ≥ 72 GiB per GPU2—
High efficiency4-GPU TPHopper or newer, ≥ 44 GiB per GPU4—
Fastest4-GPU UlyssesHopper or newer, ≥ 90 GiB per GPU4—
Large-VRAM dual GPU2-GPU UlyssesHopper or newer, ≥ 110 GiB per GPU2—

"Applies to" is the template's matching condition; actually benchmarked GPU models are listed in the "Performance" section below.

The deployment form first filters tiers by GPU architecture. The screenshot below shows a cluster with RTX 4090s: three Ampere tiers show "chip match," while Hopper tiers fall into "incompatible tiers." After a node is selected, the platform runs a placement check against each tier's per-GPU VRAM minimum, so on a 4090 only "single GPU · per-layer offload" can be deployed:

2.png

[Tier matching on RTX 4090]

When deploying on H20, the "Configuration assessment" on the right checks per-GPU VRAM against each tier's declared requirements, and the "Startup config preview" shows the command the platform actually runs. Parameters like --served-model-name and the port are injected by the platform:

3.png

[Deployment form — GPU pinned, configuration assessment passed]


4.png


[Deployment form — startup command and engine pre-start script]

05 / IMAGE PLAYGROUND

Playground: text-to-image and editing

Once deployed, the model appears under "Playground → Images." The template declares both the "image generation" and "image editing" interfaces, switchable on the page.

Text-to-image: the prompt asks the model to render specific text, and it wrote both "GPUWorks" and the small bottom text correctly. On four H20s, click-to-image takes about 2.9 seconds:

5.png

[Playground — text-to-image]

Image editing: upload a lighthouse photo, ask only to change the season to winter — the composition, lighthouse, and cabin are all preserved:

6.png

[Playground — reference-image editing]

Switch to a single RTX 4090 (per-layer offload) and the same page works. Below is an ink-wash painting with inscription generated on the 4090 — engine generation takes about 17 seconds, plus returning the image to the browser, click-to-image is about 30 seconds:

7.png

[Playground — text-to-image on RTX 4090]

The same requests can also go through the platform's OpenAI-compatible gateway, using a platform-issued API token:

plaintext
curl http://<server>/v1/images/generations \
  -H "Authorization: Bearer $TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"model":"minimax-h3-image","prompt":"…","size":"2720x1536","seed":42,"response_format":"b64_json"}'

Some generated originals (shown scaled down). 2720×1536 text-to-image:

8.jpg

[2720×1536 text-to-image]

Using the image above as reference, 2720×1536 edit:

9.jpg

[2720×1536 reference-image editing]

1536×2720 vertical poster:

10.jpg

[1536×2720 vertical poster]

06 / PERFORMANCE

Performance: across GPUs and tiers

Load testing used closed-loop requests at fixed concurrency, sampling nvidia-smi every 0.5 seconds to record VRAM and power draw.

H20 requests were sent through the platform gateway; cloud-instance requests hit the engine directly on the node, to rule out cross-region network effects.

The platform's "Evaluation" currently only benchmarks the chat interface, so the image interface used a custom script, included with the data in the evidence directory.

All requests succeeded. The table shows median end-to-end latency at concurrency 1:

AcceleratorTierPeak VRAM per GPU1024²2048²4736×35522048² edit
4 × H20-3e4-GPU Ulysses83.0 GiB2.46 s2.55 s12.8 s7.8 s
4 × H20-3e4-GPU TP35.5 GiB2.53 s2.63 s13.2 s7.8 s
2 × A100 80GB2-GPU TP61.3 GiB3.21 s3.31 s—9.0 s
2 × H20-3e2-GPU Ulysses94.3 GiB4.61 s4.70 s24.4 s14.6 s
1 × A100 80GBSingle GPU · text-encoder offload69.9 GiB7.62 s7.67 s—17.6 s
1 × H20-3eSingle GPU · text-encoder offload71.4 GiB9.45 s9.55 s46.9 s27.3 s
1 × H20-3eSingle GPU · per-layer offload12.7 GiB9.49 s9.53 s47.0 s27.3 s
1 × RTX 4090Single GPU · per-layer offload11.1 GiB18.2 s18.3 s—24.3 s
1 × A100 80GBSingle GPU · per-layer offload11.2 GiB19.3 s19.7 s—21.7 s

For the edit column: H20 used a 2720×1536 reference, while A100 and 4090 used a 2048×2048 reference, so the two are not directly comparable.

A few takeaways from the data:

  • 1024² is just as fast as 2048². Requests smaller than 2048² are first generated on a 2048² canvas, then downscaled — sharper images cost no extra time.

  • Concurrency doesn't increase throughput. 4-GPU Ulysses holds 0.41 images/s at concurrency 1, 2, 4, and 8; latency grows linearly with concurrency, reaching 19.3 s at concurrency 8. The engine processes one image at a time, and extra requests simply queue. To raise throughput, deploy more replicas.

  • 4-GPU TP is the better deal on H20. Only 3% slower than Ulysses (2.63 s vs. 2.55 s), while per-GPU VRAM drops from 83 GiB to 35.5 GiB — the saved memory can go to other services.

  • A single 4090 works. Per-layer offload places both the DiT and the text encoder in pinned host memory, copying each layer to the GPU as needed, so VRAM needs only 11 GiB. The cost is host memory: roughly 124 GiB.

  • Per-layer offload speed depends on PCIe, not compute. Same tier: H20 (PCIe 5) at 9.5 s, while the 4090 and A100 (PCIe 4) run 18–20 s.

  • Consumer cards aren't suited to multi-GPU layouts. 4090s have no NVLink, so cross-GPU traffic goes through the host. We also tried two multi-GPU layouts: 4-GPU TP with text-encoder offload at 30.6 s/image, and 2-GPU Ulysses with per-layer offload at 110 s/image — both slower than a single card, so they weren't added to the template. To raise throughput on 4090s, deploy one single-GPU replica per card, budgeting about 124 GiB of host RAM per replica.

  • Two A100s are already fast. 2-GPU TP at 3.3 s/image, not far off four H20s. With only one 80 GB card, text-encoder offload runs 7.7 s/image.

  • Same seed, different tiers, nearly identical output. Below are images generated with the same seed on 4-GPU Ulysses, 4-GPU TP, 2-GPU Ulysses, and per-layer offload:

11.jpg

[Same seed across four tiers]

VRAM reservation: every tier declares a VRAM reservation above its measured peak. The platform computes available VRAM for the omni engine as 90% of the card — an 80 GB card counts as 72 GiB — so single-GPU text-encoder offload sets its reservation at 71.5 GiB, just fitting.

Startup time: four H20s cold-start from shared storage in about 4 minutes, or about 1.5 minutes when the weights are in page cache. The two offload tiers must first move weights into pinned memory, taking 5–8 minutes.

07 / OBSERVABILITY

No need to deploy Prometheus or Grafana separately — the gateway tracks every request itself.

The service monitoring page shows request count, end-to-end latency, concurrency curves, and gateway overhead (6 ms) during the load test, with live container logs scrolling below. vLLM-Omni prints an OmniTiming line for every image processed, recording total and per-stage time:

12.png

[Service monitoring — end-to-end latency and concurrency of minimax-h3-image]

13.png

[Service monitoring — OmniTiming in live logs]

The deployment detail page shows the same stats under "Deployment metrics," along with the GPU hosting each instance and the image digest:

14.png

[Deployment details]

08 / PLATFORM UPDATES

While integrating this model, we also made several behavior improvements in the nightly version:

ProblemSymptomImprovement
Playground image sizes fixed at 512/768/1024Couldn't use the model's native 2048² or various aspect-ratio canvasesPlayground now reads the size options and defaults declared by the interface
When the main model is on shared storage, components downloaded to node local disksText encoder downloaded once per nodeComponents now download alongside the main model to its shared storage, written once

Two other observations:

  • A 2720×1536 edit under a certain seed output over-sharpened results and failed to change the season; a different seed worked fine. The cause is still being confirmed by collecting samples.

  • In service monitoring, image-request latency is currently logged under "time to first token"; this will later be changed to display per image request.

09 / FIELD NOTES

  • Use the GPUWorks Nightly version for a better experience and support.

  • Pick your tier by the card you have:

    • One card ≥ 24 GB (4090, A100 40G, L40S…): single-GPU per-layer offload, leaving about 124 GiB of host RAM.

    • One 80 GB card: single-GPU text-encoder offload.

    • Two 80 GB cards: 2-GPU TP.

    • Four 141 GB cards (H20, H200): 4-GPU TP.

    • Consumer cards: avoid multi-GPU layouts.

  • Request native canvas sizes:

    • 2048x2048, 2720x1536, 1536x2720, 2368x1760, 2496x1664, 3136x1344. Requesting smaller sizes saves no time — it only adds a resize step. For editing, use these same sizes for the reference image to get the best alignment.

  • Scale throughput with replicas, not concurrency:

    • The engine processes one image at a time. Raise throughput by adding replicas; the platform gateway distributes requests across them.

  • Verify large weights before handing them to the platform:

    • Existing weight directories aren't always reliable. We once found a MiniMax-H3 on shared storage where two tokenizer files differed from upstream. Verify against the upstream-published sha256 first, then hand it to the platform.

  • Once upstream updates, we'll release a GPUWorks vLLM-Omni runner image that includes MiniMax-H3-Image, replacing the launch image and enabling fully offline deployment. You're welcome to join our community WeChat group to discuss and exchange ideas!

10 / COMMUNITY

GPUWorks' open-source journey is just beginning. Whether you're an AI developer, an infrastructure engineer, or a hardware vendor, you're welcome to join — try different model-and-compute combinations, share your experience, report issues, and help us improve GPUWorks together.

Experience GPUWorks and join the open-source effort!


Ready to modernize your infrastructure?

Talk to our experts and see how ZStack can accelerate your cloud journey.

Most popular

Start Free Trial

Full-featured private cloud — single server free for one year, unlimited nodes for three months.

Start Free Trial
Evaluation

Schedule a Demo

See ZStack in action with a live walkthrough tailored to your use case and migration goals.

Request Demo
Resources

Get More Resources

Access white papers, migration guides, case studies, and technical documentation to plan your ZStack deployment.

Browse Resources