# ComfyUI in 2026: Set Up a Local Product-Image Studio on a 12 GB GPU

> What the ComfyUI ecosystem looks like in 2026, which image model a small business may use commercially, the hardware it needs and the steps to a local studio.

- Published: 2026-09-09
- Updated: 2026-11-02
- Author: Jacobo González Jaspe
- Language: en
- Tags: ComfyUI, Image Generation, Local AI, Hardware, Tutorial
- Canonical URL: https://vorluxai.com/en/blog/comfyui-2026-local-image-generation-stack-guide-en/
- Source: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

By the end of this post you will have ComfyUI running on your own machine with a commercially licensed image model, a template workflow for product shots, and a one-screen interface your colleagues can use without seeing a node graph. The cheapest hardware that does this comfortably is a used 12 GB GPU or a 16 GB Apple Silicon Mac. A laptop with no GPU can follow along in CPU mode, slowly.

> **TL;DR**
> - ComfyUI with FLUX.2 [klein] 4B, the FLUX.2 weight under Apache 2.0, plus a product-shot template and App Mode so colleagues never see the graph.
> - A used 12 GB GPU or a 16 GB Apple Silicon Mac; 30 to 45 minutes; no account or API key.
> - Verdict: Buy nothing if you have 12 GB of VRAM. For single products on clean backgrounds a 4B model is enough; complex scenes with text or hands still favour the largest hosted models.

## What you need
- **Hardware:** an NVIDIA GPU with 8 GB or more (12 GB is comfortable), an Apple Silicon Mac with 16 GB, or an AMD/Intel GPU with the caveats below. The official [system requirements](https://docs.comfy.org/installation/system_requirements) list NVIDIA (PyTorch with CUDA 13.0), AMD (ROCm 7.2), Intel Arc (PyTorch `torch.xpu`), Apple Silicon (Metal) and a `--cpu` fallback.
- **Disk:** the desktop app needs "at least 4.85 GB of disk space and 8 GB RAM (16 GB recommended)" per the [desktop install guide](https://docs.comfy.org/installation/desktop); add 10 to 15 GB for models.
- **Software:** ComfyUI Desktop (Windows 10+, macOS 13+ on Apple Silicon) or the manual install on Linux. Python 3.13 is recommended, 3.12 works.
- **Time:** 30 to 45 minutes including downloads. No account, no API key.

## What the ecosystem looks like in 2026
ComfyUI stopped being a single Python script a while ago. The pieces you will meet:

| Piece | What it is | Where we stand on 2026-09-09 |
|---|---|---|
| **Core** | The Python server that runs workflows | Upstream [v0.34.0](https://github.com/Comfy-Org/ComfyUI/releases) released 26 August 2026; our workstation runs 0.25.0 |
| **Desktop app** | Installer that bundles Python, the server and updates | [v0.9.4](https://github.com/Comfy-Org/desktop/releases), 28 May 2026; Windows and macOS only, Linux from source |
| **Frontend** | The graph editor, shipped as a package | 1.45.19 on our machine, per `/system_stats` |
| **Manager** | Installs and updates custom node packs from the UI | Ships in `custom_nodes/ComfyUI-Manager` on our install |
| **Templates** | Ready-made workflows for each model family | `comfyui-workflow-templates` 0.10.0 here |
| **App Mode, App Builder, ComfyHub** | Hide the graph, expose three inputs, share as a URL | Announced 10 March 2026 ([ComfyUI blog](https://blog.comfy.org/p/from-workflow-to-app-introducing), [press release](https://www.globenewswire.com/news-release/2026/03/10/3253141/0/en/ComfyUI-Launches-App-Mode-App-Builder-and-ComfyHub-Enabling-Anyone-to-Run-AI-Workflows-Without-Touching-a-Node-Graph.html)) |

Node count is a good measure of how much the platform has grown. Our install answers `/object_info` with **1,035 node types**: 559 core, 232 "partner" nodes that call paid cloud APIs (OpenAI, Kling, Runway and others) and 244 from custom packs, mostly KJNodes. You never have to touch the partner nodes; everything in this post runs offline.

**Model formats** are simpler than they look. Weights come as `.safetensors`; a suffix such as `fp8` means the file was stored at 8-bit precision to halve memory, and community GGUF builds exist for very tight VRAM. Files go into fixed folders: `models/checkpoints/` for all-in-one SD-class files, `models/diffusion_models/`, `models/text_encoders/` and `models/vae/` for newer models shipped in parts.

## Step 1: Install
Windows or macOS: download the desktop app from [comfy.org](https://www.comfy.org/download), run it, let it create its Python environment. Linux (what we run):

```bash
git clone https://github.com/Comfy-Org/ComfyUI ~/dev/ComfyUI && cd ~/dev/ComfyUI
python3 -m venv .venv && source .venv/bin/activate
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130   # NVIDIA
pip install -r requirements.txt
python main.py --listen 127.0.0.1 --port 8188
```

Open `http://127.0.0.1:8188`. Check what the server sees:

```bash
curl -s localhost:8188/system_stats | python3 -m json.tool | head -30
```

On our workstation this reports `comfyui_version 0.25.0`, `pytorch_version 2.12.1+cu130`, Python 3.12.3 and one CUDA device, an NVIDIA GB10 with 130 GB visible memory. If `devices` shows only `cpu`, PyTorch was installed without GPU support: reinstall it with the index URL for your platform from the requirements page. No GPU at all? Add `--cpu`; images take minutes instead of seconds, which is fine for testing a workflow before you buy hardware.

## Step 2: Pick a model you may use commercially
For product images the choice in 2026 is FLUX.2 [klein] 4B. It is the one FLUX.2 weight under the Apache 2.0 licence, so commercial use is allowed; the 9B and [dev] variants are non-commercial ([licence summary](https://localaimaster.com/blog/flux-2-local-setup-guide)). The [official ComfyUI tutorial](https://docs.comfy.org/tutorials/flux/flux-2-klein) lists the files and the VRAM measured by the ComfyUI team:

| File | Folder | Notes |
|---|---|---|
| `flux-2-klein-4b-fp8.safetensors` (distilled) | `models/diffusion_models/` | "~1.2s (5090) · 8.4GB VRAM" |
| `flux-2-klein-base-4b-fp8.safetensors` (base) | `models/diffusion_models/` | "~17s (5090) · 9.2GB VRAM" |
| `qwen_3_4b.safetensors` | `models/text_encoders/` | text encoder |
| `flux2-vae.safetensors` | `models/vae/` | decoder |

8.4 GB of VRAM is why a 12 GB card is the comfortable floor and an 8 GB card is possible with offloading. If you only have 8 GB and want speed, Stable Diffusion 1.5 still works: our own install carries `v1-5-pruned-emaonly-fp16.safetensors` (4.27 GB) in `models/checkpoints/`, and 641 images have come out of that `output/` folder so far.

## Step 3: Load the template and generate
In the interface open **Workflow > Browse Templates**, search "Flux.2 Klein", and pick the 4B distilled template. Missing files are flagged in red with a download link; put them in the folders above and press **R** to refresh. Type a prompt such as *"white ceramic mug on a light oak table, soft window light, product photo, 1:1"*, queue it, and check the image lands in `output/`. Expected time on a 12 GB card: seconds per image, not minutes.

## Step 4: Hide the graph for your colleagues
Click **Enter App Mode** in the top bar. In App Builder, expose only the prompt, the seed and the image size; everything else keeps the values you set. Save the workflow: anyone opening it sees a form with three fields and a result panel. This is the single feature that turns ComfyUI from a designer's tool into something a shop assistant can use on a Monday morning.

## Step 5: Automate from a script
The server is an HTTP API. Export the workflow with **Export (API)** and queue it from Python:

```python
import json, requests
wf = json.load(open("product-shot-api.json"))
wf["6"]["inputs"]["text"] = "leather wallet, top view, white background, product photo"
r = requests.post("http://127.0.0.1:8188/prompt", json={"prompt": wf})
print(r.json()["prompt_id"])          # results appear under /history/<prompt_id>
```

Point a loop at your product catalogue and you have the batch pipeline from [our batch generation tutorial](https://vorluxai.com/en/blog/comfyui-batch-image-generation-tutorial/). For consistent angles across a range, add the edge-guided step from [our ControlNet tutorial](https://vorluxai.com/en/blog/comfyui-controlnet-tutorial-guided-image-generation/).

## What we measured and what we could not
| Item | Value on our workstation | Source |
|---|---|---|
| ComfyUI core / frontend / templates | 0.25.0 / 1.45.19 / 0.10.0 | `/system_stats`, 2026-09-09 |
| PyTorch / Python | 2.12.1+cu130 / 3.12.3 | `/system_stats` |
| Node types | 1,035 (559 core, 232 partner, 244 custom) | `/object_info` |
| Custom packs installed | ComfyUI-Manager, KJNodes, WASasquatch | `ls custom_nodes/` |
| Klein 4B VRAM | 8.4 GB distilled, 9.2 GB base | ComfyUI docs, measured on an RTX 5090 |

We have not yet timed FLUX.2 [klein] on a 12 GB card ourselves; the seconds-per-image figure above is the ComfyUI team's on a 5090, and a 12 GB card will be slower. We will publish our own timing when we run it on client hardware. What we have timed is FLUX.1-schnell on our DGX Spark, at batch sizes 1, 4 and 8: 5.7 to 6.2 seconds per 1024×1024 image on 2026-11-02, with the full table in [our batch generation tutorial](https://vorluxai.com/en/blog/comfyui-batch-image-generation-tutorial/).

## Where this fits
A local image studio replaces per-image cloud fees and keeps unreleased products off third-party servers. Honest limits: a 4B model will not match the largest hosted models on complex scenes with text, hands or several people; for a catalogue of single objects on clean backgrounds it is more than enough, and the licence lets you ship the result.

## Next steps
- Generate a hundred variants from a CSV: [ComfyUI batch image generation](https://vorluxai.com/en/blog/comfyui-batch-image-generation-tutorial/).
- Keep the same angle across a product range: [ComfyUI ControlNet tutorial](https://vorluxai.com/en/blog/comfyui-controlnet-tutorial-guided-image-generation/).
- Choose the GPU or Mac before you spend: [Edge AI hardware guide 2026](https://vorluxai.com/en/blog/hardware-guide-edge-ai-2026/).

## Work with us
We run ComfyUI in production on our own hardware and set it up for clients with the licence question answered before the first image. If you want a product-image pipeline that stays in your building, [get in touch](https://vorluxai.com/en/contact/) or see [how our consulting works](https://vorluxai.com/en/consulting/).
