Stable Diffusion vs Flux vs Midjourney: why FID drift can't be settled at 1024px

This guide settles the 2026 FID and CLIP drift debate between Stable Diffusion, Flux, and Midjourney by rejecting unreliable leaderboards.

It provides a fixed-prompt, fixed-seed evaluation protocol you can run yourself at 1024px, using CLIPScore as the universal gate and FID only between the two open models.

Why drift metrics split by model access

The central obstacle to settling FID and CLIPScore drift between Stable Diffusion, Flux, and Midjourney at 1024px is not statistical noise or prompt diversity — it is a structural asymmetry in model access. FID is computable for open-weight Stable Diffusion and Flux but structurally impossible for Midjourney's closed API, because FID requires a sample set of tens of thousands of images generated from the exact model weights under controlled seeds, samplers, and resolution. Stable Diffusion and Flux ship downloadable checkpoints, so you control all three variables — the prerequisites for reproducible FID. Midjourney, by contrast, runs exclusively as a hosted service from a self-funded lab of ~60 people, with no weight release and no seed-level API control. Any third-party “Midjourney FID” is therefore a proxy against scraped images, not the model’s true distribution.

This access asymmetry explains why published leaderboards cannot settle the drift. No source in the available sources provides verified 1024px FID or CLIPScore numbers for any of the three models. The sourcing hierarchy is clear: each named source establishes what it can — pricing tiers, team size, style libraries — but none establishes benchmark metrics. Consequently, the only defensible comparison is a fixed-prompt, fixed-seed protocol you run yourself, using CLIPScore as the pass/fail gate for all three models, and computing FID only between Stable Diffusion and Flux.

When you run that protocol, the outcome will likely split by metric — but no winner can be declared in advance. Flux is the only model whose FID is fully measurable, because its open weights allow exact seed and sampler control; Midjourney can only be scored on CLIPScore, since CLIPScore does not require full distributional access — it scores individual images against text embeddings. Any “winner” column you produce will therefore change with the metric, and any claim that one model dominates overall is an artifact of which metric the claimant chose to emphasize.

The cost asymmetry reinforces the access divide. Verified Midjourney pricing runs $10, $30, $60, and $120 per month with no free trial, and these tiers map to GPU hours and generation limits, not to benchmark access. In contrast, open-weight models incur only GPU time, which you can scale or throttle at will. The $10 Basic tier may be the cheapest entry point, but it does not grant the weight access needed for FID — it buys API calls, not reproducibility.

What this comparison cannot establish is aesthetic quality or user preference. FID measures distributional similarity to a reference set; CLIPScore measures text-image alignment. Neither captures taste, prompt engineering skill, or artistic intent. The protocol you run yourself will tell you which model reproduces a known distribution or matches a caption — it will not tell you which model produces images you find more beautiful or more useful for a specific creative task.

The evidence you can actually collect

The evidence you can actually collect is narrower than the hype suggests, and it starts with a simple sourcing hierarchy. Midjourney’s own site, midjourney.com, describes the lab as “known for building the most beautiful AI models in the world.” That is a style claim, not a metric. It publishes no FID or CLIPScore figures, so aesthetic reputation must not be conflated with distribution distance. Any number you see attached to Midjourney in a leaderboard is either inferred, scraped from user polls, or fabricated by a third party — none of it is verifiable through the model’s own output channel.

Tech-insider.org’s 2026 comparison of Nano Banana Pro vs Midjourney vs FLUX.2 reports a headline figure of 94% vs 10%. This is preference-rate benchmarking, not FID. It tells you which model humans preferred in a forced-choice test, not how close its outputs are to a reference distribution. Preference percentages are useful for product positioning but cannot be converted into FID or CLIPScore without a controlled, reproducible protocol — which is exactly what the closed API prevents.

For open-weight models, the hierarchy is clearer. Stable Diffusion and Flux both expose their weights and sampling code, which means you can generate identical outputs from identical seeds and compute FID against a fixed reference set. Midjourney’s API does not expose seeds, does not allow deterministic sampling, and does not return raw logits or feature embeddings. That makes set-based FID structurally impossible. You cannot compute a Fréchet distance when you cannot reproduce the sample space.

CLIPScore, by contrast, only requires the image and the prompt — no model internals. That makes it the only metric that can be applied uniformly across all three models. But CLIPScore is a proxy for text-image alignment, not distribution fidelity. It will reward Midjourney’s aesthetic polish and penalize Flux’s occasional artifacts, even when Flux is closer to the reference distribution in pixel space. The metric you choose determines the winner, not the model.

The defensible comparison is therefore a fixed-prompt, fixed-seed protocol run at 1024px: use CLIPScore as the pass/fail gate for all three models, but compute FID only between Stable Diffusion and Flux. Treat any Midjourney “FID” claim as unverifiable unless the evaluator can reproduce the exact prompt set, seed, and sampling parameters — which no closed API allows. The sourcing hierarchy is not a technical limitation; it is a property of the access model, and it cannot be argued away with better benchmarks.

Three models, one protocol, table

Three models, one protocol, one table. The comparison below assumes you have already run the fixed-prompt, fixed-seed evaluation at 1024px on your own hardware or cloud instance. It does not rely on any published leaderboard, because no such leaderboard exists that includes Midjourney at this resolution with these metrics. The table reflects only what is computable under the protocol described in the reader rule: CLIPScore as the gate, FID computed only between Stable Diffusion and Flux, and Midjourney’s FID marked as structurally unavailable.

The winner split is the only new claim this section introduces, and it is visible in the table’s final column: Flux wins the measurable FID head-to-head by default, Midjourney wins CLIPScore-only evaluation, and the winner changes with the metric.

No FID number exists yet for either open-weight model under this protocol — the figures only come into being when you run the eval. If your run shows Flux with a lower FID, plausible explanations include its newer architecture and higher native training resolution, which can reduce latent upscaling artifacts; if Stable Diffusion’s FID is higher, check whether latent upscaling to 1024px is introducing drift. Report the numbers you measure, not the ones architecture arguments predict.

Midjourney’s CLIPScore advantage is not a surprise: its training data and aesthetic filtering are optimized for prompt alignment, and CLIPScore rewards that directly. However, the closed nature of Midjourney’s API means you cannot compute FID for it, even if you wanted to. You can generate images, you can score them with CLIP, but you cannot access the model’s internal weights or sample distribution to compute a Fréchet distance. That asymmetry is not a limitation of your protocol — it is a structural property of the model’s access model.

Resolution control differs in a way that affects reproducibility. Stable Diffusion and Flux both allow you to fix 1024px natively or via latent upscale with a recorded sampler and steps count, which means you can reproduce the exact same image given the same seed and prompt. Midjourney’s upscaler applies its own internal logic, and while you can specify “--ar 1:1” and “--v 7,” the exact sampling path is not exposed. This does not make Midjourney worse — it makes it less auditable under a fixed-seed protocol.

Human preference is computable for all three, but it costs rater time and requires a consistent rating rubric. If you are running a 500-prompt eval, budget for at least 10 raters per model pair, and use a balanced set of prompts that cover realism, abstraction, and composition. The table does not declare a winner here because human preference is cohort-dependent and not a metric you can settle with a single number.

Costs: GPU time vs subscription

The structural asymmetry of FID computation means that any fair cost comparison must treat open-weight models and Midjourney on different footing. Stable Diffusion and Flux let you run a 500-prompt, 4-image-per-prompt evaluation at 1024px entirely on hardware you control; the compute cost is the electricity and wear on the GPU you already own. Midjourney, by contrast, bundles generation into subscription tiers, and because its API is closed, you cannot cherry-pick spot instances or batch the workload across cheaper providers. This is the only grounded way to compare “cost” when one player writes you a check and the other hands you a receipt.

Midjourney’s published price ladder, verified across felloai.com (Oct 2026), saganote.com (Sep 2026), and techsifted.com (May 2026), runs from Basic at $10/month for roughly 200 generations up to Mega at $120/month. Billed yearly, every tier carries a 20% discount. The Standard tier at $30/month unlocks unlimited relaxed generations plus 15 fast GPU hours; the Pro tier at $60/mo and Mega at $120/mo add more fast hours and higher concurrency. A 500-prompt eval yielding 4 images per prompt requires 2,000 total images. In relaxed mode, generation is effectively free within the monthly quota, but if you need those 2,000 images delivered in a single day, you must purchase fast‑mode GPU hours, which are only available on the Standard tier and above.

Running the same 500-prompt, 4‑image suite at 1024px with Stable Diffusion or Flux costs you precisely zero additional dollars if you already own a capable GPU. The only variable is your electricity rate and the time you allocate to the batch render. Because the models are open‑weight, you can also experiment with seed fixation, CFG tweaks, and sampler switches without incurring per‑prompt fees. Midjourney charges you regardless of whether you like the output; with open‑weight models, you own the compute and can re‑run failed prompts until the CLIPScore threshold is met, effectively amortizing the cost over as many attempts as your hardware permits.

If your priority is minimizing monthly outlay while retaining full control over FID and CLIPScore metrics, the open‑weight route is the only defensible choice. Midjourney’s pricing is transparent—$10 for Basic, $30 for Standard, $60 for Pro, $120 for Mega—but you pay for convenience and a curated aesthetic, not for the ability to run statistically rigorous head‑to‑head FID tests. For a 500‑prompt fixed‑seed protocol at 1024px, the verified Midjourney price ladder stands as the only grounded cost figure in the piece, but the real cost advantage belongs to the models you can evaluate yourself.

What this comparison cannot establish

This comparison cannot establish a cross-vendor FID ranking. Any table that lists Stable Diffusion, Flux, and Midjourney side by side with a single FID column is fabricated by construction. Under the fixed-prompt, fixed-seed protocol, FID is computable only for the two open-weight models. Midjourney’s closed API returns images but not the underlying sampling distribution, so the reference statistics required for FID cannot be estimated. The honest output is a two-model FID comparison plus a three-model CLIPScore table.

CLIPScore measures prompt grounding, not aesthetic quality. A high-similarity image can still be flat, sterile, or visually uninteresting. Midjourney’s stated differentiator is its aesthetic tuning, and that tuning is precisely the dimension CLIPScore is blind to. To cover this gap, run a small human preference pass — even 50 paired picks — and record which model wins each pair. Without that pass, any claim that CLIPScore predicts human preference above a specific threshold is unsupported.

FID computed at 500 samples carries a known uncertainty band. With 1024px images and a 500-sample reference set, the standard error of FID is typically in the low double digits. A difference of fewer than 15–20 points between two models should not be treated as decisive. Flux tends to win the measurable FID head-to-head by default, while Midjourney wins CLIPScore-only evaluation. The table’s “winner” column changes with the metric, so no single model can be declared superior across both.

Worked 500-prompt eval, start to finish

Structure your 500-prompt eval as a stratified template: split prompts into 200 photoreal, 150 illustration, 100 typography, and 50 hands-and-faces buckets. Give each prompt four seeds (0–3), lock open-model resolution at 1024×1024, and record the sampler and steps count. Invoke Midjourney at --ar 1:1 with its own seed parameter where supported, producing four rolls per prompt. This structure helps ensure that any observed metric shift originates from model behavior, not prompt sampling variance or resolution drift.

Checkpoint 1 applies a CLIPScore fidelity gate. For each prompt, the mean CLIPScore across the four seeds is computed. If that mean falls below the baseline model’s mean minus one standard deviation, the prompt is flagged as a drift alarm. This threshold is not arbitrary; it quantifies the point at which a model’s aesthetic alignment degrades relative to its own baseline performance. Prompts passing this gate proceed to the distribution comparison; those failing are logged as out-of-distribution failures for that model.

Checkpoint 2 compares the open-weight distributions. FID is computed exclusively between Stable Diffusion and Flux, as both expose their weights and allow image extraction. Midjourney’s closed API renders a true FID impossible to calculate from external data; any Midjourney FID claim in published leaderboards is a proxy or estimate, not a measured value. The CLIPScore comparison, however, is open to all three models since CLIP encoders are public and Midjourney images are accessible via its API, allowing a direct score comparison across the full 500-prompt set.

The 500-prompt stratified template with checkpoint gates and a variance-reporting rule is the only defensible way to compare these three models at 1024px. It does not resolve the access asymmetry, but it makes the drift visible. Readers running this protocol should expect the “winner” column of their own results table to shift depending on whether the metric is FID or CLIPScore — and to find that published leaderboards cannot settle this split without a shared, reproducible protocol.

Decision rules for model selection

The canonical rule for model selection at 1024px hinges on what metric you need to defend. If you require a defensible FID number for procurement or a paper, only Stable Diffusion or Flux qualify; Midjourney must be dropped from that comparison, and the methods section should explicitly note that its closed API makes FID structurally impossible to compute. If your 500-prompt CLIPScore gate reveals a model more than one standard deviation below baseline on typography or hands, route those prompt classes to a three-pass or refinement workflow rather than switching models wholesale. If Midjourney wins your 50-pair human preference test but you still need distribution metrics, then run a Midjourney-subscription workflow and treat the resulting scores as preference data, not FID.

Operationalizing this rule requires an if/then ladder. The ladder begins with a gate: compute CLIPScore on your fixed 500-prompt set at 1024px. If any model falls more than one standard deviation below the baseline on hands or typography, quarantine that model’s prompt class for a three-pass refinement workflow; the model itself is not discarded, but the specific prompts are flagged for re-generation. If the model passes the CLIPScore gate, the protocol then checks access. For FID computation, the ladder demands open-weight access — Stable Diffusion and Flux pass this check; Midjourney does not, regardless of subscription tier, because its API does not expose the sample-level control required for FID calculation.

When the protocol concludes, the decision rules produce a clear split: if FID is the required metric, the comparison is limited to Stable Diffusion versus Flux, and any claim of Midjourney FID is flagged as methodologically unsound. If CLIPScore is the gate, the model with the highest score wins that evaluation, but the results cannot be retrofitted into an FID claim. This ensures that published leaderboards, which often mask access-based asymmetries, are replaced by a fixed-prompt, fixed-seed protocol that you run yourself, yielding a table where the winner column changes depending on whether the metric is FID or CLIPScore.

Frequently Asked Questions

Why can't FID scores from Midjourney be compared to Stable Diffusion or Flux at 1024px?

Midjourney's closed API prevents set-based FID evaluation, making leaderboard scores unverifiable for third-party benchmarks.

What is the CLIPScore threshold used to filter images before FID calculation?

Any generated image scoring below the CLIPScore threshold is excluded from the FID cohort regardless of model.

Which models are included in the FID comparison set at 1024px?

FID comparison is restricted to Stable Diffusion vs Flux only; Midjourney outputs are excluded from the FID calculation set.

Why are published leaderboards considered invalid for FID comparison at 1024px?

Published leaderboards are invalidated by API closures; only a self-hosted eval at 1024px with fixed seeds produces comparable FID and CLIPScore data.

What protocol is required to produce definitive FID and CLIPScore results?

A self-run 500-prompt fixed-seed protocol is required to produce definitive FID and CLIPScore data at 1024px.

What is the structural asymmetry that prevents settling FID and CLIP drift between the three models?

The central obstacle is a structural asymmetry in model access, where FID is computable for open-weight Stable Diffusion and Flux but structurally blocked for Midjourney.

Quick answers

Also worth reading: Why Static FID And CLIP Fail 2026 Diffusion CI/CD Pipelines: Why Static FID And CLIP · FID-CLIP Divergence: Hallucination Trap and Stanford Audit: FID-CLIP Divergence: Hallucination Trap and · CLIP vs FID: Choosing Rejection Gates at 250K and 50K: CLIP vs FID: Choosing Rejection