You have downloaded the model weights. The HuggingFace page says "10B parameters, Apache 2.0, tops the Qwen-Image-Bench." Your terminal is open. Now what?
Getting Boogu-Image-0.1 running locally is straightforward once you know which variant to grab, which settings to dial in, and how much VRAM your GPU actually has. This tutorial walks through three methods -- ComfyUI for a visual workflow, Diffusers for a Python-first approach, and online demos for zero-setup experimentation -- so you can pick the path that fits your hardware and skill level.
As of July 2026, all Boogu-Image-0.1 model variants are available on HuggingFace under the Apache 2.0 license, with source code on GitHub. The official site boogu.org also hosts live demos for each variant.
Which Variant Should I Choose?
Before installing anything, decide which variant matches your use case. Boogu-Image-0.1 ships in four variants, and picking the wrong one wastes time and VRAM.
Variant
Best For
Speed
Quality
CFG
Steps
Turbo
Quick drafts, iteration, prototyping
Fast (3-4 steps)
Very good
1.0
3-4
Base
Maximum quality, fine-tuning, dense text rendering
Slow (25-50 steps)
Highest
2.0-5.0
25-50
Edit
Instruction-driven image editing
Medium
High
Varies
25-50
Edit-Turbo
Fast image editing
Fast
Good
1.0
3-4
The short version: Start with Turbo. It produces excellent results in 3-4 steps, making it the best default for text-to-image generation. Switch to Base when you need maximum quality, when you are rendering dense text (100+ characters), or when you plan to fine-tune. Use Edit or Edit-Turbo when you already have an image and want to modify it with natural language instructions.
Hardware Requirements
Boogu-Image-0.1 is a 10B parameter model. That means meaningful VRAM requirements. Here is what you need for each precision level:
Precision
VRAM (Approx.)
Notes
bf16 (full)
~24 GB
Best quality. Requires RTX 4090 or A100. Works on Apple M1 Max (~70s/image).
fp8
~16 GB
Good balance. Runs on RTX 4080/4090. Does NOT work on Apple MPS.
INT8
~14 GB
Slightly lower quality. Fits on RTX 4080 and some 3090s.
NVFP4
~8-10 GB
Lowest VRAM. Fits on RTX 3070/4060. Quality trade-off.
If your GPU has less than 16 GB of VRAM, look at the quantized versions on HuggingFace: Boogu-Image-0.1-Turbo-fp8 and Boogu-Image-0.1-Edit-fp8. Community-contributed INT8 and NVFP4 quantizations are also available.
One important caveat for Mac users: bf16 inference works on Apple Silicon via the MPS backend (use device_map="mps" instead of "cuda"), but fp8 quantization is not supported on MPS. Stick with bf16 on Macs.
Method 1: ComfyUI (Recommended for Most Users)
ComfyUI is the most popular way to run Boogu-Image-0.1 locally. It gives you a node-based visual interface, which makes experimenting with settings, workflows, and prompt variations much faster than writing Python code for every change.
Step 1: Install or Update ComfyUI
If you already have ComfyUI installed, update it through ComfyUI Manager to make sure you have the latest node definitions. Boogu-Image-0.1 is supported natively in recent ComfyUI versions.
If you are starting from scratch, follow the official ComfyUI installation guide for your platform. On most systems, that means:
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt
Step 2: Download the Model
You have two options for getting the model files into ComfyUI.
Option A: Comfy-Org Packaged Models (Easier)
The Comfy-Org team has packaged Boogu-Image-0.1 models for direct use in ComfyUI. Open ComfyUI Manager, search for the Boogu model pack, and install it. This handles file placement automatically.
Option B: Manual Download from HuggingFace
Download the model files from the Comfy-Org/Boogu-Image repository and place them in the correct ComfyUI directories. Each variant requires three components -- the diffusion model, a text encoder, and a VAE:
The text encoder (qwen3vl_8b_fp8_scaled.safetensors) and VAE (ae.safetensors) are shared across variants -- download them once. The Turbo variant also requires its LoRA adapter file.
Load the appropriate workflow for your chosen variant:
Open ComfyUI in your browser
Click "Load" or drag the workflow JSON file onto the canvas
Verify that the model paths in the workflow nodes point to your downloaded files
Step 4: Configure the Settings
This is where people get tripped up. The Turbo and Base variants use very different sampler configurations. Using Base settings on Turbo (or vice versa) produces poor results.
Sampler: Euler
Scheduler: Simple
CFG Scale: 2.0-5.0 (start at 3.5)
Steps: 25-50 (start at 30)
A few notes on these settings:
Turbo at CFG 1.0 is not a typo. The Turbo variant was distilled to work without classifier-free guidance, so setting CFG higher than 1.0 actually degrades output quality.
Base benefits from higher CFG for text-heavy prompts. If you are rendering text in an image, try CFG 4.0-5.0.
More steps on Base improve quality up to about 40 steps. Beyond 50, returns diminish sharply.
Step 5: Set Your Resolution
Enter your desired resolution in the "Empty Latent Image" node:
1024x1024 -- stable default, good for most use cases
2048x2048 -- best for text rendering and fine details
Boogu supports multiple aspect ratios including 1:1, 2:3, 3:2, 3:4, 4:3, 1:2, 2:1, 9:16, and 16:9. Common choices include 1024x768 (4:3 landscape), 768x1024 (3:4 portrait), and 1920x1080 (16:9 widescreen). Keep the total pixel count at or below 2K resolution for stable results.
Step 6: Write Your Prompt and Generate
Type your prompt in the text box and click "Queue Prompt." Your first generation may take longer as ComfyUI loads the model into VRAM.
See the prompt tips section below for guidance on writing effective Boogu-Image prompts.
Method 2: Diffusers (Python API)
If you prefer working in Python -- for scripting, batch generation, or integrating Boogu into a larger pipeline -- the Diffusers library from Hugging Face is the way to go.
Note that fp8 quantization requires an NVIDIA GPU with CUDA support. It does not work on Apple MPS.
For batch generation workflows, wrap the pipeline call in a loop and reuse the loaded pipe object. Model loading is the expensive step -- once the model is in VRAM, subsequent generations run at inference speed without reload overhead.
prompts = [
"A watercolor painting of a Japanese garden in autumn",
"A cyberpunk cityscape at night with neon reflections on wet streets",
"A detailed botanical illustration of a sunflower, scientific style",
]
for i, prompt in enumerate(prompts):
image = pipe(
prompt=prompt,
num_inference_steps=4,
guidance_scale=1.0,
height=1024,
width=1024,
).images[0]
image.save(f"boogu_batch_{i}.png")
Method 3: Online Demos (Zero Setup)
If you want to try Boogu-Image-0.1 without installing anything, the official site boogu.org hosts live demos for each variant:
Base demo -- full quality text-to-image generation
Turbo demo -- fast generation with 3-4 step inference
Edit demo -- upload an image and edit it with natural language
These demos run on the project's servers, so you do not need a GPU. They are ideal for evaluating whether Boogu fits your needs before committing to a local installation.
Keep in mind that public demos may have queue times during peak hours, and resolution options may be limited compared to running locally.
The demos are useful for a quick side-by-side comparison. Try the same prompt on both Turbo and Base to see the quality-speed tradeoff firsthand before deciding which variant to download for local use.
Prompt Tips for Boogu-Image-0.1
Boogu-Image responds well to detailed, descriptive prompts. Here is what works and what does not.
Use Long, Detailed Prompts
Unlike some models that perform best with short prompts, Boogu-Image benefits from specificity. Compare:
Weak prompt:
A cat on a table
Strong prompt:
A fluffy orange tabby cat lounging on a rustic wooden farmhouse table, warm afternoon sunlight streaming through a nearby window, a ceramic vase with wildflowers in the background, soft bokeh, photorealistic, 4K detail
The more visual information you provide -- lighting, materials, composition, camera angle, style -- the better the output.
Bilingual Support
Boogu-Image supports prompts in both English and Chinese. You can write prompts in either language or mix them. Chinese prompts are handled natively, not through translation, which means Chinese-language descriptions of cultural subjects tend to produce more authentic results.
Text Rendering Prompts
One of Boogu-Image's standout features is text rendering. The Base variant can render 100+ characters accurately at 2K resolution. To render text in your images:
Put the exact text in quotation marks within your prompt
Specify the font style, size context, and placement
Use the Base variant at 2K resolution for best results
Example:
A vintage coffee shop menu board with white chalk lettering on dark green, reading "Today's Special: Lavender Oat Milk Latte $5.50", hand-drawn coffee cup illustration in the corner, cozy warm lighting
Resolution Guidance
512x512 to 1024x1024 -- fast, stable, good for iteration
1024x1024 to 1536x1536 -- balanced detail and speed
1536x1536 to 2048x2048 -- maximum detail, best for text rendering and print-quality output
For Turbo at 1024x1024, expect generation times around 2-5 seconds on an RTX 4090, or about 52 seconds on an Intel integrated GPU (community-reported benchmark at 4 steps).
Common Issues and Fixes
Model fails to load with OOM error
Your GPU does not have enough VRAM for the selected precision. Switch to fp8, INT8, or NVFP4 quantization. See the hardware requirements table above.
fp8 crashes on Mac
Expected behavior. fp8 quantization is not supported on the Apple MPS backend. Use bf16 instead with device_map="mps" in your pipeline configuration.
Turbo output looks overcooked or saturated
You are probably using CFG higher than 1.0. Set guidance_scale (or CFG Scale in ComfyUI) to exactly 1.0 for Turbo.
Base output looks noisy or undercooked
Increase your step count. Start at 30 steps and work up to 40-50. Also try increasing CFG to 4.0-5.0.
ComfyUI does not recognize the model
Make sure you have updated ComfyUI and its dependencies. The Comfy-Org packaged model option is the easiest path -- update from ComfyUI Manager, which handles node compatibility automatically.
Text in images is garbled or incomplete
Switch to the Base variant at 2K resolution. Turbo handles short text well but struggles with dense or long text strings. Base was specifically optimized for text rendering fidelity.
Frequently Asked Questions
Is Boogu-Image-0.1 free to use commercially?
Yes. Boogu-Image-0.1 is released under the Apache 2.0 license, which permits commercial use, modification, and redistribution without royalty fees.
Can I fine-tune Boogu-Image-0.1?
Yes. The Base variant is the recommended starting point for fine-tuning. Turbo is a distilled model optimized for speed, so fine-tuning results on Turbo are less predictable.
What is the difference between Turbo and Base?
Turbo generates images in 3-4 steps at CFG 1.0, making it roughly 8-10x faster than Base. Base runs at 25-50 steps with CFG 2.0-5.0, producing higher quality output with more control over the generation process. Base also handles dense text rendering better than Turbo.
Does Boogu-Image-0.1 support ControlNet or LoRAs?
The model is based on an architecture compatible with the broader diffusion model ecosystem. Check the Boogu-Image GitHub repository for the latest on community adapters and ControlNet support.
How does Boogu-Image compare to FLUX?
Boogu-Image-0.1 reuses the FLUX.1 VAE but has a different generation backbone. On the Qwen-Image-Bench, Boogu-Image-0.1-Base scores 53.58 overall, placing it above many larger models.
Can I run Boogu-Image-0.1 on a laptop GPU?
It depends on the GPU. With NVFP4 quantization (8-10 GB VRAM), it can run on laptop GPUs like the RTX 4060 Mobile. Full bf16 requires 24 GB, which rules out most laptops. Generation will be slower on laptop hardware, but it works.
What resolutions does Boogu-Image-0.1 support?
Boogu-Image-0.1 supports resolutions from 512x512 up to 2048x2048 in supported aspect ratios (1:1, 2:3, 3:2, 3:4, 4:3, 1:2, 2:1, 9:16, 16:9). The sweet spot for most use cases is 1024x1024. Text rendering and fine detail work benefit from 1.5K-2K resolution.
Why are my Turbo outputs different from what I see in demos?
The most common cause is incorrect sampler settings. Turbo requires Euler sampler with sgm_uniform scheduler at CFG 1.0 and 3-4 steps. Using a different sampler, scheduler, or higher CFG produces noticeably worse results. Double-check your settings against the configuration table in this guide.
Skip the Setup: Try AI Image Generation Online
Setting up a local diffusion model is rewarding but not always practical. If you want to generate AI images without managing GPU drivers, VRAM limits, model downloads, and Python environments, aigptimage.com offers 12+ AI image models you can use right from your browser.
Models available include GPT Image 2 (3 credits at 1K resolution), Nano Banana 2 (6 credits at 1K), and several others like Z-Image and Qwen Image 2 at 3 credits each. New users get free daily check-in credits adding up to 30 per week, and the Standard plan at $29.90/month includes 300 credits. Check the pricing page for full details.
Whether you run Boogu-Image locally for maximum control or use a cloud platform for convenience, the best tool is the one that fits your workflow.
