DEV Community: Prompting Pixels

Train a Custom Z‑Image Turbo LoRA with the Ostris AI Toolkit (RunPod Edition)

Prompting Pixels — Tue, 02 Dec 2025 14:34:26 +0000

What we’re building

A complete, reproducible workflow to train a Z‑Image Turbo LoRA with the Ostris AI Toolkit, running on a rented GPU (RunPod). We’ll go from blank slate to a downloadable .safetensors LoRA, then load it into a downstream workflow (e.g., ComfyUI) to test the results with a trigger token.

You’ll learn:

How to spin up the right environment on RunPod
How to assemble and configure a dataset for concept training
How to pick the right model, adapter, and sample prompts for monitoring
How to kick off and observe training progress
How to export and use your LoRA in your own pipeline

💡 Pro tip: Z‑Image Turbo is fast and surprisingly VRAM‑friendly. Even before the base model drops, the distilled weights already make for practical LoRA experimentation.

Check out the accompanying video on YouTube.

TL;DR (Quick Reference)

Start a RunPod instance using the “Ostris AI Toolkit” template.
Create a dataset (8–20 images is a good starting point). Optionally add captions.
New job → select Z‑Image Turbo + LoRA target.
Set a unique trigger token (e.g., myuniqueconcept) and configure sample prompts.
Run ~3,000 steps to start; expect ~1 hour on a high-end GPU (e.g., RTX 5090).
Download the resulting LoRA (.safetensors) from the job’s Checkpoints.
Load the LoRA into your favorite workflow (ComfyUI, etc.) and prompt with the trigger.

Step 1 — Spin up the GPU workspace

On RunPod, search for and launch the Ostris AI Toolkit template. Keep disk size generous (datasets and samples eat space as you iterate).

🧪 Debug tip: If you see 0% GPU utilization during training, your job likely didn’t start or is stuck on CPU. Check the Training Queue and logs.

Step 2 — Assemble a tiny but consistent dataset

Hop into Datasets → New Dataset. Name it something meaningful; I like a short handle that matches my future trigger token.

Upload 8–20 representative images. Keep variety in poses and contexts, but a consistent subject identity.

Captions are optional. If you add them, keep the phrasing consistent (e.g., always include your trigger token).

🧭 Guideline: Resolution 1024×1024 is a solid baseline with Z‑Image Turbo. If your source images vary wildly, consider pre-cropping/centering the subject.

Step 3 — Configure the training job like a pro

Head to New Job:

Training name: something short you’ll recognize later
Trigger token: a unique string (avoid real words; e.g., xqteachu, zimg_concept01)
Architecture: Z‑Image Turbo (LoRA target)

You’ll see a training adapter path. There’s also a newer “v2” adapter rolling out. If it’s available in your build, you can switch the file name from v1 to v2 to try it out.

Attach your dataset and set preview sampling. Samples during training are clutch—they confirm your LoRA is “taking.”

For samples, create two contrasting prompts so you can inspect generalization:

“{trigger}, cinematic portrait, soft light, 85mm, bokeh”
“{trigger}, full body action scene, dynamic pose, outdoor, golden hour”

💡 Pro tip: Keep the LoRA strength modest when previewing (e.g., 0.7–0.9). Too high can overcook and hide issues until it’s too late.

If your GPU is tight on VRAM, turn on the Low VRAM option in the model panel.

Step 4 — Start the job and watch it like a hawk

Create Job → Training Queue → Play → Start.

On a 5090, ~3k steps typically finishes around the 1‑hour mark (defaults). If samples are configured every 250 steps, you’ll see the subject “phase in” across iterations.

🧪 Debug tip: If loss flatlines suspiciously early or samples look unrelated to your subject after ~1k steps, your trigger might not be present in the sample prompts, or your dataset is too small/too noisy.

Step 5 — Evaluate progress and export the LoRA

Open the Samples tab to review the training trajectory. You’ll usually notice early frames not obeying the trigger, then progressively adapting to your subject.

When it’s done, jump to the job Overview → Checkpoints. Download the newest .safetensors file—this is your LoRA.

📦 Housekeeping: Save the training config alongside the .safetensors so you can reproduce tweaks later (steps, adapter version, dataset size, etc.).

Step 6 — Try the LoRA in your workflow

I like to validate in ComfyUI with a simple graph: base Z‑Image Turbo → CLIP encode prompt (including trigger) → sampler → VAE → preview.

Example prompt:

“myuniqueconcept, cheerful portrait, natural light, editorial style”

If the result skews too strongly to the subject or artifacts creep in, lower the LoRA strength a bit and re‑sample.

Final output from one of my runs:

One-command ComfyUI on Cloud GPUs: A Practical, Repeatable Setup

Prompting Pixels — Sun, 30 Nov 2025 21:59:33 +0000

What we're building

A repeatable way to boot a cloud GPU (RunPod or Vast.ai), paste a single command, grab the exact ComfyUI version you want, auto-install your favorite custom nodes, and download models from Hugging Face/Civitai into the correct folders. No more “did I put that LoRA in the right place?” or “why is this template six months behind?”.

We’ll use a free script generator to produce the one-liner and show you how to tweak, debug, and extend it for your workflow.

💡 Pro tip: Time is literally money on cloud GPUs. Automating the boring parts pays for itself on the first run.

Why this was a pain (until now)

If you’ve tried to stand up ComfyUI on a fresh GPU instance, you’ve probably done some combination of:

Opening a terminal, then manually git pulling ComfyUI to get a newer version
Downloading models piecemeal from Hugging Face or Civitai
Guessing model folder locations (checkpoints vs LoRA vs VAE)
Cloning custom nodes and hoping dependencies resolve
Restarting ComfyUI multiple times to make new nodes appear

That’s too many manual steps, which means it’s slow, error-prone, and easy to forget when you come back a week later.

The fix: generate a deployment command once, reuse forever

We’ll use the generator at:

https://deploy.promptingpixels.com/

It outputs a one-line shell command that:

Installs or updates ComfyUI to a specific version
Downloads your selected models into the correct ComfyUI subfolders
Installs custom nodes you choose from the ComfyUI registry
Adapts paths to your provider (RunPod/Vast.ai) or your local OS
Supports tokens for gated downloads

🧭 Heads up: The generated command is provider-aware. Pick the right target before copying.

Hands-on: from blank GPU to ComfyUI, step-by-step

We’ll demonstrate with Vast.ai, but I’ll call out RunPod differences as we go.

1) Launch a GPU instance

Vast.ai: Use an image/template that includes a Jupyter Terminal or shell access.
RunPod: Either the ComfyUI template or a general-purpose image with CUDA.

Open a terminal on the instance:

2) Generate your script

Visit https://deploy.promptingpixels.com/
Choose App: ComfyUI
Pick the provider (Vast.ai or RunPod)
Add Models:
- Search from Hugging Face or Civitai
- The generator will route each file to the correct ComfyUI directory
Add Custom Nodes:
- Search popular nodes (e.g., Impact Pack) and add them
Optionally pin the ComfyUI version (handy for reproducible builds)

💡 Pro tip: Use presets to recreate environments from previous projects. Consistency saves debugging time.

3) Copy the one-liner and run it

Paste the generated command into your instance terminal. It typically looks like a wget/curl piping into bash. If you need tokens for gated models, export them first:

# Optional: tokens for gated downloads
export HF_TOKEN=hf_your_read_token_here
export CIVITAI_TOKEN=your_civitai_token_here

# Example shape of the generated command (yours will be specific)
bash <(wget -qO- https://deploy.promptingpixels.com//api/script/cmim9aus50008n5vdgw3g00yv) --hf-token=YOUR_HF_TOKEN

Go grab a coffee. When it finishes, ComfyUI will be set up with your exact configuration.

4) Launch ComfyUI

Start ComfyUI from your provider’s UI (or the app menu). If new nodes don’t show up in the menu, do a quick restart of the app.

Verify and debug like a developer

I like to sanity-check a fresh environment with a few quick commands.

Check the ComfyUI version you actually deployed

COMFYUI_ROOT="${COMFYUI_ROOT:-/workspace/ComfyUI}"  # adjust per provider if needed
git -C "$COMFYUI_ROOT" rev-parse --short HEAD

Confirm models landed in the right folders

ls -1 "$COMFYUI_ROOT/models/checkpoints" | head
ls -1 "$COMFYUI_ROOT/models/loras" | head
ls -1 "$COMFYUI_ROOT/models/vae" | head

See which custom nodes got installed

ls -1 "$COMFYUI_ROOT/custom_nodes" | sort | head -n 20

🧪 Tip: If a node has Python deps, open its README. Some custom nodes require an extra pip install or a build tool. The generator handles common cases, but niche nodes can have surprises.

Provider-specific notes

Vast.ai common ComfyUI path:
- /workspace/ComfyUI
RunPod common ComfyUI path:
- /workspace/runpod-slim/ComfyUI

If you’re on a non-template image or your provider changed paths, set COMFYUI_ROOT manually and use the “Full Script” editor to update paths before running.

⚠️ Warning: Custom nodes appear after ComfyUI restarts. If you installed nodes while the UI was running, restart the service/app.

Full script mode: for tinkerers and control freaks

Click “Full Script” in the generator to see and edit everything it plans to run. This is great when you want to:

Pin exact commits for ComfyUI or nodes
Add extra pip packages
Change model destination directories
Integrate with a persistent volume
Insert health checks or post-install tests

Example tweaks you might add:

# Pin a specific ComfyUI commit
git -C "$COMFYUI_ROOT" fetch --all
git -C "$COMFYUI_ROOT" checkout <commit-or-tag>

# Install extra Python deps required by a custom workflow
source /venv/bin/activate 2>/dev/null || true
pip install xformers==0.0.23 safetensors==0.4.3

# Verify GPU is visible
nvidia-smi || echo "No GPU found (driver/container mismatch?)"

Troubleshooting and “wish I knew this sooner”

Hugging Face 403? You probably need a token for that model/repo.
```
export HF_TOKEN=hf_xxx
```
Slow model downloads: instance egress can be limited. Consider smaller test models first to validate paths.
Not enough disk: large checkpoints can exceed ephemeral storage. Use a larger volume or a persistent disk.
Node missing in the menu: restart ComfyUI after node install/update.
CUDA mismatch errors: ensure your image, driver, and PyTorch stack align. Templates help, bare images can drift.
Case-sensitive paths: ComfyUI model folders are strict: “checkpoints”, “loras”, “vae”, etc.
Port blocked? Verify the provider exposes the ComfyUI port (often 8188) and the service is running.

🛠️ Debug pattern I use: tail logs while launching the UI to spot import errors.
ps aux | grep -i comfy
# or check the provider's app logs panel if available

Developer tips

Use presets to create named environments for different workflows (e.g., “ControlNet Editing”, “Tiny SDXL Playground”).
Pin versions when collaborating so everyone runs the same stack.
For long downloads, wrap your terminal session in tmux/screen to avoid drops.
Cache model folders on a persistent volume to avoid re-downloading every session.
If you’re on Windows/macOS locally, point the generator to your ComfyUI path and generate a matching script for your OS.

💡 Pro tip: You can run the generator for local machines too. Set the install path and let it do the folder mapping for you.

Quick Reference (TL;DR)

Generator: https://deploy.promptingpixels.com/
Workflow:

1. Launch GPU instance (RunPod/Vast.ai) and open a terminal
2. In the generator, pick provider + ComfyUI version
3. Add models (HF/Civitai) and custom nodes
4. Copy the one-liner, set tokens if needed, paste into terminal
5. Launch ComfyUI; restart once to load new nodes

Helpful env vars:

export HF_TOKEN=hf_xxx
export CIVITAI_TOKEN=xxx
export COMFYUI_ROOT=/workspace/ComfyUI  # adjust if your layout differs

Verify after install:

git -C "$COMFYUI_ROOT" rev-parse --short HEAD
ls "$COMFYUI_ROOT/models/checkpoints" | head
ls "$COMFYUI_ROOT/custom_nodes" | head

If you’ve got feature ideas or run into edge cases, the tool’s maintained and open to feedback: deploy@promptingpixels.com

Happy building!

Ship ComfyUI on RunPod (Dev-Friendly): Cloud GPU, models, and zero local setup

Prompting Pixels — Fri, 28 Nov 2025 21:30:42 +0000

What we’re building

A browser-based ComfyUI workstation running on a rented GPU (RunPod), preloaded with your favorite models and custom nodes, with no local installs. You’ll:

Launch a GPU pod with the official ComfyUI template
Install models LoRA/custom nodes the fast way (copy/paste one-liner)
Restart ComfyUI cleanly and verify everything works
Pull images off the pod and keep costs in check

If you like command-line control, I added optional CLI and debugging bits along the way.

TL;DR (Quick Reference)

Pick a GPU (3090 is great for learning; 5090 is fast if you need speed)
Use the RunPod ComfyUI template (no manual installs)
Enable the Web Terminal and paste a deployment one-liner from Prompting Pixels
Set Hugging Face and Civitai API tokens before running the script
Restart ComfyUI from Manager inside the UI
Download outputs via File Browser (port 8080)
Stop the pod when you’re done to avoid charges

The problem I was trying to solve

I wanted ComfyUI with good models and a clean environment without touching my local machine. My laptop can’t compete with a data center GPU, and I’m not babysitting CUDA installs or driver versions. RunPod + an official ComfyUI template + a model installer script is the shortest path I’ve found.

Plan of attack

1) Provision a GPU pod on RunPod

2) Select the official ComfyUI template

3) Wait for services to come up (ComfyUI on port 8188)

4) Use a one-liner to install models/custom nodes

5) Restart ComfyUI and generate images

6) Download results and pause billing

1) Provision the GPU pod

Sign into RunPod and open Pods. Filter for an affordable but capable GPU.

Starter pick: RTX 3090 (~$0.30–0.50/hr)
Faster iterations: RTX 5090 (~$0.75–0.90/hr)

💡 Pro tip: Don’t overspend on GPU at the start. You can always spin up a beefier pod later to re-run workflows faster.

Attach the right template

On the config screen, change the template to the official RunPod ComfyUI image.

Search “ComfyUI” and pick the RunPod-owned template (not a random user).

Name your pod and deploy on-demand.

⚠️ Warning: Keep an eye on allocated disk size. Models are big. 100–200 GB leaves room for a couple of XL checkpoints + LoRAs + outputs.

2) Wait for services, then open ComfyUI

RunPod will boot your pod and wire up HTTP ports. You want ComfyUI on port 8188 to be “Ready” (green).

Click “ComfyUI” to open the UI in a new tab.

💡 Pro tip: JupyterLab (port 8888) and File Browser (port 8080) are also exposed. I use them for quick inspections/edits without SSH.

3) Install models and custom nodes (no manual path wrangling)

We’ll use a one-liner generator so you can pick models/nodes via checkboxes and paste a script once. Open:

deploy.promptingpixels.com
Choose your base models (e.g., JuggernautXL, RealVisXL)
Add LoRAs/styles and useful nodes (UltimateSDUpscale is solid)
Select “RunPod” as the provider
Copy the generated one-liner

Now in your pod’s Connect tab, enable the Web Terminal and open it:

Paste the command you copied. It will look conceptually like this:

# Example shape — use the exact one-liner from the site
bash <(wget -qO- https://deploy.promptingpixels.com//api/script/cmijdjpcm000knikfe33dqbc2) --hf-token=YOUR_HF_TOKEN

⚠️ Warning: Replace YOUR_HF_TOKEN and YOUR_CIVITAI_TOKEN with real API tokens.

Hugging Face: https://huggingface.co/settings/tokens

Civitai: https://civitai.com/user/account

Prefer not to paste tokens in plain text?

export HF_TOKEN=hf_XXXXXXXXXXXXXXXXXXXXXXXXXXXX
export CIVITAI_TOKEN=ct_XXXXXXXXXXXXXXXXXXXXXXXX
# Then paste the one-liner and change flags to:
# ... --hf-token "$HF_TOKEN" --civitai-token "$CIVITAI_TOKEN"

Go grab a drink; downloads can take a while.

4) Restart ComfyUI cleanly

After the installer finishes, switch to your ComfyUI tab and use the Manager to reload nodes and models.

💡 Pro tip: If you see “Bad Gateway” once, wait ~30s and refresh. The service is coming back up.

At this point, models and nodes should show up in dropdowns and node pickers.

5) Generate and export results

Create a simple workflow, run it, and confirm outputs appear in ComfyUI’s output directory.

To batch-download images, use File Browser (port 8080).

Default credentials for File Browser:

Username: admin
Password: adminadmin12

Navigate: runpod-slim → ComfyUI → output, then right-click to download or multi-select.

💡 Pro tip: For automation, you can also zip the output folder and grab a single archive. Or sync to an object store if you want to get fancy.

Debugging and ops cheat sheet

When things go sideways, here’s what I actually run:

GPU sanity:

  nvidia-smi

Disk space:

  df -h
  du -h --max-depth=1 runpod-slim/ComfyUI/models | sort -h

Memory headroom:

  free -h

Permissions jank (rare, but happens with new files/folders):

  chmod -R u+rwX,g+rwX runpod-slim/ComfyUI

Quick reset if Manager restart isn’t enough:
- Stop and start the pod from the RunPod dashboard
Verify ports:
- ComfyUI on 8188, File Browser on 8080, JupyterLab on 8888

🧪 Tip for VRAM errors: Drop resolution, batch size, or disable high-memory nodes first. On 24GB cards, SDXL at 1024px usually needs conservative settings.

Gotchas (aka “wish I knew this earlier”)

Model sizes add up fast. Plan 10–30 GB per XL checkpoint, plus LoRAs and VAE.
The first template boot can take a few minutes—don’t panic-refresh too early.
A “Ready” indicator for port 8188 is the source of truth. If it isn’t green, ComfyUI isn’t up yet.
After adding nodes, always restart via Manager before assuming “it didn’t install.”
Tokens matter: a bad Hugging Face or Civitai token silently causes partial downloads.
Billing is minute-by-minute. A forgotten running pod is an involuntary donation.

Keep costs under control

When you’re done, pause the pod to stop charges while preserving your data. Termination deletes everything—use it when you’re really done.

Stop = pause billing, keep storage
Terminate = destroy pod and data

💡 Pro tip: Name pods clearly (e.g., comfyui-sdxl-playground) so you don’t forget what’s safe to shut down.

Extras for power users

JupyterLab (8888) for quick scripts and file edits
SSH keys for terminal lovers (optional, Web Terminal works fine)
Volume planning: if you’re a model hoarder, allocate >200 GB up front
CI-like behavior: keep a lightweight pod for experimenting, spin a faster one for final renders

Quick Reference

GPU pick
- 3090 = economical learning
- 5090 = fast iteration
Services
- ComfyUI: port 8188
- File Browser: port 8080 (admin/adminadmin12)
- JupyterLab: port 8888
Tokens
- Hugging Face: https://huggingface.co/settings/tokens
- Civitai: https://civitai.com/user/account
Installer
- Use deploy.promptingpixels.com, provider “RunPod”, copy the one-liner
Common commands

  nvidia-smi
  df -h
  free -h

Cost control
- Stop pod when idle
- Terminate only when you want a clean slate

What’s next

Add ControlNet and pose/edge preprocessors for surgical control
Wire up an S3 bucket to sync outputs automatically
Build a tiny HTTP service that triggers ComfyUI workflows (webhooks + queue)
Try LoRA training pods to create your own styles
Spin a second pod with a bigger GPU just for render days

If you ship anything cool with this setup, share your workflow JSON and model picks—I love seeing what people make with a clean ComfyUI rig.

Spin Up ComfyUI on Vast.ai Without Surprises: A Practical, Developer-First Guide

Prompting Pixels — Wed, 26 Nov 2025 15:35:41 +0000

What we're building

I needed a beefy GPU for ComfyUI experiments and my laptop tapped out fast. Instead of building a home lab, I deployed ComfyUI on Vast.ai, added models, and kept the bill under control. In this tutorial, we’ll do the same—end to end—while avoiding hidden bandwidth fees and common gotchas.

We’ll:

Rent a GPU on Vast.ai (aff. link) and choose the right pricing
Use the official ComfyUI template with sensible storage
Load models using three different methods (GUI, terminal, and a one-liner generator)
Pull down generated images efficiently
Keep runtime costs predictable and know when to stop/destroy
Troubleshoot with a developer’s toolkit (CLI, logs, and sanity checks)

TL;DR (Quick Reference)

Pick a GPU with ≥24GB VRAM for comfy workflows; watch for bandwidth $/TB
Use the official “ComfyUI” template; give yourself ~200GB disk
Launch → Open → Launch ComfyUI and Jupyter Terminal
Models go under /workspace/ComfyUI/models/... (checkpoints, loras, vae, etc.)
Press R in ComfyUI to reload models after adding files
Stop to keep storage; Destroy to stop all billing (you’ll lose data)
Troubleshoot: check nvidia-smi, disk, memory, and ComfyUI logs

Hint: If you only read one thing: hover the Vast.ai price to see bandwidth cost per TB. Don’t pay $20+/TB by accident.

Step 1 — Pick a GPU without getting burned by bandwidth

On Vast.ai, go to Console → Search. Filter for GPUs that match your needs. For most ComfyUI workflows:

RTX 4090 / 5090: excellent performance for SD/Flux-style pipelines
RTX 3090 (24GB VRAM): great value and compatible with many models
RTX PRO 6000: workstation-level headroom; fewer compromises

You’ll see rates per hour—but that’s not the whole story.

Hover the price to reveal the full breakdown, especially internet bandwidth:

If that TB cost looks wild, filter it down first:

Warning: If you plan to download large models (Flux, Wan, Hunyuan Video, or multiple SDXL variants), bandwidth costs can exceed compute costs. Pick a host with cheap $/TB.

Step 2 — Use the official ComfyUI template and set storage once

Before clicking Rent, click Change Template and search for “ComfyUI”. Choose the official Vast.ai ComfyUI template (it comes with CUDA, Jupyter, SSH, etc.).

Storage sizing guidelines:

100GB minimum: barebones experiments
200GB recommended: several models + comfy headroom
300GB+: lots of checkpoints, LoRAs, and video models

Pick now—resizing later means recreating the instance.

Step 3 — Launch, then sanity-check the machine

Click Rent, then open Instances and wait for the Open button.

Open → you’ll see app launchers. Start with Jupyter Terminal and run quick checks:

# GPU and driver
nvidia-smi

# RAM and disk
free -h
df -h /workspace

# ComfyUI folder structure present?
ls -la /workspace/ComfyUI

Then launch ComfyUI from the portal and confirm the UI loads.

If the UI opens, you’re golden:

Step 4 — Load models (three practical paths)

Option A: ComfyUI Manager (GUI-first)

Use the Manager inside ComfyUI to install a downloader node:

Open ComfyUI → Manager
Custom Nodes Manager → search “ComfyUI Model Downloader”
Install and use it to pull from Hugging Face / CivitAI
It places files in correct subfolders automatically

Press R in ComfyUI to reload model lists.

Option B: Jupyter Terminal (fast and explicit)

From the instance portal, open Jupyter Terminal and drop models into the right paths.

Common directories:

Base checkpoints: /workspace/ComfyUI/models/checkpoints
LoRAs: /workspace/ComfyUI/models/loras
VAE: /workspace/ComfyUI/models/vae
CLIP/Text encoders: /workspace/ComfyUI/models/clip
Upscalers: /workspace/ComfyUI/models/upscale_models
ControlNet: /workspace/ComfyUI/models/controlnet

Examples:

# Example: download a checkpoint with curl (auto-follow redirects)
cd /workspace/ComfyUI/models/checkpoints
curl -L -o model.safetensors "https://huggingface.co/.../resolve/main/model.safetensors"

# Faster parallel downloader (aria2c)
aria2c -x 16 -s 16 -k 1M -o model.safetensors "https://huggingface.co/.../resolve/main/model.safetensors"

# Hugging Face CLI (requires token for gated repos)
pip install -q huggingface_hub
huggingface-cli login --token $HF_TOKEN
huggingface-cli download ORG/REPO --include "*.safetensors" --local-dir /workspace/ComfyUI/models/checkpoints

Then reload the UI:

Focus the ComfyUI tab and press R

Option C: One-liner setup via AI Launcher

If you want a single script that installs everything (ComfyUI + models + custom nodes), this is the smoothest path:

Visit https://promptingpixels.com/deploy
Choose Vast.ai
Pick models (HF / CivitAI) and custom nodes
Copy the generated one-liner
Paste it into Jupyter Terminal once your instance is up
Done—everything lands in the correct folders automatically

Note: I personally love the AI Launcher @ Prompting Pixels as it makes it super easy to config without wasting money while the Instance is active. Plus you can reuse the config again and again.

Step 5 — Generate and pull down your images

ComfyUI saves outputs under /workspace/ComfyUI/output. Use Jupyter to grab files:

Open Jupyter from the portal
Browse: workspace → ComfyUI → output
Select and Download single or multiple files

Extras:

# Zip a whole run for one-click download
cd /workspace/ComfyUI/output
zip -r run_$(date +%F_%H%M).zip .

# Prefer syncing? Launch Syncthing from the portal and pair with your desktop.

Cost control and lifecycle

Think of your instance in two states:

Running: you pay hourly compute + bandwidth
Stopped: compute stops, you pay a small daily storage fee to keep the disk

When you’re done for the day:

Stop if you’ll resume soon (keeps data, small daily fee)
Destroy to end all billing (deletes everything)

Example numbers I’ve seen:

~0.39/hour compute (varies by GPU)
~1.30/day storage when stopped (adjusts with disk size and host)

Always check per-host pricing breakdown.

Debugging and diagnostics (do these first)

When something feels off, open Jupyter Terminal and run:

# Is the GPU accessible?
nvidia-smi

# Enough disk space?
df -h /workspace

# Which folders are consuming space?
du -h -d 1 /workspace/ComfyUI/models | sort -h

# See ComfyUI logs (adjust if your template logs somewhere else)
ps -ef | grep -i comfy
tail -n 200 /workspace/ComfyUI/logs/*.log 2>/dev/null || echo "No logs found here"

# Network sanity (if downloads are failing)
curl -I https://huggingface.co

Common issues and fixes:

Models not showing up: files in wrong folder; press R to refresh model lists
Out of memory during generation:
- Lower resolution or batch size
- Use a smaller model or quantized variant if available
- Remove redundant nodes in the graph
- Consider a GPU with more VRAM
Can’t open ComfyUI after launch:
- Wait 60–90 seconds; services might still be booting
- Refresh the browser
- Check instance status in Vast.ai
- Confirm local firewall isn’t blocking
Disk full mid-run:
- Zip and download outputs
- Destroy and recreate with larger storage (resizing isn’t supported mid-flight)
- Or spin a new instance and migrate using the portal copy/move tools

Hint: I’ve occasionally hit a “bad” host. If everything looks right but services won’t behave, destroy and pick a different provider—datacenter GPUs tend to be more consistent.

Things I wish I knew earlier

Press R inside ComfyUI to reload models—no restart required
Bandwidth $/TB can dwarf your hourly rate if you fetch large models often
200GB is a sweet spot unless you’re hoarding multiple SDXL/Flux/Video models
aria2c is notably faster than curl/wget for big downloads
Stopping your instance preserves data cheaply—great for weekend projects
Syncthing is built into the portal; it’s convenient for background syncs

Example: quick test workflow

Once models are in place:

Open ComfyUI and load a simple text-to-image graph
Set batch_size=1 and 768x768 (or lower if VRAM is tight)
Generate and confirm images land in /workspace/ComfyUI/output
Zip outputs and download

Quick CLI snippets

# Create folders just in case
mkdir -p /workspace/ComfyUI/models/{checkpoints,loras,vae,clip,upscale_models,controlnet}

# Validate a model file after download
ls -lh /workspace/ComfyUI/models/checkpoints/*.safetensors
sha256sum /workspace/ComfyUI/models/checkpoints/*.safetensors | head

# Clean old outputs to free space
find /workspace/ComfyUI/output -type f -mtime +7 -print -delete

Gotchas (so you don’t have to learn them the hard way)

You can’t resize disk on a running instance; plan storage up front
Some providers throttle bandwidth—aria2c with multiple connections helps
If the portal shows ComfyUI “running” but the page won’t load, wait. The server can still be warming up
Gated models on Hugging Face require a token (HF_TOKEN) and huggingface-cli login
LoRA and VAE folders are separate—don’t drop everything into checkpoints

What’s next

Add ControlNet workflows and experiment with video models on bigger GPUs
Automate model syncing with a bootstrap script or dotfiles
Expose the ComfyUI API and script batch jobs from your local machine
Try other clouds and compare $/hr + $/TB to build your own cost model
Containerize your custom nodes so you can lift-and-shift between hosts easily

Happy building—and may your bandwidth be cheap and your VRAM plentiful!