AIYOU
A canvas of twelve nodes that carries an idea to a finished short drama: outline, episode split, character sheets, storyboards, keyframes, then video — with a provider layer that keeps the run alive by falling back down a priority list when a model’s quota runs out.

What it is
A node-based studio for producing AI short dramas, shipped as a React web app with a Tauri desktop shell. Twelve node types cover the pipeline — outline, episode split, character design (a three-view sheet plus a nine-grid expression sheet), storyboard script, 2K storyboard images, Sora prompt assembly, per-shot video, episode analysis — and you build a run by dragging nodes onto a canvas and connecting them. Generation goes through a provider layer with a per-category priority list and automatic demotion, so a quota error or a run of failures moves the work to the next model instead of ending it. The README states the cost of the sample episode as under two yuan.
Who built itThe repository is owned by this account, which has two commits in it. 131 of the 139 are attributed to a different account, superman32432432, under user@example.com — an address reserved for examples rather than a mailbox — and three to a third contributor. The README is written in the first person singular and reads as one person’s work — including the part where they grade it. The account that owns the repository has 12 public repositories and 8 followers.
How it is put together
The parts · 6The pipeline is the interface. Rather than a wizard that walks a creator through stages, the product is a canvas: each stage of production is a node, a run is a graph you draw, and outputs travel along the connections, so the same twelve node types compose into a straight line or into branches that generate three versions of a shot. Each node type carries its own prompt builder and its own provider adapters, which is what keeps the twelve stages from turning into twelve special cases in the UI — the differences live in services/promptBuilders/ and the provider folders, and the canvas only knows about nodes and edges. Underneath, two layers do the unglamorous work: a provider layer that holds a priority list per media category and demotes a model that fails or runs out, and a storage layer that decides where the images and video end up. The second of those is the part of the design the repository never settled — it is specified three different ways across five documents, and the tree contains the evidence of all three.
- components/ and components/nodes/
- The canvas and its parts.
components/nodes/is six files including a 196,800-byteMediaContent.tsxand a 139,191-byteBottomPanel.tsx; beside them sitModelConfigPanel.tsx,StorageSettingsPanel.tsx,SmartSequenceDock.tsx,SonicStudio.tsx,StoryboardEditor.tsxand a 31,731-byteStoryboardVideoNode.tsx— the panels a production tool needs once the graph is real. - services/
- Where the twelve node types actually differ:
nodes/holds the implementations,promptBuilders/the per-stage prompt assembly, and four provider folders —soraProviders/,llmProviders/,videoProviders/,videoPlatforms/— sit behind them, withapiInterceptor/andapi/handling the transport, andstorage/the persistence. - handlers/ and hooks/
handlers/useNodeActions.tsis 149,348 bytes in a single file — the node graph’s command surface — next to workflow and keyboard handlers;hooks/holds nine smaller hooks for canvas state, history, node maps, node operations, viewport culling and window size.- server/
- A local Express service, ten source files:
index.jsat 80,707 bytes,db/index.jsanddb/migrate.js, three route files for connections, media and nodes, a logger, andmodel-config.jsonat 8,953 bytes. The README configures it against Tencent COS; the architecture document specifies SQLite and local folders; both are in the tree. - src-tauri/ and the front end
- A Tauri shell so the same React app runs as a desktop application, with 52 icon files under
src-tauri/icons. The front end itself is React 19.2 with TypeScript 5.8, Vite 6.2, Zustand for state, React Flow for the graph, and Tailwind — and despite the README’s architecture section advertising afrontend/directory, there is no such directory: everything sits at the repository root. - docs/, the root markdown and .claude/skills/
- Nineteen files under
docs/and nine more at the root — a 49 KBDETAILED_REFACTOR_GUIDE.md, a 43 KBCOMMERCIALIZATION_ROADMAP.mdand a 34 KB plan to go with it, a 32 KB node-standardisation write-up, and a 28 KB style guide for the genre — plus a 23 KBgenerate-doc.js..claude/skills/holds the project’s own 16,595-byte node-builder skill and a vendored interface skill whose data folder includes a 96,553-byte style table and platform adapters for fourteen coding tools.
Choices, and what they beat
A local server rather than calling the model APIs from the front end over the arrangement the project started with, where the browser held the keys and made the calls
The backend architecture document opens by naming that as the thing being replaced, and gives its reasons for the two pieces it introduces: Node.js with Express and TypeScript because the stack then matches the front end and full-stack work stays in one language, and SQLite because it needs no separate database service, is a single file to back up, and supports transactions.
Generated media goes into a folder the user picks over browser
localStorageand a cloud object bucketThe storage design states the goal directly — store every generated image and video in a user-chosen folder, organised by canvas and node type — and the README gives the reason it matters to the audience it is aimed at: local deployment, so a creator’s material stays private. The migration plan exists because everything generated before that change was sitting in the browser.
A failing model is replaced rather than reported over surfacing the error and letting the run stop
The fallback guide names the triggers it treats as routine — quota exhausted, HTTP 429 and 503, billing errors, three consecutive failures — and the recovery rule: a model that fails three times is marked unavailable and skipped, then tried again an hour later. Every substitution raises a notification naming both models, so the switch is visible without being an interruption.
Twelve node types instead of one flow over a fixed pipeline that runs the stages in order
The README states the composition as the product’s advantage — connect nodes by dragging and generation follows, in the words it uses, like building with blocks — and the tree reflects it: each node type has its own implementation, its own prompt builder and its own provider adapter, which is the cost of making the order something the user decides.
Read fromdocs/BACKEND_ARCHITECTURE.md (31,874 characters) and docs/LOCAL_STORAGE_DESIGN.md (19,406), MODEL_FALLBACK_GUIDE.md, README.md, docs/SERVICE_LAYER_COMPLETED.md, server/README.md and the complete 999-file tree with sizes.
Build log
6 stages- 01
The worklist pointed at a fork
The gallery entry was
lay950822/AIYOU: a fork, with no stars, one public repository on the account and a bio pointing at a Chinese domain. The upstream isyubowen123/AIYOU_open-ai-video-drama-generator— 136 stars and 49 forks, created 2026-02-04, last pushed 2026-03-05 — and both copies carry the same description, the same 110-versus-139 commits from the same authoring account, and the same example address. A secondary source that lists a fork as if it were the project is the failure this archive is built to catch: the record is filed against the origin, and the worklist entry is marked with where the file really lives. The fork also explains its own anomaly, which had looked like a GitHub bug —pushed_atreading earlier thancreated_atis what a fork looks like when the upstream history predates the copy. - 02
The author grades it 30 out of 100
Most READMEs sell. This one audits. Beneath the feature tables and the badges, the author writes that the project existed to train their own vibe-coding ability, that it is therefore incomplete and has plenty of small bugs, and then marks it: 30 out of 100 for the system, 50 for the prompts, on the grounds that the prompts are the part worth anything. The conclusion is stated as plainly — that it can serve as a tool for conversation and study, and not as a productivity tool — followed by the announcement of a rewrite intended to close the gaps that this one left open, and an open invitation for practitioners to argue with it. Two things about that are worth the archive’s attention: the score is attached to a repository with 136 stars and 49 forks, and it is the author’s own, which is the only kind of self-assessment this archive can quote without checking anything.
- 03
What six months of build artefacts weigh
GitHub reports the repository at 126 MB. The source is a small fraction of that. Committed into the tree are
npm-cache/_cacache, 628 files and 157 MB of npm’s own content-addressable cache — single blobs of eight megabytes, sitting under a folder that is named as what it is; avideos/directory of twelve files and 71.8 MB of generated output; and areleases/directory holding one packaged build of 15.8 MB. The same instinct shows up in the dependency metadata: the project has four lockfiles —package-lock.jsonandpnpm-lock.yamlat the root, and both of them again insideserver/. None of it breaks anything, and all of it is what a repository looks like when committing is also the backup strategy. - 04
The storage layer was designed five times
docs/holds nineteen files, and the ones about where generated media lives are:LOCAL_STORAGE_DESIGN.md(19 KB),LOCAL_STORAGE_PLAN_V2.md(41 KB),LOCAL_STORAGE_MIGRATION_PLAN.md(44 KB),LOCAL_STORAGE_IMPLEMENTATION_GUIDE.md(10 KB) andWEB_STORAGE_OPTIMIZATION_PLAN.md(29 KB) — a design, a second design, a migration between them, a guide to carrying it out, and an optimisation pass. The second design picks the File System Access API so a browser app can write images and video into a folder the user chooses, laid out as one directory per canvas and one subdirectory per node type, with a metadata index file at the root and a migration path for everything currently inlocalStorage. A separate 31 KBBACKEND_ARCHITECTURE.mdanswers the same question the other way, by moving the work to a local Express server with SQLite; its own opening line describes the change as replacing an architecture that called the AI APIs directly from the front end. Both documents are still in the tree, and the tree shows which one shipped:server/exists, with a 80,707-byteindex.jsin plain JavaScript rather than the TypeScript the document had argued for, alongsidedb/and three route files. - 05
Model fallback treated as a feature rather than an error path
The parts of this project that would be an afternoon’s work in most codebases have a guide of their own.
MODEL_FALLBACK_GUIDE.mddocuments a priority list per media category — image, text, video, audio — that the user reorders in a settings tab, and beneath it an automatic demotion: quota exhausted, HTTP 429 or 503, or three consecutive failures, and the request moves to the next model down. Three failures marks a model unavailable and it is skipped; an hour later it is tried again. Health is shown per model as success rate, consecutive failures and the timestamp of the last error, the counters live inlocalStorageunder one key, and every switch raises a notification that names both the model that ran out and the one that took over. It is a small piece of engineering with a large effect on what the product feels like: a canvas full of long-running generations that does not stop when one vendor’s quota does. - 06
One person’s build log, as far as the record can see
The history is 139 commits — 58 in January, 78 in February and 3 in March — of which 80 carry a model trailer: Claude Sonnet 4.5 seventy-four times, Opus 4.5 and Opus 4.6 three times each. The oldest commit is dated 2026-01-06, a month before the repository existed, so the work began before there was anywhere public to put it. 131 commits carry the example address
user@example.com, which is why the contributor list reads as three accounts rather than the one the README sounds like. Two tags,v0.1.0andv0.1.1, and no releases. The community left one pull request — a custom Gemini base URL, closed with no comment — and one issue, which is open and asks whether there is a video tutorial, adding that the author’s correspondent has no idea how to use it. The project also brought its own agent instructions:.claude/skills/aiyou-node-builder.mdis 16,595 bytes on how to add a node to this codebase, and a vendored interface skill ships adapters for fourteen different coding tools. Nothing has been pushed since 2026-03-05.
Adjacent records
All records →No. 047
AI Comic Builder
A self-hosted pipeline that takes a script to a finished animated episode: parse it, extract the characters, generate four-view reference sheets, storyboard it, generate keyframes per shot, then interpolate the video and burn in subtitles.
No. 033
MiroFish
A prediction engine that builds a parallel world of hundreds of AI agents out of a document you upload, then runs it forward to see what happens next.
No. 042
Neko Master
A self-hosted dashboard that shows where a home gateway’s traffic actually goes — by domain, by IP, by proxy node — reading it live from Clash, mihomo or OpenClash over WebSocket.