A 0.22B Model Matches an 11.9B One at Inpainting, and Runs 15x Faster

TL;DR

On June 17, 2026, researchers from Huazhong University of Science and Technology and vivo AI Lab put Moebius on arXiv: an open-source image inpainting model with just 0.22B parameters that, per the paper, rivals and in some scenarios surpasses the 11.9B FLUX.1-Fill-Dev on natural and portrait benchmarks. That is under 2% of the parameter count for a claimed >15x speedup in total inference time. The trick is not a bigger model. It is a smarter distillation recipe that trains the small model entirely in latent space. For anyone running image tools on a single consumer GPU, this is the more interesting kind of progress: not a new frontier ceiling, but the same quality dragged down into hardware you actually own.

What they shipped

Moebius is a latent diffusion inpainting model. You hand it an image plus a mask, it fills the masked region. The headline is the size-to-quality ratio:

• 0.22B parameters versus FLUX.1-Fill-Dev at 11.9B. The paper frames this as "less than 2%" of the parameters.
• >15x acceleration in total inference time against 10B-level baselines, with a reported per-step cost of about 26 ms.
• Evaluated across natural scenes (Places2) and portraits (CelebA-HQ, FFHQ), where it matches or edges out FLUX.1-Fill-Dev and SD3.5 Large-Inpainting on generation quality.
• It is open source: weights and code are on GitHub, paper on arXiv (2606.19195).

The point the authors are making is explicit: the field's default move, throw more parameters at the problem, is not the only way to reach industrial-grade inpainting quality. A carefully trained sub-billion model can sit in the same quality band as a model fifty times its size.

How a 0.22B model keeps up

The mechanism is distillation, but with two design choices that matter. First, Moebius learns from a larger teacher model (PixelHacker) using an adaptive multi-granularity distillation strategy: instead of matching the teacher at a single level, the student is supervised at multiple granularities and the training dynamically balances several gradient-based losses so no single objective dominates.

Second, and this is the part with real compute implications, the whole distillation happens strictly in latent space. There is no expensive pixel-space decoding in the training loop to compare student and teacher outputs. The model also uses a custom Local-Lambda Mix Interaction block to keep the architecture compact. The combination is what buys both the parameter cut and the inference speedup at once.

Why a builder should care

Inpainting is not a toy task. It is the engine behind object removal, photo cleanup, generative fill, masked edits, and a lot of the "magic eraser" features shipping in consumer apps. The problem until now has been that the good open models in this space are 10B-plus, which means real VRAM, slow steps, and either a fat GPU or a cloud bill.

1. It fits where the big models do not

A 0.22B latent diffusion model is small enough to run comfortably on a single mid-range consumer GPU, and the per-step cost is low enough that interactive editing stops being a server-side luxury. If you are building a local-first photo tool or a self-hosted editing pipeline, the difference between an 11.9B and a 0.22B backbone is the difference between "needs a datacenter" and "runs on the laptop."

2. The throughput is the product feature

A >15x inference speedup is not just a cost line. At roughly 26 ms per step, inpainting moves toward something that feels live. For any app where a user paints a mask and waits, latency is the experience, and this is the axis Moebius optimizes hardest.

3. It is one more nail in scale-at-all-costs

This lands the same week the open-weight conversation has been dominated by ever-larger frontier drops. Moebius is the counterprogramming: take a known capability, distill it down, and give it away. We have seen this movie in language models, where small distilled models keep eating tasks people assumed needed the frontier. The same compression dynamic is now visibly playing out in image generation.

The honest caveats

Read the claim precisely, because the framing does a little work.

• It is a specialist, not a generalist. FLUX.1-Fill-Dev is part of a broad generative family; Moebius is tuned for inpainting. "Rivals an 11.9B model" means on this task, on these benchmarks, not across everything that model can do.
• The numbers are the authors' own. The benchmarks (Places2, CelebA-HQ, FFHQ) are standard and the code is public, which is good, but independent reproduction on your own images is still the real test. Inpainting quality is partly subjective and benchmark wins do not always survive contact with messy production data.
• Distillation inherits the teacher's ceiling. A student distilled from PixelHacker is bounded by what the teacher knows. The speedup is real; the quality is "as good as," not "better than the entire field."
• It is fresh off arXiv. Submitted June 17, 2026. Treat the headline numbers as a strong vendor-grade claim pending the community kicking the tires, not settled fact.

None of that undercuts the core result. The interesting thing about Moebius is not that it sets a new quality record. It does not. It is that it holds a near-frontier quality bar at a fraction of the size and cost, and ships the weights so you can check. For builders, "as good as the big one, small enough to run, free to use" is frequently the more valuable kind of release.

Key Takeaways

• Moebius is a 0.22B open-source image inpainting model from HUST and vivo AI Lab, on arXiv as 2606.19195 (submitted June 17, 2026).
• It claims parity with, and in places improvement over, the 11.9B FLUX.1-Fill-Dev on Places2, CelebA-HQ, and FFHQ, using under 2% of the parameters.
• Reported >15x speedup in total inference time, roughly 26 ms per step, making interactive and local inpainting practical.
• The method is adaptive multi-granularity distillation done entirely in latent space, avoiding pixel-space decoding during training.
• It is a specialist model and the figures are the authors' own, so independent reproduction on real workloads is the bar before you bet on it.
• The broader signal: the small-distilled-model wave that hit language models is now compressing image generation too.

Sources: arXiv: Moebius (2606.19195), Moebius project page, GitHub: hustvl/Moebius, Hugging Face Papers