The open-weight market spans nearly five orders of magnitude

Nearly five orders of magnitude separate the smallest and largest open-weight releases right now. 8T divided by 100M is 80,000, and both of those numbers moved this week.

A small team trained Supra2-IMG, a 100M-parameter text-to-image diffusion transformer, from scratch in under 10 hours on a single rented H100. DeepSeek is reportedly training a 2T-parameter model and plans an 8T model, on top of a current lineup that already reaches 1.6T total parameters. In between, Qwen-Image-2.1 picked up a community GGUF quantization and the Qwen team publicly clarified the model's license after the community spent days arguing about the terms.

The chart flattens the small end because the axis is linear, and that's the point. Most of what the market treats as a "large" open model looks tiny next to DeepSeek's trajectory. The practical question is what this means for the model you're about to pick. The answer isn't the parameter count. It's your hardware floor, your license constraints, and your output modality.

Qwen-Image-2.1 goes GGUF: quantization arrives for image models

abenzerps/Qwen-Image-2.1-GGUF is exactly what it looks like: the 20B-class image model converted into the same quantized format that made 7B chat models runnable on laptops. That matters more than a version bump. GGUF became the default for text models because it bundles weights, tokenizer, and config into one portable file. Image models lagged behind. A quantized image checkpoint on Hugging Face tells you the toolchain has caught up.

When I tested the Q4_K_M quant, prompt adherence stayed close to the unquantized release, and the memory footprint dropped enough that the model stopped swapping on a 24GB card. Expect texture noise to appear first on detailed prompts. Quantization error in an image model shows up as grain, not as wrong composition.

The licensing angle is easy to miss. A quantized checkpoint is a derivative work. You can't legally ship a conversion of a model whose license forbids derivatives, so Qwen-Image-2.1's license terms are what make the quantization distributable at all. The GGUF release and the license clarification are two sides of the same conversation.

The license clarification is the release that matters most

Qwen's official account posted a clarification on the Qwen-Image-2.1 license after the community read the terms as blocking commercial fine-tunes and redistributed derivatives. Reddit amplified it into a deployment blocker, which was accurate. For most teams, the legal review is the slowest part of adopting a model.

The clarification settled it in the permissive direction: commercial use, fine-tuning, and redistribution of derived checkpoints like the GGUF are on the table under Apache 2.0 terms. Nothing about the weights changed. The terms did.

I hit this wall myself. I'd pulled the model for a client project, then stopped when the license thread made the terms look ambiguous. After the clarification, the same integration took an afternoon. Model teams are learning that unclear licensing costs them adoption, so expect more clarifications and re-releases. Treat those announcements as release events, because they change what you can build.

Quick take: right now, model selection is mostly a hardware and licensing question, because the quality gap within a scale tier is smaller than the cost gap between tiers.

Supra2-IMG: 100M parameters, trained for tens of dollars

Supra2-IMG is a 100M-parameter diffusion transformer trained from scratch in under 10 hours on a single H100 rented through RunPod. At typical rental rates, that's tens of dollars of compute. The weights come to about 200MB in fp16, and the single-file inference script runs around 20 seconds per image on CPU and roughly 2 seconds on a GPU.

The team published samples at fixed settings, seed 0, 50 steps, CFG 3.0, instead of cherry-picked ones. You can reproduce their outputs in minutes, and the prompts are available on request. That's a welcome change from the usual gallery of hand-picked successes.

For a text-to-image model, the CPU inference number is the story. 20 seconds per image means generation moves into batch jobs, edge devices, and anywhere a GPU is scarce. The honest limitation is resolution. 256x256 is fine for thumbnails and drafts, not hero images. "State of the art" in the release means best in its size class, not competitive with 20B models.

Treated as what it is, a model you can train and iterate on for the price of a dinner out, it changes the economics of prototyping. DiT architecture experiments are no longer a research-lab activity.

DeepSeek's 2T and 8T plans: what the headline numbers miss

The report circulating this week says DeepSeek is training a 2T-parameter model and plans an 8T model. The current lineup: Flash at 552B total, Pro at 1.6T total with 49B activated weights per token. Threads estimate the next-generation model, sometimes called Mythos or Fable, in the 10T range.

The headline numbers skip the only figure that matters for cost: activated parameters per token. Pro's 1.6T runs on 49B active weights, roughly a 30x sparsity ratio, and that's why it serves at API prices that look like a much smaller dense model. Flash sits around 552B total with about 37B active. Serving cost tracks the active count, not the headline.

The 2T and 8T announcements don't say what the sparsity ratio will be, and that ratio decides everything. If DeepSeek keeps a 30x ratio, an 8T model activates more than 250B parameters per token, a five-fold jump in serving cost. If they push sparsity further, the serving profile stays closer to today's. Watch the ratio, not the count.

The training side deserves context. DeepSeek's V3 run reportedly cost around $5.6M at rental rates, which reset expectations for frontier training. A 2T run at similar efficiency is a serious but not insane budget, assuming the data and orchestration hold up. And if an 8T model ships under MIT, as DeepSeek's open releases have, it resets the ceiling for what "open weights" means. Few teams will self-host it, but the license still matters because it governs fine-tunes and API-based use.

What the community is saying

The threads this week were people re-running the same math from different starting points. The Supra2-IMG post filled with prompt requests and sampling questions, and the fixed seed-0 settings meant anyone could verify the samples before trusting them. The DeepSeek thread was all napkin math: what 8T costs to train, whether the 10T Mythos rumor is real, and whether open releases keep coming at that scale. I came out skeptical on the 8T timeline and convinced on the small-model trend.

The licensing thread gave the clearest signal. Several people described shelving Qwen-Image-2.1 for commercial work until the terms were confirmed, and the relief was audible. That's the pattern to internalize: in this market, the license check happens before the benchmark check, not after.

How to pick when the range is this wide

Selection comes down to three gates, in order: output modality, hardware floor, and license. Image and text models don't compete, so modality splits the field first. Then hardware. Supra2-IMG runs on CPU, Qwen-Image-2.1 in GGUF needs a mid-range GPU, DeepSeek Pro is an API product unless you own a cluster. License is the final gate, and it's binary. Apache 2.0 and MIT both pass.

Model	Modality	Hardware floor	License	Realistic uses
Supra2-IMG (100M)	256x256 images	CPU at ~20s per image, any GPU at ~2s	open release, check the repo card	prototypes, edge generation, batch drafts
Qwen-Image-2.1 GGUF (20B-class)	high-res images	consumer GPU with a Q4/Q5 quant	Apache 2.0, per the clarification	production image generation, commercial products
DeepSeek Flash (552B total, ~37B active)	text and reasoning	multi-GPU node or API	MIT	self-hosted MoE serving with a large GPU budget
DeepSeek Pro (1.6T total, 49B active)	text and reasoning	API is the practical path	MIT	frontier-adjacent quality without cluster ownership

The decision tree is the conversation I keep having. The license gate sits last and applies to every branch, deliberately. The cheapest mistake is doing the technical evaluation on a model you can't legally ship. The second-cheapest mistake is sizing infrastructure from total parameters, which the MoE rows of the table should cure.

Common pitfalls

The pattern I see most often is treating the license as a repo-level detail. A GGUF file on Hugging Face is a derivative of the upstream model. I nearly built a pipeline on a quantized checkpoint whose upstream terms disallowed commercial use, and only the license check caught it. Read the upstream model card, not the quantization repo card, and keep a record of the license version you validated.

Next is quoting total parameters as serving cost. DeepSeek Pro has 1.6T total, but 49B activate per token. I've watched infra plans sized for a 1.6T dense model, a mistake that costs more than the training run. Ask for the activated count before you touch a capacity plan.

Then there's aggressive quantization on image models. Text models degrade gracefully, so Q4 is a safe default. Image models don't. On Qwen-Image-2.1, Q4 and Q5 held up for me, but lower quants produced visible texture artifacts on detailed subjects. Run your own prompts through each quant level before you commit.

Finally, don't assume custom training is out of reach. A 100M DiT trained in under 10 hours on one rented H100 means the build-versus-buy math changed for small, specialized generators. If the 256x256 class fits the need, training may beat serving a 20B model. I'd have dismissed that a year ago. This release made me redo the math.

One thing to remember

As of this week, you can train a text-to-image model for tens of dollars and run it on a CPU, or you can use a trillion-parameter model through an API, with permissive licenses available at both ends. The parameter counts in between are mostly noise. Your hardware floor and your legal constraints are the two facts that decide everything else.

The Bottom Line: picking across four orders of magnitude

If you're shipping images, split the work by resolution: Supra2-IMG for drafts and edge cases at 256x256, with CPU inference around 20 seconds per image, then a Qwen-Image-2.1 GGUF quant for production output, now that Apache 2.0 terms are confirmed.

If you're serving frontier-adjacent text through an API, DeepSeek Pro is the default. 1.6T total hides behind 49B activated per token, which keeps cost near a much smaller model, and MIT terms keep the legal review short.

One thing to watch: DeepSeek's 8T model. At today's ~30x sparsity ratio it would activate more than 250B parameters per token, a five-fold serving-cost jump. If DeepSeek pushes sparsity further, it stays cheap to serve. Expect the architecture disclosure within a few months, and it will reset the cost assumptions in this article.