The Data Life
ShippedSep 2026 – Oct 2026Solo builder

Comfy Montage

Drop a batch of photos, get a narrated, scored short film: one 128-node ComfyUI workflow, called as an API.

react-three-fiberrapierfastapicomfyuicomfy-apigeminicloud-run
The finished montage playing on a large screen in the app's 3D scene: a sunset over the ocean with birds, the photo cards around it and the story's words piled in front as outlined 3D letters

Overview

A tech demo for the Comfy Developer Platform. You drop a few photos on a table and write one line about the trip; a ComfyUI workflow running on a Comfy API serverless deployment sends back a narrated, scored montage. Gemini reads each photo and arranges a story, then one 128-node graph renders a Wan 2.2 transition per beat, an ACE-Step score, Chatterbox narration, and the final mix.

Seven photos from Bodega Bay became a 22-second film in about four minutes, on a GPU that scales to zero and costs nothing while idle. The app makes the wait the show: every step streams into a three.js scene, and every run opens back up in Comfy Cloud as a workflow anyone can copy. It's hosted for comfy.org on Cloud Run behind sign-in.

I also made the 57-second launch video with HyperFrames, built on 3840×2400 recordings of the app. It's narrated in my own voice, cloned with Chatterbox on Comfy Cloud, and scored by Sonilo on Comfy Cloud from the cut itself, so the platform made the promo's voice and music too.

Media

The 57-second launch video: the app end to end, narrated in my cloned voice, with a Sonilo score made from the cut.
What it made: seven Bodega Bay photos turned into a narrated, scored 22-second film.
Drop photos on the table, or toss a recorded run's pile to replay it.
Gemini reads each photo and boxes what can move.
Cards line up in story order under their beat titles.
Rendering on the Comfy API: chips light in the order the GPU works them while tiles lift off the cards.
Layers: every Wan cut, narration line, the ACE-Step score and the voice bus.
Under the hood: the 128-node graph goes out in one POST /api/v2/jobs.
The same workflow, grouped, on the Comfy Cloud canvas.
Deploying it with the Build Wizard: pick a GPU, set workers, $0.00/hr when idle.

Features

Photos on a table

Drop up to twelve photos and they tumble onto a physics table. Recorded runs lie in piles under the drop ring; toss one to replay it.

Watch it think

Gemini boxes what can move in each photo, the cards line up under their beat titles, and the story falls from the sky as 3D words you can grab and throw.

The crew strip

A chip for every model in the graph, lighting up in the order the GPU actually works them, with an estimated time on each.

Honest timing

Before Start, the app says how long the run will take and why: a cold GPU loads its models first, a warm one just renders.

Layers

The finished film explodes into a stack: every Wan cut, every narration line where it was placed, the ACE-Step score and the voice bus, with one playhead and solo buttons.

Open in Comfy Cloud

Every run saves its grouped workflow, photos included, as a public share link, so the result is a starting point, not a dead end.

Technical

React 19, React Three Fiber, Rapier physics and zustand in the browser; a FastAPI orchestrator streams one NDJSON response per run. It calls Gemini 2.5 Flash for captions, boxes and the story, builds the graph, submits it with comfy-sdk to the Comfy API v2, and relays SSE progress and outputs back as events.

The deployment is a pinned Build: ComfyUI at a tag, two custom node packs by commit, and every model by its Hugging Face source (Wan 2.2 14B fp8 with lightx2v LoRAs, ACE-Step 1.5, Chatterbox). The app runs on Cloud Run behind Identity-Aware Proxy, with infrastructure in OpenTofu and deploys from GitHub Actions.

One planner, two graphs

The same plan emits a flat API-format graph for the deployment (subgraph instances can't be POSTed) and a grouped subgraph version for the Cloud canvas, with each clip's prompt baked into its own subgraph.

Progress from what the GPU reports

ComfyUI runs the narration, music and Wan clips in a different order every time, so the crew strip lights and reorders from node progress instead of trusting the plan's order.

An estimate fitted to real jobs

From the deployment's own job records: about 15 s plus 5.5 s a photo to read and arrange, 0.22 s per 512×384 frame on a warm worker, and about 150 s to load models after 45 minutes idle.

Demo tapes

A recorded run is its event stream with real timestamps plus the media. It replays through the same code path as a live run, with the waits compressed, on any static host.

Runs survive leaving the tab

A stream that goes quiet for 20 s falls back to polling the job, and the run in flight lives in IndexedDB, so a reload or a discarded tab still lands the film.

Social posts

linkedin

Draft · drafted 2026-10-20
M
Miles

I built an app that turns a handful of photos into a narrated short film, and the whole pipeline is one ComfyUI workflow called as an API.

You drop photos on a table and write one line about the trip. Gemini reads each photo and boxes what can move: the tree, the deer, the wave. Then it writes the story: a title for every shot, the narration, the order they play in.

Then a single 128-node workflow does the rest, on a Comfy API serverless deployment. Wan 2.2 animates each transition, ACE-Step writes the score, Chatterbox reads the lines. Seven photos from Bodega Bay became a 22-second film in about four minutes, on a GPU that costs nothing while it's idle.

I wanted the wait to be the show. The app streams every step: model chips light up in the order the GPU works them, and when the film lands you can explode it into layers. Every clip, every narration line, the music on its own.

The workflow is the product. I built it in ComfyUI on Comfy Cloud, the Build Wizard deployed it, and every run opens back up in Comfy Cloud as a workflow you can copy and change.

Even the voice in the video is mine, cloned with Chatterbox on Comfy Cloud, and Sonilo scored it from the cut itself.

What would you build if a whole generative pipeline were one API call?

x / bluesky / threads

Draft · drafted 2026-10-20
M
Miles
1/7

I built an app that turns a handful of photos into a narrated short film.

The whole pipeline is one ComfyUI workflow, called as an API. 🧵

138 / 280
M
Miles
2/7

Drop photos, add one line about the trip. Gemini reads each photo and boxes what can move: the tree, the deer, the wave.

Then it writes the story: a title for every shot, the narration, the order they play in.

Attachment: read-gemini-boxes.jpg
210 / 280
M
Miles
3/7

Then one 128-node workflow runs on a Comfy API serverless deployment.

Wan 2.2 animates each transition, ACE-Step writes the score, Chatterbox reads the lines. The chips light up in the order the GPU works them.

Attachment: render-crew.jpg
211 / 280
M
Miles
4/7

Seven photos from Bodega Bay became a 22-second film in about four minutes.

The GPU scales to zero, so it costs nothing while it's idle.

137 / 280
M
Miles
5/7

When the film lands you can explode it into layers: every Wan cut, every narration line, the music on its own.

Attachment: layers.jpg
110 / 280
M
Miles
7/7

Even the voice in the video is mine, cloned with Chatterbox on Comfy Cloud.

Build it in ComfyUI. Ship it with Comfy. https://platform.comfy.org

📎 No attachment, so the link preview shows
141 / 280