Open-Source vs. Closed Image Models

For every product using image generation, you'll face a choice: hit a closed API (Midjourney, OpenAI, Flux Pro via fal/Replicate) or self-host open weights (SD 3.5, Flux Dev, SDXL). Both are valid — the tradeoffs are architectural, not moral.

When closed wins

• MVP — need to ship next week, volume is low.
• Non-technical team — no ML/ops headcount.
• Regulatory cover needed — Firefly's indemnification is real money.
• Highest possible aesthetic quality — Midjourney and Flux Pro are the ceiling.

When open wins

• Scale > 50k images/day — API costs beat amortized infra.
• Tight latency requirements — <2s per image on your GPUs.
• Data privacy — medical, legal, defense, financial.
• Heavy customization — branded character LoRAs, ControlNet pipelines.
• Air-gapped deployment — on-prem or edge.

The hybrid pattern

Real teams mix: use a closed API for the highest-quality hero shots, open weights for high-volume in-product generation. Or: prototype with closed, migrate high-volume paths to open once unit economics matter.

Self-hosting stack in 2026

1. 1Inference engine: ComfyUI for graph-based workflows; Diffusers (Python) for programmatic; vLLM-style sglang or replicate/cog for serving.
2. 2GPU infra: RunPod, Modal, fly.io GPUs, AWS/GCP for enterprise.
3. 3Quantization: int8 / int4 Flux Dev runs on 16GB VRAM at acceptable quality.
4. 4Distillation: Flux Schnell (4-step) or LCM-LoRAs for sub-second inference.
5. 5Queue + cache: Redis/Upstash for job queue; R2/S3 for outputs.

# Serving Flux Dev via Modal (Python serverless GPU)
import modal

app = modal.App("flux-service")
image = modal.Image.debian_slim().pip_install(
    "diffusers==0.32.0", "torch==2.5.1", "transformers", "accelerate"
)

@app.cls(gpu="H100", image=image, container_idle_timeout=120)
class FluxService:
    @modal.enter()
    def load(self):
        import torch
        from diffusers import FluxPipeline
        self.pipe = FluxPipeline.from_pretrained(
            "black-forest-labs/FLUX.1-dev",
            torch_dtype=torch.bfloat16,
        ).to("cuda")
        # Load our LoRA stack
        self.pipe.load_lora_weights("./brand_lora.safetensors")

    @modal.method()
    def generate(self, prompt: str, steps: int = 28):
        result = self.pipe(
            prompt=prompt,
            num_inference_steps=steps,
            guidance_scale=3.5,
        ).images[0]
        return result

# Costs ~$0.001-0.003 per image amortized on H100 at utilization.

What changed in 2026

• Black Forest Labs (Flux) ships Pro via API and Dev under a permissive non-commercial-research license for weights.
• Stability AI SD 3.5 has gentler community licensing than SD3 caused.
• Meta released Chameleon weights in late 2024; multimodal AR competitor.
• Inference costs on open weights dropped ~40% year-over-year due to quantization + distillation.