Krea 2 Turbo in ComfyUI: Low-VRAM Inference Guide

Krea 2 Turbo produces impressive results, but its model files are large enough to make a 12GB GPU look like a questionable target. I wanted to find out whether it was genuinely practical on my RTX 3060, rather than merely possible with very slow generation times or frequent out-of-memory errors.

I therefore ran a controlled ComfyUI benchmark across four resolutions, three step counts, and both the Standard and Reasoning workflows. Each configuration was repeated three times after warm-up, for a total of 72 measured generations.

The good news is that Krea 2 Turbo successfully reached 1920×1080 without an OOM. The more useful result, however, is that 1280×720 at 6 steps provides a much better everyday balance, generating a game-art concept in about 28 seconds on this machine.

---

💻 Hardware Setup

I ran every test on the following machine:

• GPU: NVIDIA GeForce RTX 3060 (12GB GDDR6 VRAM)
• CPU: AMD Ryzen 5 5500 (6 Cores / 12 Threads)
• RAM: 64GB DDR4
• OS: Windows 11 Pro (x64)

---

🛠️ Model Configuration

For the clean benchmark, I used the following ComfyUI-ready FP8 files:

1. UNET / Diffusion Model: krea2_turbo_fp8_scaled.safetensors
   Place it in ComfyUI/models/diffusion_models.

2. Text Encoder: qwen3vl_4b_fp8_scaled.safetensors
   Place it in ComfyUI/models/text_encoders.

3. VAE: qwen_image_vae.safetensors
   Place it in ComfyUI/models/vae.

I kept ComfyUI completely unmodified for this run. With the Qwen3-VL 4B encoder, ComfyUI detects TEModel.QWEN3VL_4B natively and exposes the 12 transformer layers expected by Krea 2, without any custom patch.

Download the workflows and prompts: The Standard and Reasoning ComfyUI workflow files, along with the four structured prompts used for the visual benchmark, are available in the companion GitHub repository.

---

⏱️ Startup and Warm-up Overhead

Before measuring the warm runs, I recorded the startup and first-load overhead:

• ComfyUI Server Boot Time: 49.30 seconds
• First-Run Warm-up Latency (Standard): 49.72 seconds (Preloads UNET, VAE, and Qwen3-VL text encoder)
• First-Run Warm-up Latency (Reasoning): 65.63 seconds (Preloads additional KreaReason LLM generation weights)
• Peak Warm-up VRAM: 11,753 MB

---

📊 Standard Workflow Benchmark

For the Standard workflow, I used Krea 2 Turbo directly without the additional prompt-expansion stage. I repeated every configuration three times with different sampling seeds so ComfyUI could not reuse cached results. The values below are genuine warm generation times.

---

📊 Reasoning Workflow Benchmark

The Reasoning workflow adds the KreaReason node before sampling. It asks Qwen3-VL to expand and reinterpret the prompt, then passes the resulting conditioning to Krea 2 Turbo. As with the Standard workflow, every configuration was repeated three times with different seeds.

---

📈 Reasoning Overhead Analysis

Reasoning Adds a Significant Per-Generation Overhead

The KreaReason workflow adds approximately 30 to 50 seconds to each generation on this RTX 3060 setup. This additional time comes primarily from the Qwen3-VL 4B prompt-expansion stage rather than from diffusion sampling.

For rapid iteration, the Standard workflow is clearly preferable. Reasoning should be treated as an optional prompt-interpretation tool for complex or final generations, not as a free quality upgrade.

It is also important to understand what Reasoning changes: it does not simply render the same composition at a higher quality level. It expands and reinterprets the prompt, which can significantly alter the subject, silhouette, environment, framing, and visual details.

Here are three representative comparisons:

Performance Chart Comparison

---

⏱️ Choosing Between 4, 6, and 8 Steps

In practice, the step count is the easiest way to trade speed for refinement:

• 4 steps: Fast drafts and prompt exploration.
• 6 steps: Best speed-to-quality compromise. Provides fully resolved compositions while keeping iteration speed fast.
• 8 steps: Best suited for final presentation renders, detailed concept images, and important hero asset explorations.

Reviewing the Standard widescreen configurations (1280x720) highlights how these steps translate to clock time:

• 4 steps: 19.57 seconds
• 6 steps: 28.44 seconds
• 8 steps: 37.42 seconds

1280x720, Standard, 6 steps is the recommended iteration sweet spot on this machine, offering detailed game-asset concepts in under 30 seconds.

---

🚀 Recommended Configurations

1. Fast Drafts

• Resolution: 1280x720
• Workflow: Standard
• Step Count: 4 steps
• Avg Timing: 19.57 seconds

2. Iteration Sweet Spot

• Resolution: 1280x720
• Workflow: Standard
• Step Count: 6 steps
• Avg Timing: 28.44 seconds

3. Final Hero Render

• Resolution: 1920x1080
• Workflow: Standard
• Step Count: 8 steps
• Avg Timing: 88.18 seconds

4. Optional Prompt Expansion

• Resolution: User choice (e.g. 1024x1024 or 1280x720)
• Workflow: Reasoning
• Usage: Trigger Reasoning only when a complex prompt benefits from reinterpretation.
• Overhead: Expect approximately 30 to 50 additional seconds per generation. Reasoning is not a default quality mode.

---

🖼️ Selected Visual Comparisons

I generated more comparison grids than I needed for the final article. The six below are the most useful because each one illustrates a specific finding without turning the page into a full benchmark archive.

Step Count: Sci-Fi Cargo Crate

The crate is already coherent at 4 steps. Six steps improve structure and material definition, while 8 steps mainly add polish rather than changing the concept completely.

Resolution and Aspect Ratio: Sci-Fi Cargo Crate

This comparison shows why resolution and framing cannot be separated here: moving from square to widescreen changes the composition as much as the pixel count.

Standard vs Reasoning: RPG Blacksmith Carriage

Reasoning does not merely sharpen the same cart. It reinterprets the design, adds a more elaborate forge structure, and changes the overall silhouette.

Standard vs Reasoning: Cinematic Corridor and Canyon

This is the clearest example of Reasoning behaving like a prompt rewrite. The environment, architecture, lighting, and framing all change substantially.

Resolution and Aspect Ratio: Cinematic Corridor and Canyon

The Full HD frame gives the scene more horizontal space, but it should not be read as a simple detail upgrade because the wider canvas also changes the layout.

Step Count: Powered Armor Suit

The armor remains recognizable at every setting. Four steps are useful for quick design exploration, while 6 and 8 steps produce cleaner surfaces and more resolved mechanical details.

---

📐 Resolution and Aspect-Ratio Note

The resolution comparison visual grids compare a square format (1024x1024, 1:1) to widescreen landscape layouts (1280x720 and 1920x1080, 16:9).

Composition differences between these cells stem from both the pixel density changes and the shifted aspect ratio. A wider frame changes how the model arranges environmental objects and frames the subject.

For strict resolution testing at a locked aspect ratio, a future benchmark could compare:

• 1024x576 (16:9)
• 1280x720 (16:9)
• 1536x864 (16:9)
• 1920x1080 (16:9)

---

📝 Unwanted Text in Game-Asset Prompts

In game-asset generation, some of the generated images exhibited text-like typographical artifacts (e.g. garbled letters on panels or poster backgrounds) even though the prompt explicitly requested no text, no logo, no UI.

Expressions in the prompt such as:

• AAA game-art
• production asset
• presentation
• key art
• concept sheet

can encourage the model to produce typography. I found it safer to replace them with cleaner, object-only descriptors:

• high-end stylized game prop render
• single isolated subject
• clean studio background
• production-ready design

The blacksmith cart is a good example: some outputs gained catalog-style lettering even though the prompt explicitly asked for no text. I kept those artifacts in the comparison images because they are part of the model’s actual behavior.

---

💾 VRAM and Offloading Observations

Because the combined weights of the FP8 quantized Krea 2 DiT model (~12.5GB) and the Qwen3-VL text encoder (~5.2GB) exceed the physical VRAM limits of the card, ComfyUI relies on PCIe dynamic weight swapping.

During the text-encoding phase, the text encoder is loaded into VRAM. During the sampling phase, the text encoder is offloaded to system memory and the DiT weights are brought in. This offloading process introduces a constant PCIe swap overhead of ~3.5s to 4.5s at the beginning of each sampler execution.

---

⚠️ Limitations

• This benchmark covers only krea2_turbo_fp8_scaled.safetensors; I did not compare the BF16, INT4, MXFP8, or NVFP4 variants.
• The machine has 64GB of system RAM. I did not test the same workflow with 32GB or less, so the results should not be generalized to lower-RAM systems.
• The VRAM baseline includes normal Windows and display-driver usage.
• PCIe offloading speed depends on the motherboard, PCIe generation, lane width, and other local system activity.
• Timed repeats used different seeds to bypass ComfyUI caching. The dedicated visual comparison grids used fixed seeds where a controlled image comparison was required.

---

🏁 Final Conclusion

On this machine, Krea 2 Turbo FP8 is not merely capable of starting on a 12GB card: it is practical enough for regular local iteration.

The most useful everyday setting was 1280x720, Standard workflow, at 6 steps, averaging 28.44 seconds. Full HD also completed reliably without an Out-Of-Memory error, but the maximum observed VRAM usage reached 11,822 MB, leaving very little headroom.

These results apply specifically to an NVIDIA GeForce RTX 3060 with 12GB of VRAM and 64GB of system RAM.

---

📝 Article Takeaways

• For daily iteration, 1280x720, Standard workflow, and 6 steps gave the best balance at 28.44 seconds per image.
• Reasoning is a prompt-expansion mode, not a general quality switch. It noticeably changes interpretation and adds roughly 30 to 50 seconds per generation.
• Full HD generation worked without OOM, but it pushed the RTX 3060 close to its VRAM limit, so it is better reserved for final presentation renders.