Boogu-Image on a single RTX 4090: the Edit and Turbo models, hands-on

Most image generators have a one-way job: text goes in, a picture comes out. A unified model is different — the same network can both read (understand a prompt and any images you give it) and draw (generate or edit a picture). Boogu-Image-0.1 is exactly that: a 10B Apache-2.0 model family, forked from OmniGen2, that the authors trained with about an order of magnitude less data than comparable open models — and it still holds its own.

Under the hood the pipeline has three parts. A Qwen3-VL multimodal LLM is the "understanding" half: it encodes the instruction and any input photos into rich embeddings. A double-stream MMDiT diffusion transformer (built on Lumina2 blocks) is the "generation" half: it denoises a latent guided by those embeddings. And the open-source FLUX.1 VAE decodes that latent into the final pixels. That is the whole trick behind the "one model that sees and paints" picture above.

The family ships several variants (plus fp8-quantized versions of each). I focused on the two most useful on a single GPU: the Edit model for image editing, and the Turbo model for fast text-to-image. They share the same 10B architecture; what differs is the task and the sampling recipe.

The repo recommends conda; I translated that to an asdf + uv venv. Order matters for ML installs: torch first (CUDA wheels), then the repo, then the compiled flash-attn extension, then the checkpoints. The one snag worth flagging up front is that the repo's flash-attn helper assumes pip exists — a uv venv has none, so I installed the matched prebuilt wheel directly.

# 1. environment (Python 3.10, the repo's tested version)
uv venv .venv --python "$(asdf which python)" && source .venv/bin/activate

# 2. GPU-first install — CUDA 12.6 torch, then the repo
uv pip install -r requirements/torch2.7-cu126.txt
uv pip install -e .

# 3. flash-attn: the helper downloads a wheel to /tmp but can't pip-install in a uv venv
python utils/get_flash_attn.py || true
uv pip install /tmp/flash_attn-2.8.3+cu126torch2.7-cp310-cp310-linux_x86_64.whl

# 4. checkpoints (~36 GB each) -> a data disk
export HF_HOME=/d/hugging_face_cache HUGGINGFACE_HUB_CACHE=/d/hugging_face_cache
hf download Boogu/Boogu-Image-0.1-Edit  --local-dir $HF_HOME/boogu-models/Boogu-Image-0.1-Edit
hf download Boogu/Boogu-Image-0.1-Turbo --local-dir $HF_HOME/boogu-models/Boogu-Image-0.1-Turbo

Two things bite if you skip them. First, a runtime invariant: device must be exported as a shell variable before launch, not only passed as a flag — several modules read os.getenv("device") at construction time to pick the CUDA / flash-attention path. Second, do not let a later uv pip install (e.g. for Gradio) re-resolve the torch stack — it silently bumped my pinned torch 2.7.1+cu126 up to 2.11+cu130 and broke the flash-attn ABI. Pin torch last.

To make the Edit model pleasant to use I wrapped it in a small Gradio app: upload an image, type an instruction, generate. It loads the pipeline once at startup and exposes the steps / guidance / seed knobs.

The Edit model takes an image plus an instruction and returns an edited image. No masks, no control maps — just a sentence. "Remove the dog," "add glasses," "put him in a kimono." The Qwen3-VL half reads both your words and the picture, so the instruction can refer to what's actually in the image.

The simplest demonstration is object removal. Here is the model's own example — a dog in a car window, and the instruction to remove it and rebuild the background:

To really probe the Edit model I took a single black-and-white studio portrait and pushed it through twelve instructions — from a gentle colorize to dropping the same man into a Kyoto garden or in front of the pyramids. Every image below was generated at the repo's canonical settings: Boogu-Image-0.1-Edit, native 1536×1792, 50 steps, text guidance 4.0, image guidance 1.0, group offload — about 3.5 min each on the 4090.

Six of them in detail, with the exact instruction and an honest verdict on each:

Getting those clean results took two fixes that are worth recording, because both look like model problems and are actually configuration problems.

The fix for both is the same offload strategy: block-level group offload. Instead of pinning the whole transformer on the GPU, it streams a couple of blocks at a time, freeing ~19 GB for activations — so the model can generate at full native resolution. Peak VRAM dropped to ~16 GB, and because use_stream=True overlaps the transfers with compute, it is only modestly slower than whole-model offload (~4.3 vs 2.8 s/step).

from diffusers.hooks import apply_group_offloading
for mod in (pipe.transformer, pipe.mllm, pipe.vae):
    apply_group_offloading(mod, onload_device="cuda:0",
                           offload_type="block_level",
                           num_blocks_per_group=1, use_stream=True)
# + export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True

With sharpness solved, the interesting problem appeared: on a dramatic edit (studio → outdoor sunset) the man came out looking like a different, younger person. The instinct is to blame the prompt, but the real lever is image guidance. Per the inference guide, image_guidance_scale = 1.0 — the default — disables the reference-image term in classifier-free guidance. With nothing anchoring the output to the input face, a big scene change lets it drift.

So I swept it. Two things turned out to matter, and they pull in opposite directions:

• Image guidance saturates fast. Values of 1.5, 2.0 and 3.0 all lock the identity and are nearly identical to each other; pushing on to 4, 6 or 9 changes nothing more. The useful range is tiny.
• Steps matter more than I expected. Going from 30 → 50 steps is what resolved the gray, grizzled goatee and the fine skin texture — and it noticeably improved identity even at the default guidance.

Here is the counter-intuitive part. High image guidance buys identity but costs edit freedom: pinning the output to the input pixels also pins the framing, so the "put him in a kimono in a garden" instruction can only recolour the cropped studio shot — it can't build the full-body scene you saw above. For the "around the world" gallery the model needs that freedom, so the repo default 1.0 actually produces the more successful edits.

The Turbo model is the same 10B network, distilled to generate in just 4 steps with no CFG. It is text-to-image only. After a one-time warm-up, each 1024² image took ~14–15 seconds on the 4090 — against roughly 3.5 minutes for a 50-step Edit. That speed difference reframes how you use it: Turbo is for iterating, Edit is for finishing.

Boogu-Image is a likeable, genuinely capable open model, and running both halves on one 24 GB card was very doable. Turbo is the one I'd reach for daily — four-step, ~15-second, photorealistic text-to-image is a joy to iterate with, and stylization and bilingual prompts are strong. Its only real weakness is in-image text, which the slower Base model handles better.

Edit is more nuanced. Localized edits — colorize, add an object, change clothing, swap a background — are reliable and clean. Whole-scene transformations are impressive when you let them happen (image guidance 1.0, 50 steps), at the documented cost that identity is a strong likeness rather than a perfect lock. The most reusable lessons are mechanical and apply to any large unified model on a 24 GB GPU: match max_input_image_pixels to the input or you'll upscale a blurry latent; use block-level group offload to fit native resolution; and treat image_guidance_scale as an identity-vs-edit-strength dial, not a quality knob.