Stillfront-comfyui-sf-nodes/README.md

SF ComfyUI Nodes

66 custom ComfyUI nodes from Stillfront, covering AI image and video generation, LLM integration, and tooling for working with large game asset libraries. Every node is prefixed SF so they're easy to find in the node search.

Stillfront/WaveSpeed	54 nodes — image, video and 3D generation through WaveSpeed AI: VEO 3.1, Sora 2, Seedance 2.5, GPT Image 2.5, Nano Banana 2.1/Pro, Seedream 5.0, Qwen, Flux Kontext, WAN 2.5, InfiniteTalk, Tripo P2 and H3.1, Rodin 2.5, Meshy 7.1, upscalers
Stillfront/VertexAI	7 nodes — Imagen 3/4, VEO 3.1 and Nano Banana Pro via Google Cloud Vertex AI
Stillfront/Utils	7 nodes — Google Sheets integration, prompt batching, resolution presets
Stillfront/LLM	6 nodes — Claude, Gemini and GPT in your graph, plus the asset library tooling and a system-prompt coach below

Worth a look

The asset library workflow — point Claude at a folder of game assets and it writes a searchable manifest describing every one. After that, any workflow can ask for "the character art that suits a boss-fight poster" and get back the right reference images plus a generated prompt that already matches your project's art style — without a single image being opened at generation time.

Two nodes do this: SF Claude Library Builder catalogues once, SF Claude Asset Director searches on every run. Both run on your existing Claude Code login, so there's no API key and no per-token billing.

SF Google Sheet Prompt Queue — drive a batch of generations straight from a Google Sheet, marking rows done as you go and resuming where you left off.

---

Installation

Via ComfyUI Manager (recommended)

Search for "SF ComfyUI Nodes" in the ComfyUI Nodes Manager and click Install.

Manual

cd ComfyUI/custom_nodes
git clone https://github.com/Stillfront/comfyui-sf-nodes.git
cd comfyui-sf-nodes
pip install -r requirements.txt

---

Configuration

Copy config.ini.tmp to config.ini and fill in your API keys:

[API]
wavespeed_api_key = YOUR_WAVESPEED_API_KEY

Alternatively, set keys via environment variables:

Variable	Used by
WAVESPEED_API_KEY	All WaveSpeed nodes
ANTHROPIC_API_KEY	SF LLM Chat (Claude)
GEMINI_API_KEY	SF LLM Chat (Gemini)
OPENAI_API_KEY	SF LLM Chat (GPT)
Google Application Default Credentials	All VertexAI nodes

For VertexAI nodes, authenticate via the Google Cloud CLI:

gcloud auth application-default login

---

Node Categories

Stillfront/LLM

Chat with large language models directly inside your ComfyUI workflows, with optional image input.

Node	Description
SF LLM Chat	Multi-model chat supporting Claude (Opus, Sonnet, Haiku), Gemini 3 (Pro, Flash), and OpenAI GPT-5 series. Supports image input and reports token usage.
SF Text Analyzer	Analyze and process text strings within workflows.
SF Claude Code	Send text and images to Claude through the Claude Code CLI on your own machine, using your existing Claude login instead of an API key. Image slots appear as you fill them.
SF Claude Asset Director	Point Claude at an asset library and it chooses which references suit the brief and writes the image prompt to go with them. Outputs an IMAGE batch plus the prompt, ready to wire into any generation node.
SF Claude Library Builder	Point Claude at a folder of game assets and it writes a searchable manifest describing each one. Can also reorganise and rename the files. Feeds SF Claude Asset Director.
SF Claude Prompt Coach	Improves the system prompt behind a prompt-writing node. Give it that system prompt, the prompt it wrote, the references and the result, plus your feedback, and it returns a revised system prompt. Remembers earlier rounds — see below.

The asset library workflow

These two nodes are a pair. Library Builder catalogues your assets once; Asset Director then searches that catalogue on every run without ever opening an image.

   one time, when assets change          every generation
┌──────────────────────────────┐   ┌──────────────────────────────────┐
│ SF Claude Library Builder    │   │ SF Claude Asset Director         │
│ opens every image,           │──►│ searches the manifest,           │──► images + prompt
│ writes manifest.json         │   │ opens nothing                    │
└──────────────────────────────┘   └──────────────────────────────────┘

That split is the point: cataloguing is slow (~5s per asset) but happens rarely, while choosing is instant and happens constantly.

The manifest schema (sf-asset-library/1):

{
  "schema": "sf-asset-library/1",
  "project": "Fantasy RPG",
  "art_style": "Hand-painted 2D, saturated palette, thick outlines, 3/4 view",
  "generated": "2026-10-08",
  "assets": [
    {
      "file": "characters/heroes/knight_aldric.png",
      "name": "Aldric the Knight",
      "category": "character",
      "subcategory": "hero",
      "archetype": "tank",
      "tags": ["armoured", "sword", "front view", "heroic"],
      "desc": "Armoured human knight in silver plate with a red tabard, standing front-on."
    }
  ]
}

It's shaped for fast searching rather than for humans: one flat list (cheaper to scan than a tree), the same keys on every entry, faceted fields (category / subcategory / archetype / tags) to narrow by, and a one-sentence desc carrying the meaning. The top-level art_style matters more than it looks — Asset Director reads it and keeps every prompt it writes consistent with it, so a library generates in one coherent style.

Library Builder modes:

Mode	What it touches
manifest only (default)	Nothing. Reads the images, returns the JSON as text
organise into a copy	Writes a tidy, renamed copy to output_path; originals untouched
organise in place	Renames and moves your actual files

write_manifest is off by default, so the first run shows you the JSON without writing anything. Turn it on once you're happy, or paste the text in yourself.

Start in manifest only. Reorganising is genuinely useful on a folder of IMG_0021.png and final_v2 copy.png, but it moves real files — try it on a copy first.

Large libraries are processed in batches, not one session. batch_size (default 15) caps how many assets Claude handles per call — asking it to hold a whole large library open, compose one giant manifest, and write the file all in a single uninterrupted session is what used to blow up in turns and cost on libraries of 100+ assets, with nothing produced at the end. Each batch now only reads its own assets and replies with JSON; the node assembles and writes the manifest itself, so no file-writing tool is ever handed to Claude for this.

Reruns are incremental. With update_existing on (the default), the node reads the manifest already in the library and only catalogues files it doesn't yet describe. So the normal workflow is: drop new assets into the folder, run the same node against the same path, and only the new ones cost anything. Entries whose file has since been deleted are dropped automatically. Turn update_existing off to re-describe everything from scratch.

(Not available in organise into a copy mode, where the manifest holds post-rename paths that can't be matched against the untouched source folder.)

Separately, a hidden checkpoint (.sf_library_builder_checkpoint.json, removed automatically on success) covers a run that dies partway. Rerunning resumes — finished batches are skipped, not re-paid for.

If a batch's reply comes back cut off — the model ran past its reply length limit partway through describing a wordy set of assets — that batch is automatically retried as two smaller halves, repeatedly if needed, rather than failing the run. You'll see it in the log as Batch 7/7: the reply was cut off… Retrying as two batches of 5 and 6.

Using SF Claude Asset Director

Give it a folder of assets and a brief; it returns the references Claude chose and the prompt it wrote for them. Wire images and prompt straight into Nano Banana, Seedream, or anything else that takes an image batch and a text prompt.

It decides from a manifest, not from the pixels. Put a file in the library — assets.json by default, though any text or JSON works — describing what each asset is:

{"assets": [
  {"file": "knight.png", "desc": "Armoured knight character, heroic, front view"},
  {"file": "castle.png", "desc": "Stone castle environment, background location"}
]}

That keeps a large library cheap to work with: no image is opened unless you ask for it.

Input	Purpose
library_path	The asset folder. Point it at a Google Drive for Desktop sync folder to work off Drive
manifest	Descriptions file inside the library (default assets.json); falls back to filenames if absent
system_prompt	Standing rules — e.g. "Choose only character assets unless a background is asked for"
instruction	The brief for this run. Type it or wire a string in
max_images	Ceiling on how many references Claude may pick
pad_to_fit	On (default): scale each image onto a shared canvas, keeping aspect ratios. Off: stretch them all to one size
look_at_images	Off (default). On, Claude opens the files as well — better picks on an unlabelled library, but ~5s per image
seed	Not sent to Claude; change it to force a fresh choice rather than ComfyUI's cached one

Outputs are images (batch), prompt, and picked (the filenames chosen, for checking its work).

Why pad_to_fit exists: a ComfyUI image batch is one tensor, so every frame must share dimensions — and an asset library won't. Padding preserves aspect ratios at the cost of black bars; stretching avoids bars at the cost of distortion. Which is better depends on the model you're feeding.

Requires Claude Code installed and signed in, same as SF Claude Code.

Using SF Claude Prompt Coach

For tuning the system prompt of a prompt-writing node such as SF Claude Asset Director or SF Claude Code. Each run is one round:

1. Connect the system prompt you're tuning and the generated prompt it produced.
2. Connect the result and the references to the image_N slots (a new slot appears as you fill one) and say what each is in image_notes — image 1: the result from Nano Banana, image 2: style reference. Claude refers to images by the same numbers, so you can too in feedback: "image 1 lost the thick outlines from image 2".
3. Write your feedback. Claude treats it as the most important input.
4. Run. system_prompt is the revised version; analysis says what Claude saw, the root causes, and what it changed. Feed the revised prompt back into your prompt writer, generate again, and run the coach again with the new result.

Memory. Runs with the same session_name share one Claude Code session, so Claude remembers earlier rounds — what it changed, what you said, what got better or worse. Change the name to start fresh. Everything is also kept in output/sf_prompt_coach/<session_name>/: log.md (every round's inputs, analysis and revised prompt), system_prompt_v1.md, v2… and each round's images. The log never fades, unlike a long session, and Claude reads it when it needs older detail. To keep talking to it outside ComfyUI, run claude --resume <session_id> from that folder.

Nothing hidden. The node's own instructions are the coach_system_prompt text box, sent as Claude's whole system prompt; everything else Claude sees is the message built from your inputs, which is also written to the log. Edit the text in place, or connect your own text node to that input to override it, but keep the <analysis> / <system_prompt> reply format the node reads. Unless image_notes say otherwise, the built-in instructions treat image 1 as the generated result and images 2 and up as the references.

Runs on your Claude Code login like SF Claude Code; model defaults to Opus.

Using SF Claude Code

This node shells out to the Claude Code CLI, so it bills against your Claude subscription rather than an Anthropic API key.

Requirements: Claude Code must be installed and signed in on the machine running ComfyUI. The node searches your PATH plus the usual install locations, and gives a clear error if it can't find it.

Input	Purpose
prompt	What you want Claude to do
system_prompt	Shapes the reply, e.g. "Reply with only the prompt text, no preamble." Leave blank to skip
model	default, opus, sonnet, or haiku
timeout_seconds	Give up after this long (default 300)
seed	Not sent to Claude — change it to force a fresh reply instead of ComfyUI's cached one
image_1…	Connect an image and the next slot appears, up to 16

Worth knowing before you build a big batch around it:

• Roughly 5–6 seconds per call minimum. Claude Code is an agent that reads each image as a tool call, so it's slower than a direct vision API request.
• Subscription rate limits apply. Heavy batch use will hit them; SF LLM Chat with an API key is the pay-per-token alternative that won't.
• Not portable. Anyone else installing this pack needs their own Claude Code install and login for this particular node. Every other node in the pack is unaffected.

---

Stillfront/VertexAI

Generate images and videos using Google Cloud Vertex AI. Requires a Google Cloud project and Application Default Credentials.

Node	Description
SF VertexAI Imagen 3 Text to Image	Generate images from text using Google Imagen 3.0. Supports multiple aspect ratios, safety settings, and up to 4 images per run.
SF VertexAI Imagen 4 Text to Image	Generate images using the latest Imagen 4.0 model.
SF VertexAI Imagen 4 Upscale	Upscale images using Imagen 4.0.
SF VertexAI Nano Banana Pro	Image generation via the Nano Banana Pro model on Vertex AI.
SF VertexAI Nano Banana Pro Edit	Edit existing images using Nano Banana Pro on Vertex AI.
SF VertexAI Veo 3.1 Text to Video	Generate videos from text prompts using Google VEO 3.1 via Vertex AI.
SF VertexAI Veo 3.1 Image to Video	Animate a still image into a video using Google VEO 3.1 via Vertex AI.

---

Stillfront/WaveSpeed

Image and video generation nodes powered by the WaveSpeed AI API. All nodes require the SF WaveSpeed Client node to authenticate.

Setup

Connect an SF WaveSpeed Client node (enter your WaveSpeed API key) to any WaveSpeed generation node.

Cost badge

The newer nodes show an estimated cost per run in dollars in their header, e.g. ~$0.04/run, and update it as you change the settings — model, resolution, quality, duration, add-ons, the number of connected reference images and n. The prices come from WaveSpeed's model pages (web/js/sf_wavespeed_pricing.js); WaveSpeed notes those can lag, and the charge on the task is what you actually pay. A reference input carrying a batch counts as one image, so multi-image edits can be slightly underestimated.

Nodes marked (Legacy) are older nodes kept so existing workflows still load; use the node named without it for new work.

Video Generation

Node	Description
SF WaveSpeed Seedance 2.5	ByteDance Seedance 2.5 with native audio: text-to-video, image-to-video from a start frame and optional end frame, or reference-to-video from up to 30 reference images. In the prompt, "the character from image 1 enters the bar" means the image in slot image_1 — the node turns those mentions into Seedance's @Image N tags. 480p–4k, 4–30 s, billed per second. Outputs a VIDEO plus its URL.
SF WaveSpeed VEO 3.1 Text to Video	Google VEO 3.1 text-to-video generation.
SF WaveSpeed VEO 3.1 Image to Video	Google VEO 3.1 image-to-video animation.
SF WaveSpeed VEO 3.1 Reference to Video	VEO 3.1 video generation using a reference image.
SF WaveSpeed VEO 3.1 Fast Text to Video	Faster VEO 3.1 text-to-video variant.
SF WaveSpeed VEO 3.1 Fast Image to Video	Faster VEO 3.1 image-to-video variant.
SF WaveSpeed Sora 2 Text to Video	OpenAI Sora 2 text-to-video generation.
SF WaveSpeed Sora 2 Text to Video Pro	Sora 2 Pro — higher quality text-to-video.
SF WaveSpeed Sora 2 Image to Video	OpenAI Sora 2 image-to-video animation.
SF WaveSpeed Sora 2 Image to Video Pro	Sora 2 Pro — higher quality image-to-video.
SF WaveSpeed Wan 2.5 Text to Video	WAN 2.5 text-to-video generation.
SF WaveSpeed Wan 2.5 Text to Video Fast	WAN 2.5 faster text-to-video variant.
SF WaveSpeed Wan 2.5 Image to Video	WAN 2.5 image-to-video animation.
SF WaveSpeed Wan 2.5 Image to Video Fast	WAN 2.5 faster image-to-video variant.
SF WaveSpeed Wan 2.2 Animate	WAN 2.2 image animation.
SF WaveSpeed InfiniteTalk	Animate a portrait image with audio to create a talking-head video.
SF WaveSpeed InfiniteTalk Multi	InfiniteTalk with multiple reference inputs.

Image Generation

Node	Description
SF WaveSpeed GPT Image 2.5	OpenAI's GPT Image models through WaveSpeed, built to match ComfyUI's OpenAI GPT Image 2.5 partner node — see below.
SF WaveSpeed Nano Banana	Google's Nano Banana 2.1, Nano Banana 2 and Nano Banana Pro through WaveSpeed, generate and edit in one node, built to match ComfyUI's Nano Banana Pro (Google Gemini Image) partner node — see below.
SF WaveSpeed Seedream 5.0	ByteDance Seedream 5.0 Pro or Flash, generate and edit in one node. Up to 10 references, up to 2K. Flash is a flat $0.027 at any resolution.
SF WaveSpeed Outpaint Resizer	Turns one image into several resolutions without redrawing it: crop where that is enough, otherwise FLUX Fill, Bria GenFill or Bria Expand paints only the new strips. Optional torn-edge mask on every output — see below.
SF Banner Resizer	Reframes one finished image into several resolutions — crop where that is enough, otherwise GPT Image 2.5 recomposes it, as in the Art Pipeline Hub — see below.
SF WaveSpeed Nano Banana Text to Image (Legacy)	Nano Banana text-to-image generation.
SF WaveSpeed Nano Banana Edit (Legacy)	Edit images using the Nano Banana model.
SF WaveSpeed Nano Banana Pro Text to Image (Legacy)	Nano Banana Pro text-to-image.
SF WaveSpeed Nano Banana Pro Text to Image Multi (Legacy)	Nano Banana Pro with multiple inputs.
SF WaveSpeed Nano Banana Pro Text to Image Ultra (Legacy)	Nano Banana Pro Ultra quality variant.
SF WaveSpeed Nano Banana Pro Edit (Legacy)	Edit images with Nano Banana Pro.
SF WaveSpeed Nano Banana Pro Edit Multi (Legacy)	Nano Banana Pro edit with multiple inputs.
SF WaveSpeed Nano Banana Pro Edit Ultra (Legacy)	Nano Banana Pro edit Ultra quality variant.
SF WaveSpeed Qwen Text to Image	Qwen text-to-image generation.
SF WaveSpeed Qwen Edit	Edit images using Qwen.
SF WaveSpeed Qwen Edit Plus	Qwen Edit with extended capabilities.
SF WaveSpeed Qwen Edit LoRA	Qwen edit with LoRA support.
SF WaveSpeed Qwen Edit Plus LoRA	Qwen Edit Plus with LoRA support.
SF WaveSpeed Seedream V4	ByteDance Seedream V4 image generation.
SF WaveSpeed Seedream V4 Sequential	Seedream V4 sequential generation.
SF WaveSpeed Seedream V4 Edit	Edit images with Seedream V4.
SF WaveSpeed Seedream V4 Edit Sequential	Seedream V4 sequential editing.
SF WaveSpeed Wan 2.5 Text to Image	WAN 2.5 text-to-image generation.
SF WaveSpeed Wan 2.5 Image Edit	Edit images using WAN 2.5.
SF WaveSpeed Flux Kontext Dev	Flux Kontext Dev image generation.
SF WaveSpeed Flux Kontext Pro	Flux Kontext Pro image generation.
SF WaveSpeed Flux Kontext Max	Flux Kontext Max — highest quality variant.
SF WaveSpeed Flux ControlNet Union Pro 2	Flux image generation with ControlNet guidance.

These run in parallel

SF WaveSpeed GPT Image 2.5, SF WaveSpeed Nano Banana, SF WaveSpeed Seedream 5.0, SF WaveSpeed Seedance 2.5, and the Tripo P2, Tripo H3.1, Rodin 2.5 and Meshy 7.1 3D nodes run concurrently, the way ComfyUI's partner nodes do. Put several of them side by side and press Run: they all submit and wait together, so the run takes about as long as the slowest one rather than the sum of all of them.

They're asynchronous nodes, which ComfyUI starts as background tasks and keeps scheduling other work around — no change to ComfyUI is involved, so updates don't affect it. Only nodes that don't depend on each other overlap; WaveSpeed may also cap how many jobs one account runs at once.

The older SF WaveSpeed nodes still run one at a time.

Using SF WaveSpeed Nano Banana

Same controls as the partner node — prompt, model, aspect ratio, resolution, and an optional images input that switches it to editing (batch up to 14 references with Batch Images) — plus Nano Banana 2.1 and a few WaveSpeed extras. It bills your WaveSpeed key instead of ComfyUI credits. (Its internal id is still SFWaveSpeedNanoBananaPro, so older workflows keep loading.)

Model	WaveSpeed model
Nano Banana 2.1	google/nano-banana-2.1 — the default: ranks above Pro on the public leaderboards at about a third of the price
gemini-3-pro-image-preview	google/nano-banana-pro
Nano Banana 2 (Gemini 3.1 Flash Image)	google/nano-banana-2

Extras: n sends several requests at once (replacing the old Multi nodes); 8K on Pro runs on WaveSpeed's ultra endpoint (replacing the old Ultra nodes); the 1:4, 4:1, 1:8 and 8:1 aspect ratios work with 2.1 only; and web / image search (advanced inputs, paid add-ons) work with 2 and 2.1. Combinations a model doesn't support stop with an error instead of being sent.

What WaveSpeed's API doesn't offer, and so the node leaves out rather than fakes: the text output (the partner's second output, a written response from the model), response_modalities, the system prompt, and the files input. As on the partner node, seed isn't used by the model — change it to force a re-run.

Using SF WaveSpeed Outpaint Resizer

Turns one finished image into up to 8 sizes, edited in the Output sizes list on the node (width, height and a mode per row). Each row adds an output labelled with its size.

• auto (default) crops when that cuts away no more than auto_crop_limit (15%) of the picture, and outpaints otherwise. crop always scales and centre-crops; outpaint always paints new area. A size with the image's own shape is just resized. Crops and resizes are free.
• Outpainting never redraws the artwork: the chosen model — flux-fill (cleanest joins, best for strips above/below; clean_corners repaints FLUX's occasional fake signature), bria-genfill (best for strips left/right) or bria-expand (strong on squares) — paints only the new strips, the original pixels are pasted back with a soft seam, and each size is scaled from that. Sizes that share a shape share one paid generation.
• prompt is the whole prompt every model receives, sent as written; emptying it restores the default. bria-expand also has a visible negative_prompt.
• edge_mask (optional): connect a mask of a shaped edge, such as a torn-paper right edge, and pick mask_side. The whole shape is scaled to the full length of that side of every output and cut out, so the outputs carry transparency and Save Image writes transparent PNGs. The masked area of the input is filled in first, so no old edge pixels leak into the results. invert_mask flips it.

The plan output lists what happened to each size, the paid calls and the estimated cost; the badge shows the worst case, since auto rows may turn out free.

Using SF Banner Resizer

Turns one finished image into as many sizes as you list, one per line in resolutions (1920x1080, 800x450, …, up to 8). Each line adds an output labelled with its size. It works the way the Art Pipeline Hub's marketing pipeline makes its final sizes:

• Sizes within crop_threshold (default 8%) of the image's shape are cover-resized and centre- cropped. No AI, no cost.
• Every other size is recomposed by GPT Image 2.5: the image goes to GPT with reflow_prompt (the Hub's own, editable) at the nearest shape GPT supports, and GPT redraws it in that shape — extending the existing background and repositioning what is there rather than inventing new elements. The result is then cover-resized and centre-cropped to the exact pixels. Sizes that share a shape share one generation.

Because GPT redraws the whole picture there are no seams, but fine detail can shift slightly from the original. The plan output lists what was done for every size. The badge shows the worst case: one generation per distinct shape.

Using SF WaveSpeed GPT Image 2.5

Same interface as ComfyUI's partner node: pick a model and the controls below it change to what that model supports; connect reference images and it switches from generating to editing, with image slots appearing as you fill them. The difference is billing — it runs on your WaveSpeed key through SF WaveSpeed Client instead of ComfyUI credits.

Where it differs from the partner node, it's because WaveSpeed's API differs:

	Partner node	This node
Models	2.5 Flare, 2.5 Sunburst, 2, 1.5, 1	Same minus gpt-image-1, which WaveSpeed doesn't offer
Size (2 / 2.5)	Exact pixels, e.g. 1536x1024, or Custom	Aspect ratio (15 options) + resolution 1k / 2k / 4k
Background	All models	gpt-image-1.5 only — the only one WaveSpeed accepts it for
n (1–8)	One request	n parallel requests, returned as one batch; each billed separately
Inpainting mask	Yes	No — WaveSpeed's edit endpoints have no mask input
Reference images	Up to 16	Up to 16; 10 for gpt-image-1.5
Extras	—	output_format; input_fidelity when editing with 1.5

Like the partner node, seed isn't sent (the API has none) — change it to force a re-run. Transparent backgrounds keep their alpha channel; opaque results are ordinary RGB images.

3D Generation

Node	Description
SF WaveSpeed Tripo P2 Image to 3D	Tripo's P2 model — the same one behind ComfyUI's Tripo P2: Image to Model partner node — billed to your WaveSpeed account instead of ComfyUI credits. Quad or triangle topology, a target face count, texture quality from none to extreme, PBR, delighting, UVs, and seeds.
SF WaveSpeed Tripo H3.1 Image to 3D	Tripo's high-detail H3.1 model — about a fifth of P2's price on WaveSpeed. Quad or triangle topology, 1,000–2,000,000 faces, standard or detailed geometry and textures, PBR, and seeds. Same outputs as the P2 node.
SF WaveSpeed Rodin 2.5 Image to 3D	Hyper3D Rodin Gen-2.5 from 1–5 views. Quad budgets of 4K/8K/18K/50K faces or triangle budgets up to 500K, PBR or shaded materials, delighting, T/A-pose, and the HighPack add-on for 4K textures. Defaults to 18K quads in FBX. Same outputs as the Tripo nodes.
SF WaveSpeed Meshy 7.1 Image to 3D	Meshy 7.1 with standard, low-poly or smart-topology meshes, quad or triangle, a 100–300,000 polygon target, PBR, an optional texture image or prompt — and humanoid auto-rigging, which also returns walk and run cycles, plus an optional animation preset.

Outputs mirror the partner node, so they plug into Preview 3D and Save 3D directly: Tripo returns FBX when quad is on and GLB when it's off, so the matching output is populated and the other is empty. The file is also saved to output/3d/, with its path and CDN URL as strings.

P2 or H3.1? They're two different Tripo families. P2 is the low-poly line: it builds game-ready geometry at the face count you ask for, down to 48 faces, with clean quads — Tripo still labels it a preview release, so results can shift. H3.1 is the high-detail model, up to 2,000,000 faces, cheaper on WaveSpeed (≈$0.24 vs ≈$1.20 per model), but with a 1,000-face floor and a mesh reduced from a dense one rather than built low-poly. Put both nodes on the same image to compare — they run in parallel.

face_limit runs 48–50,000 for triangles or 48–25,000 for quads; -1 lets Tripo decide. It's a target, not a hard cap. Leave export_orientation unset if the model is headed for rigging or retexturing — Tripo warns those steps can come out mis-rotated without reporting an error.

Upscalers

Node	Description
SF WaveSpeed Image Upscaler	Upscale images via WaveSpeed AI.
SF WaveSpeed Runway Upscale	Upscale images using RunwayML via WaveSpeed.

---

Stillfront/Utils

Utility nodes for building and enhancing workflows.

Node	Description
SF Prompt List	Combine 2–50 text inputs into a single comma-separated string. Add or remove inputs using the inputcount control.
SF Qwen Resolution	Visual resolution preset selector with aspect ratio preview.
SF Text Analyzer	Analyze text content within a workflow.
SF Google Sheet Cell	Read a single cell from a publicly shared Google Sheet. Specify the sheet tab by GID, row by number (1-indexed), and column by letter (A, B, C, ...).
SF Google Sheet Range	Read a range of cells from a publicly shared Google Sheet and join them into a single string with a configurable delimiter. Supports multi-row, multi-column ranges.
SF Google Sheet Prompt Queue	Run a batch of prompts straight from a Google Sheet. Reads prompts from one column, skips any row you've marked as finished in a second column, and sends the rest downstream — the graph runs once per prompt.

Google Sheet nodes require the sheet to be shared as "Anyone with the link can view." The sheet tab GID is found in the browser URL after #gid= when you have that tab open.

Using SF Google Sheet Prompt Queue

Set your sheet up with prompts in one column and an empty column beside it for tracking:

	A	B
1	Prompt	Status
2	a red cat on a windowsill	done
3	a blue dog in the snow
4	a green bird mid-flight

With the defaults (prompt_col A, status_col B, skip_first_row on), a run sends rows 3 and 4 and skips row 2. Each prompt triggers a separate pass through the downstream graph.

• max_rows caps how many prompts go out per run — 10 by default.
• Marking is manual. Type anything into the status column — done, x, executed — and that row is skipped next time. Clear the cell and it gets queued again.
• Scanning stops at the first empty prompt cell, so anything below a gap is ignored.
• The sheet is re-read on every run, so edits you make in the browser are picked up automatically. Add rows or clear status cells and just hit Run again.
• Refresh sheet is optional — it reports how many prompts are pending without running the graph.

---

Interface improvements

Not nodes — small fixes to ComfyUI's own interface that come with the pack.

Folder picker in the Save workflow dialog

ComfyUI's Save / Save As dialog normally wants the whole path typed by hand — Stillfront/NewMoon/My Workflow — to save into a subfolder. With this pack installed, the dialog also shows your workflow folders as a tree: click a folder, type just the name, confirm.

• + New folder adds a folder at the selected level; it's created on disk when you save into it
• The dialog opens on the folder of the workflow you're editing, already selected
• Only the Save dialogs get the picker — Rename and Export, which reuse the same prompt, are left alone
• ComfyUI still does the actual saving, so tab tracking and overwrite warnings behave exactly as before

Turn it off under Settings → Stillfront → Workflows.

---

Requirements

• Python 3.10+
• ComfyUI
• See requirements.txt for full Python dependency list

License

MIT License — see LICENSE for details.