StoryGen Atelier: turning storyboard frames into a stitched video

The interpolation chain is the actual idea

StoryGen Atelier is an AI-assisted storyboard and video generation tool, and the part of it that matters is the way it turns a set of still images into a moving sequence.

The project calls this an Interpolation Chain with a sliding window strategy, and the README is clear that the process is fully automated and consists of three phases.

The first is transition analysis. The system iterates through the storyboard list with a sliding window and processes each pair of adjacent shots, Shot A to Shot B. It calls Gemini to analyse the visual content of both frames, and Gemini outputs a specific Transition Prompt and a suggested Duration describing how to move smoothly from the first frame to the second. The example given in the README is the kind of instruction you would give a camera operator, a slow dolly zoom in while panning right.

The second phase is clip generation with Vertex AI Veo, and it runs in parallel. For each pair of shots, the Gemini prompt plus Shot A as the start frame and Shot B as the end frame are sent to Veo to generate a connecting clip. For the final shot, the system generates a separate closing shot with a prompt like holding on the final frame with a gentle cinematic finish, which gives the story a static or subtle ending rather than an abrupt cut.

The third phase is assembly with ffmpeg, and it is deliberately cheap. All the generated mp4 clips are written to a list in chronological order, and the merge uses the concat protocol in copy mode with -c copy, so the video streams are copied rather than re-encoded. The output is a file called full_story_xxx.mp4.

The design consequence is worth stating plainly. The motion between your frames is not an animation of your images, it is newly generated footage that was asked to land on them, which is why a transition prompt matters so much.

Two models, one for text and images and one for video

The model split is what shapes the requirements.

Gemini does the text and the images. The Gemini text model generates storyboard scripts, and the Gemini image model generates the frames, with support for custom styles and shot counts. The style examples in the README cover anime, cyberpunk, Ghibli style, realism and Chinese ink, and there is an example gallery of frames exported from local data.

Vertex AI Veo does the video. That is the part with a heavier dependency, because the requirements say you must have a Google Cloud project with the Vertex AI API enabled, since the Veo model is used for video generation. The environment file names the model explicitly as veo-3.1-generate-preview, along with the project id and a location of us-central1.

The Gemini side needs a plain API key, and the environment file shows the two model names, gemini-3-pro-preview for text and gemini-3-pro-image-preview for images.

The README also has a prompt guide, a built-in guide/VideoGenerationPromptGuide.md for model prompting reference, and the guide/ directory in the project layout holds the prompt guides. That file matters more than it sounds, because the transition prompts are what steer Veo, and the quality of the final video depends on how well those instructions are written.

The pipeline is event driven rather than a single call. The feature list names a Logs Dashboard with video logs and storyboard logs persisted in SQLite, supporting viewing, exporting and clearing, and a Gallery for saving, loading and deleting generated storyboards and videos. So a run produces artefacts that survive the request that made them.

MiniMax as an alternative provider, switched by one key

The environment configuration shows a second set of providers layered on top of the Google ones, and the switching logic is unusually clean.

The .env example has three provider switches: LLM_PROVIDER, IMAGE_PROVIDER and VIDEO_PROVIDER. Setting LLM_PROVIDER to minimax routes the storyboard and transition text to MiniMax-M3. Setting IMAGE_PROVIDER to minimax uses image-01 for the storyboard frames. Setting VIDEO_PROVIDER to minimax generates the clips with MiniMax-H3 instead of Vertex Veo.

The README states the rule plainly: MiniMax is optional, and leaving LLM_PROVIDER, IMAGE_PROVIDER and VIDEO_PROVIDER empty keeps Gemini and Vertex, with image and video switching to MiniMax automatically once MINIMAX_API_KEY is set.

That last detail is the part to know before you deploy. The switch is not only explicit configuration; setting the API key alone is enough to move the image and video paths. If you are experimenting with one provider and do not realise the key is present, you may find your clips coming from a different model than you expected. The region handling is per provider, with MINIMAX_API_REGION=global_en pointing at api.minimax.io and cn_zh pointing at api.minimaxi.com, and the README notes that backend/.env.example lists the remaining knobs, including M3 thinking control, regional and host overrides, duration and ratio, and a callback URL.

The other two providers are configured the same way, with MINIMAX_TEXT_MODEL=MiniMax-M3, MINIMAX_IMAGE_MODEL=image-01, MINIMAX_VIDEO_MODEL=MiniMax-H3 and MINIMAX_VIDEO_RESOLUTION=2K.

The start script, and the failure it was written to fix

The recommended setup is a single script from the root directory, and the README explains the reasoning behind it in unusual detail.

# Grant execution permission (only needed once)
chmod +x start_servers.sh
# Start servers
./start_servers.sh

On macOS there is a double-clickable start_macos.command. The script checks for Node.js 18 and npm, warns when ffmpeg is missing, installs the backend and frontend dependencies automatically on the first run, starts the backend API on port 3005 and the frontend on port 5180, and waits until both ports answer before printing the URL. Logs go to backend.log and frontend.log.

The last paragraph of that section is the interesting part, because it explains what was wrong with the previous version. On failure the script prints the reason plus the tail of the failing log and keeps the window open, because the old script backgrounded both servers and exited, so a missing dependency surfaced only as a window that flashed and closed, with a Cannot find module 'express' error staying hidden in the log.

That is a small but revealing piece of engineering. The failure mode of a backgrounded dev script is that the error is written to a file nobody is watching, and the fix is to keep the process alive and print the tail of the log.

The manual path is the standard one, running the backend and the frontend separately:

cd backend
npm install
cp .env.example .env  # And fill in real keys
npm run dev           # Or npm start

and the frontend on its default port 5180 with npm install and npm run dev, and a production build with cd frontend and npm run build. The directory layout matches: backend/ for the Node.js and Express API, frontend/ for React, Vite and Mantine, guide/ for the prompt guides, and exampleImg/ for the example frames.

A full stack, and what it does not do

The tech stack is small enough to state in full. The frontend is React with Vite and Mantine UI as the component library. The backend is Node.js with Express, better-sqlite3 for high-performance data storage, and fluent-ffmpeg for video stitching. The AI services are Google Gemini for text and image, and Google Vertex AI Veo for video.

The project is Apache-2.0 licensed, the primary language is JavaScript, and the last push to the main branch was on 2026-09-17, with no GitHub releases.

The top level entries show a small footprint: a.gitignore, the LICENSE, three README variants, backend/, exampleImg/, frontend/, guide/, and three shell or command files, start_macos.command, start_servers.sh and stop_servers.sh.

What the tool does not do is worth naming, because the feature list is a list of generation features and not of editing features. There is no timeline, no trimming, no per-clip regeneration loop, and no way to hold a specific shot while redoing its transition. The storyboard is generated, the clips are generated, and the video is assembled. The Logs Dashboard gives you a record of what happened, and the Gallery lets you keep and delete results, and those are the two places where the tool acknowledges that a generated result might not be the one you want.

That is a coherent scope for a pipeline tool rather than an editor, but it means the intended use is a first cut that you either accept or regenerate, not a piece you refine.

Editorial conclusion

Adopt StoryGen Atelier if your workflow starts from a written script and you want a narrated video built from generated still frames, because the interpolation chain is the part worth having, since it gives each transition a written camera move instead of a generic dissolve. Do not adopt it if you need frames to match exactly across cuts, because the intermediate clips are generated by a video model rather than derived from the stills, so the composition can drift. Before you set it up, get a Gemini key and a Google Cloud project with the Vertex AI API enabled, and note that the MiniMax provider switches are driven by the presence of an API key, so leaving it unset keeps the Gemini and Vertex path.

Frequently asked questions

Official sources

1. 0xsline/StoryGen-Atelier on GitHub
2. Issues
3. License: Apache-2.0
4. README