Stable Diffusion Cloud GPU 2026: Run SDXL & Flux Without a Local GPU

VRAM Requirements by Model

Your choice of model determines the GPU you need. Here's the minimum VRAM for each major image model in 2026 (float16 unless noted):

RTX 4090 (24 GB VRAM) covers all models above without quantization. It's the default GPU on GhostNexus at $0.50/hr.

Cost Per Image on Cloud GPU

An RTX 4090 generates SDXL images at roughly 4–6 seconds each (20 steps, DPM++ 2M). At $0.50/hr:

A batch of 1,000 SDXL images costs under $0.70 on GhostNexus. Compare that to Midjourney Pro at $60/month for 1,000 images, or DALL-E 3 at $0.04–$0.08 per image.

GPU Cloud Provider Comparison (Image Generation)

Run SDXL on Cloud GPU: Full Script

Submit this script to GhostNexus with the Python SDK — it generates 4 images and prints the generation time:

import torch
from diffusers import StableDiffusionXLPipeline, DPMSolverMultistepScheduler
import time

# Load SDXL with optimized scheduler
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
    use_safetensors=True,
)
pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
pipe = pipe.to("cuda")
pipe.enable_xformers_memory_efficient_attention()

prompts = [
    "A cyberpunk city at night, neon lights, ultra detailed, 8k",
    "Portrait of an astronaut on Mars, cinematic, Hasselblad",
    "Ancient forest waterfall, golden hour, photorealistic",
    "Abstract geometric art, vibrant colors, minimalist",
]

t0 = time.perf_counter()
for i, prompt in enumerate(prompts):
    image = pipe(
        prompt=prompt,
        num_inference_steps=20,
        guidance_scale=7.5,
        width=1024, height=1024,
    ).images[0]
    image.save(f"/tmp/output_{i}.png")
    print(f"Image {i+1}/4 done — {time.perf_counter()-t0:.1f}s elapsed")

total = time.perf_counter() - t0
print(f"\n4 images in {total:.1f}s ({total/4:.1f}s/image)")
print(f"Estimated cost: ${total/3600 * 0.50:.5f}")

# Submit with the SDK:
import ghostnexus

client = ghostnexus.Client()
job = client.run("sdxl_batch.py", task_name="sdxl-batch-4")
for chunk in job.stream_logs():
    print(chunk, end="", flush=True)

# Output:
# Image 1/4 done — 5.2s elapsed
# Image 2/4 done — 10.4s elapsed
# Image 3/4 done — 15.7s elapsed
# Image 4/4 done — 20.9s elapsed
#
# 4 images in 20.9s (5.2s/image)
# Estimated cost: $0.00290

Running Flux.1 on Cloud GPU

Flux.1-dev produces significantly better image quality than SDXL but requires more VRAM and takes longer per image. On an RTX 4090 (24 GB):

• →Flux.1-schnell: 4 inference steps, ~25s/image, best quality/speed ratio. Cost: $0.0035/image.
• →Flux.1-dev: 20–50 steps, ~100s/image, maximum quality. Cost: $0.014/image.
• →Flux.1-dev (fp8 quantized): Runs in 8 GB VRAM on RTX 3080, ~150s/image, minor quality loss.

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe = pipe.to("cuda")

image = pipe(
    "A hyperrealistic portrait of a woman in Renaissance style",
    num_inference_steps=4,  # schnell = 4 steps
    guidance_scale=0.0,
    height=1024, width=1024,
).images[0]
image.save("/tmp/flux_output.png")

ControlNet and img2img on Cloud

ControlNet requires an additional 1–2 GB VRAM on top of the base model. On an RTX 4090, SDXL + ControlNet generates images in 8–12 seconds at 1024×1024:

• ✓Canny edge, depth, pose, and tile ControlNets all work out of the box
• ✓Upload your source images via inline=True with base64-encoded data
• ✓Output images returned in job logs as base64 or saved to a persistent volume (coming Q3 2026)

Frequently Asked Questions