How to Run Chroma1-HD Locally: An Open Base Model for Text-to-Image

Chroma1-HD is an 8.9 billion parameter text-to-image model built on FLUX.1-schnell and released under a fully permissive Apache 2.0 license. It runs through Hugging Face Diffusers on an NVIDIA GPU, and its real selling point is that it's meant as a clean, unrestricted base for finetuning rather than a finished chatbot-style product.

Written by Priya Raghunathan, local-AI hardware reviewer. I check parameter counts, licenses, hardware requirements and install commands against the primary source before recommending a setup path.

A new top-20 entrant on Hugging Face's text-to-image list

Chroma1-HD, published by the solo developer behind the lodestones account, entered the top 20 of Hugging Face's text-to-image trending list more than a year after its August 2025 release, a sign of steady community pickup rather than a launch-week spike. At time of writing the model page shows 442 likes and 64,792 downloads. The README lists no GitHub repository for the model itself. The most-liked Space built around it is RioShiina/ImageGen (233 likes), a browser demo you can try before installing anything.

Specs at a glance

What it actually does

Chroma1-HD isn't trying to be a polished consumer image generator out of the box. It's a base model, a starting checkpoint meant for finetuning into specialized versions rather than for running as-is in a product. The model card is explicit about this: it's pitched at researchers, developers, and artists who want to build a custom model on a foundation that nobody can revoke or relicense out from under them later. If you just want pictures from text prompts today, the RioShiina Space above gets you there faster. If you want to train a style or character model and keep full control of the weights, Chroma1-HD is built for exactly that second job.

The model started from FLUX.1-schnell's 12 billion parameter design and cut it down through a specific set of changes rather than generic pruning. The developer replaced a 3.3 billion parameter timestep-encoding layer with a smaller 250 million parameter feed-forward network, added MMDiT masking so the model ignores T5 text encoder padding tokens instead of wasting capacity on them, and used a custom timestep sampling distribution during training to avoid loss spikes. Together those changes account for most of the drop from 12B to 8.9B parameters.

12B → 8.9B Parameters: I replaced a 3.3B parameter timestep-encoding layer with a more efficient 250M parameter FFN.

Training used 5 million samples curated from a 20 million sample pool spanning artistic, photographic, and niche styles, chosen specifically to avoid the narrow style bias that comes from training only on a single aesthetic. For the fast, CFG-free variant tuned for fewer sampling steps, the developer publishes a separate checkpoint, Chroma1-Flash, rather than baking that behavior into Chroma1-HD itself.

Install and run with Diffusers

import torch
from diffusers import ChromaPipeline

pipe = ChromaPipeline.from_pretrained("lodestones/Chroma1-HD", torch_dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()

prompt = [
    "A high-fashion close-up portrait of a blonde woman in clear sunglasses. The image uses a bold teal and red color split for dramatic lighting. The background is a simple teal-green. The photo is sharp and well-composed, and is designed for viewing with anaglyph 3D glasses for optimal effect. It looks professionally done."
]
negative_prompt = ["low quality, ugly, unfinished, out of focus, deformed, disfigure, blurry, smudged, restricted palette, flat colors"]

image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    generator=torch.Generator("cpu").manual_seed(433),
    num_inference_steps=40,
    guidance_scale=3.0,
    num_images_per_prompt=1,
).images[0]
image.save("chroma.png")

40 inference steps and a guidance scale of 3.0 are the values from the model card's own example, and they're a reasonable starting point. A negative prompt is doing real work here too: Chroma1-HD, like most FLUX-derived models, responds well to being told what to avoid as well as what to generate.

Faster inference with quantization

If you have a CUDA GPU with enough room to skip CPU offload, int8 dynamic quantization through gemlite cuts generation time substantially. On the developer's own hardware, the same prompt and settings dropped from roughly 66 seconds to about 28 seconds across repeated runs once gemlite patched the transformer's linear layers and torch.compile was applied to the transformer and VAE forward passes.

Run it in ComfyUI

ComfyUI is the other supported path, and it needs a few extra downloads beyond the checkpoint itself: a T5 XXL text encoder and the FLUX VAE, both published by other Hugging Face accounts, plus a workflow file the Chroma1-HD repository ships directly.

• Download the T5 XXL text encoder into ComfyUI/models/clip
• Download the FLUX VAE into ComfyUI/models/vae
• Place the Chroma1-HD checkpoint itself in ComfyUI/models/diffusion_models
• Load the Chroma1-HD workflow JSON into ComfyUI and run it

License and intended use

Chroma1-HD ships under Apache 2.0, one of the most permissive open source licenses available, so commercial use, modification, and redistribution are all allowed without asking permission. The model card frames the intended use narrowly on purpose: finetuning into specific styles or characters, research into generative model behavior and safety, or as a component inside a larger system, rather than as a finished product you point end users at directly.

Known limitations

There's no published minimum VRAM figure and no official quantized or CPU-only build beyond the community gemlite recipe above, so you're left estimating hardware needs rather than reading them off the card. The developer is also direct about the model having no built-in safety filter: it was trained on broad, filtered internet data and can reflect the biases in that data or generate content some would consider harmful or explicit, so anything built on top of it needs its own moderation layer rather than relying on the base checkpoint to refuse requests.

FAQ

What is Chroma1-HD?

An 8.9 billion parameter text-to-image model built on a modified FLUX.1-schnell architecture, released under Apache 2.0 by the developer lodestones. It's designed as a base model for finetuning rather than a finished consumer image generator.

Is Chroma1-HD free for commercial use?

Yes. Apache 2.0 permits commercial use, modification, and redistribution without needing permission from the developer.

How much VRAM does Chroma1-HD need?

The model card doesn't publish a minimum. The reference script uses CPU offload, which trades speed for lower GPU memory use, so it can run on cards that can't hold all 8.9B parameters at once. Expect noticeably faster generation on a GPU with enough room to skip offloading and add int8 quantization instead.

What is Chroma1-HD based on?

FLUX.1-schnell, with the original 12 billion parameters cut to 8.9 billion through a smaller timestep-encoding layer, MMDiT masking of T5 padding tokens, and a custom timestep sampling distribution during training.

Where to go from here

• Browse other local image generation models: the local AI model directory lets you compare specs side by side.
• New to running Diffusers models locally? the how-to guide index has setup guides for other local models that cover the same workflow.