Open Source
Open Source

Ant Ming-Image: MIT is free for commercial use, Qwen is not

A fact-check of inclusionAI/Ming-Image (2026-09-24 GitHub API snapshot: 91 stars, 6 forks, Python, MIT). One design line ships two weights: Design for text-to-design, producing UI, dashboards, infographics and posters end to end, and Design-Layer, which splits a flat design into 2 to 9 semantically independent RGBA transparent layers. The architecture is a 6.15B design transformer plus a 17.01B multimodal LLM plus a 3.09B connector, about 26.44B total (vendor basis). It offers a native RGBA VAE, 8K structured prompts, and sampling defaults of steps 12 and CFG 1.0 for Design (2.0 for Layer), with recommended resolutions 2048 and 1024. The license red line: MIT allows commercial use, self-hosting and derivative work, contrasting with Qwen-Image 2.1's non-commercial Qwen Research License. The hardware floor is a single 80 GiB GPU at BF16; speed and benchmark figures are tagged vendor basis and not independently retested.

Published September 25, 20269 min read
<!-- ming-image-resource | open-source | Ant Ming-Image: MIT is free for commercial use, Qwen is not -->

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.

ItemMeasured value (GitHub API snapshot, 2026-09-24)
RepositoryinclusionAI/Ming-Image (inference code repo)
Stars91
Forks6
Primary languagePython
Created2026-09-17
WeightsHuggingFace inclusionAI/Ming-Image-0.1-Design and -Layer; ModelScope mirrored
GitHub API license fieldMIT (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:

bash
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-only

Sampling 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.
  • --resolution takes a positive integer and snaps to the nearest bucket; --steps / --cfg can 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:

bash
python -m unittest -v tests.test_inference_smoke.InferenceSmokeTest.test_two_step_showcase_smoke

Note 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:

DimensionMing-Image (MIT)Qwen-Image 2.1 (Qwen Research License)
License typeMIT (permissive)Qwen Research License Agreement
Commercial useYesNon-commercial, restricted
Self-hostingYesYes (but license-bound)
Modify and close sourceYesRestricted
Source confirmationFour 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-Design and inclusionAI/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.

This article is AI-assisted and human-edited. Last updated: 2026-09-25

FAQ

Can Ming-Image really be used commercially for free? Is the MIT claim solid?
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.
How does it differ from Qwen-Image 2.1, and why compare them?
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.
Can I run it on a 24 GiB 4090?
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.
What is the inference command, and how many steps by default?
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.
Can the layers from Layer be edited directly in Figma?
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.

Related

Open Source

Step-Code Open Source: StepFun's Terminal Agent at 438 Stars

A fact-check of stepfun-ai/Step-Code (2026-09-27 GitHub API snapshot: 438 stars, 41 forks, TypeScript, license field MIT, created 2026-06-01, pushed 2026-09-26, 44 open issues). A terminal coding agent covering the full task loop of reading code, editing code and running tests; it binds to the Step provider (auto-discovers Step models at login, the opposite of MiniMax Code's BYOK multi-provider route); it supports MCP servers, Agent Skills and multi-agent orchestration out of the box; the /goal command delegates long-horizon tasks; StepPage publishes a local page as a live static site in one command. Vendor-reported figures: Terminal Bench 2.1 pass rate 80.9% tied for first, self-built Multi-Frame benchmark 73.3% on top, lowest average 5.09M tokens — all tagged vendor self-reported and not independently retested.

Sep 27, 20269 min read
Open Source

Sequence In, Structure Out: Why Did a 62-Star Repo Make Nature?

structRFM is a structure-guided RNA foundation model from the MIRACLE lab at USTC; the paper appeared in Nature on November 5, 2026 (DOI 10.1038/s41586-026-11210-2). The repository heqin-zhu/structRFM is MIT licensed and showed 62 stars in a November 6, 2026 GitHub API check; it was created in February 2025 and its README still points to the August 2025 bioRxiv preprint. The team says the roughly 21 million sequence-structure pairs, model weights and source code are public: the dataset is built from RNAcentral and BPfold with a 512-token length cap and is 4.5 GB on Zenodo. SgMLM structure-guided masked language modeling and MUSES multi-source structure ensembling let the model emit sequence-level, nucleotide-level and pair-level features from sequence alone, supporting secondary and tertiary structure prediction, splice site prediction, IRES identification, ncRNA classification and zero-shot homology classification.

Nov 6, 20269 min read
Open Source

17 Seconds on a CPU: Can an API Prove Which Model Answered?

anthropics/FlashProve is an open-source research prototype for zero-knowledge verifiable inference from Anthropic (Apache-2.0, 843 stars per a November 5, 2026 GitHub API check, version 0.16.0, officially labeled a research artifact: not maintained and not accepting contributions). The three-step protocol: the provider publishes a weight commitment ID offline (about 39 minutes on one H100), attaches a GPU-generated proof to each reply (about 19MB per 1024 tokens), and anyone verifies with cp_verify on a plain CPU in seconds. It runs Llama 4 Maverick at full 400B size on a single H100 at about 110 tokens per second of proof prefill with about 17-second CPU verification, at a cost of roughly 70 to 95 times normal inference GPU time; soundness is formally proved in Lean 4. It proves provenance, not correctness, and no major provider ships proofs yet.

Nov 5, 20269 min read