stable-diffusion-xl-base-1.0

stable-diffusion-xl-base-1.0

Stability AI's SDXL base model, which makes and edits images from text prompts through the diffusers library, alone or paired with a refiner.

Made by stabilityai on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: stable-diffusion-xl-base-1.0 is the base model of SDXL from Stability AI. It makes and changes images from text prompts. It is a latent diffusion model with 2.6B parameters. Two frozen text encoders read your prompt: OpenCLIP-ViT/G and CLIP-ViT/L.

The base model works on its own. It can also hand its noisy latents to a refiner model that finishes the last denoising steps.

Who it suits: It suits developers, designers and researchers who can run Python code and want to generate images from a prompt on their own machine. The snippet in the card moves the model to a CUDA device.

Industry | Who uses it | How they use it | Example
Design | Visual designers | Draft images from a written prompt | A concept picture for a mood board
Marketing | Content teams | Make illustrations for posts and pages | A header image from a one line brief
Games and media | Artists | Sketch scenes and characters before painting | A character study from a prompt
Research | Machine learning researchers | Study and build on a diffusion model | Comparing base and refined output

Skip it if you only want a hosted image tool with no code.

Where to use it:

• Python with the diffusers library
• Windows, macOS or Linux for the file download
• A CUDA graphics card, as the card's snippet uses one
• Clipdrop, which the card names as a free place to try SDXL

Use case | Who | What they get back
Text to image | Creators and developers | An image made from a prompt
Base plus refiner | People who want finer detail | An image refined in the last denoising steps
Image to image with SDEdit | Developers | A high-resolution pass over latents from the base model

How to set it up: You need a few things in place first.

• Python and pip
• diffusers version 0.19.0 or newer
• transformers, safetensors and accelerate, plus the invisible watermark package
• A CUDA graphics card, since the snippet calls cuda
• About 10.3 GB of disk for the F32 weights, from the record

1. Upgrade diffusers to a version at or above 0.19.0.
2. Install the extra packages the card lists.
3. Run the Python snippet from the next section.

pip install diffusers --upgrade
pip install invisible_watermark transformers accelerate safetensors

To get the repository files onto your computer first, use Hugging Face's own steps.

pip install -U huggingface_hub
hf download stabilityai/stable-diffusion-xl-base-1.0

How to use it: You write a short Python script that loads the pipeline, sends it to the GPU and passes a prompt. The card also describes a two-stage run, where the base model makes latents and a refiner finishes them. With torch 2.0 or newer, wrapping the unet in torch.compile can speed up inference by 20 to 30 percent, per the card.

from diffusers import DiffusionPipeline
import torch

pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16, use_safetensors=True, variant="fp16")
pipe.to("cuda")

# if using torch < 2.0
# pipe.enable_xformers_memory_efficient_attention()

prompt = "An astronaut riding a green horse"

images = pipe(prompt=prompt).images[0]

Tool | What it does
Base model alone | Makes the image in a single stage
Base plus refiner | The base makes noisy latents and the refiner finishes the denoising
SDEdit pass | A high-resolution model reworks the base latents with the same prompt, a little slower

Example: You run the script with the prompt "An astronaut riding a green horse". The pipeline returns an image, and the script keeps the first one in the images variable.

For newcomers and experts: Start with the base-only script. Install the packages, run it once with the astronaut prompt and look at the image it returns. Try the refiner only after that works.

SDXL splits the work between experts. The base model produces latents at the size you want, and a refiner specialized in the final denoising steps takes over, for example 40 steps with 80 percent on the base. In the card's preference chart, the base model beats SDXL 0.9 and the earlier Stable Diffusion releases, and adding the refiner scores best overall.

Write a text prompt
Base model makes latents
Refiner finishes the denoising
You get the final image

Good to know:

• License: CreativeML Open RAIL++-M
• Cost to run: none named, but the snippet needs a CUDA graphics card
• Data it reaches: it downloads model files from Hugging Face onto your computer

On Hugging Face, 13 November 2026

• Task: text to image
• Library: diffusers
• Parameters: 2.6B
• Weights: about 10.3 GB in F32; about 1.3 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 4,688,522
• Likes: 8,466
• License: openrail++
• Quantized versions: 25
• Fine-tunes: 1,236
• Tags: diffusers, onnx, safetensors, text-to-image, stable-diffusion

Links

• Model: https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0
• Files: https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download stabilityai/stable-diffusion-xl-base-1.0

Then follow the usage in its model card. Nothing in this kit runs by itself.