# ComfyUI 2026: estudio local de fotos de producto con 12 GB

> Cómo es el ecosistema ComfyUI en 2026, qué modelo puede usar comercialmente una pyme, el hardware necesario y los pasos hasta un estudio de imágenes local.

- Publicado: 2026-09-09
- Revisado: 2026-11-02
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: ComfyUI, Generación de Imágenes, IA Local, Hardware, Tutorial
- URL canónica: https://vorluxai.com/blog/comfyui-2026-local-image-generation-stack-guide-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

Al terminar este artículo tendrás ComfyUI funcionando en tu propia máquina con un modelo de imagen de licencia comercial, una plantilla para fotos de producto y una pantalla sencilla que tus compañeros pueden usar sin ver un solo nodo. El hardware más barato que lo hace con soltura es una GPU de segunda mano de 12 GB o un Mac con Apple Silicon y 16 GB. Un portátil sin GPU puede seguir los pasos en modo CPU, despacio.

> **TL;DR**
> - ComfyUI con FLUX.2 [klein] 4B, el peso de FLUX.2 con licencia Apache 2.0, una plantilla de foto de producto y el App Mode para que tus compañeros no vean el grafo.
> - Una GPU de segunda mano de 12 GB o un Mac con Apple Silicon y 16 GB; de 30 a 45 minutos; sin cuenta ni clave de API.
> - Veredicto: no compres nada si ya tienes 12 GB de VRAM. Para productos sueltos sobre fondo limpio, un 4B basta; las escenas complejas con texto o manos siguen favoreciendo a los modelos alojados más grandes.

## Qué necesitas
- **Hardware:** una GPU NVIDIA de 8 GB o más (con 12 GB vas cómodo), un Mac con Apple Silicon y 16 GB, o una GPU AMD/Intel con los matices de abajo. Los [requisitos oficiales](https://docs.comfy.org/installation/system_requirements) cubren NVIDIA (PyTorch con CUDA 13.0), AMD (ROCm 7.2), Intel Arc (PyTorch `torch.xpu`), Apple Silicon (Metal) y un modo `--cpu` de respaldo.
- **Disco:** la aplicación de escritorio pide al menos 4,85 GB de disco y 8 GB de RAM (16 GB recomendados) según la [guía de instalación](https://docs.comfy.org/installation/desktop); suma entre 10 y 15 GB para modelos.
- **Software:** ComfyUI Desktop (Windows 10 o superior, macOS 13 o superior en Apple Silicon) o la instalación manual en Linux. Python 3.13 es el recomendado; 3.12 funciona.
- **Tiempo:** entre 30 y 45 minutos con descargas. Sin cuenta y sin clave de API.

## Cómo es el ecosistema en 2026
ComfyUI dejó hace tiempo de ser un único script de Python. Las piezas con las que te vas a cruzar:

| Pieza | Qué es | Dónde está el 09-09-2026 |
|---|---|---|
| **Núcleo** | El servidor Python que ejecuta los flujos | Upstream [v0.34.0](https://github.com/Comfy-Org/ComfyUI/releases), publicada el 26 de agosto de 2026; nuestra estación corre la 0.25.0 |
| **Aplicación de escritorio** | Instalador con Python, servidor y actualizaciones | [v0.9.4](https://github.com/Comfy-Org/desktop/releases), 28 de mayo de 2026; solo Windows y macOS, en Linux desde el código |
| **Frontend** | El editor de grafos, distribuido como paquete | 1.45.19 en nuestra máquina, según `/system_stats` |
| **Manager** | Instala y actualiza paquetes de nodos desde la interfaz | Vive en `custom_nodes/ComfyUI-Manager` en nuestra instalación |
| **Plantillas** | Flujos listos para cada familia de modelos | `comfyui-workflow-templates` 0.10.0 aquí |
| **App Mode, App Builder y ComfyHub** | Ocultan el grafo, exponen tres campos y se comparten por URL | Anunciados el 10 de marzo de 2026 ([blog de ComfyUI](https://blog.comfy.org/p/from-workflow-to-app-introducing), [nota de prensa](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)) |

El número de nodos mide bien cuánto ha crecido la plataforma. Nuestra instalación responde en `/object_info` con **1.035 tipos de nodo**: 559 del núcleo, 232 nodos "partner" que llaman a API de pago en la nube (OpenAI, Kling, Runway y otros) y 244 de paquetes externos, casi todos de KJNodes. Los nodos partner no hacen falta para nada de lo que sigue; todo este artículo funciona sin conexión.

Los **formatos de modelo** son más simples de lo que parecen. Los pesos vienen en `.safetensors`; un sufijo como `fp8` indica que el archivo se guardó a 8 bits para ocupar la mitad de memoria, y existen versiones GGUF de la comunidad para VRAM muy justa. Cada archivo va a una carpeta fija: `models/checkpoints/` para los archivos todo en uno de la familia Stable Diffusion, y `models/diffusion_models/`, `models/text_encoders/` y `models/vae/` para los modelos nuevos, que se distribuyen por partes.

## Paso 1: instala
En Windows o macOS, descarga la aplicación desde [comfy.org](https://www.comfy.org/download), ejecútala y deja que cree su entorno de Python. En Linux (lo que usamos nosotros):

```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
```

Abre `http://127.0.0.1:8188`. Comprueba qué ve el servidor:

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

En nuestra estación de trabajo esto devuelve `comfyui_version 0.25.0`, `pytorch_version 2.12.1+cu130`, Python 3.12.3 y un dispositivo CUDA, una NVIDIA GB10 con 130 GB de memoria visible. Si `devices` solo muestra `cpu`, PyTorch se instaló sin soporte de GPU: reinstálalo con la URL de índice de tu plataforma, la que indica la página de requisitos. ¿Sin GPU? Añade `--cpu`; las imágenes tardan minutos en vez de segundos, suficiente para probar un flujo antes de comprar hardware.

## Paso 2: elige un modelo que puedas usar comercialmente
Para fotos de producto, la elección en 2026 es FLUX.2 [klein] 4B. Es el único peso de FLUX.2 con licencia Apache 2.0, así que el uso comercial está permitido; las variantes 9B y [dev] son no comerciales ([resumen de licencias](https://localaimaster.com/blog/flux-2-local-setup-guide)). El [tutorial oficial de ComfyUI](https://docs.comfy.org/tutorials/flux/flux-2-klein) lista los archivos y la VRAM medida por el equipo de ComfyUI:

| Archivo | Carpeta | Notas |
|---|---|---|
| `flux-2-klein-4b-fp8.safetensors` (destilado) | `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/` | codificador de texto |
| `flux2-vae.safetensors` | `models/vae/` | decodificador |

Esos 8,4 GB de VRAM explican por qué una tarjeta de 12 GB es el suelo cómodo y una de 8 GB es posible con descarga a RAM. Si solo tienes 8 GB y quieres velocidad, Stable Diffusion 1.5 sigue funcionando: nuestra propia instalación tiene `v1-5-pruned-emaonly-fp16.safetensors` (4,27 GB) en `models/checkpoints/`, y de esa carpeta `output/` han salido ya 641 imágenes.

## Paso 3: carga la plantilla y genera
En la interfaz abre **Workflow > Browse Templates**, busca "Flux.2 Klein" y elige la plantilla 4B destilada. Los archivos que falten aparecen en rojo con un enlace de descarga; colócalos en las carpetas de arriba y pulsa **R** para refrescar. Escribe un prompt como *"taza de cerámica blanca sobre mesa de roble claro, luz suave de ventana, foto de producto, 1:1"*, ponlo en cola y comprueba que la imagen aparece en `output/`. Tiempo esperado en una tarjeta de 12 GB: segundos por imagen, no minutos.

## Paso 4: esconde el grafo para tus compañeros
Pulsa **Enter App Mode** en la barra superior. En App Builder expón solo el prompt, la semilla y el tamaño de imagen; todo lo demás conserva los valores que fijaste. Guarda el flujo: quien lo abra verá un formulario con tres campos y un panel de resultados. Esta es la función que convierte ComfyUI de herramienta de diseñador en algo que una dependienta puede usar un lunes por la mañana.

## Paso 5: automatiza desde un script
El servidor es una API HTTP. Exporta el flujo con **Export (API)** y encólalo desde Python:

```python
import json, requests
wf = json.load(open("foto-producto-api.json"))
wf["6"]["inputs"]["text"] = "cartera de piel, vista cenital, fondo blanco, foto de producto"
r = requests.post("http://127.0.0.1:8188/prompt", json={"prompt": wf})
print(r.json()["prompt_id"])          # los resultados aparecen en /history/<prompt_id>
```

Apunta un bucle a tu catálogo y tienes la cadena por lotes de [nuestro tutorial de generación en lote](https://vorluxai.com/blog/tutorial-comfyui-generacion-imagenes-lote/). Para mantener el mismo ángulo en toda una gama, añade el paso guiado por bordes de [nuestro tutorial de ControlNet](https://vorluxai.com/blog/tutorial-comfyui-controlnet-generacion-guiada/).

## Qué medimos y qué no
| Dato | Valor en nuestra estación | Fuente |
|---|---|---|
| Núcleo / frontend / plantillas de ComfyUI | 0.25.0 / 1.45.19 / 0.10.0 | `/system_stats`, 09-09-2026 |
| PyTorch / Python | 2.12.1+cu130 / 3.12.3 | `/system_stats` |
| Tipos de nodo | 1.035 (559 núcleo, 232 partner, 244 externos) | `/object_info` |
| Paquetes externos instalados | ComfyUI-Manager, KJNodes, WASasquatch | `ls custom_nodes/` |
| VRAM de Klein 4B | 8,4 GB destilado, 9,2 GB base | docs de ComfyUI, medido en una RTX 5090 |

Todavía no hemos cronometrado FLUX.2 [klein] en una tarjeta de 12 GB nosotros mismos; la cifra de segundos por imagen es la del equipo de ComfyUI en una 5090, y una tarjeta de 12 GB será más lenta. Publicaremos nuestro propio tiempo cuando lo ejecutemos en hardware de un cliente. Lo que sí hemos cronometrado es FLUX.1-schnell en nuestra DGX Spark, con lotes de 1, 4 y 8: entre 5,7 y 6,2 segundos por imagen de 1024×1024 el 2-11-2026, con la tabla completa en [nuestro tutorial de generación por lotes](https://vorluxai.com/blog/tutorial-comfyui-generacion-imagenes-lote/).

## Dónde encaja
Un estudio de imagen local sustituye las tarifas por imagen de la nube y mantiene los productos sin lanzar fuera de servidores ajenos. Límites honestos: un modelo de 4B no iguala a los modelos alojados más grandes en escenas complejas con texto, manos o varias personas; para un catálogo de objetos sueltos sobre fondo limpio sobra, y la licencia te deja publicar el resultado.

## Siguientes pasos
- Genera cien variantes desde un CSV: [ComfyUI: genera 100 imágenes de producto](https://vorluxai.com/blog/tutorial-comfyui-generacion-imagenes-lote/).
- Mantén el mismo ángulo en toda la gama: [Tutorial ComfyUI ControlNet](https://vorluxai.com/blog/tutorial-comfyui-controlnet-generacion-guiada/).
- Elige la GPU o el Mac antes de gastar: [Mejores dispositivos para IA local en 2026](https://vorluxai.com/blog/local-ai-hardware-catalog-2026-what-to-buy-at-each-budget-es/).

## Trabaja con nosotros
Usamos ComfyUI en producción en nuestro propio hardware y lo montamos para clientes con la pregunta de la licencia resuelta antes de la primera imagen. Si quieres una cadena de fotos de producto que no salga de tu edificio, [escríbenos](https://vorluxai.com/contact/) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
