← All posts
Field reports

Try ComfyUI on Google Colab: 4 Workflows for Images and Video

Pick what you want to make in ComfyUI — prompt-to-image, photo-real portraits, short video, or character animation — restore it in one Google Colab cell, then see our measured 10–11 minute standard-memory T4 Z-Image-Turbo walkthrough and R2 vs Google Drive comparison.

Renest field team November 12, 2026·9 min read
Pass this on XRedditLinkedIn

If you have never used ComfyUI before, the fastest way to see what it can make is to start from a workflow that already ran to completion, rather than wiring custom nodes and hunting models by hand.

Pick the output you want to try in Google Colab:

What you want to makeDirect Colab entrySize & hardware notes
Images from a promptFLUX.2 Klein 4B · Z-Image-TurboKlein: 12.5 GB (Colab T4 not timed yet). Z-Image: 20.70 GB (10–11 min on standard-memory T4 with --force).
Short video from a promptWan 2.2 TI2V 5B18.2 GB, restored on 24–32 GB GPUs (Colab T4 not timed yet).
Animate a character from videoWan Animate 224.9 GB, requires >15 GB VRAM (A40 / A100-class GPU) and a paid Renest plan.

Or browse all four side by side on /colab (https://renest.ai/colab).

A 1024x1024 close-up portrait of a woman with long curly brown hair in front of pink houses and boats, rendered at stage S5 on a standard-memory Google Colab Tesla T4 runtime from the Z-Image-Turbo starter setup.

Above is what came straight out of Z-Image-Turbo in one of our two standard-memory Colab T4 runs (15,360 MiB VRAM, 12.7 GiB host RAM, run with --force to pass the 15.4 GiB host RAM floor). Both timed runs produced a 1024 × 1024 image in about 10–11 minutes on an account with a positive compute-unit balance — not an unpaid zero-balance free Google account, which we note clearly in the step-by-step guide below.

The common workflow (5 steps for all 4 setups)

Whichever workflow you pick above, the path in Colab is the same:

  1. Pick a setup and get a Colab restore code. On /colab or app.renest.ai/colab, click Try in Colab on the workflow you want. After signing in with a free account (FLUX.2 Klein 4B, Z-Image-Turbo, and Wan 2.2 TI2V 5B are free to claim; Wan Animate 2 requires a paid plan), Renest copies a 7-day restore code to your clipboard and gives you an Open Colab Notebook button.

The Renest Colab landing card showing "Your Colab code is ready" with FLUX.2 Klein 4B (11.6 GB, 9 files, verified) to illustrate the code screen, a blurred restore code box, a Copied button, and an Open Colab Notebook button.

(Shown above with FLUX.2 Klein 4B only to illustrate the code-issuing screen; the blurred box holds the restore code, and the timed Colab runs in the second half of this post used Z-Image-Turbo.)

  1. Switch Colab to a GPU and paste the code. Opening the link loads renest-ai/renest-notebooks/colab/comfyui.ipynb. Set Runtime → Change runtime type to a GPU (such as T4 GPU), paste your code into handoff_code, and click Play on Cell 1. No manual git clone, folder sorting, or SSH terminal is needed.

The Renest ComfyUI One-Click Restore & Launch notebook open in Google Colab, showing clickable environment links in English, the handoff_code input field, and the /content/ComfyUI workspace field.

  1. Wait while Renest restores, checks, and tests. Cell 1 installs renest, checks the runtime's GPU/driver/CPU (S0), downloads the setup's files (S1), verifies SHA-256 checksums on disk (S2), rebuilds its isolated Python environment with uv (S3), starts ComfyUI (S4), and executes the original workflow once (S5).

  2. Layer 1 — See the first verified output right inside the notebook. As soon as S5 finishes, Cell 1 displays the rendered image inline inside the Colab cell output (Verified out-of-the-box render), along with a plain notice if --force bypassed any host machine floor check.

  3. Layer 2 — Open the full ComfyUI WebUI, change a prompt, and run again. Next, the launcher (renest_colab.py) downloads cloudflared, keeps ComfyUI listening locally on 127.0.0.1:8188, opens an HTTP/2 *.trycloudflare.com tunnel, and polls /system_stats until HTTP 200 before printing Open ComfyUI and Copy URL. If clicking Open ComfyUI inside Colab returns 403, click Copy URL and paste it into a new browser tab's address bar.

Account policy note (Google Colab FAQ): Google states that on free-of-charge managed runtimes without a positive compute-unit balance, bypassing the notebook UI to interact primarily via a Web UI is disallowed and runtimes may be terminated without warning; purchasing a paid plan with a positive compute-unit balance lifts that restriction. Because our measured runs used an account with compute units (329.65 → 327.01 across the entire session), we have not yet tested an unpaid zero-balance free account end to end.


Inside one full Colab test: Z-Image-Turbo (20.70 GB) on standard-memory T4

To measure what actually happens during the wait instead of guessing, we timed cold end-to-end restores (renest 0.1.33 --force) of Z-Image-Turbo - text to image (20,702,870,361 bytes, 9 assets) on two standard-memory Colab Tesla T4 runtimes (15,360 MiB VRAM, 2 vCPU, 12.7 GiB host RAM, 235.58 GiB free disk):

StageWhat happensUS Nevada T4US Oregon T4
S0 CheckInspect GPU, CUDA driver, CPU avx2, disk, RAM floor (--force)12.4 s12.3 s
S1 DownloadFetch all 9 assets (20.70 GB) from R2 with inline SHA-256256.3 s (648.8 Mbps)273.1 s (609.0 Mbps)
S2 Verify & PlacePlace files on /content & re-read local SHA-25687.3 s87.8 s
S3 DependenciesRebuild isolated Python 3.11.10 env with uv99.3 s112.9 s
S4 Start AppBoot ComfyUI on port 8188 & pass health check25.4 s30.5 s
S5 Test RenderExecute recorded workflow on T4 (1024×1024 output)119.9 s122.7 s
Total (S0–S5)Cold VM to saved 1024×1024 image (rc=0)609.8 s (10m10s)652.2 s (10m52s)

Stacked bar chart showing Standard-Memory Colab T4 Restore Breakdown across stages S0 through S5 for 20.70 GB Z-Image-Turbo: Run 1 in US Nevada T4 totals 609.8 s (S1 256 s, S2 87 s, S3 99 s, S4 25 s, S5 120 s), and Run 2 in US Oregon T4 totals 652.2 s (S1 273 s, S2 88 s, S3 113 s, S4 30 s, S5 123 s), run with --force past the 15.4 GiB floor and measured to the S5 test render before opening WebUI.

Three important boundaries around those measurements:

  • Timing ends at S5 image save: 609.8 s and 652.2 s stop when the 1024 × 1024 test image (z-image-turbo_00001_.png, 1,252,594 bytes) finishes writing — before launching and opening ComfyUI in a browser tab.
  • --force bypassed the host RAM floor: Colab's standard T4 runtime enforces a 12.7 GiB cgroup host RAM limit without swap, below Z-Image-Turbo's 15.4 GiB pre-check floor, so --force was needed to continue.
  • Compute unit cost: At T4's 1.15 CU/hr billed rate, an 11-minute restore-to-render window estimates by rate × time to roughly 0.21 CU (1.15 × 11 / 60). Across the whole multi-run benchmark session (including Drive pre-staging, retries, and idle waiting), account balance dropped 2.64 CU (329.65 → 327.01), so ~0.21 CU is a rate×time estimate rather than an isolated single-run bill.

Why Renest fetches from R2 instead of Google Drive (20.69 GB same-VM test)

Many Colab guides recommend copying checkpoints from Google Drive (/content/drive). To measure the real difference, we ran both on the exact same cold US Oregon T4 VM (15,360 MiB VRAM, 2 vCPU, 12.7 GiB RAM, /content disk): Google Drive (drive.mount FUSE copy + fsync + SHA-256) ran first, target files were deleted and DriveFS unmounted, and Renest R2 (renest 0.1.33 --force) ran next.

The weights tested were Z-Image-Turbo's three safetensors files (20,690,152,836 bytes: z_image_turbo_bf16.safetensors 12.31 GB, qwen_3_4b.safetensors 8.04 GB, and ae.safetensors 335 MB):

Method on the same Oregon T4 VMWhat it deliveredBreakdownTotal
Renest R2 (S1 + S2, renest 0.1.33 --force)All 9 setup files downloaded, checked, & placedS1 download & hash 273.1 s (609.0 Mbps) + S2 disk re-verify 87.8 s361.0 s (6m01s)
Google Drive (drive.mount FUSE copy + verify)3 bare .safetensors weights onlyFUSE copy 320.2 s (516.9 Mbps) + SHA-256 97.7 s418.0 s (6m58s)

Horizontal bar chart comparing Same-VM Delivery and SHA-256 Verification on 20.69 GB Z-Image-Turbo in US Oregon: Renest R2 S1 plus S2 finishes in 361.0 s (S1 273.1 s download and hash plus S2 87.8 s disk re-verify) vs Google Drive drive.mount FUSE copy plus SHA-256 at 418.0 s (320.2 s FUSE copy plus 97.7 s SHA-256), 57.0 s faster (~14%), noting Drive's 15 GB free quota limit and 368.3 s pre-staging time.

  • Same-VM delta: 57.0 s faster (~14%). Comparing full R2 download + local disk check (361.0 s) against Drive FUSE copy + SHA-256 (418.0 s), Renest finished faster while delivering all 9 assets ready for ComfyUI instead of three bare model files. (S1 finished initial download + inline digest at 273.1 s, followed by S2's 87.8 s disk re-verify in 0.1.33.)
  • 15 GB free Drive limit: Free Google accounts share a 15 GB storage ceiling across Gmail, Photos, and Drive, so 20.69 GB of Z-Image-Turbo weights does not fit without a paid Drive plan. Pre-staging those files into Drive beforehand also took 368.3 s.
  • Output sanity check: Placing the Nevada T4 1024 × 1024 output next to the site preview (originally packed on an NVIDIA A40), both show the same subject, lighting, and dockside pink houses — confirming the restored workflow executes end to end on T4 rather than claiming identical cross-GPU pixels (see three gates, not an exit code).

Side-by-side image comparing the Z-Image-Turbo site example preview on the left (960x600) with the actual 1024x1024 image rendered during S5 on a Google Colab Tesla T4 on the right, showing matching scene, subject, lighting, and background composition.

Six Colab runtime notes from these runs

  • Watch 12.7 GiB host RAM, not just 15 GiB VRAM. Colab standard T4 VMs give you 15,360 MiB VRAM and 235.58 GiB ephemeral /content disk, but a 12.7 GiB host RAM ceiling without swap. Z-Image-Turbo ships a BF16 diffusion model (z_image_turbo_bf16.safetensors, 12.31 GB), not FP8; bypassing its 15.4 GiB floor check with --force worked here, though host RAM headroom stays tight if you add extra nodes or loaders.
  • Keep Python isolated from Colab's base image. Setting UV_SYSTEM_PYTHON=0 and UV_NO_CONFIG=1 lets uv rebuild an isolated Python 3.11.10 virtualenv in S3 without colliding with Colab's preinstalled packages.
  • Don't run weights straight off /content/drive. Mounted Drive uses FUSE (418.0 s copy + verify, 516.9 Mbps), and free Drive caps at 15 GB.
  • Local /content disk SHA-256 hashes at ~210–235 MB/s. Measuring raw file_digest across those 20.69 GB weights took 91.6 s (Nevada) and 97.7 s (Oregon), matching S2's 87–88 s local re-check.
  • Disconnect and delete the runtime when finished. Active runtimes keep billing compute units while open; shut down from Runtime → Disconnect and delete runtime when done.
  • Why Copy URL sits next to Open ComfyUI. Colab's cell iframe can attach a Referer header that triggers 403 on tunnel links. Cell 1 renders links with referrerpolicy="no-referrer", probes /system_stats through the public URL before displaying it, and provides Copy URL to paste straight into a fresh tab.

What this doesn't say

  • Only Z-Image-Turbo was timed end to end on Colab T4 here. FLUX.2 Klein 4B and Wan 2.2 TI2V 5B have only been timed by us on rented GPUs so far (see Which ComfyUI setup should I start with), and Wan Animate 2 requires >15 GB VRAM and a paid plan — do not try it on a 15 GB T4.
  • Zero-balance free Google accounts are not yet tested end to end. Both T4 tests used an account with compute units and --force, and we did not time opening or interacting inside the browser WebUI tab.
  • The Oregon R2 vs Drive comparison ran sequentially on one VM (Drive first, target files removed and DriveFS unmounted, then Renest R2), because /proc/sys/vm/drop_caches is read-only inside Colab containers — so we report exact cleanup steps performed rather than claiming kernel page-cache resets.

Start from /colab to choose one of the four workflows, or read Try a starter nest and verified environments.

Pass this on XRedditLinkedIn

See a restore check itself.

Claim a starter nest — a run we packed and checked — and restore it on a machine you rent. Free, no card.