Last month this site tore down an on-device agent whose licensing tied everyone in knots: omnimind-ai/OmniBot used segmented dual licensing, so commercial use meant signing a contract first. This time the story is clean. Ant Group's inclusionAI open-sourced its Ming-Image design line, the repository is inclusionAI/Ming-Image, and the license field comes back as MIT straight from the GitHub API. For teams that want to ship a design model inside a product, the license matters more than parameter counts, so we settle the license first and then talk about what it can draw.
Repo Facts: 91 Stars, Very Early, but MIT Is Confirmed
Every number below comes from the GitHub API, snapshot taken 2026-09-24. Stars and forks move daily, so read this as a same-day cross-section rather than a standing conclusion, and treat no star count as proof of quality.
| Item | Measured value (GitHub API snapshot, 2026-09-24) |
|---|---|
| Repository | inclusionAI/Ming-Image (inference code repo) |
| Stars | 91 |
| Forks | 6 |
| Primary language | Python |
| Created | 2026-09-17 |
| Weights | HuggingFace inclusionAI/Ming-Image-0.1-Design and -Layer; ModelScope mirrored |
| GitHub API license field | MIT (spdx_id: mit) |
A few notes. First, 91 stars is "just born": the repo was created 2026-09-17 and pushed through 2026-09-23, a week before the snapshot. We do not rank by stars, and we do not read star count as strength - few stars on an early project is normal. Second, the primary language is Python because this is an inference code repo; the real image work runs inside the design transformer and the companion text stack. Third, the MIT license is not a guess; it is the spdx_id the GitHub API returns directly, cross-confirmed by three more sources below. This is one of the few facts we state flatly.
One more word on size: the repo is about 52.88 GB and the weights about 49.25 GiB (orcarouter figure), with no model_index.json standardized entry - the route is "git clone the inference repo plus python infer.py". For engineers wiring it into a pipeline, that means reading the README rather than waiting for an SDK.
The Two Models: Design Generates End to End, Layer Splits a Design Into Layers
The Ming-Image line actually ships two weights, both in the 6B class, but they do different jobs.
Ming-Image-0.1-Design: text to design. Drop in a one-line brief and it emits a complete visual design end to end - UI screens, dashboards, infographics, and posters all come out directly, with text and layout holding steady instead of the classic "register" rendered as "reglster" failure. It plans global layout, color, and asset style in one pass rather than painting and stitching, so the look stays coherent.
Ming-Image-0.1-Design-Layer: layer decomposition. Take one already-flattened design image and split it into 2 to 9 semantically independent RGBA transparent layers. Text, subject, and background layers are separate, so you can edit the copy, move the subject, or swap the background on its own without redrawing the whole image. For a design workflow that equals turning "generate an image" into "generate an editable engineering file", which is the single most different step from ordinary text-to-image.
On parameter scale, flagged as vendor or evaluation figures, not independently retested: the design transformer itself is 6.15B; the companion text stack also carries a 17.01B multimodal LLM plus a 3.09B connector, for a total of about 26.44B parameters. The Design-Layer weight specifically is 6,154,908,736, per the orcarouter figure. We have not independently retested these numbers; treat them as order-of-magnitude only, not as benchmark conclusions.
Core Capabilities: Native RGBA, 8K Prompt, End to End, Layering
The README and model card lay the capabilities out plainly; here are four.
One, native RGBA VAE. It generates transparent assets with an Alpha channel directly - people, products, icons, and decorations come out see-through, already cut out with no matting pass. For compositing, stickers, or transparent-background assets, this removes a post-processing chain, and it is why the project calls itself "design" rather than "drawing".
Two, 8K long structured prompt. The model organizes your request into four dimensions - copy, modules, layout, and visual style - as a structured long input, understood in full rather than truncated. In other words you can feed it something close to a requirements document with font sizes, palettes, and module relations, and it reads them all.
Three, end-to-end holistic generation. As noted, it plans global layout, color, and asset style in one pass, avoiding the style fracture that comes from generating pieces and stitching them. This is the core difference from "emit elements then assemble the page" routes, and the reason posters and dashboards - strongly holistic artifacts - prefer it over a general text-to-image model.
Four, the layering mechanism. The Layer model has a three-piece internals: a Type Token explicitly constrains each layer's design role; Alpha-Aware Layer Optimization handles transparent-edge artifacts; Composite-Layer Stack Consistency constrains the re-stacked result to reconstruct the original. Together they guarantee "it splits open and also snaps back", avoiding layers that misalign or fail to reconstruct the source.
As a side note on the delivery chain: the official ling-cookbook repo ships a Design Skill (Text-to-Page, which drafts a plan before writing code) and a PPT Skill (one-click restore of a design image into an editable PPT). These are entry points that connect the model to concrete workflows, not the model itself, but they save you a fair amount of glue code.
Architecture Deep Dive: 6.15B Design Transformer plus 17.01B LLM plus 3.09B Connector
Spreading the parameters from the previous sections, the architecture is a "design transformer plus multimodal LLM text stack" route, flagged as vendor and evaluation figures, not independently retested.
- Design transformer: 6.15B. This is the trunk that actually paints, turning the structured request into visual layout and pixels.
- Multimodal LLM: 17.01B. This is the semantic brain of the text stack, reading the four dimensions - copy, modules, layout, visual style - of the 8K prompt in full and accurately.
- Connector: 3.09B. This bridges the structured intent the LLM understood to the design transformer, for a total of about 26.44B.
Why split into three stages? Because in design tasks, semantic understanding and visual generation are different jobs: one eats long text and reasons structurally, the other controls layout and pixels. Separating the text stack from the painting trunk reuses a mature multimodal LLM while the design transformer focuses on drawing; that is why the 17.01B text stack outweighs the 6.15B trunk - understanding-side overhead, not waste.
The native RGBA VAE is the last segment of the painting trunk in this architecture: it outputs not plain RGB but RGBA with Alpha, so transparent assets are generated natively, not added later. On this point it matches Qwen-Image 2.1, which also supports RGBA natively, but the two licenses are completely different, as the next section shows. Worth stressing: native RGBA output is the precondition that lets this architecture attempt Layer decomposition at all - without a transparency channel, layers are empty talk.
Getting It Running: git clone plus infer.py, Sampling Defaults Already Set
The path to a running setup is short; the commands are quoted directly from the GitHub README:
export CUDA_VISIBLE_DEVICES=0
git clone https://github.com/inclusionAI/Ming-Image
cd Ming-Image && pip install -r requirements.txt
# text to design
python infer.py --model inclusionAI/Ming-Image-0.1-Design --task text-to-image \
--prompt "your prompt" --resolution 2048 --output-dir outputs/t2i
# layer decomposition
python infer.py --model inclusionAI/Ming-Image-0.1-Design-Layer --task layer \
--prompt "Decompose this image into N layers ..." --resolution 1024
# validate the checkpoint contract only (no weights loaded)
python infer.py --model inclusionAI/Ming-Image-0.1-Design --task text-to-image \
--prompt "A red circle on a white background" --validate-onlySampling defaults (vary by task, all from the README):
- Text-to-image: steps 12, CFG 1.0, resolution buckets 1024 / 2048, 2048 recommended (square).
- Layer decomposition: steps 12, CFG 2.0, buckets 512 / 1024, 1024 recommended.
--resolutiontakes a positive integer and snaps to the nearest bucket;--steps/--cfgcan override explicitly.- With FlashAttention2 installed, add
--attn-implementation flash_attention_2(the portable CLI defaults to eager).
Prompt Enhancement (PE, a preprocessing step outside infer.py) is worth mentioning: use Ling-3.0-flash-VL or qwen3.8-27B to rewrite a short description into Figma-style structured JSON, then feed that to --prompt; the system prompt ships in assets/. This step is optional but improves stability on long requests.
The smoke test command is also given:
python -m unittest -v tests.test_inference_smoke.InferenceSmokeTest.test_two_step_showcase_smokeNote this needs both model weights plus a single 80GiB card to pass; it is an acceptance-level test, not something you click after install. It verifies the Design-plus-Layer two-stage linkage, most useful for confirming your environment is not misconfigured.
License Red Line: MIT for Commercial Use, vs Qwen-Image 2.1 Non-Commercial
This is the focus of the article, and the point most easily misread.
Ming-Image's MIT is not a lone signal. GitHub API, datanorth.ai, bittide.aicompass.dev, and orcarouter.ai all state MIT consistently, and all note commercial use allowed. So the following three sentences can be stated flatly: under the MIT license you may self-host, you may use it commercially, and you may modify and redistribute. Four sources agree, which makes this one of the few facts in this batch we need not tag with "figure".
The natural contrast is the same-track Qwen-Image 2.1: its license is the Qwen Research License Agreement, non-commercial. That means on the Qwen line you can play in research, but shipping it inside a product or service is restricted; Ming-Image's MIT has no such wall. A table makes it clearer:
| Dimension | Ming-Image (MIT) | Qwen-Image 2.1 (Qwen Research License) |
|---|---|---|
| License type | MIT (permissive) | Qwen Research License Agreement |
| Commercial use | Yes | Non-commercial, restricted |
| Self-hosting | Yes | Yes (but license-bound) |
| Modify and close source | Yes | Restricted |
| Source confirmation | Four sources agree (GitHub API etc.) | Vendor figure |
The hardware bar must be stated clearly (per the model card): the default and minimum validated deployment is a single GPU with at least 80 GiB of VRAM, in BF16. That is the only configuration that runs both model families end to end. A 24 GiB consumer card has no official guidance; the INT4 / GGUF quantization builds that appeared within hours in the community are community routes, not official endorsements.Deployment frameworks: the official side gives three routes - diffusers, vLLM-Omni (recipes / installation guide), and ComfyUI; the community side produced INT4 / INT8 / FP8 / GGUF / ComfyUI builds within hours, all tagged "community, not official". To get onto a consumer card you can only take the community quantization, and stability is on the community, not a promise from the vendor.
Benchmark numbers are all tagged as figures: the model card claims the top spot on Artificial Analysis' UI/UX open-source leaderboard, but that board is presented as an image, with no citable numbers in text, no named competitors, and no reproducible script; both datanorth and orcarouter note it cannot be independently verified, and we did not retest it. The Crello-Test 12-firsts, the 183s vs 795s per inference (about 4.3x faster), the about 20 seconds per image after engineering optimization, and the edit cost at only 1/7 of GPT-image2 - all of these come from ai-bot and vendor marketing, and are uniformly tagged "vendor or model-card figure, not independently retested".
Our take and the division of labor: this site's batch 22 "image model cost comparison" looks only at unit price and raw quality; this article looks only at design workflow, editability, layers, RGBA, license, and self-hosting. Batch 33 "AI video workbench comparison" is video and real time; this article is static design images. Closing thought: Ming-Image proves a design image can be open-sourced under MIT, split into layers, and self-hosted - not that a small card can run it or that the leaderboard numbers are retested. Between the license claim and the hardware claim sit your own 80GiB of VRAM and one pass of the smoke test.
FAQ
Q1: Can Ming-Image really be used commercially for free? Is the MIT claim solid? A1: Solid. The GitHub API license field returns spdx_id: mit directly, and datanorth.ai, bittide.aicompass.dev, and orcarouter.ai all also state MIT and note commercial use allowed, four sources in agreement. Under MIT you may self-host, use commercially, and modify. This is not a guess; it is a fact we can state flatly.
Q2: How does it differ from Qwen-Image 2.1, and why compare them? A2: The core difference is the license. Both support RGBA natively, but Qwen-Image 2.1 is Qwen Research License (non-commercial) and restricted for products, while Ming-Image is MIT with no such wall. Capability numbers (Crello, speed) come from vendor or model-card figures we did not retest; the comparison takes only the license as the red line.
Q3: Can I run it on a 24 GiB 4090? A3: The vendor gives no deployment guide for a 24 GiB consumer card. The only validated configuration per the model card is a single GPU with at least 80 GiB VRAM in BF16. The INT4 / GGUF quantization builds that appeared within hours are community routes, not official endorsements, and stability is on the community, not an official promise.
Q4: What is the inference command, and how many steps by default? A4: After git clone and pip install -r requirements.txt, run python infer.py --task text-to-image|layer. Text-to-design defaults to steps 12, CFG 1.0, recommended resolution 2048; layer decomposition defaults to steps 12, CFG 2.0, recommended 1024. With FlashAttention2 installed add --attn-implementation flash_attention_2. See the getting-started section.
Q5: Can the layers from Layer be edited directly in Figma? A5: Layer outputs 2 to 9 RGBA transparent layers where text, subject, and background can be edited, moved, and swapped separately, but it is not a Figma source file. For an editable PPT, the official PPT Skill restores a design image into an editable PowerPoint and lives in the ling-cookbook repo; the Figma side needs your own integration, and the vendor promises no native round trip.
Sources
- GitHub repository
inclusionAI/Ming-Image: README and GitHub API (https://api.github.com/repos/inclusionAI/Ming-Image), snapshot 2026-09-24: 91 stars / 6 forks / Python / created 2026-09-17 / license field MIT - HuggingFace weights
inclusionAI/Ming-Image-0.1-DesignandinclusionAI/Ming-Image-0.1-Design-Layer, ModelScope mirrored - ai-bot.cn: https://ai-bot.cn/ming-image-0-1-design/
- datanorth.ai/news/ant-group-releases-ming-image-0-1-design
- bittide.aicompass.dev/article/.../ming-image-0-1-design
- orcarouter.ai/blog/ming-image-0-1-design-vs-nano-banana-2 and vs-qwen-image-2-1
- License conclusions cross-confirmed by the GitHub API MIT field plus three sources; benchmark, Crello, and speed numbers mostly come from model-card and vendor chart figures, not independently retested by this site
Based on the README and GitHub API as of 2026-09-24; star counts are a same-day snapshot and change daily.