ComfyUI on GX10: Image Generation with Nodes, and Which Models Are Fine for Paid Work

01What you will learn

• How ComfyUI works: nodes, wires and a workflow that is saved as a file.
• Which image models are free to use for commercial work and which are not — and how to check it yourself.
• How to install ComfyUI on a GB10-class machine and open it from your own computer without exposing it to the network.
• How to make a first image with Z-Image-Turbo, then with FLUX.1 [schnell].
• What a LoRA is and why the base model's licence passes through it.
• Why a finished image can give away more than you think.

02Before you start

• A machine of the NVIDIA GB10 class (for example ASUS Ascent GX10 or DGX Spark) with DGX OS, set up through first boot.
• Access to its terminal — directly or over SSH.
• Python 3 with venv, and git. The ComfyUI README says Python 3.13 is very well supported, and that 3.12 can be tried if extensions have trouble.
• A free Hugging Face account: the Black Forest Labs model pages ask you to accept their conditions before you download files.
• Disk space. The NVIDIA guide for the first Z-Image-Turbo test asks for at least about 30 GB free and about 24 GB of GPU memory; FLUX models are bigger still — check with df -h.
• Internet for the downloads; after that the models run locally.

03Steps

1. What goes where

   Everything lives in one folder: the Python environment, ComfyUI itself and a models/ folder with the model files. Why separate model folders? One model consists of several files (the main model, a text encoder, a decoder), and ComfyUI looks for each in its own place.

   Folder in ComfyUI/models/	What goes there
   unet/ or diffusion_models/	The main model (for FLUX — flux1-schnell.safetensors)
   text_encoders/	Text encoders that turn the description into numbers
   vae/	The ae.safetensors decoder that turns numbers into pixels
   loras/	Small add-ons to the model (step 9)

2. Licence first, download second

   This is the main difference between "it runs" and "we can sell it". Below is what the Hugging Face model pages say, read on 03.10.2026. Licences change — before every new project open the model's page and check again.

   Model	Licence (as on the page)	Fine for commercial work?
   FLUX.1 [schnell]	Apache-2.0; the card says "personal, scientific, and commercial purposes"	Yes
   FLUX.2 [klein] 4B	Apache-2.0; "open weights available for commercial use"	Yes
   Z-Image-Turbo	Apache-2.0	Yes
   Qwen-Image	Apache-2.0	Yes
   Text encoders flux_text_encoders (clip_l, t5xxl)	Apache-2.0 (as on the page of this copy)	Yes ⚠️ we have not checked the licences of the original models
   Stable Diffusion 3.5 Large	Stability Community License: free, including commercial use, below USD 1 million total annual revenue; above that an enterprise licence	Conditional — only below the threshold; read the agreement
   SDXL base 1.0	The field says openrail++, but in the "Direct Use" section the card says "intended for research purposes only"	Unclear ⚠️ — we have not read the text; do not use it for a client until we have checked
   FLUX.1 [dev]	FLUX.1 [dev] Non-Commercial License	No
   FLUX.1 Krea [dev]	The same non-commercial licence as FLUX.1 [dev]	No
   FLUX.2 [dev]	FLUX Non-Commercial License; for commercial users the vendor points to separate "Self-Hosted Commercial License Terms"	No — only with a paid licence from the vendor
   FLUX.2 [klein] 9B	FLUX Non-Commercial License	No

   ✅

   For paid work: FLUX.1 [schnell], not FLUX.1 [dev]

   That is why this lesson builds the workflow on schnell. If you have ready workflows for [dev], swap the model for schnell and reduce the steps (step 8).
   ⚠️

   "But the images are mine, right?" — do not rely on that

   The text of the FLUX.1 [dev] licence contradicts itself about outputs. Section 2(d) says Output may be used for any purpose, including commercial. Section 4(a), however, forbids using the model or "any data produced by the FLUX.1 [dev] Model" for "any commercial or production purposes". And "Non-Commercial Purpose" excludes revenue-generating activity and work that directly affects end users. For client work do not bet on the more favourable reading — use a model under Apache-2.0.

   One more thing: Apache-2.0 for the model does not mean every image is safe. Trademarks, the likenesses of real people and other people's works remain your responsibility.

3. Check the machine

   bash · on the machinecopy

   python3 --version
   pip3 --version
   nvidia-smi

   You expect a Python version, a working pip3 and a table with the GPU. The memory line may say "Not Supported" — that is normal for GB10.

4. Install ComfyUI

   We make an isolated Python environment so that we do not touch system packages. This follows the steps of the NVIDIA guide for DGX Spark: PyTorch for CUDA 13.0 (suitable for Blackwell), then ComfyUI and its dependencies.

   bash · on the machinecopy

   python3 -m venv comfyui-env
   source comfyui-env/bin/activate
   
   pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu130
   
   git clone --branch v0.33.2 https://github.com/comfyanonymous/ComfyUI.git
   cd ComfyUI/
   pip install -r requirements.txt

   Version v0.33.2 is the one the NVIDIA guide pins as of 03.10.2026. ComfyUI ships a new version about every two weeks — see the latest stable tag on GitHub. We have not run these commands.

5. Download the FLUX.1 [schnell] models

   First log in to Hugging Face and accept the conditions on the FLUX.1-schnell page (even though the licence is free, the page asks for consent to share contact details). Then download the three groups of files — each into its own folder. From the ComfyUI/ folder:

   bash · from ComfyUI/copy

   pip install -U huggingface_hub
   hf auth login
   
   hf download black-forest-labs/FLUX.1-schnell flux1-schnell.safetensors --local-dir models/unet
   hf download black-forest-labs/FLUX.1-schnell ae.safetensors --local-dir models/vae
   hf download comfyanonymous/flux_text_encoders clip_l.safetensors t5xxl_fp16.safetensors --local-dir models/text_encoders

   File and folder names follow the ComfyUI examples for FLUX. There is also a lighter text encoder (t5xxl_fp8_e4m3fn_scaled) for less memory; with 128 GB of shared memory it is more natural to use the full one. ⚠️ The download commands have not been run; if a name does not resolve, check the file list on the model's page.

6. Start it and open it from your own computer

   bash · on the machinecopy

   python main.py

   Without extra options ComfyUI listens only on the machine itself, on port 8188. In a second terminal window check:

   bashcopy

   curl -I http://localhost:8188

   You expect an HTTP 200 response. From your own computer you reach the editor through an SSH tunnel — a protected corridor that opens nothing to the network:

   bash · on your computercopy

   ssh -L 8188:localhost:8188 <user>@<server-address>

   Leave the connection open and open http://localhost:8188 in your browser.

   ⚠️

   Do not run --listen 0.0.0.0 on a shared network

   The NVIDIA guide uses it so that the machine can be reached from other devices — that opens the editor to the whole network. ComfyUI has no built-in password you can rely on, and code is started through the editor. Keep it on loopback and use the tunnel.

7. First test: Z-Image-Turbo

   We start with the simplest thing NVIDIA describes for DGX Spark: a ready template. The model is Apache-2.0 and consists of three files (about 20 GB in total). From ComfyUI/:

   bash · from ComfyUI/copy

   wget -P models/diffusion_models/ https://huggingface.co/Comfy-Org/z_image_turbo/resolve/main/split_files/diffusion_models/z_image_turbo_bf16.safetensors
   wget -P models/text_encoders/ https://huggingface.co/Comfy-Org/z_image_turbo/resolve/main/split_files/text_encoders/qwen_3_4b.safetensors
   wget -P models/vae/ https://huggingface.co/Comfy-Org/z_image_turbo/resolve/main/split_files/vae/ae.safetensors

   Restart ComfyUI, then in the browser: Templates → Image → Z-Image-Turbo: Text to Image → Run. If a file is missing, ComfyUI shows an error with a download address and a folder. NVIDIA writes that the image is produced in about 30 seconds ⚠️ — we have not measured our own time. Watch the GPU with nvidia-smi in a second window.

8. A workflow with FLUX.1 [schnell]

   Now the same, but with the model whose licence is clear for paid work. The graph is the same as the ComfyUI examples show it — you can drag the example image from the examples page onto the editor and the workflow loads (ComfyUI saves the workflow inside the images themselves). Or assemble it by hand:

   Node	What you set
   Load Diffusion Model	flux1-schnell.safetensors
   DualCLIPLoader	clip_l + t5xxl_fp16, type flux
   Load VAE	ae.safetensors
   CLIP Text Encode	The description of the picture (English usually works better)
   Empty Latent Image	Size, for example 1024 × 1024, batch_size 1
   KSampler	steps 4, cfg 1.0, sampler euler, simple ⚠️ the last two are defaults in the examples; we have not checked them
   VAE Decode → Save Image	Turns the result into pixels and saves it to output/

   💡

   What is different about schnell

   schnell is distilled for 1 to 4 steps (per the model page), and the diffusers example uses guidance_scale=0.0 and 4 steps. That is why we use 4 steps and cfg 1.0 — not 28–30, as the old versions of this lesson said for FLUX [dev]. The [dev] page shows other values (its example uses 50 steps and guidance 3.5). Do not carry settings over between the two models. ⚠️ A negative prompt is pointless at cfg 1.0, but KSampler wants an input for it — connect the same description; this has not been checked against a document.

   If you need a faster option under a commercial licence, also look at FLUX.2 [klein] 4B (Apache-2.0, about 13 GB of memory per the model page): it is on the supported list in the ComfyUI README, but we have not written out its workflow here.

9. LoRA: a small add-on with a big licence

   A LoRA is a small file that "teaches" the base model a style or an object. It goes into models/loras/ and is attached with a LoRA-loading node between the model loader and the sampler. Two rules:

   • Only for the model it was trained for. A LoRA trained for FLUX.1 [dev] does not load onto schnell.
   • The base's licence carries over. The FLUX.1 [dev] licence defines as a "Derivative" any modified or fine-tuned version of the model. So a LoRA made on [dev] is not for paid work. For commercial use train on an Apache-2.0 model and keep a record of which model it was made on.

   If your LoRA has a trigger word, include it in the description; start the LoRA strength at around 0.8 and adjust by eye. ⚠️ We have not trained or tested a LoRA here.

10. Security: extensions and images

    • Extensions (custom nodes) run code on the machine. They are usually installed through ComfyUI-Manager: the ComfyUI README says to enable it with pip install -r manager_requirements.txt and python main.py --enable-manager (check python main.py --help for your version ⚠️). Install only from sources you have checked.
    • Every image carries its whole workflow — ComfyUI saves it in the file, including the descriptions and the sampling seed. Before you send or publish an image, clear the metadata (for example by exporting it again through an image editor).
    • Download models from the producers' own pages, not from random copies.
    • Keep ComfyUI on loopback and reach it through the tunnel (step 6).

11. Monitoring

    bashcopy

    nvidia-smi

    It shows the GPU load (without a memory counter — see "Before you start"). For how much memory your models take, see the lesson "What fits on GX10".

04Check

• nvidia-smi shows the GPU, and the Python environment is active.
• ComfyUI answers HTTP 200 on port 8188 and opens through the tunnel.
• The models are in the right folders: unet, text_encoders, vae.
• The Z-Image-Turbo template returns an image.
• The FLUX.1 [schnell] graph with 4 steps returns an image.
• For every model you will use for a client you have written down the licence with a date.
• No model with a non-commercial licence is in a paid project.

Test

05What's next

06Sources

1. NVIDIA: Generate Images and Videos with ComfyUI (DGX Spark) — install, PyTorch for CUDA 13.0, the Z-Image-Turbo template, port 8188.
2. ComfyUI on GitHub (README) 🔒 local — Python, ComfyUI-Manager, workflow inside images.
3. ComfyUI: FLUX examples — folders and files.
4. FLUX.1-schnell · FLUX.1-dev · FLUX.1-Krea-dev 🌐 global — licences.
5. FLUX.2-dev · FLUX.2-klein-4B · FLUX.2-klein-9B — licences.
6. Stable Diffusion 3.5 Large · SDXL base 1.0 — licences.
7. Qwen-Image · Z-Image-Turbo · flux_text_encoders — licences and files.
8. The text of the FLUX.1 [dev] licence — sections 2(d), 4(a) and the definition of "Non-Commercial Purpose".