Running Stable Diffusion?

Stable Diffusion OOM or pipeline stuck? We ship it properly.

A notebook can generate an image in ComfyUI on a borrowed GPU; shipping that same output as a feature inside your product, running on predictable hardware, at a price you can show finance, is a different piece of work. We take a weekend prototype and turn it into something queueable, observable and safe to point at real users.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

sd-inference.log

still crashing

What it is

Stable Diffusion at a glance

Stable Diffusion is an open weights latent diffusion image model first released by Stability AI and the CompVis group in August 2022. It generates images from text prompts, image prompts, structural guides via ControlNet, and reference images via IP Adapter, all on consumer GPU hardware.

The ecosystem now includes SDXL, SD3 and SD3.5, SDXL Turbo for near real time generation, FLUX models from Black Forest Labs that run on the same tooling, and thousands of community LoRAs on Civitai and Hugging Face. Production use typically runs through the diffusers library, ComfyUI or Automatic1111, deployed behind a queue on dedicated GPU workers or a serverless GPU provider.

Type
Latent diffusion text to image model
First released
August 2022, SDXL in July 2023, SD3 in 2024
License
CreativeML Open RAIL++ for most releases, commercial licensing on later versions
Maintained by
Stability AI, plus open source maintainers of diffusers, ComfyUI and Automatic1111
Typically used for
Product imagery, marketing assets, avatars, game and design iteration, controlled variations of existing art

The honest version

Stable Diffusion pros and cons

No technology is all upside. This is where Stable Diffusion earns its place and where it tends to cause trouble.

Where Stable Diffusion is strong

  • Open weightsYou can run the model on your own GPU without sending prompts or images to a third party, which matters for IP sensitive workloads and regulated industries.
  • A huge community ecosystemLoRAs, custom nodes, upscalers, ControlNets and style adapters for almost any use case already exist, which shortens the distance from idea to usable image.
  • Fine tuning is practicalLoRA, Dreambooth and textual inversion let a team train a model on their own products or style in hours on a single GPU rather than days on a cluster.
  • Deterministic with a seedFixing the seed, model, scheduler and prompt reproduces an output exactly, which makes testing and regression work meaningfully.
  • Runs on affordable hardwareSDXL and newer models produce commercial grade output on a single consumer GPU, so inference cost per image is a fraction of hosted services at volume.
  • ControlNet and IP Adapter give real controlPose, depth, canny edges, reference images and segmentation guide the output precisely rather than hoping a prompt does the job, which is what moves image generation from demo to product.

Where Stable Diffusion bites

  • VRAM is the constant constraintSDXL at full resolution, with ControlNet and a refiner, will exhaust a 16 GB card. Every production feature has to account for VRAM budget and know when to offload or quantise.
  • The toolchain changes weeklyComfyUI nodes, diffusers versions and community LoRAs break each other on a regular cadence. Pinning everything is not optional in a production pipeline.
  • Licensing is genuinely complexEach model and each LoRA has its own licence, some restrict commercial use, some require attribution, and some are permissive. Shipping without checking each one is a legal risk.
  • Output quality is prompt dependentThe same model can produce a magazine cover or a blurry mess depending on prompt craft, scheduler choice and step count. Teams underestimate how much prompt engineering a real product needs.
  • Cold starts are painfulLoading an SDXL checkpoint, a LoRA stack, ControlNet and the VAE from disk into GPU memory takes seconds. A serverless design without warm workers will feel much slower than the local demo.
  • Safety filters are coarseThe built in NSFW check blocks what it thinks are unsafe outputs by returning a black image, which is useless as product feedback and must be replaced with something meaningful.

Sound familiar?

Common Stable Diffusion problems we fix

The Stable Diffusion problems that bring people to us, and what you have once each one is fixed.

torch.cuda.OutOfMemoryError

Inference crashes on CUDA out of memory

A pipeline that worked on a 24 GB card is being run on a 16 GB one, or a LoRA stack and ControlNet together are pushing past the memory budget without any offload configured.

Pipeline fits the GPU in use

shape mismatch: [1, 4, 64, 64] vs [1, 4, 96, 96]

Shape mismatch between components

A VAE or LoRA trained for one resolution being fed latents from a pipeline configured for another, which crashes somewhere mid denoise rather than at load time.

Components aligned to one resolution

LoRA weights are incompatible with base model

LoRA will not merge with the chosen base

A LoRA trained against SD 1.5 being loaded into an SDXL pipeline, or a community LoRA that was quietly repacked and now has mismatched layer names.

LoRA matched to base, loader fixed

latency: 14s per image at p95

Latency not meeting the product target

Full precision SDXL at thirty steps with a refiner and ControlNet is simply slow on the current hardware. We swap in a turbo variant, reduce steps and fuse components to hit the budget.

Target latency met under load

NSFW content detected, replacing output with black image

Safety filter blocking legitimate outputs

The bundled checker fires on brand imagery or product shots because the training distribution flagged a texture or skin tone, leaving users with an opaque failure.

Classifier replaced with usable policy

cold start 48s on first request

Serverless cold starts kill the UX

Each request on an idle worker loads a checkpoint, a LoRA stack and ControlNet weights from scratch. Users see a half minute delay before any pixels appear.

Warm pool with real latency floor

safetensors_rust.SafetensorError

Checkpoints fail to deserialize

A truncated download, a wrong format for the diffusers version, or a safetensors file that was quietly renamed from a different architecture altogether.

Checkpoints verified and pinned

GPU spot bill: $4,100

GPU bill out of proportion to usage

Dedicated GPUs idling overnight, spot instances recreated hourly, or a workflow running every step at maximum precision when a lower one would be indistinguishable.

Right sized to actual traffic

What we do

Stable Diffusion help, from prototype to production

Turn one ComfyUI workflow into a service, or let us run the whole image pipeline.

Prototype to production
Your ComfyUI graph or diffusers script turned into a queued, observable service with retries, timeouts and a budget per request.
Fine tuning
LoRA and Dreambooth training on your product catalogue, brand style or character set, with evaluation sets so the result is measurable rather than vibes.
Inference cost reduction
Model choice, step count, scheduler, quantisation and warm pool sizing tuned together, with cost per image tracked before and after.
Safety and moderation
Proper content classifiers, prompt filtering and output scoring replacing the bundled NSFW check, with behaviour you can audit.
ControlNet and IP Adapter pipelines
Structured image generation where pose, depth, reference or layout drive the output, not just a prompt, so results stay on brief.
Managed Tech
Model updates tracked, GPU workers monitored, dependency pinning kept honest, and an engineer on call who understands your pipeline when it starts misbehaving.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Stable Diffusion alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Stable Diffusion questions

Something else? Call+1 737 727 7327

Why does our Stable Diffusion server keep hitting CUDA OOM?

The common causes are a pipeline that stacks SDXL, ControlNet, a refiner and a LoRA on a card that cannot hold them all, a batch size too large for the resolution, and VAE operations running at the same time as the UNet instead of sequentially. We add offload, pick a smaller checkpoint when it fits, and fit the memory budget before adding features back in.

Can we fine tune Stable Diffusion on our own brand or products?

Yes. LoRA training on a few dozen to a few hundred curated images produces a reusable weight file, in hours on a single GPU, that adapts the base model to your style. Dreambooth goes further when you want the model to learn a specific subject. We handle the dataset preparation, the training runs and the evaluation against a held out set so you can see where the model is reliable.

How do we use Stable Diffusion in production safely?

Replace the bundled NSFW checker with a classifier you have measured, filter prompts before they reach the model, keep logs of inputs and outputs for audit, and watermark or sign generated images where downstream systems need to tell them apart from real photos. The bundled defaults are not a safety posture; they are a placeholder.

Should we self host or use Replicate, Fal or Hugging Face?

Managed APIs are the right call for low or spiky volume, where you pay per second and someone else deals with GPUs. Self hosted wins when you have steady traffic, IP sensitive content, or very specific model stacks. We will run the numbers against your actual request rate rather than quote a sticker price.

What hardware do we actually need?

SDXL and newer models produce commercial grade images on a single L4, A10 or RTX 4090 class GPU, and faster on an A100 or H100. Smaller SD 1.5 workloads still run on an 8 GB card at modest resolution. The right hardware depends on the resolution, the step count, how many LoRAs you stack and your latency budget, which is a short conversation before any order.

How much does Stable Diffusion help cost?

Estimates are free of charge. Describe the workflow, send a sample output or an error from the logs, and we send a price before any work begins.

Free estimate

Stable Diffusion giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.