Skip to content

Stable Diffusion XL

Model Source Revision Weight license Parity (CPU, fp32)
sdxl-base-1.0 stabilityai/stable-diffusion-xl-base-1.0 4621659 CreativeML-OpenRAIL++-M Verified
sdxl-lightning-2step ByteDance/SDXL-Lightning c9a24f4 CreativeML-OpenRAIL++-M Verified
sdxl-lightning-4step ByteDance/SDXL-Lightning c9a24f4 CreativeML-OpenRAIL++-M Verified
sdxl-lightning-8step ByteDance/SDXL-Lightning c9a24f4 CreativeML-OpenRAIL++-M Verified
hyper-sdxl-1step ByteDance/Hyper-SD bc08d97 Unspecified Verified
dmd2-sdxl-4step tianweiy/DMD2 be22767 CC-BY-NC-4.0 Verified
dmd2-sdxl-1step tianweiy/DMD2 be22767 CC-BY-NC-4.0 Verified
juggernaut-xl-v9 RunDiffusion/Juggernaut-XL-v9 cf41923 CreativeML-OpenRAIL-M Verified
animagine-xl-4.0 cagliostrolab/animagine-xl-4.0 2b7c1b3 CreativeML-OpenRAIL++-M Verified
dreamshaper-xl-1.0 Lykon/dreamshaper-xl-1-0 41e6644 CreativeML-OpenRAIL++-M Verified
sdxl-refiner-1.0 (+ image input) stabilityai/stable-diffusion-xl-refiner-1.0 5d4cfe8 CreativeML-OpenRAIL++-M Verified
sdxl-turbo stabilityai/sdxl-turbo 7115331 sai-nc-community Verified
ssd-1b segmind/SSD-1B 60987f3 Apache-2.0 Verified
segmind-vega segmind/Segmind-Vega 7714c43 Apache-2.0 Verified
koala-700m etri-vilab/koala-700m 5e73a31 Unspecified Verified
koala-1b etri-vilab/koala-1b 8ef26f3 Unspecified Verified
koala-lightning-700m etri-vilab/koala-lightning-700m 358e0e3 Unspecified Verified
koala-lightning-1b etri-vilab/koala-lightning-1b b4114f7 Unspecified Verified
playground-v2 playgroundai/playground-v2-1024px-aesthetic 737a24e playground-v2-community Verified
playground-v2.5 playgroundai/playground-v2.5-1024px-aesthetic 1e032f1 playground-v2dot5-community Verified

Stable Diffusion XL

Catalog: sdxl · Models: sdxl-base-1.0, sdxl-lightning-2step, sdxl-lightning-4step, sdxl-lightning-8step, hyper-sdxl-1step, dmd2-sdxl-4step, dmd2-sdxl-1step, juggernaut-xl-v9, animagine-xl-4.0, dreamshaper-xl-1.0 · Task: t2i (the refiner sdxl-refiner-1.0 has its own section below)

Architecture. Two frozen text encoders: CLIP ViT-L/14 (penultimate layer output) and OpenCLIP bigG (penultimate layer output and pooled output). The concatenated outputs condition a 2.6B-parameter U-Net with text_time micro-conditioning: the original size, the crop position and the target size of the image, encoded as a 6-element vector per sample. The VAE is an f=8 KL autoencoder with a scaling factor of 0.13025 (1024×1024×3 image ↔ 128×128×4 latent). The scheduler is the Euler published with the checkpoint (timestep_spacing="leading", steps_offset=1): 50 steps perform 50 U-Net evaluations.

SDXL-Lightning. These three models place a distilled U-Net on the SDXL base. Their defaults are respectively 2, 4 and 8 steps, guidance 0.0, and Euler scheduling with timestep_spacing="trailing".

Hyper-SD. hyper-sdxl-1step places the published Hyper-SDXL U-Net on the SDXL base. It uses an LCM scheduler built from the SDXL scheduler configuration and defaults to 1 step, guidance 0.0, explicit timesteps [800] and 1024×1024.

DMD2. dmd2-sdxl-4step and dmd2-sdxl-1step place the published full float32 DMD2 U-Net on the SDXL base. Both use an LCM scheduler built from the SDXL scheduler configuration, guidance 0.0, and 1024×1024. Their defaults are respectively 4 steps with explicit timesteps [999, 749, 499, 249] and 1 step with [399].

Community fine-tunes. juggernaut-xl-v9, animagine-xl-4.0 and dreamshaper-xl-1.0 are complete SDXL fine-tunes rather than U-Net overlays. They retain their published DDPM (trailing spacing), Euler and DEIS (leading spacing) schedulers, respectively. Juggernaut targets photorealistic work, Animagine targets anime tag prompts, and DreamShaper is a general artistic fine-tune. Juggernaut and Animagine publish float16 component tensors, which are upcast when the pipeline runs in CPU float32; DreamShaper publishes float32 components.

Usage.

python -m imagehub.pretrained sdxl-base-1.0 checkpoints/sdxl-base-1.0
python -m imagehub.pretrained juggernaut-xl-v9 checkpoints/juggernaut-xl-v9
python -m imagehub.pretrained animagine-xl-4.0 checkpoints/animagine-xl-4.0
python -m imagehub.pretrained dreamshaper-xl-1.0 checkpoints/dreamshaper-xl-1.0
from imagehub import pipeline

with pipeline(
    "t2i", backend="sdxl-base-1.0", model="checkpoints/sdxl-base-1.0", device="mps"
) as pipe:
    result = pipe("a cat, oil painting", seed=42, negative_prompt="blurry")
    result.images[0].save("cat.png")

Hyper-SD follows the model card's explicit-timestep recipe:

python -m imagehub.pretrained hyper-sdxl-1step checkpoints/hyper-sdxl-1step
from imagehub import pipeline

with pipeline("t2i", backend="hyper-sdxl-1step", model="checkpoints/hyper-sdxl-1step") as pipe:
    result = pipe("a cat, oil painting", steps=1, guidance=0.0, timesteps=[800], seed=42)
    result.images[0].save("cat.png")

DMD2 follows the model card's explicit-timestep recipes:

python -m imagehub.pretrained dmd2-sdxl-4step checkpoints/dmd2-sdxl-4step
python -m imagehub.pretrained dmd2-sdxl-1step checkpoints/dmd2-sdxl-1step
from imagehub import pipeline

with pipeline("t2i", backend="dmd2-sdxl-4step", model="checkpoints/dmd2-sdxl-4step") as pipe:
    result = pipe(
        "a cat, oil painting",
        steps=4,
        guidance=0.0,
        timesteps=[999, 749, 499, 249],
        seed=42,
    )
    result.images[0].save("cat.png")

Settings. steps (50, at most 1000), guidance (5.0; 1 and below turns guidance off), width/height (the U-Net config's native size, 1024 here, and multiples of 8), negative_prompt (None; with an empty negative prompt, zero embeddings are used), num_images (1), seed, latents, and the micro-conditioning inputs original_size, crops_coords_top_left and target_size (default to the generated size and (0, 0)). The SDXL backend supports the checkpoint's Euler, DDPM, DEIS or LCM scheduler and an explicit timesteps sequence for Euler and LCM; supplying timesteps sets the step count. Unrecognized settings raise an error.

Seed compatibility. On CPU, the same seed gives the same image as diffusers with generator=torch.Generator("cpu").manual_seed(seed) (validation). As with SD 1.x, MPS and CUDA runs are smoke tests only; there is no claim of exact equality on these devices.

Out of scope. There is no safety checker, and the optional image watermark is off. Image input (img2img) is available only for the SDXL refiner, which has its own section; other schedulers and fp16 parity are not in this release.

License. The SDXL base and SDXL-Lightning weights are licensed under CreativeML Open RAIL++-M; the license's use restrictions bind whoever downloads and uses the weights. The Hyper-SD model card has no license metadata, and the repository's license file covers only the FLUX-related files, so the Hyper-SDXL weights are recorded as Unspecified. The DMD2 weights are licensed under CC-BY-NC-4.0, which prohibits commercial use. imagehub does not distribute weights. Juggernaut XL v9 is licensed under CreativeML OpenRAIL-M. Animagine XL 4.0 and DreamShaper XL 1.0 are licensed under CreativeML Open RAIL++-M. The license restrictions bind whoever downloads and uses the weights.

SDXL refiner

Catalog: sdxl · Models: sdxl-refiner-1.0 · Task: t2i (image input required)

Architecture. The refiner is an SDXL U-Net specialised in the low-noise end of the schedule. It differs from the base model in four ways: it has a single text encoder (OpenCLIP bigG: penultimate hidden state, 1280 channels, and its pooled output), a U-Net with four resolution levels (384, 768, 1536, 1536 channels; 4 transformer layers per block), a text_time conditioning vector of five time ids per sample (original size, crop position and an aesthetic score) instead of six, and the VAE and scheduler of the base model. vae/ is used; the repository's second vae_1_0/ is not.

Usage.

python -m imagehub.pretrained sdxl-refiner-1.0 checkpoints/sdxl-refiner-1.0
from PIL import Image
from imagehub import pipeline

with pipeline(
    "t2i", backend="sdxl-refiner-1.0", model="checkpoints/sdxl-refiner-1.0", device="mps"
) as pipe:
    result = pipe("a cat, oil painting", image=Image.open("cat.png"), strength=0.3, seed=0)
    result.images[0].save("refined.png")
  • The image is required. It is converted to RGB, rounded down to a multiple of 8 and resized with Lanczos as diffusers' VaeImageProcessor does, encoded by the VAE by sampling the posterior (this draws from the seeded generator before the noise does) and scaled by 0.13025. The result has the size of the preprocessed input; width, height and latents are not accepted.
  • Strength. strength (default 0.3) keeps the last int(steps * strength) of the steps timesteps: the encoded image is noised to the sigma at the first kept step and denoised from there. A strength so small that no step remains is rejected.
  • Defaults. 50 steps, guidance 5.0, strength 0.3, aesthetic_score 6.0 and negative_aesthetic_score 2.5. Since force_zeros_for_empty_prompt is false, an empty negative prompt is encoded, not zeroed. Other settings: negative_prompt, num_images, seed, original_size, crops_coords_top_left, target_size and their negative_* counterparts. Unrecognized settings raise an error.
  • Not supported. Running the refiner after the base model in latent space (denoising_end on the base and denoising_start on the refiner, ensemble of expert denoisers) is out of scope: the refiner takes an image. Also not supported: the other schedulers of the img2img pipeline, several input images, IP-Adapter, a safety checker, the invisible watermark and fp16 parity.
  • Seed compatibility. On CPU, the same seed, image and settings give the same image as diffusers 0.40.0 StableDiffusionXLImg2ImgPipeline with generator=torch.Generator("cpu").manual_seed(seed) (validation). MPS and CUDA runs are smoke tests only.
  • License. CreativeML Open RAIL++-M; the license's use restrictions bind whoever downloads and uses the weights. The repository is not gated. imagehub does not distribute weights.
  • Memory. In float32: U-Net about 9.4 GB, text encoder 2 about 2.8 GB, VAE 0.3 GB.

SDXL Turbo

Catalog: sdxl-turbo · Models: sdxl-turbo · Task: t2i

Architecture. A distilled SDXL model with the same two frozen text encoders, text_time micro-conditioning and f=8 KL autoencoder design as SDXL. Its native image size is 512×512. The checkpoint publishes an Euler ancestral scheduler with timestep_spacing="trailing" and steps_offset=1; its ancestral noise is drawn from the same seeded CPU generator as the initial noise.

Usage.

python -m imagehub.pretrained sdxl-turbo checkpoints/sdxl-turbo
from imagehub import pipeline

with pipeline("t2i", backend="sdxl-turbo", model="checkpoints/sdxl-turbo", device="mps") as pipe:
    result = pipe("a cat, oil painting", seed=42)
    result.images[0].save("cat.png")

Settings. steps defaults to 1, guidance defaults to 0.0 and width/height default to 512. Other supported settings match SDXL. Other SDXL models retain defaults of 50 steps and 5.0 guidance and take their default size from the U-Net config. Unrecognized settings raise an error.

Seed compatibility. On CPU, the same seed gives the same image as diffusers with generator=torch.Generator("cpu").manual_seed(seed) (validation), including the ancestral noise at every scheduler step. MPS and CUDA runs are smoke tests only; there is no claim of exact equality on these devices.

Out of scope. There is no safety checker, and the optional image watermark is off. Image input (img2img) is available only for the SDXL refiner, which has its own section; other schedulers and fp16 parity are not in this release.

License. The weights use the sai-nc-community license and are limited to non-commercial use. The license's use restrictions bind whoever downloads and uses the weights. imagehub does not distribute weights.

SSD-1B and Segmind-Vega

Catalog: ssd-1b, segmind-vega · Models: ssd-1b, segmind-vega · Task: t2i

Architecture. A distilled SDXL model with the same frozen CLIP ViT-L/14 and OpenCLIP bigG text encoders, f=8 KL autoencoder and Euler scheduler as SDXL. Its 1.3B-parameter U-Net uses per-block transformer depths and a mid block without attention while retaining SDXL's text_time micro-conditioning.

Segmind-Vega is the smaller 0.74B-parameter U-Net from the same progressive distillation work. Its three U-Net levels use one, one and two transformer layers per attention block, and its middle block has one residual block and no attention. The text encoders, VAE, Euler scheduler and SDXL micro-conditioning are unchanged.

Usage.

python -m imagehub.pretrained ssd-1b checkpoints/ssd-1b
python -m imagehub.pretrained segmind-vega checkpoints/segmind-vega
from imagehub import pipeline

with pipeline("t2i", backend="ssd-1b", model="checkpoints/ssd-1b", device="mps") as pipe:
    result = pipe("a cat, oil painting", seed=42, negative_prompt="blurry")
    result.images[0].save("cat.png")

Use backend="segmind-vega" with model="checkpoints/segmind-vega" for Vega. The model card recommends a negative prompt and guidance around 9.0 for image quality; imagehub retains the reference pipeline defaults unless those options are supplied.

Settings. The defaults and supported settings are the same as for SDXL: steps (50, at most 1000), guidance (5.0), width/height (the U-Net config's native size, 1024 here, and multiples of 8), negative_prompt (None), num_images (1), seed, latents, original_size, crops_coords_top_left and target_size. Unrecognized settings raise an error.

Seed compatibility. SSD-1B's recorded CPU validation gives the same image as diffusers with generator=torch.Generator("cpu").manual_seed(seed). The dedicated Vega suite includes the same comparison; its real-checkpoint record is produced by the controller (validation). MPS and CUDA runs are smoke tests only; there is no claim of exact equality on these devices.

Out of scope. There is no safety checker, and the optional image watermark is off. Image input (img2img) is available only for the SDXL refiner, which has its own section; other schedulers and fp16 parity are not in this release.

License. The weights are licensed under Apache-2.0. imagehub does not distribute weights.

Memory. Segmind-Vega's U-Net is about 3.0 GB in float32; a complete float32 pipeline is about 6.6 GB. SSD-1B is larger because its U-Net retains more transformer blocks.

KOALA

Catalog: koala · Models: koala-700m, koala-1b, koala-lightning-700m, koala-lightning-1b · Task: t2i

Architecture. KOALA distills SDXL into smaller denoising U-Nets while retaining SDXL's two text encoders, f=8 KL autoencoder, Euler scheduler and text_time micro-conditioning. Both U-Nets use one residual layer per level. KOALA-700M uses transformer depths [1, 2, 5] and omits the middle block; KOALA-1B uses [1, 2, 6] and retains the SDXL cross-attention middle block.

Usage.

python -m imagehub.pretrained koala-700m checkpoints/koala-700m
python -m imagehub.pretrained koala-1b checkpoints/koala-1b
python -m imagehub.pretrained koala-lightning-700m checkpoints/koala-lightning-700m
python -m imagehub.pretrained koala-lightning-1b checkpoints/koala-lightning-1b
from imagehub import pipeline

with pipeline("t2i", backend="koala-700m", model="checkpoints/koala-700m") as pipe:
    result = pipe("a portrait painting of a golden retriever", seed=42)
    result.images[0].save("retriever.png")

Use backend="koala-1b" and the matching snapshot for the larger variant. The model cards show 25-step generation and a negative prompt for image quality; imagehub retains the reference pipeline defaults unless options are supplied.

The Lightning checkpoints use the same two U-Net layouts but are trained for few-step generation. Select backend="koala-lightning-700m" or backend="koala-lightning-1b" with its matching snapshot. Their model-card defaults are 10 steps, guidance 3.5 and Euler trailing timestep spacing.

Settings. The supported settings match SDXL: steps (50 for base KOALA and 10 for Lightning, at most 1000), guidance (5.0 for base KOALA and 3.5 for Lightning), width/height (1024 by default and multiples of 8), negative_prompt (None), num_images (1), seed, latents, original_size, crops_coords_top_left and target_size. Unrecognized settings raise an error.

Validation. Dedicated CPU float32 tests compare the published tensor layouts, tokenizers, text encoders, U-Net, VAE, Euler scheduler and two public-API generations per checkpoint against diffusers 0.40.0. MPS and CUDA runs are smoke tests only.

Out of scope. There is no safety checker or watermark. Image-to-image, other schedulers and reduced-precision parity are not included.

License. The model repositories do not declare weight-license metadata. The linked author code repository describes separate non-commercial and proprietary commercial terms; review the terms before downloading. imagehub does not distribute weights.

Memory. The full-precision U-Net files are about 3.1 GB for each 700M release and 4.6 GB for each 1B release. The two text encoders and VAE add about 3.6 GB.

Playground v2

Catalog: playground-v2 · Models: playground-v2 · Task: t2i

Architecture. An SDXL-family model with the same two frozen text encoders, U-Net layout and text_time micro-conditioning as SDXL. Unlike Playground v2.5, it keeps the standard SDXL autoencoder (scaling factor 0.13025) and the Euler ancestral scheduler with the scaled-linear noise schedule and leading timestep spacing. Its native image size is 1024×1024.

Usage.

python -m imagehub.pretrained playground-v2 checkpoints/playground-v2
from imagehub import pipeline

with pipeline(
    "t2i", backend="playground-v2", model="checkpoints/playground-v2", device="mps"
) as pipe:
    result = pipe("a cat, oil painting", seed=42)
    result.images[0].save("cat.png")

Settings. steps defaults to 50, guidance defaults to 3.0 (the value recommended on the model card) and width/height default to 1024. Other supported settings match SDXL. Unrecognized settings raise an error.

Seed compatibility. On CPU, the same seed gives the same image as diffusers with generator=torch.Generator("cpu").manual_seed(seed) (validation). The Euler ancestral scheduler draws its per-step noise from the same seeded generator. MPS and CUDA runs are smoke tests only; there is no claim of exact equality on these devices.

Out of scope. There is no safety checker, and the optional image watermark is off. The SDXL refiner model, img2img, other schedulers and fp16 parity are not in this release.

License. The weights use the playground-v2-community license, which restricts commercial use under its terms; see the license. imagehub does not distribute weights.

Playground v2.5

Catalog: playground-v2 · Models: playground-v2.5 · Task: t2i

Architecture. An SDXL-family model with the same two frozen text encoders and text_time micro-conditioning. Its EDM DPM-Solver++ scheduler is a second-order multistep scheduler with Karras sigmas and EDM preconditioning. The f=8 KL autoencoder uses a scaling factor of 0.5, with per-channel latents_mean and latents_std applied before decoding. Its native image size is 1024×1024.

Usage.

python -m imagehub.pretrained playground-v2.5 checkpoints/playground-v2.5
from imagehub import pipeline

with pipeline(
    "t2i", backend="playground-v2.5", model="checkpoints/playground-v2.5", device="mps"
) as pipe:
    result = pipe("a cat, oil painting", seed=42)
    result.images[0].save("cat.png")

Settings. steps defaults to 50, guidance defaults to 3.0 and width/height default to 1024. Other supported settings match SDXL. Unrecognized settings raise an error.

Seed compatibility. On CPU, the same seed gives the same image as diffusers with generator=torch.Generator("cpu").manual_seed(seed) (validation). MPS and CUDA runs are smoke tests only; there is no claim of exact equality on these devices.

Out of scope. There is no safety checker, and the optional image watermark is off. Image input (img2img) is available only for the SDXL refiner, which has its own section; other schedulers and fp16 parity are not in this release.

License. The weights use the playground-v2dot5-community license, which restricts commercial use under its terms; see the license. imagehub does not distribute weights.

Reference and imagehub, side by side

Drag the slider. Left is the recorded reference, right is imagehub, from the same seed, on CPU in float32.