There are many providers nowadays offering model inference as a service. Most of them provide TypeScript SDKs, and some of them provide Swift packages. None of them offer hybrid local and remote generation support, which is increasingly essential for customers trying to balance reach, quality, and cost.

Today, we are releasing a preview of MediaGenerationKit, a Swift package that allows you to integrate the latest open-weight media generation models into your app. You can choose to run them locally, host inference stack on your own Cloud or through our Cloud. For model selection, you can directly use a Hugging Face link to reference a model, or use one of our internal model identifiers. It supports the same comprehensive generation configurations that the Draw Things app supports.

For a simple example, it is really just a few lines of code:

import Foundation
import MediaGenerationKit

@main
struct ExampleApp {
  static func main() async throws {
    try await MediaGenerationEnvironment.default.ensure(
      "flux_2_klein_4b_q8p.ckpt"
    )

    var pipeline = try await MediaGenerationPipeline.fromPretrained(
      "flux_2_klein_4b_q8p.ckpt",
      backend: .local
    )

    pipeline.configuration.width = 1024
    pipeline.configuration.height = 1024
    pipeline.configuration.steps = 4

    let results = try await pipeline.generate(
      prompt: "a cat in studio lighting",
      negativePrompt: ""
    )

    try results[0].write(
      to: URL(fileURLWithPath: "/tmp/cat.png"),
      type: .png
    )
  }
}

Unlike draw-things-cli, MediaGenerationKit allows you to offload generation tasks either to your local gRPC server or to our Cloud Compute backend. For our Cloud Compute backend, you can request an API key with your existing Draw Things+ account, or purchase one, at api.drawthings.ai/dashboard. The default API key supports up to 20 generation tasks per month for the Free tier and up to 200 generation tasks per month for the Draw Things+ tier. Beyond that, you would use the pay-as-you-go API flow.

You can integrate MediaGenerationKit today using Swift Package Manager:

import PackageDescription

let package = Package(
  name: "MyApp",
  dependencies: [
    .package(
      url: "https://github.com/drawthingsai/media-generation-kit.git",
      revision: "37e0b70092ad1a0c1d4c6b24f16e17b73f1b1fb3"
    )
  ],
  targets: [
    .executableTarget(
      name: "MyApp",
      dependencies: [
        .product(name: "MediaGenerationKit", package: "media-generation-kit")
      ]
    )
  ]
)

To learn more about the project, read the README at https://github.com/drawthingsai/media-generation-kit

At the same time, if you look at datasheets of their direct competitors, especially for the RTX 5080 Mobile, the picture is more nuanced. For AI workloads such as LLM prefilling and image generation, the RTX 5080 Mobile still advertises roughly 320 TFLOPs of peak compute. By comparison, our most efficient FP16 matrix multiplication shader on the M5 Max delivers about 60 TFLOPs. Part of that gap is a necessary trade-off for a thinner, quieter, and more elegant design. Another part is that the advertised ~320 TFLOPs figure for the RTX 5080 Mobile is based on FP8 matrix multiplication, which is a lower-precision format than FP16.

With Draw Things v1.20260330.0, we are releasing Metal Quantized Attention to help close that gap. In real-world AI workloads such as image and video generation, our shaders now regularly reach around 110 TFLOPs on M5 Max. That brings Apple Silicon closer than ever to the RTX 5080 Mobile in practical terms, assuming thermal limits allow that device to sustain its peak performance.

Metal Quantized Attention

Metal Quantized Attention is our implementation of a low-bit attention operator written in Metal compute shaders. It takes FP16 or BF16 query, key, and value tensors, performs online quantization to Int8, and carries out the attention computation almost entirely in Int8. Queries and keys use row-group-wise scale quantization, while values use row-wise affine quantization.

In practice, this delivers a 1.24× to 1.41× speed-up over our Metal Flash Attention shader, which is already our fastest attention shader on M5 with Neural Accelerators.

Int8 Matrix Multiplication with Row-wise Scales

We also did a careful analysis of the quality impact of Int8 math with row-wise scales and found it to be an acceptable trade-off relative to the full-precision base model. In our testing, it is comparable to, and often better than, our 6-bit palettized quantization scheme.

The fused shader handles row-wise dynamic activation quantization, Int8-to-Int8 matrix multiplication, and post-accumulation dequantization together. End to end, our dynamic quantization + Int8 matrix multiplication + dequantization fused kernel is about 1.61× to 1.87× faster than our FP16 baseline.

End-to-End Speed-up

In v1.20260330.0, we enabled Metal Quantized Attention by default on M5 devices. You can still turn it off in Machine Settings. This feature applies across all models. Int8 matrix multiplication applies only to the 8-bit S models we recently added.

End to end, these changes deliver a 1.19× to 1.76× speed-up over v1.20260323.0. For a single sampling step alone, excluding model loading, text encoding, image decoding, and model lowering, the improvement ranges from 1.43× to 1.95×.

Pulling Ahead over Other Implementations

Metal Quantized Attention and fused Int8 matrix multiplication push our implementation well ahead of other Apple Silicon implementations for the same task. In our testing, we have seen performance ranging from 1.24× to 2.57× faster than the next best alternatives, including mflux, Ollama, iris.c, and mlx-video.

As always, our shader work is publicly available under the FreeBSD 3-Clause License, and our inference stack is publicly available under the LGPLv3 license. For local media generation tasks with your agent, you can also use draw-things-cli.

Draw Things Test Set is our attempt to answer those questions.

A few guiding principles shaped this Test Set and made it interesting to a broader audience, which is why we want to share an early status update.

1. We focused on practical use cases. People use Draw Things for all kinds of work, both professional and recreational. We want the Test Set to reflect those real-world uses, and to provide guardrails so that future model development does not regress on the capabilities people actually care about.

2. We focused on differentiating model capabilities in a way that clearly shows the progress made over the past few years. Rather than nitpicking aesthetics, we want the differences between models to be obvious, without depending on highly trained human taste to decide which result is only marginally better.

3. We wanted to map where model capabilities could go next, and what remains missing from the current generation. Ideally, the next wave of models will begin to close some of these gaps.

We ran all models on our own inference stack, which gives each one a fair playground. That allows us to fix parameters, keep results reproducible, and optimize each setup appropriately for the model being tested.

We plan to release the Calibrated Test Set publicly while keeping the full Test Set private to avoid saturation. Today, I want to share some of the findings that emerged during its construction. While I will highlight a few failure cases from closed-source models, those results may not be reproducible on your end. For models available in the Draw Things app, however, the results are reproducible. For each prompt, we select the best result across multiple trials, spanning different aspect ratios (1:1, 2:3, 3:2, 3:4, and 4:3) and resolutions.

1. Anatomy is still an issue

Contrary to common belief, anatomy is still a problem for the current generation of models, especially in complex scenes with conflicting instructions.

Prompt: A wide-angle realistic photo of a woman holding a steady yoga headstand on a mat. A grey tabby cat is curled up sleeping on her vertically upturned feet, while a small child in the foreground is carefully stacking a precarious tower of three wooden toy blocks on the woman’s horizontal stomach. The scene requires a clear void between the woman’s torso and the floor, with distinct points of contact for both the cat and the blocks.

Even in simpler cases, larger models still tend to hold an advantage over smaller ones. Distilled models in particular can show more anatomical issues than their base counterparts.

Prompt: A person throwing a red ball to a dog in a sunny park. The ball is in mid-air between the person’s extended arm and the jumping dog.

2. Knowledge distribution is uneven

Diffusion Transformer models arguably contain much more world knowledge than earlier U-Net-based ones, and pairing them with a real LLM certainly helps. But the knowledge distribution is still uneven, and the gaps between models remain obvious.

Prompt: A high-resolution product photo of a 1998 Apple iMac G3 in Bondi Blue. The shot emphasizes the translucent pinstriped plastic casing, clearly revealing the internal metal CRT shielding and vacuum tube components through the shell. It includes the matching hockey puck circular mouse and the translucent keyboard. The active screen displays the Mac OS 8 desktop with classic Platinum-style icons.

Prompt: A cinematic low-angle shot of a Lockheed SR-71 Blackbird on a wet tarmac at dawn. The image must capture the corrugated, ribbed texture of the matte-black titanium skin. The focus is on the Pratt and Whitney J58 engine nacelles, featuring the sharp, conical movable intake spikes. Small puddles of red JP-7 fuel are visible leaking onto the ground beneath the fuselage, reflecting the Skunk Works logo on the tail fins.

3. Physics and math are still challenging

Models appear to have some understanding of physics, but that understanding is still shallow.

Prompt: A realistic photograph of exactly 7 sheep standing on a green field, each sheep fully and clearly visible and individually countable.

Prompt: A ball bouncing, shown at three points in its trajectory: the moment of impact with the ground (slightly compressed), mid-bounce upward, and at the peak of the bounce. Motion blur should be appropriate for each stage.

4. Common sense is hard

By “common sense,” we mean the things left unsaid but still necessary for the image to make sense.

Prompt: The exact moment of collision between two cars in an intersection. One red sedan T-boning a blue SUV. The image must show: both front airbags deploying, broken glass mid-shatter, the deformation of metal, and appropriate motion blur on debris.

Prompt: A wine glass that has just been knocked off a table, captured 0.5 seconds after leaving the edge. The glass should be tilted at a realistic angle for its falling trajectory, with wine beginning to spill out following gravity but not yet scattered.

5. LLMs are unreliable raters

It is tempting to use an LLM as a judge to automate model evaluation. In practice, that is unreliable.

An LLM often makes the same mistake the image model makes, which can artificially inflate some models’ scores more than others. That is one of the main reasons we want to release our calibrated Test Set: it is rated by humans, which gives us a better sense of the actual error bounds.

Prompt: A photo of a classic red British telephone box K6 model on a London street corner. The box should feature the distinctive crown emblem at the top and the correct multi-pane glass windows.

Prompt: A realistic, high-shutter-speed photo of a ballet dancer performing a graceful high jete leap directly over a sleeping golden retriever. In the background, an artist at an easel is sketching the exact scene onto a canvas. The dancer’s shadow must fall realistically across the dog’s fur, and the sketch on the canvas must visibly mirror the dancer’s pose.

Prompt: A composite architectural visualization. The top section shows a photorealistic 3D cutaway view of the ground floor of a modern house, revealing a furnished living room (with sofa and TV) and a kitchen (with an island) separated by a partial wall. This 3D model hovers directly above a matching 2D architectural blueprint floor plan of the same level with perfectly aligned layout.

6. Style transfer and relighting are surprisingly good, even with small models

When most of the heavy lifting is already done, especially semantic preservation, even small models can perform well on edits that are less semantic in nature. In some cases, these edits are even more physically plausible than the models’ image-generation counterparts.

Prompt: Relight the entire scene to place them outdoors around a campfire at night. The only light source should be the warm, flickering orange glow of the fire coming from below their faces. This should create strong upward-casting shadows (under brows, noses, and chins) and illuminate the texture of their clothing from beneath, while keeping the background pitch black.

Prompt: Change the lighting to warm golden hour sunset, with orange tones and long shadows.

Prompt: Edit the statue’s feet to be wearing detailed, modern high-top basketball sneakers. The sneakers must appear to be carved entirely from the same block of aged marble, matching the stone texture, color, and weathering of the rest of the statue.

7. Editing models are not reasoners

The current generation of editing models is unable to perform even simple reasoning tasks. Some models, such as Qwen Image Edit 2511, do show more initiative, but they are still far from where they need to be.

Prompt: Fill in the dates correctly.

Prompt: Draw the next moon phase.

Prompt: Draw the solution path from Start to Finish.

We are still actively working through the Test Set, so this is only a status update on what we have seen so far. If this research direction is interesting to you, feel free to contact us at info@drawthings.ai

From the beginning, we have had an internal command-line tool for running image generation. It has been invaluable for quickly debugging different parts of our pipeline.

Over time, however, as the app gained more features, it became more convenient to debug them directly inside the app. As a result, the command-line tool gradually fell out of maintenance.

Our public repository, draw-things-community, maintains our core inference stack under the GPLv3 license. We regularly build and release gRPCServerCLI for both NVIDIA platforms and macOS from this public source repository.

draw-things-cli is a reboot of that command-line tool. It is vibe-coded, which makes it straightforward to implement many of the command-line niceties you would expect: shell auto-completion, direct image output in the terminal, automatic model downloads when needed, and recommended settings from the community repository when available. Powered by Draw Things’ custom inference stack, it is also the fastest image generation tool on macOS. It is fully open-source, under GPL-v3 license.

To install draw-things-cli today, you can use Homebrew or build it from source. To install it with Homebrew:

brew install drawthingsai/draw-things/draw-things-cli

Interactive image generation and editing are not new. But existing approaches come with compromises. You either have to rely on older, heavily distilled models such as Stable Diffusion 1.5 or SDXL, reduce resolution or step count, or run on cloud hardware such as H100s at hourly rates.

In v1.20260323.0, Draw Things introduces Lightning Draft. With Lightning Draft enabled on M5 Max, you can run state-of-the-art models such as FLUX.2 [klein] 4B, 9B, or Z-Image Turbo at their recommended settings with interactive latency of around or under one second locally. This makes prompt iteration dramatically easier and opens up new forms of creative exploration that were not practical before.

In the same v1.20260323.0 release, we also continued shipping performance improvements for M5 chips. With a clearer understanding of the Neural Accelerators’ performance characteristics, we improved our MatMul kernel by roughly another 10% on M5 for large matrices. In practice, that translates into about a 2% to 5% speed gain for larger models such as FLUX.2 [dev] and LTX-2.3 22B.

Today marks the first day of our release week. More updates are coming throughout the week. Stay tuned!

Draw Things is promised to be the most efficient way to run generative media on your Apple devices. When Z Image Turbo arrived, we knew we had to support it and rigorously quantify its performance and quality claims.

Z Image Turbo is a 6B-parameter DiT model that borrows many of the most successful tweaks from DiT models developed over the years. Our 6-bit–quantized variant, fully loaded into RAM, occupies only ~4 GiB, making it an ideal always-on sidekick for your design tasks. This stands in stark contrast to the ~11 GiB required by Qwen Image.

It is also a step-distilled model out of the box, so no separate Lightning LoRA is needed.

To properly evaluate Z Image Turbo, we first invested in an efficient implementation. Across a wide range of Apple devices, the Draw Things implementation is up to 54% faster than other available implementations.

An apples-to-apples comparison shows that Z Image Turbo is not dramatically faster than previous models on a per-step basis. It delivers a 1.01×–1.23× improvement over FLUX.1 [dev], a 1.31×–1.41× improvement over Qwen Image, and a 1.31×–1.45× improvement over HiDream [fast], all measured per step.

However, Z Image Turbo’s versatility and low RAM requirement make it excellent for rapid iteration and, in practice, it often feels faster to use.

Prompt: 35mm analogue full-body portrait of a beautiful woman wearing black sheer dress, catwalking in a busy market, soft colour grading, infinity cove, shadows, kodak, contax t2

Like Qwen Image and other recently released models, it also handles a wider range of resolutions more gracefully.

There are more cases we would like to share when we added more recent released models to our app, stay tuned!

The recent release of M5 debuts Draw Things with 3.5× performance improvements over M4. This was achieved through Apple’s MPSGraph API, first enabled in our 1.20250912.0 release. While MPSGraph API adequately implements Neural Accelerators support, it lacks the fine-grained memory and performance optimizations that we have developed through our ongoing Metal FlashAttention research.

Version 1.20251107.1 is our first release containing the preview version of Metal FlashAttention v2.5 w/ Neural Accelerators. It delivers up to 4.6× performance improvements on M5 over M41. With adequate cooling2, it sometimes outperforms M2 Max and narrows the gap to M3 Ultra. Its efficient memory management allows 5-second, 480p (448×768) video generation (with Wan 2.2 A14B models) on an M5 iPad with 16GiB of RAM.

We will discuss more Metal FlashAttention v2.5 w/ Neural Accelerators implementation details in a separate post on the Engineering@Draw Things channel, stay tuned!

Performance

Metal FlashAttention v2.5 w/ Neural Accelerators delivers the fastest performance on Apple’s non-Pro M-series chips, often rivaling or exceeding previous Max M-series chips. With several large image-generation models (FLUX.1 [schnell], a 12B-parameter model; Qwen Image, a 20B-parameter model; and HiDream, a 17B-parameter model), the M5 iPad can now generate high-resolution images in under a minute.

On A19 Pro, it improves on our previously reported numbers (with MPSGraph API), and now rivals M3 Pro (18c) performance.

On M5 iPad, we observe 3.6× to 5.5× raw performance improvements over M4 iPad, and 3.3× to 4.6× end-to-end improvements. In the mid-range, M5 iPad performs as well as M2 Max3. At the high end, M5 iPad often runs about 80% slower than M3 Ultra (60c).4

Support

Metal FlashAttention v2.5 w/ Neural Accelerators leverages the Neural Accelerators across all key operators — including matrix multiplication, attention, and segmented matrix multiplication, the latter being essential for Mixture-of-Experts models.

Availability & Limitations

The source code of Metal FlashAttention v2.5 w/ Neural Accelerators is available at https://github.com/liuliu/ccv/tree/unstable/lib/nnc/mfa/v2. Draw Things 1.20251107.1 integrates the full implementation of Metal FlashAttention 2.5 w/ Neural Accelerators. It is currently released as a preview because there are still performance cliffs around odd attention sequence lengths and large head dimensions. BF16 support is turned off due to unsolved bugs. The neural accelerators-enabled shaders also take a significantly longer time to specialize (often 10s or more for the first generation). We expect to resolve these issues in future updates.

Edit (20251118): 1.20251117.1 now supports BF16 as well as binary artifacts cache for neural accelerators-enabled shaders.

In February, we introduced Cloud Compute, built on top of our Server-Offload feature. It lets you tweak all the same parameters available in local generation — but now, the heavy lifting happens on our high-performance servers. This feature is available to both Community members and Draw Things+ customers, differing only in their Compute Unit allotment and the Privacy Pass guarantee.

What Are Compute Units?

Compute Units represent the complexity of a media generation task. They help us ensure fair server usage across the community by limiting how long each generation can run.

While this system keeps things fair, it can sometimes limit creative freedom — and we wanted to change that.

Introducing Boost

Version 1.20251007.2 introduces Boost, a new way to push beyond the default Compute Unit limits for Draw Things+ customers.

A Boost is a one-time token that allows you to exceed your standard Compute Unit limit. It’s only consumed when your generation completes successfully. Each Boost is 60,000 Compute Units, and you can stack multiple Boosts together — for example, three Boosts raise your upper limit to 180,000 Compute Units.

Availability

Boosts are available to Draw Things+ customers. We’ll begin issuing one-time free Boosts to our Draw Things+ customers over the coming days and weeks.

Because of how Boosts are tracked and verified, Boosts and Privacy Pass cannot be used together at this time.

The newly released iPhone 17 Pro features the powerful A19 Pro SoC with new GPU Neural Accelerators. Combined with other GPU improvements, it delivers exceptional performance for its size. For compute-bound tasks such as diffusion-based neural networks, Draw Things has seen a remarkable 2× generational improvement across many state-of-the-art models.

On iPhone 17 Pro, the FLUX.1 [schnell] / [dev] models at 768×768 run at ~10s per step, finishing 2-step inference in under 35 seconds. Even the latest 20B-parameter models, such as Qwen Image, run at ~13s per step, completing 2-step inference just over 45 seconds at 768×768. At larger resolutions, efficiency shines even more: 1024×1024 inference takes just over 50 seconds for the FLUX series and just around 65 seconds for the Qwen Image series—truly delivering MacBook Pro–like performance.

Draw Things remains focused on delivering the best media generation models—locally, privately, and efficiently. Stay tuned and subscribe for more exciting updates!

Notes

The iPhone 16 Pro numbers reflect typical daily usage without additional cooling (such as fans or ice packs). At a room temperature of 70°F, thermal throttling begins after about a minute, reducing performance for 1024×1024 and 1280×1280 generations. In contrast, the iPhone 17 Pro manages thermals far better, maintaining stronger sustained performance over longer runs.

• Avoiding excessive on-device battery usage;

• Avoiding large local disk usage from downloaded models;

• Running larger models that would otherwise be slow or impractical on-device.

However, running art generation on a server often comes with hidden trade-offs that customers may not fully realize:

• Their art generations may be subject to DMCA takedowns—even outside the U.S. or within fair use—with little recourse (an imbalance between copyright claims and fair-use defenses).

• The text–image pairs they generate can be used as preference data to train better models, or even sold to third parties, often without explicit acknowledgment (most users unknowingly sign away these rights during onboarding).

• So-called “privacy-first” claims by service providers are often weak: at best, just policies that can be changed later, and at worst, unenforceable promises quickly broken in the name of “move fast and break things.”

Draw Things+ Cloud Compute

Recognizing the real benefits for our customers, Draw Things introduced Cloud Compute earlier this year, building on our publicly released Server-Offload feature.

The Server-Offload feature allows customers to host art generation servers that the Draw Things app can connect to—either on a powerful local computer (Mac or Linux with NVIDIA GPUs) or a remotely hosted machine from a bare-metal provider. It is fully open-source at https://github.com/drawthingsai/draw-things-community and supports every feature the app can run locally.

Cloud Compute builds directly on Server-Offload. Our GPU servers are hosted by reputable bare-metal providers and run the exact same Docker image we publish publicly at https://hub.docker.com/u/drawthingsai. The authentication front-end also runs on our open-source code, hosted by reputable cloud providers.

By design, Server-Offload / Cloud Compute handles requests ephemerally in RAM only, ensuring your data cannot be stored or inspected later. Many services who claimed privacy-first would be happily stop here. But not us.

Privacy Pass

To turn privacy promises into privacy guarantees, we looked at several approaches:

• Homomorphic encryption: promising, but impractical without hardware support and still niche in the crypto world;

• Transparency logs: immutable, third-party (or distributed) logs tracking what software runs in the cloud;

• Hardware attestation: verifying, via trusted hardware, that the declared software is actually running—often paired with transparency logs;

• Security audits: external firms reviewing code and practices to verify that claims match reality.

Inspired by Kagi Search’s Privacy Pass, we chose to implement Privacy Pass as our first step towards providing concrete privacy guarantees to our Cloud Compute customers.

Privacy Pass ensures that even someone with full access to our backend cannot link a specific art generation to a specific customer.

Let’s go over this step-by-step. To effectively prevent abuse while maintaining service quality, we ask customers to sign in with Apple before using Cloud Compute. This enables standard controls: rate-limiting, authentication, prioritization for Draw Things+ users, and more.

Normally, the Draw Things app communicates with our backend in two steps:

1. Request our authentication endpoint to sign a generation request payload, using a locally saved user ID token (so we can attach queue prioritization and rate-limit data).

2. Send the signed token to our GPU servers to generate the art.

The problem: the same signed token flows from authentication to GPU servers. In principle, this allows someone to link a user (from authentication endpoint) to their generated art (from GPU servers).

With Privacy Pass, this becomes a three-step process:

1. Request a Privacy Pass from our backend, using the user ID token locally (we can count issued passes and enforce limits).

2. Use the unwrapped Privacy Pass (different from the one seen by our backend) to request a signed generation payload from the authentication endpoint.

3. Send the signed token to GPU servers for art generation.

Because the privacy pass you get in step 1 is different from privacy pass you use for step 2, our backend cannot connect a specific art generation to a specific user. Anonymity is guaranteed.

Availability

Privacy Pass is currently available only to Draw Things+ customers. Each Draw Things+ customer can issue up to 500 Privacy Passes per day. If that limit is exceeded, the system falls back to standard authentication without Privacy Pass.

You can also disable Privacy Pass from Machine Settings. If the shield icon is shown, Privacy Pass is active.

The Model

Draw Things provides Qwen Image 1.0 in the following variants:

1. 8-bit quantized model — ~16 GiB peak runtime VRAM; suitable for devices with 24 GiB or more total RAM.

2. 6-bit quantized model — ~11 GiB peak runtime VRAM; suitable for devices with 16 GiB or more total RAM.

3. FP16 model — ~30 GiB peak runtime VRAM; suitable for devices with 48 GiB or more total RAM.

4. BF16 model — ~30 GiB peak runtime VRAM; suitable for M3 and later devices with 48 GiB or more total RAM.

The quantization schemes have been meticulously tested to match the reference implementation with virtually no perceptible loss in quality. On devices with less than 16 GiB total RAM, Draw Things intelligently offloads partial weights, cutting peak runtime VRAM requirements further by more than 50% without speed penalties.

Prompt: A coffee shop entrance features a chalkboard sign reading "Qwen Coffee 😊 $2 per cup," with a neon light beside it displaying "通义千问". Next to it hangs a poster showing a beautiful Chinese woman, and beneath the poster is written "π≈3.1415926-53589793-23846264-33832795-02384197".

The Speed

In general, Qwen Image runs about 10% slower than FLUX.1 in apple-to-apple comparisons. For example, on iPhone 16 Pro, a 2-step generation (with 4-step Lightning LoRA) at 768×768 takes roughly 100 seconds.

Superior Prompt Adherence

Qwen Image excels at prompt adherence. It can separate complex entity descriptions more accurately than HiDream-I1 in our tests, and far better than FLUX.1.

For fairness, cross-model comparisons use Qwen Image 1.0 (6-bit) with 8-Step Lightning LoRA and Text Guidance set to 1.0, comparable to other CFG-distilled models (e.g., HiDream I1 [dev], FLUX.1 Krea [dev]).

Prompt: a smiling indian man with a google t-shirt next to a frowning asian man with a shirt saying nexus at a meeting table facing each other, Ultra HD, 4k, cinematic composition.

• FLUX.1 [dev] — fails to separate facial expressions.

• FLUX.1 Krea [dev] — separates expressions, but composition doesn’t follow the prompt (“facing each other”).

• HiDream I1 [dev] — captures subtler expressions but less precise. Google logo color is wrong.

• Qwen Image — succeeds at both expression and composition.

The Resolutions

Qwen Image kept composition well from small resolutions (512x512) to large resolutions (2048x2048). That means for less powerful devices, you can do smaller resolution image generations without compromises beyond resolutions.

Prompt: 35mm analogue full-body portrait of a beautiful woman wearing black sheer dress, catwalking in a busy market, soft colour grading, infinity cove, shadows, kodak, contax t2

From left to right: 512x512, 768x768, 1024x1024, 1280x1280, 1536x1536, 2048x2048

• FLUX.1 [dev] — loses quality at 1536×1536 and degrades comprehension at 2048×2048.

• FLUX.1 Krea [dev] — maintains quality but fails on composition at 2048×2048.

• HiDream I1 [dev] — struggles at 512×512.

• Qwen Image — minor prompt confusion at low resolutions (“catwalk” misread as “cat ears”), but holds composition and quality even at 2048×2048.

The Hero

Qwen Image 1.0 excels in “wall of text” situations.

Prompt: Ultra HD, 4k, cinematic composition. A photograph of an anthropomorphic polar bear in a navy suit with a red bow-tie, in front of a blackboard, in what appears to be a college class-room. On the blackboard, colorful chalks are used to write "Two households, both alike in dignity,
In fair Verona, where we lay our scene,
From ancient grudge break to new mutiny,
Where civil blood makes civil hands unclean.
From forth the fatal loins of these two foes
A pair of star-cross'd lovers take their life;
Whose misadventured piteous overthrows
Do with their death bury their parents' strife.

Qwen Image 1.0 still produces some spelling errors, but among the four models tested, it comes closest to accuracy.

The Bad

While Qwen Image 1.0 demonstrates exceptional prompt adherence, it can be unpredictable aesthetically. It supports a wide range of styles, but with a simple prompt, it sometimes defaults to random stylistic preferences. Adjustments are often needed for precise aesthetics.

Prompt: A baby yoda wearing a halloween pajama, holding a sign says "Qwen Image 1.0 ❤️ Draw Things".

The prompt trapped the model into 3D / illustration style, requiring targeted prompt tuning to switch styles.

Adjusted prompt: A amateur photograph of baby yoda wearing a halloween pajama, holding a sign says "Qwen Image 1.0 ❤️ Draw Things". Home video.

Engineering Note

Qwen Image model is a 60-layer MMDiT model. As we’ve discussed in BF16 and Image Generation Models, deep MMDiT architectures produce progressively larger activations during training. For Qwen Image, the final layers reach activation ranges around 60 million, which requires BF16 for proper support. To make the model usable in FP16, activations must be scaled down in more places. We’ll publish a separate write-up detailing our findings.