promptGOAT is a native desktop studio that turns 22 hosted image, video, audio and LLM backends — plus your local ComfyUI — into a single visual workflow. Prompt it, generate it, edit it, stitch it, and track every cent it cost.
ONE-TIME FEE · LIFETIME LICENSE · BRING YOUR OWN KEYS
One generate button. Every model you already use.
Nine systems, one canvas. Each one is summarized here — and broken down in full detail in the deep dive below.
Image, video, audio, music, TTS and LLM services behind one Generate button — with queue lanes, progress, auto-generate loops and crash-safe recovery.
Drop in any workflow — promptGOAT flattens subgraphs, builds a settings panel on the card, randomizes seeds, binds reference images and streams live progress.
Media, prompt, note, model and folder cards on a zoomable canvas with full undo, grid snap, alignment tools — your whole project in one spatial view.
Presets in weighted categories — 7 weight tiers, locks, excludes, favorites — assembled live by the composer. Three pick modes turn one setup into a thousand coherent variations.
Watch folders sync live into a searchable media library that reads the prompt, seed and model out of every render — and files stay safe to move even while they're on a board.
Crop, trim, overlays and 40 keyframable effects with easing and presets — plus collage, stitch, weave, Ken Burns and crash zoom — all rendered in the background, pixel-identical to the preview.
Browse, install and publish community preset packs — voted on, human-moderated, integrity-checked twice, with donations that go straight to the author.
Pick one of 106 narrative structures across 11 categories, cast a 36-field character sheet, and let any LLM — or your own pen — fill a beat map that lands on the board as shot cards.
Every generation logged locally with prompt, settings, tokens, cost and energy — plus spend caps that stop a runaway loop before the job is even sent.
Faithful to the app: a prompt is a card, a model is a card, a folder is a card — and a generation lands as a card next to the cards that made it, joined by a colored lineage border. Every card carries reference-slot badges, a lock, resize handles and full undo.
API model card. Each hosted model exposes its real settings — aspect, resolution, duration, audio, format — right on the card, with color-coded reference slots, savable per-card presets and one Generate button. ComfyUI workflows get the same card with their own analyzed settings panel.
Slow tracking shot, rain-soaked neon market…
blurry, watermark, text
Media card. Outputs carry their complete generation record — model, reference log, prompts, timing and cost — so any result can be reproduced weeks later. The teal lineage border matches the prompt card that made it: which prompt made this is answered by looking, not searching.
Low-angle hero shot at golden hour, 35mm anamorphic, volumetric haze, film grain…
oversaturated, deformed hands, watermark
Prompt card. A fragment of prompt, not "the prompt": cards assigned to a slot join top-card-first, in stacking order — drag one above another and you've rewritten the sentence. Number them (SEQ 2/5) and the board fires a whole shot list in order, unattended.
portrait of a weathered sea captain, dramatic rim light, Kodak Portra 400, 85mm shallow depth…
Composer card. A live mirror of the preset engine's assembled prompt, color-coded by category — lighting gold, film stock blue, lens green — updating as you toggle chips. Set it to RANDOM and every generation rolls a fresh, weighted, still-on-brief variation.
Folder card. Points at a folder on disk and cycles through its images — fixed, increment or random. Assign it to a reference slot and every generation in a batch pulls the next reference automatically.
Vault card. A live, searchable window into your media library, right on the board — full-text search, sort by newest/oldest/largest, thumbnail sizing, and drag any result straight into a reference slot.
Shot 14 — swap to the low-noise LoRA pair, keep the harbour fog. Client loved take 3's palette; lock that grade preset before the next batch.
Note card. Plain text on the canvas — the thing you actually think in. Notes live next to the work they describe instead of in a doc nobody reopens.
File card. Any file on disk — name, size, type — pinned to the board. Move the file anywhere and the card follows it; delete it and the card cleans itself up. Nothing rots.
Section box. A resizable, labelled container that groups cards visually — the Script Builder drops one per act when it exports a storyboard to the board.
The complete breakdown of what ships with your license. Pick a system — everything listed is in the app today, not on a roadmap.
One Generate button in front of 22 hosted backends and your local hardware. The app orchestrates the queue; you stay in the creative loop.
Google's Nano Banana family (Nano Banana, Nano Banana 2, Nano Banana Pro) plus Imagen 4 Ultra & Fast, OpenAI GPT Image 2 / 1.5 / 1 / Mini, Kling Image v1.5 through v3 and o1, and Topaz upscaling & restoration.
Google Veo 3.1 (Standard / Fast / Lite), Kling v2.6 / v3 / v3-omni / video-o1, Runway, Luma, Minimax — plus Topaz Apollo (interpolation & slow-mo), Chronos, Astra 1 & 2 (generative upscale with creativity, sharpness and realism dials) and Aion.
ElevenLabs, Suno, Udio, MusicGen, OpenAI TTS and Fish Audio — including a built-in Fish voice browser card right on the board.
OpenAI's GPT-5 family, Anthropic Claude, Google Gemini, Groq and DeepSeek — plus fully local models through Ollama for zero-cost, private text work.
Every job gets a lane with elapsed time and live progress. Queue as many as you want, cancel any of them, or flip on auto-generate and let it run.
Chain prompt cards across the board into an ordered run — promptGOAT walks the queue and fires each prompt in sequence.
Per-job recovery records are replayed after a crash, and finished outputs are re-scanned from history — a restart never loses a paid generation.
Completions can auto-assign themselves as reference images for the next round — iterate image-to-image without leaving the canvas.
Per-job, per-session and per-month limits are checked before a job is sent — and hitting one halts auto-generate cleanly instead of looping on refusals. Leave a batch running overnight and it stops at the number you chose.
Local and API models in one searchable picker with favorites — switch a card from a hosted model to a local workflow in two clicks.
An infinite canvas where the prompt is a card, the model is a card, and the output appears next to the cards that made it. The largest system in the app — 45,000 lines — and the one everything else plugs into.
Prompts, models & workflows, media with waveforms, notes, files, folder-cyclers, live vault grids, a composer mirror and labelled section boxes — and every card serializes, locks and resizes.
Prompt cards assigned to a slot join top-card-first: the physical stacking order on your canvas is the order of the sentence. Drag a card above another and you've rewritten the prompt — no list, no priority field.
When a generation lands, the prompt, the references and the result get the same colored border. Three weeks later, "which prompt made this?" is answered by looking at the board, not searching a log.
Cards are assigned to a model's real inputs — image, video, audio, positive, negative — with badges instead of edges. The mental model of a corkboard, with the power of a node graph and none of the spaghetti.
Press generate and a working card appears immediately, tracks progress, and resolves into the finished media — or a visible failure. Jobs survive a crash or restart, so a paid two-minute render never just vanishes.
Number prompt cards 1…N and the board walks your storyboard unattended — the composer rolling fresh randomness and a folder card cycling reference images into every take.
Add, delete, move, resize and text edits all go through the undo stack — there is no back door — with smart merge coalescing so dragging a card is one Ctrl+Z, not forty.
Reverse, flip / mirror, rotate, Ken Burns, crash zoom, trim, frame removal, audio boost, bookmark export — every one renders in the background and drops the result next to the original.
Collage (manual and auto), image chase, video stitch and video weave compose whatever you have selected — the board already knows which files you mean, so there's no export/import round-trip.
Move, rename or delete a file on disk and every card re-points or cleans itself up through the undo stack — no dead grey rectangles, no broken thumbnails, ever.
30 px grid snap, alignment and distribution tools, marquee multi-select, section boxes for grouping, and level-of-detail zoom that keeps a 400-card board interactive.
Multiple named boards autosave continuously (plus daily snapshots) into a portable JSON format, your exact viewport is restored, and an interrupted sequential run picks up where it stopped.
A prompt stops being something you write and becomes something you configure — and then something you can roll dice on. Lighting is a part. Camera is a part. Every part is a preset; presets live in categories; the composer assembles the active ones into the prompt that fires.
FIXED is a normal prompt. INCREMENT sweeps a category one preset per generation — 47 lighting presets become 47 renders, one per setup, a parameter sweep for aesthetics. RANDOM rolls every category fresh: weighted, without replacement, as many picks as you set.
Very Rare ×0.1 to Always ×5, color-coded on the chip so you can see a category's odds at a glance. Lock a preset and no roll removes it; exclude one and no roll brings it back — control pins in a dice machine.
A pre-sentence reads as English ("Shot on" + Kodak Portra 400). A pre-prompt stamps every active preset and auto-letters them — [Character A], [Character B] — exactly the syntax multi-subject models want, without typing it a hundred times.
Flag a category as negatives and the composer and pick modes can never touch it. It becomes a shelf you reach for from the board — apply "Quality Baseline" or "Anatomy" to any card's negative field, one library per model family if you like.
Paste anything — a deterministic local parser splits JSON, lists or blocks, so an LLM can never drop one of your prompts. Generate with any model, cost shown first. Download from the Exchange. Or just type.
All four paths land in the same review table — favorite, weight, title and full prompt per row, with select-all / remove-selected — so nothing enters your library unseen.
A fresh install seeds 190 presets across 12 categories — subjects, lighting, film stock, camera, mood, a negative library — as editable user presets, not read-only built-ins. Hit RANDOM and generate inside the first thirty seconds.
Turn it on and every finished generation files itself onto the presets that made it. After a week, your library has taught itself what your entire aesthetic looks like — hover any chip to see it.
Live search across titles and prompt text, bulk move / delete with single-pass refreshes, undoable deletion that restores reference images too — proven on a 4,865-preset working library.
Preset saves are ordered, atomic and backed up with rotation — a crash mid-save can't eat months of curation. Export any category as a .goatpack file to back up, move or share.
Your preset library is the most valuable thing you build here — months of curation. The Exchange is how it stops being a private artefact: share it, version it, and get supported for it. A growing library of community packs is live right now — counted straight from the server, and growing as creators publish.
A .goatpack carries the category — name, color, grammar, pick count — and every preset's title, prompt, weight and favorite. A pack is words: never your reference images, file paths, or anything about your machine.
Add Category → Browse the Exchange: search, sort by Trending / Top rated / Newest / Most downloaded, and Load Pack pours the prompts into the same review table your own pastes use. A stranger's category is reviewed exactly like your own.
Share to Exchange… takes a title, description and tags — and tells you exactly what becomes public before the button goes live. Every pack is read by a human before it publishes, and the app says "queued for review", not "published", because that's the truth.
▲ / ▼ on every pack — one vote per license, enforced by the database itself. Voting again replaces your vote, and you can't vote for your own pack.
Publish v2 of your own pack and v1 is superseded — gone from browsing, still downloadable, so nobody's installed link ever rots. An author page gathers everything you've published under one name.
Your own Ko-fi, PayPal, Patreon, Buy Me a Coffee or GitHub Sponsors link travels with the pack — https-only and allow-listed. Fans pay you directly; promptGOAT never holds the money or takes a cut.
Every download is verified against the server's SHA-256 and re-validated locally with the same rules the server enforces — so a sideloaded pack that never met the server can't bypass anything.
No sign-up, no passwords, no account database to breach — the key you already own is your identity. It's the anti-spam design too: a hundred fake upvotes cost a hundred licenses.
A pack flagged as a negative library arrives as one — so an importer's first RANDOM roll can never concatenate "blurry, watermark" onto their positive prompt. There is a test for exactly this.
The default sort is a gravity curve — score over age — so the library can't calcify around whatever was uploaded first. And downloads count for what they are: votes cast with a click instead of an opinion.
A full writers' room inside the studio: pick from 106 story structures across 11 categories — 661 named, hinted beats — cast a 36-field character sheet, then let any LLM fill the beats, or write every word yourself.
Save the Cat to Kishōtenketsu, heist beat sheets to TikTok hooks to VSL sequences. The picker searches names, descriptions, categories and even beat names; every structure carries an honest description of what it's for and where it fails; starred ones float to the top. And the library keeps growing.
The shape is locked before the AI writes a word, becoming a scaffold of named, hinted beats — so a 15-beat run stays coherent from opening image to final image, where a chat window drifts by beat six.
Rename, insert, reorder and delete beats — the structure is a starting point, not a cage. Ask any beat for three genuinely different takes, laid side by side, and pick — instead of regenerating over the top of the last one.
Every beat breaks into 2–12 consecutive takes — framing, camera movement, action, light — written to cut together, with characters named and wardrobe, location and lighting held across the cuts. Each shot exports as its own prompt card, in order.
36 fields, three ways to fill each one: pick from 1,513 curated presets in 160 groups (builds, wounds, verbal tics, accents…), let the AI cast a crew that knows your beats, or type your own — and save it as a preset forever. One click compiles the fields into the visual block image models actually read.
Pin a portrait to a character and it exports as an image card beneath their card — one drag from any reference slot, so your lead has the same face in shot 1 and shot 40.
Every AI call is fed the other tabs: beats know the cast by name, shots know the lighting, style knows the story it serves. Fill All Tabs builds cast → beats → world → style in dependency order, each step feeding the next.
One click restores the entire script to before the last fill, 25 levels deep — and 40 timestamped revisions per script are kept on disk, so yesterday's draft (and the draft before the fill you regret) is one click away.
Dialogue written per character — in their speech style, vocabulary, tics and accent — with ~60 emotion and effect markers in Fish Audio's exact S1 / S2 syntax. Write the scene, get a performance.
Add to Board turns the script into sectioned, sequenced shot cards wired for the generation queue — and Pull from Board brings canvas edits back into the script. Or export Markdown and Fountain for the humans you work with.
Every other tool ends at the moment of generation — the file lands in outputs/ and becomes your problem. The vault is what happens next: a library that watches your folders, reads your renders, and opens a full editor on double-click.
New, changed and removed files sync incrementally in the background — debounced, diffed, no rebuild, and your scroll position never jumps while ComfyUI drops forty files into the folder you're culling.
The prompt, negative, model, seed, sampler, steps and CFG are pulled out of the image file itself — A1111 / Forge and ComfyUI formats, plus embedded EXIF dates — indexed, searchable, and shown in Info & Tags with one-click copy.
Type golden hour and get back every render you ever made with those words in the prompt — six months later, out of forty thousand files. A real FTS index over prompts, tags, models and paths, not a filename filter.
Right-click any image and the view is ranked by visual similarity — a 64-bit perceptual hash, robust to resizes and re-compression, computed on a worker thread, closest first. This is how you prune four thousand near-duplicates.
Videos play muted under your cursor — reviewing forty takes costs forty seconds. Rubber-band, Shift / Ctrl select, arrow-key cull or Ctrl+A, then move, send to board or delete hundreds in one click.
Deletion is undoable all session — Ctrl+Alt+Z brings back even a 200-file bulk delete. At shutdown, files go to the Recycle Bin from their original path (so restore actually restores), or are securely shredded if that's your policy.
Rate 0–5, favorite, and free-tag anything — annotations key on the file path, so they survive every rescan — and the search box finds those too.
Move or delete a file that's on a board and promptGOAT releases the OS handles first, then re-points or cleans up the cards — no Windows file locks, no broken references, and saved grades travel with the file.
Crop with rotation, flips and ratio presets — the source → export readout is computed by the exact code the exporter uses, so the number you read is the file you get. Trim frame-accurately. Composite text, images and shapes and burn them in.
Halation, bloom, VHS, pixel sort, slit-scan and 35 more on a 2-D keyframe timeline — five easing modes, record-the-curve-while-it-plays, randomize inside a band, hard-step strobe mode — plus a dedicated camera-shake editor with its own presets.
Hit apply and you're back on the board immediately, while a live card renders itself into the finished clip — with a real percentage, and a Cancel that lands within one frame instead of at the end.
Reorder the stack and it renders in exactly that order — dropping to a per-frame render rather than letting ffmpeg quietly rearrange your look. What you previewed is what you ship: the same code path, not "close to".
The hardest part of local AI — wrangling workflows — handled by the most heavily tested code in the app. Bring a workflow; get a clean settings panel.
Subgraphs are flattened by port signature, reroutes collapsed, and dangling references refused with a clear error instead of a silent bad render.
Each workflow gets an editable settings panel right on its board card — every control typed and bounded from ComfyUI's own schema (a sampler dropdown lists the samplers your server actually has), with a two-band zone bar showing the optimal range and the range you can get away with.
Reference images bind to the loaders that actually feed the output (SUPIR-aware), and unused loaders are pruned automatically.
Dual seed randomization per run — reproducible when you want it, fresh when you don't.
Fully async REST + WebSocket client: live progress, cancel, and force-reset. A wedged ComfyUI never wedges the studio.
If anything dies mid-run, outputs are recovered from ComfyUI's history and re-matched to their jobs with full metadata.
A curated download catalog — models, workflows, and ComfyUI itself — with queued downloads and atomic installs, wired into Settings and the first-run wizard.
New curated workflows and models ship to the promptgoat.studio catalog and simply appear in your hub — fresh tools keep arriving without an app update or a support ticket.
Point promptGOAT at your own workflow folders and drop in anything you build or download. Your workflows get the same analysis, settings panels and queueing as the curated ones — no approval, no gatekeeping.
promptGOAT detects your GPU and VRAM and recommends models that will actually run well on your hardware.
An assistant reads the workflow's structure — the raw graph is never uploaded — and returns human labels, plain-English explanations and safe ranges, every number re-validated against the node's real bounds, twice. Includes tuned heuristics for Wan 2.2's paired high/low-noise loaders.
An exotic custom node with no schema anywhere is marked as a best-effort guess instead of being presented as fact. The system knows the difference between what it knows and what it assumed — almost nothing does.
AI spend is real money. promptGOAT counts every cent — and, when you tell it to, stops you before the next one.
Per-generation, per-session and per-month limits — checked before the job is sent, so a generation that would breach a cap never costs anything. Hitting one hard-stops Auto Generate instead of looping on refusals.
This session: $2.40 · This month: $61.10 · 76% of your limit — amber at 75%, red at 90%, because the warning that changes behavior is the one that arrives before the block.
Prompt, references, resolution, tokens, cost, energy and full workflow settings logged for every single run — including failed runs, which frequently still bill you. A tracker that only counts successes is a tracker that lies.
Spend and energy over time, grouped by project, with CSV export for invoicing clients or expensing your experiments.
Provider prices change; your tables keep up. Override any rate — or paste a provider's pricing page and let the LLM assistant extract the numbers.
LLM batch operations show a cost estimate up front, so the decision is yours before the first token is billed.
A per-generation energy estimate alongside cost — know the footprint of your pipeline, not just the price.
API keys live in Windows' DPAPI-encrypted store — never in plain-text config files — and auth headers are scrubbed from every log.
All backend traffic is HTTPS with automatic upgrade of plain URLs; SQL is parameterized end to end.
Automatic retry with backoff and jitter on transient failures; hard failures surface immediately with the real error.
Instant key delivery, activation in seconds, a 7-day offline grace window, and self-service machine moves — no calls to support to switch PCs.
Rotating local logs and crash dumps stay on your machine unless you choose to share them.
The first-run wizard walks you through adding API keys for the services you use. Prefer fully local? It can install ComfyUI and starter models matched to your GPU instead.
Drop model cards, prompt cards and references onto the canvas. Wire a composer to your preset library — or install a community pack from the Exchange — and let weighted randomness feed you variations.
Queue generations across models, edit results in the built-in editor, stitch clips into sequences — and export knowing exactly what the whole thing cost.
promptGOAT is a native C++ application, not a web app in a wrapper. There is no promptGOAT cloud between you and your work.
No subscription, no tiers, no feature gates. One fee unlocks the entire studio — every backend, the board, the storyboard builder, the vault, the editor, the preset engine — for life.
Limited-time launch price · yours forever · bring your own keys
Launch pricing — the price will go up. The license never expires, whenever you buy.
Because promptGOAT doesn't resell compute. You bring your own API keys and pay OpenAI, Google, Kling and the rest directly, at their prices, with zero markup — and local ComfyUI generation costs nothing at all. There's no usage for us to meter, so there's no reason to rent you your own studio.
One activation per license, enforced fairly: moving machines is self-service (up to 3 moves per month), and a 7-day offline grace window means travel never locks you out. Requires Windows 10/11 (64-bit); a GPU is only needed for local generation. The $20 launch price is temporary — the license you buy at any price is forever.
Your entire AI pipeline — hosted and local — on one canvas, on your machine.
Pay once. Own it forever.