# SceneQueue: Turn ComfyUI Prompt Batches into Editable Visual Storyboards
Generating a batch of images is easy. Maintaining that batch after the first generation is not.
When a sequence is stored as a large JSON workflow or a long prompt file, even a small change becomes tedious:
- find the prompt associated with the image;
- edit it outside the gallery;
- rebuild or re-queue part of the workflow;
- remember which version produced which image;
- manually create transition prompts when the sequence needs another frame.
This becomes especially painful when working on manga pages, storyboards, character sequences, visual narratives, or any project where the order of the images matters.
I built **SceneQueue** to make the generated batch itself editable.
> **GitHub:** https://github.com/al4xdev/scenequeue
> **Docker:** ghcr.io/al4xdev/scenequeue:latest
---
## From a prompt list to a visual sequence
*
Caption: The Last Delivery — an eight-frame manga demo included with SceneQueue.
SceneQueue sits next to ComfyUI and represents prompts as ordered frames. You generate the complete batch normally, but the result is displayed as a persistent visual storyboard rather than a disposable output grid.
From the gallery, you can:
- open any generated frame;
- inspect its original template and resolved prompt;
- edit the prompt and re-queue the same frame;
- compare an AI suggestion against the original prompt;
- keep previous prompt revisions;
- insert a new frame before or after an existing image;
- retry failed frames without rebuilding the batch;
- extend the sequence while preserving its order.
The objective is not to replace ComfyUI. ComfyUI remains responsible for image generation. SceneQueue provides a workflow for managing the sequence around it.
---
## Editing the batch from the gallery
Caption: Selecting an ordered prompt database and queueing the complete batch.
Caption: The generated batch becomes a visual album while preserving frame order.
The first demo shows SceneQueue running in a mobile browser.
The interface exposes generated sessions as albums. Each album retains its prompt database, subject configuration, frame order, generation status, and resulting images.
Instead of returning to a JSON file when one frame needs adjustment, I can open that image, modify its prompt, and re-queue it directly. The replacement keeps the same position in the sequence.
This makes iteration much easier because the image and its prompt remain connected.
Caption: A generated frame retains its resolved prompt and can be edited or re-queued in place.
SceneQueue also separates reusable prompt components:
- subject;
- appearance;
- wardrobe;
- pose;
- scene;
- style.
Prompt templates can reference these values through placeholders such as {subject}, {appearance}, and {scene}. The same ordered sequence can therefore be regenerated with a different character, location, style, or wardrobe without rewriting every frame manually.
Caption: Ordered prompt templates with reusable placeholders and per-segment insertion controls.
---
## Prompt editing with visible AI suggestions
Caption: The assistant highlights its changes before the prompt is accepted and re-queued.
The optional prompt assistant uses OpenRouter, but it does not silently replace the prompt.
You provide a simple editing instruction, such as:
> Dark hair
SceneQueue displays:
1. the original prompt;
2. the proposed prompt;
3. a highlighted diff showing what changed.
The suggestion remains editable before it is applied. You can discard it, adjust it with another instruction, or accept it and re-queue the frame.
This review step is important to me. An assistant is useful for transforming prompts, but the user should still see exactly what will be sent to the image model.
OpenRouter is optional. Prompt editing, batch generation, gallery management, retries, and manual insertion continue to work without an API key.
---
## Generating frames before or after an image
The second demo shows the feature that motivated much of the project: **AI Insert Before** and **AI Insert After**.
Starting from any frame, I can describe what should happen next and request between one and five new frames. SceneQueue sends the assistant the surrounding prompts as context and asks it to create a connected sequence.
Caption: New manual or AI-assisted frames can be inserted before or after any selected image.
For example:
> She arrives at the station and notices that something is wrong.
Caption: A short instruction describes the action or transition for the new sequence.
SceneQueue can generate three continuation prompts, insert them after the selected frame, preserve the indices of the remaining sequence, and immediately queue the new images in ComfyUI.
Caption: SceneQueue generates the contextual prompts and inserts them into the ordered database.
Caption: The inserted frames appear in their new positions and are queued immediately in ComfyUI.
Caption: A generated continuation frame remains connected to its prompt and surrounding sequence.
The assistant can use:
- the preceding frame;
- the succeeding frame, when one exists;
- the requested action or transition;
- the position of the new frame within a multi-frame insertion;
- the existing placeholders and visual configuration.
This does not guarantee perfect character consistency—that still depends heavily on the selected model, LoRAs, seeds, references, and workflow—but it removes much of the mechanical work involved in extending a prompt sequence.
Every generated prompt is stored in the prompt database and remains editable afterward.
---
## ComfyUI integration
SceneQueue communicates with ComfyUI through its HTTP API and WebSocket interface.
Caption: ComfyUI connection, workflow mapping, resolution, models, and sampling controls are configured from the frontend.
The included workflow uses standard ComfyUI nodes:
- CheckpointLoaderSimple;
- CLIPTextEncode;
- EmptyLatentImage;
- KSampler;
- LatentUpscale;
- VAEDecode;
- SaveImage.
Checkpoints and LoRAs are discovered dynamically from the connected ComfyUI instance. The selected checkpoint, LoRAs, resolution, sampler, scheduler, step count, CFG, denoise, and optional high-resolution pass can all be changed from the web interface.
Users can also replace the bundled API workflow with their own exported ComfyUI workflow and configure which node receives the positive prompt.
Generated files are synchronized back into the SceneQueue gallery. When both applications use the same filesystem, SceneQueue attempts to use hard links first to avoid duplicating large image files.
---
## Included manga demo
The repository contains a safe-for-work eight-frame manga preset called **The Last Delivery**.
It demonstrates:
- stable subject and wardrobe placeholders;
- establishing and reaction shots;
- visual reveals;
- action frames;
- a closing shot;
- continuity across an ordered micro-story.
The preset is intentionally model-neutral. It provides the narrative and compositional structure, while the final appearance depends on the checkpoint, LoRAs, and sampling configuration selected in your ComfyUI installation.
---
## Installation
SceneQueue is local-first. Prompts, API credentials, workflow edits, generated images, and configuration are stored under .data/ and are not committed to the repository.
### Using Docker
```bash
docker run -d \
--name scenequeue \
--restart unless-stopped \
-p 8889:8889 \
--add-host host.docker.internal:host-gateway \
-v scenequeue-data:/app/.data \
ghcr.io/al4xdev/scenequeue:latest
```
Open:
```text
```
If ComfyUI is running directly on the host, use this URL in SceneQueue Settings:
```text
http://host.docker.internal:8188
```
Change 8188 if your ComfyUI instance uses another port.
### Running from source
Requirements:
- Python 3.11 or newer;
- uv;
- a running ComfyUI instance.
```bash
git clone https://github.com/al4xdev/scenequeue.git
cd scenequeue
./start.sh
```
Then open:
```text
```
---
## Technical stack
SceneQueue is intentionally small and dependency-light:
- FastAPI backend;
- vanilla JavaScript frontend;
- ComfyUI HTTP API and WebSocket events;
- optional OpenRouter prompt assistant;
- atomic JSON persistence;
- installable PWA interface;
- Docker images for AMD64 and ARM64;
- GitHub Actions CI;
- Ruff, pytest, and mypy in strict mode.
There is no authentication layer. SceneQueue should remain bound to localhost or a trusted private network.
---
## Why I released it
Most image-generation tools focus on creating the first result. My frustration started after that point.
Once a batch becomes a sequence, the important questions change:
- Which prompt produced this frame?
- What changed between these two revisions?
- How do I insert a transition without rebuilding everything?
- How do I extend the story while keeping the surrounding context?
- How do I regenerate one image without losing its position?
SceneQueue is my attempt to make that iteration loop visible and manageable.
The project is open source under the MIT license. Feedback, bug reports, workflow examples, and contributions are welcome: