Skip to content

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.

Screenshot of AIYOU
Editor screenshot, 29 Sep 2026AIYOU ↗

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 · 6

The 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-byte MediaContent.tsx and a 139,191-byte BottomPanel.tsx; beside them sit ModelConfigPanel.tsx, StorageSettingsPanel.tsx, SmartSequenceDock.tsx, SonicStudio.tsx, StoryboardEditor.tsx and a 31,731-byte StoryboardVideoNode.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, with apiInterceptor/ and api/ handling the transport, and storage/ the persistence.
handlers/ and hooks/
handlers/useNodeActions.ts is 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.js at 80,707 bytes, db/index.js and db/migrate.js, three route files for connections, media and nodes, a logger, and model-config.json at 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 a frontend/ 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 KB DETAILED_REFACTOR_GUIDE.md, a 43 KB COMMERCIALIZATION_ROADMAP.md and 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 KB generate-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 localStorage and a cloud object bucket

    The 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
  1. 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 is yubowen123/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_at reading earlier than created_at is what a fork looks like when the upstream history predates the copy.

  2. 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.

  3. 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; a videos/ directory of twelve files and 71.8 MB of generated output; and a releases/ 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.json and pnpm-lock.yaml at the root, and both of them again inside server/. None of it breaks anything, and all of it is what a repository looks like when committing is also the backup strategy.

  4. 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) and WEB_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 in localStorage. A separate 31 KB BACKEND_ARCHITECTURE.md answers 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-byte index.js in plain JavaScript rather than the TypeScript the document had argued for, alongside db/ and three route files.

  5. 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.md documents 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 in localStorage under 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.

  6. 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.0 and v0.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.md is 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 →