Text-to-Image Model

Playground v2.5 self-hosted: the aesthetic baseline that fits on one 24GB card

A 6.94GB fp16 checkpoint, native 1024x1024 output, MJHQ-30K FID of 4.48. Start on an RTX 3090 at $0.193/GPU-hour and own the whole pipeline.

Playground · self-hosted

Sort out the name first. Searching for "Playground" today hits two unrelated things: a line of downloadable open-weight diffusion models (v1 to v2 to v2.5), and a web product that has since become an AI design studio - the latter now fronts third-party models like GPT Image 2, Nano Banana Pro and Seedream, which has nothing to do with what you can run yourself. The thing you can actually pull down is playgroundai/playground-v2.5-1024px-aesthetic on Hugging Face: 404k downloads, and the last set of weights the org ever shipped (March 2024).

Architecturally it is a 3B-parameter latent diffusion model that follows Stable Diffusion XL exactly: the same UNet2DConditionModel (sample_size 128, cross_attention_dim 2048, block_out_channels [320, 640, 1280]) and the same two frozen text encoders, OpenCLIP-ViT/G and CLIP-ViT/L. All the difference is in the training recipe. The paper, "Playground v2.5: Three Insights towards Enhancing Aesthetic Quality" (arXiv:2402.17245), names three: switch to an EDM noise schedule to recover colour and contrast, prepare a balanced bucketed dataset so portrait and landscape hold up, and align to human preference for people-heavy detail. The result is 4.48 FID on MJHQ-30K, against 7.07 for Playground v2 and 9.55 for the SDXL-1.0 refiner on the same benchmark.

So what about Playground v3? The paper (arXiv:2409.10695) is real: 24B parameters, with Llama3-8B deep-fused layer by layer into the image transformer - each image block mirrors the corresponding LLM block and takes that layer's hidden states as conditioning, while image queries attend over concatenated image and text keys. No T5, no CLIP, plus an in-house 16-channel VAE, and CapsBench (200 images, 2,471 questions) shipped alongside. But the weights were never released, and the playgroundai GitHub org still has no public repositories. "Deploying Playground v3 locally" is not a path that exists; v2.5 is. That is not bad news - 3B means one consumer 24GB card, at a fraction of the cost of chasing the frontier.

01 —

Versions and variants: what you can download, what you can't

Open weights stop at v2.5; v3 is a paper and a product

Version	Parameters	VRAM	Context	Notes
playgroundai/playground-v2.5-1024px-aesthetic	3B (SDXL-architecture UNet + dual CLIP text encoders)	fp16 single file 6.94GB / fp32 single file 13.9GB / full repo 62.4GB	Native 1024x1024 plus portrait and landscape buckets; 77-token CLIP text context	The only version worth deploying. Ships with EDMDPMSolverMultistepScheduler at guidance_scale 3.0 and 50 steps; swap in EDMEulerScheduler and raise guidance_scale to 5.0. MJHQ-30K FID 4.48.
playgroundai/playground-v2-1024px-aesthetic	3B (same architecture as v2.5)	~7GB class in fp16 (same SDXL 3B UNet)	1024x1024	Previous-generation aesthetic model, MJHQ-30K FID 7.07. Go straight to v2.5 unless you are reproducing a comparison; at 248 downloads the community moved on long ago.
playground-v2-512px-base / playground-v2-256px-base	3B	~7GB class in fp16	512x512 / 256x256	Base weights with no aesthetic alignment, meant for continued pretraining and ablations. Download counts in the single and double digits - research material, not a generation model.
Playground v3 (PG-v3)	24B (deep-fused Llama3-8B)	Weights not released; cannot be self-hosted	All text conditioning comes from Llama3-8B with its native 8K context; trained with 256/512/1024 bucketing	arXiv:2409.10695. Drops T5 and CLIP entirely, uses an in-house 16-channel VAE, and introduced CapsBench. No Hugging Face repo, no public GitHub code - available only inside Playground's own product.

02 —

Picking a card: a 3B model should not bankrupt you

6.94GB of fp16 weights plus 1024px activations puts the sweet spot at 24GB

Single-card 1024x1024 generation, pipeline bring-up, batch evaluation
RTX 3090 24GB$0.193/GPU-hour
The 6.94GB fp16 checkpoint leaves well over ten spare gigabytes for activations and VAE decode, and this is the cheapest 24GB tier we rent - no reason to spend more while evaluating.
Concurrent generation, ComfyUI batch runs, serving an endpoint
RTX 4090 24GB$0.540/GPU-hour
Same 24GB, substantially more throughput; 50-step EDM sampling is pure compute, so images per hour is what sets your cost per image.
1024px LoRA / DreamBooth fine-tuning with gradient checkpointing and cached latents
RTX 5090 32GB$0.723/GPU-hour
SDXL-class 1024px LoRA runs fit on 24GB only with 8-bit optimizers and careful settings; 32GB buys real batch size and bucket headroom, which halves the tuning cycle.
Full UNet fine-tune, multi-resolution bucketed training, heavy data preprocessing
RTX A6000 48GB$0.817/GPU-hour
Full-parameter training on a 3B UNet holds weights, gradients, optimizer state and EMA at once; 48GB is the lowest tier that avoids aggressive sharding. Step up to A100 SXM4 80GB at $1.088/GPU-hour when you need it.

03 —

Four steps from bare instance to first image

The two things that go wrong are downloading the wrong files and using the wrong sampler

01
Spin up an instance and pull only the fp16 files
Boot a PyTorch image, install the deps, and filter the download with --include. The full repo is 62.4GB because it carries fp32 weights and duplicated components; all you need is the 6.94GB fp16 checkpoint plus configs. The EDM schedulers landed in diffusers 0.27.0 - an older version fails with an ImportError.
```
pip install "diffusers>=0.27.0" transformers accelerate safetensors && hf download playgroundai/playground-v2.5-1024px-aesthetic --include "*.fp16.safetensors" "*.json" "*.txt" --local-dir pgv25
```
02
Minimal diffusers inference - do not drop variant="fp16"
Without variant="fp16" the pipeline fetches fp32 weights and doubles both VRAM and download. The model ships EDMDPMSolverMultistepScheduler; guidance_scale=3.0 at 50 steps is the combination the authors give. If you switch to EDMEulerScheduler, raise guidance_scale to 5.0 or the output goes visibly flat.
```
python -c "import torch;from diffusers import DiffusionPipeline;p=DiffusionPipeline.from_pretrained('playgroundai/playground-v2.5-1024px-aesthetic',torch_dtype=torch.float16,variant='fp16').to('cuda');p('cinematic portrait, muted colors, detailed, 8k',num_inference_steps=50,guidance_scale=3.0).images[0].save('out.png')"
```
03
On ComfyUI, you must attach the EDM sampling node
This is the single most common failure. Playground v2.5 normalizes latents differently from SDXL: SDXL applies latent x 0.13025, while v2.5 uses (latent - mean) x 0.5 / std, with mean [-1.6574, 1.886, -1.383, 2.5155] and std [8.4927, 5.9022, 6.5498, 5.2299]. Load it as a plain SDXL checkpoint and you get washed-out, contrast-free images. ComfyUI has native support: after Load Checkpoint, insert ModelSamplingContinuousEDM with sampling set to edm_playground_v2.5, sigma_max 120.0 and sigma_min 0.002, and it switches to the SDXL_Playground_2_5 latent format for you.
```
python main.py --listen 0.0.0.0 --port 8188
```
04
Trim VRAM or push throughput
When memory is tight, combine model-level CPU offload with tiled VAE decode to keep the peak under 16GB at a tolerable speed cost (sequential offload also works but is too slow to be practical). For serving, go the other way: the community has published TensorRT engine builds targeting A10G, A100 and H100, and fixed-resolution workloads see the biggest latency win. Remember to open the port on the instance before reaching ComfyUI or Jupyter from outside.
```
pipe.enable_model_cpu_offload(); pipe.vae.enable_tiling()
```

The arithmetic: this model is cheap enough not to think twice

Evaluation: RTX 3090 24GB at $0.193/GPU-hour, three hours to pull weights and produce a first batch, 0.193 x 3 = $0.579. Storage is where people leak money - keeping only the fp16 checkpoint costs 6.94 x $0.414 = $2.87/month, while lazily cloning the whole repo costs 62.4 x $0.414 = $25.83/month, a nine-fold difference that makes the --include filter in step one worth real money. One 1024px LoRA run on an RTX 5090 32GB for six hours is 0.723 x 6 = $4.34; a full-parameter UNet fine-tune on an RTX A6000 48GB for a full day is 0.817 x 24 = $19.61. Pulling 2GB of finished images out costs 2 x $0.0081 = $0.02. Compute is metered per second and priced per hour, and it stops billing the moment the instance stops - storage keeps running until you destroy it, so clear that 62.4GB scratch directory when training ends. No minimum, no setup fee, no quota request.

04 —

FAQ

Can I deploy Playground v3 locally? Where are the weights?

You can't, and there are none. PG-v3 exists only as arXiv:2409.10695 - 24B parameters with Llama3-8B deep-fused - with no Hugging Face repo and no public code in the playgroundai GitHub org. If you want to self-host something with Playground lineage, v2.5 is the target. At 3B it starts on a single RTX 3090 24GB at $0.193/GPU-hour on NexGPU, first image within minutes of boot.

How much VRAM does Playground v2.5 actually need? Is 16GB enough?

The fp16 weights are a firm 6.94GB. Add attention activations and VAE decode for a single 1024x1024 image and a 16GB card will run it with tiled VAE, but with no slack. 24GB is where it gets comfortable: real batch sizes, LoRA stacking, high-res fix. On NexGPU a Tesla T4 16GB is $0.298/GPU-hour while an RTX 3090 24GB is $0.193/GPU-hour - the bigger card is the cheaper one, so there is no reason to squeeze.

Why are my Playground v2.5 images washed out with no contrast?

Because it was loaded as an ordinary SDXL checkpoint. v2.5 was trained under EDM and normalizes latents differently: SDXL does latent x 0.13025, v2.5 does (latent - mean) x 0.5 / std. In ComfyUI, attach ModelSamplingContinuousEDM and set sampling to edm_playground_v2.5. In diffusers, keep the bundled EDMDPMSolverMultistepScheduler and use guidance_scale=3.0. To settle it quickly, boot our ComfyUI image on an RTX 4090 at $0.540/GPU-hour and run the two configurations side by side - ten minutes and you have your answer.

Are there GGUF or INT4 quantized builds of Playground v2.5?

No official ones, and effectively none from the community either. The GGUF ecosystem grew around DiT-style models such as Flux and SD3, whereas v2.5 is a UNet-based SDXL relative. The real memory levers are fp16 weights, ComfyUI's fp8 weight storage, tiled VAE, or compiling a TensorRT engine (builds targeting A10G, A100 and H100 already exist). At 6.94GB in fp16 there was never much to gain from quantizing. If you want to compile TensorRT engines, our A100 PCIE 80GB is $0.824/GPU-hour.

Can Playground v2.5 be used commercially? What is the licence?

It ships under the Playground v2.5 Community License, which is not an OSI-approved open-source licence. Research and commercial use are free below 1 million monthly unique users (MUUs); above that you must request a licence from Playground. Redistribution must retain the notice "Playground v2.5 is licensed under the Playground v2.5 Community License," and Attachment A lists prohibited uses. Read the licence text itself for compliance decisions. Instances on NexGPU are entirely yours - neither the weights nor the outputs pass through us.

What hardware do I need to fine-tune Playground v2.5? Is it the same as SDXL?

Essentially yes - the UNet is structurally identical, so most SDXL LoRA and DreamBooth scripts work after changing the model ID. The one thing to get right is keeping the EDM sampling and latent normalization. For 1024px LoRA we suggest RTX 5090 32GB at $0.723/GPU-hour; for full-parameter runs start at RTX A6000 48GB at $0.817/GPU-hour and move to A100 SXM4 80GB at $1.088/GPU-hour as the dataset grows. NexGPU spans 51 countries and regions with 1,175 verified nodes and 2,498 GPUs, up to 14 GPUs per node and 2,152GB of node VRAM at the top end, so multi-GPU bucketed training is covered. Support is bilingual over Telegram with no ticket queue.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.