Ming-Image-0.1-Design Is Free and MIT: The Open AI UI and Poster Generator, Now Native in ComfyUI

Ant Group’s inclusionAI team quietly released Ming-Image-0.1-Design on September 17: an open-weight, MIT-licensed text-to-image model built for the kind of work most image models get wrong. Landing pages, app screens, infographics, product ads and posters with lots of readable text. It can also output true transparent PNGs, and a sister model splits a flat design into separate editable layers.

The news this week is access. On September 24, ComfyUI merged native Ming-Image support, and Comfy-Org published int8 and 4-bit repacks. Until then, the official setup needed an 80 GB datacenter GPU. Now there’s a free browser demo, a ComfyUI path for consumer cards, and a commercial-friendly license. Here’s what actually works today and what it costs you in disk space and VRAM.

Ming-Image-0.1-Design at a Glance

• What it is: an open design-focused text-to-image model (6B diffusion transformer) for UI mockups, posters, infographics and other text-heavy layouts, plus a Layer model that breaks a flat image into RGBA layers.
• What’s free: everything. The weights are MIT (commercial use allowed), there’s a free Hugging Face demo, and ComfyUI supports it natively.
• What it costs: disk space and GPU memory. The official repo is 52.9 GB, and the smallest Comfy-Org combo is still about 19 GB of weights.
• The catch: “6B” undersells it. Most of the download is a 34 GB language-model text encoder, and the only setup the lab has validated is one 80 GB GPU.
• Where it ranks: reportedly #1 among open-weight models in Artificial Analysis’s UI/UX design category, but only mid-pack (#45) on the general image leaderboard.

What Ming-Image-0.1-Design Actually Does

Most image models are trained to make pretty pictures. Ming-Image-0.1-Design is trained to make compositions: a hero banner with a headline, three product cards and a price, or a mobile screen with a nav bar and readable labels. The official GitHub repo describes the release as a series of two models:

• Ming-Image-0.1-Design creates full designs at a square 1024 or 2048 px, using 12 steps at CFG 1.0 by default.
• Ming-Image-0.1-Design-Layer takes a flattened design and splits it into N transparent layers (for example text, card, product and background), saved as layer_01.png, layer_02.png and so on.

The prompting approach is unusual. Ming works best with a structured JSON prompt that lists Figma-style layers from back to front. Each layer gets normalized coordinates, a hierarchy note and hex color specs, and every piece of on-screen text is quoted exactly once. You don’t write that by hand. The repo includes a rewriter system prompt (assets/t2i_rewriter_system_prompt.txt) that turns a short caption into JSON using an instruction-following model such as Ling-3.0-flash-VL or Qwen3.8-27B. If you read our breakdown of Fibo 1.5’s JSON-native prompting, this is the same idea, aimed at layout accuracy instead of photo control.

Transparent Backgrounds and Layer Decomposition

For a true alpha channel, the model card says to start your prompt with exactly one of ten fixed trigger phrases. English options include RGBA, 4-channel, transparent background and cutout PNG, alpha=0 outside the object. Combining two phrases is specifically discouraged. The output is a real 4-channel RGBA image, not a white background you have to remove yourself.

Native transparency isn’t unique anymore. Qwen-Image-2.1 shipped it four days after Ming. The difference that matters is the license: Qwen’s is research-only, while Ming’s is MIT. For client work, that difference decides which one you can use.

inclusionAI also released two agent workflows: the Ling UI Design skill, which turns generated mockups into UI code and checks the result visually, and Image-to-Editable-PPT, which rebuilds a generated slide image as a PowerPoint slide with native text and shapes. Useful if you already work with agentic design tools like Doop.

How Good Is It? Who Measured What

Ant’s launch post claims Ming ranks #1 among open-weight models on Artificial Analysis. That’s true, but only for one category. According to AlphaSignal’s write-up of the Artificial Analysis data, Ming scores 1,082 Elo in the UI/UX design subset, which puts it #17 of 81 models overall and first among open weights. It’s also the top open model in the Layout and Text Rendering subsets.

The general picture is less impressive. When we checked the Artificial Analysis text-to-image arena on September 25, Ming was #45 with 997 Elo (±8, about 21,000 votes). FLUX.2 [dev] had 1,000 and Qwen Image Max had 998. With a margin of ±8, those three are a statistical tie. In other words, Ming is a specialist. Use it for layouts and text, not as a replacement for your photo model.

Try Ming-Image-0.1-Design Free

Option 1: browser demo (no install). Open the official Ming-Image demo Space. It runs on Hugging Face ZeroGPU, which is free but gives you a limited daily GPU quota, and signed-in accounts get more. Type a prompt, add one RGBA trigger phrase if you want transparency, and click generate. For layer splitting, try the community Layer demo, but it runs on basic hardware, so expect queues.

Option 2: ComfyUI on your own GPU. Support landed in ComfyUI PR #16482 (by kijai, merged September 24). It covers text-to-image, image editing, multiple reference images, the Layer model, and int8/w4a8 quantization. Because it’s new, update to the latest master instead of waiting for a stable release:

cd ComfyUI && git pull && pip install -r requirements.txt
pip install -U huggingface_hub
hf download Comfy-Org/Ming-Image \
  diffusion_models/ming_image_0.1_design_int8_convrot.safetensors \
  text_encoders/ming_image_0.1_ling_mini_2.0_w4a8.safetensors \
  vae/ming_image_vae_bf16.safetensors \
  --local-dir models

That downloads about 19.2 GB from the Comfy-Org/Ming-Image repo: a 6.18 GB int8 diffusion model, a 12.81 GB w4a8 text encoder and a 0.25 GB VAE. If you have more room, the int8 text encoder is 19.51 GB and the BF16 versions are 12.31 GB and 36.68 GB. To start, load the ming_image_test_01.json workflow attached to the PR.

Hardware, honestly: nobody has published measured VRAM numbers for the ComfyUI path yet. Based on file sizes alone (our estimate, not a benchmark), a 24 GB card with 32 GB or more of system RAM is the realistic minimum for the int8 plus w4a8 combo, since ComfyUI loads the encoder and the diffusion model in turn. The community GGUF quants go down to 4.71 GB (Q2_K) and 5.87 GB (Q4_K_M) for the diffusion model and use the ComfyUI-GGUF loaders. The uploader notes that a compatibility fix is still pending, though, so treat them as experimental. Mac users can try the community MLX 4-bit port.

Option 3: the official CLI (80 GB GPU). If you rent a cloud H100 or A100 80GB, the reference pipeline is git clone https://github.com/inclusionAI/Ming-Image, pip install -r requirements.txt, and then python infer.py --model inclusionAI/Ming-Image-0.1-Design --task text-to-image --prompt "your prompt" --resolution 2048.

Honest Trade-Offs

• “6B” is misleading. The diffusion transformer is 6B, but the full pipeline includes a 34 GB Ling-mini-2.0 MoE text encoder. OrcaRouter counts 26.44B parameters in total.
• Square only. Text-to-image output is 1024×1024 or 2048×2048. For 16:9 banners or 9:16 stories, you’ll have to crop or outpaint.
• The prompt rewriter is basically required. Short prompts work, but the vendor’s results depend on the JSON layer format, so you need a second model to write it.
• Early ComfyUI issues. One tester found that a repacked int8 file with missing metadata was detected as Z-Image and crashed at VAE decode. A fix went in before the merge, but other third-party repacks may hit the same problem.
• Vendor-picked samples. The gallery above is curated. Independent arena scores place Ming in the middle overall, so it’s not a general-purpose leader.

Workflow Tips for Designers

1. Run the repo’s rewriter system prompt in any free chat model to turn “SaaS pricing page, three tiers” into layer JSON, then paste that JSON into the demo.
2. Put every piece of on-screen text in quotes, exactly once. The prompt format is built around rendering quoted strings verbatim.
3. Generate product cutouts with an RGBA trigger phrase and composite them in Photoshop or Figma instead of running a separate background remover.
4. Use the Layer model on your own flat mockups to get editable text, card and background layers you can adjust separately.
5. Iterate at 1024 px and only render the final at 2048 px. With 12 steps, a 1024 draft is fast even on the free demo quota.

Want to see how closed models handle this same kind of work? Watch our Grok vs Meta Muse vs GPT Image 2.5 design challenge on the Creative AI Show YouTube channel, then try the same briefs in Ming’s free demo.

FAQ

Is Ming-Image-0.1-Design free?

Yes. The weights are free on Hugging Face and ModelScope, there’s a free ZeroGPU demo, and ComfyUI supports it natively at no cost. The only costs are your own hardware or cloud GPU time.

Can I use Ming-Image-0.1-Design commercially?

Yes. Both the Design and Layer models are released under the MIT License, which allows commercial use. You’re still responsible for trademarks or likenesses that show up in your outputs.

What are Ming-Image-0.1-Design’s system requirements?

Officially, one CUDA GPU with 80 GB of VRAM running BF16. In ComfyUI, the int8 plus w4a8 files total about 19 GB, and a 24 GB card with 32 GB or more of system RAM is a reasonable estimate (not yet independently measured). GGUF quants may work on less.

Does Ming-Image work in ComfyUI?

Yes, as of September 24, 2026. Update ComfyUI to the latest master and use the Comfy-Org/Ming-Image files. Text-to-image, editing and the Layer model are all supported.

Accurate as of September 25, 2026. Pricing, quantizations and leaderboard positions move fast.