cs-board review: turning a reference voice and Chinese copy into whiteboard animation

What cs-board actually produces, and who is standing in front of it

cs-board, titled Whiteboard Voice-Picture Workshop, takes three inputs: a reference audio clip, Chinese copy, and optionally a style image plus character references. It returns an MP4 of whiteboard animation, meaning illustrations that are drawn on screen in strokes while narration plays. The README's own flow diagram is short: reference audio plus Chinese copy plus optional style or character references, then voice cloning, content decomposition, unified imagery, animation rendering, subtitle and audio-video compositing, then an MP4.

The intended user is someone producing explainer or story content in Chinese who already has a voice to imitate and does not want the source audio to leave the machine. The README states that materials, keys, job history and finished videos stay local by default, and that a team on the same LAN can share one production queue. That is a specific audience: a small studio or an internal content team with a GPU box running IndexTTS, not a solo user who wants to type a prompt into a website.

Three production modes are documented. Standard production splits the copy into scenes and generates unified imagery with whiteboard drawing. Custom reference adds one style image and one to five characters, each with one to three reference images, so a fixed IP or brand look carries through the whole video. Dynamic infographic aligns narration into a phrase timetable first, then reveals content elements only after the corresponding speech begins, which the README frames as avoiding the picture running ahead of the voice.

The pipeline behind the workbench: checkpoints, phrase timing and a local overlay for Chinese words

The repository splits into web (the React front end), webapp (the Python backend and task queue), video_renderer (Remotion), scripts, docs, tests and a SKILL.md at the root. The README describes checkpoints for dubbing, storyboards, images, segment videos and the final cut, so changing local render settings does not require calling the models again. That is the design decision worth noting: the expensive, non-deterministic steps are separated from the cheap, repeatable ones. If you re-render with a different stroke amount, you should not be paying for image generation twice.

The dynamic infographic mode has a documented contract, linked from the README as docs/semantic-timing-contract.md. The mechanism described is a phrase timetable derived from the real narration, with chapter and key-point structure generated afterward. Elements appear only once their speech has started. This is a harder problem than it sounds, because it requires the narration timing to be known before the layout is fixed.

One constraint is stated plainly: image models produce garbled Chinese text, so cs-board overlays 4 to 10 character key phrases locally instead, and that overlay can be switched off in one action. Read that as an admission about the illustration step rather than a feature. If your content depends on accurate Chinese labels inside the artwork itself, this pipeline will not give them to you; it gives you clean text on top of art that is otherwise text-free.

Twelve visual templates are listed, each with a preview, described visual characteristics and recommended content. The README notes the previews use GitHub Raw URLs so the table images render, and that the front end currently ships 12 templates, with the comic ink-line explainer style being the addition if you remember 11.

Installing cs-board and producing a first video

The README lists the environment requirements up front: Windows 10/11 or macOS 15+, Python 3.11+, Node.js 22.13+, FFmpeg and FFprobe on the system PATH, a reachable IndexTTS 2.5 service (Gradio or FastAPI), and an OpenLux API key with permissions for both a text model and an image model. Check the audio and video dependencies first, because the pipeline fails early without them.

ffmpeg -version
ffprobe -version

On Windows the same two commands run in PowerShell. On macOS with Homebrew, the README gives this install line for the runtimes:

brew install python@3.13 node ffmpeg

Installation is a one-time sequence from the repository root. On macOS or Linux it is three commands: prepare the environment, install the backend requirements into the created virtual environment, and install the front end dependencies.

python3.13 scripts/prepare_env.py
.venv/bin/python -m pip install -r webapp/requirements.txt
(cd web && npm ci)

If Python dependency installation is slow from mainland China, the README shows prefixing the command with the Tsinghua PyPI mirror rather than changing global pip configuration.

PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple python3.13 scripts/prepare_env.py
PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple .venv/bin/python -m pip install -r webapp/requirements.txt

Start the workbench with ./start-webapp.sh on macOS, or .\start-webapp.ps1 on Windows. The README states the script starts the front end and backend and opens http://127.0.0.1:13000/, and that devices on the same LAN can reach it through the address the script prints. On macOS the first run of dynamic infographic mode prepares Remotion and Whisper.cpp resources for the current platform.

./start-webapp.sh

Then open API settings in the top right and fill in five things: the OpenLux API key, stored only in the local .webapp/config.json and never echoed back in full; the text model, default gpt-5, used to decompose copy and generate storyboards or infographic structure; the image model, default gpt-image-2; an optional separate image endpoint and key for cases where text and images come from different providers, where leaving one blank falls back to the configuration above; and the IndexTTS address and interface type, with the README noting Gradio is usually http://127.0.0.1:7860 and FastAPI usually port 8000. After a successful connection test, upload 10 to 30 seconds of single-speaker, low-noise reference audio, paste at least 10 Chinese characters, pick a production mode and a visual template.

Where cs-board breaks: IndexTTS, platform limits and the OpenLux dependency

The hardest dependency is the one cs-board does not ship. You must supply a reachable IndexTTS 2.5 service, either Gradio or FastAPI, and the README treats that as a prerequisite rather than something the installer sets up. If you do not already run IndexTTS, the five-minute startup is not five minutes; it is however long it takes you to stand up a separate speech synthesis service, which is outside this repository.

Platform support is asymmetric. Windows 10/11 gets a PowerShell one-click script, and macOS 15+ gets a shell script with support for both Intel and Apple Silicon, because Remotion video rendering requires it. The README states directly that macOS 14 and lower can start the interface and API, but that video rendering with the current Remotion version is not guaranteed to succeed. Linux is not listed among the environment requirements at all, even though the install instructions include macOS/Linux shell commands and the test commands run under macOS/Linux. The repository layout and the requirements list point in different directions here, and the README does not resolve it.

There is also a commercial dependency in the generation path. The text and image steps go through an OpenLux API key, and the README's sponsor block advertises MiniMax H3 video generation from Metaso with per-second pricing and OpenAI-compatible and ComfyUI support. Nothing in the README says the sponsor service is required for cs-board to work, so treat the sponsorship as an advertisement and the OpenLux key as the actual documented requirement. Either way, the illustration and decomposition steps are not offline; only the voice cloning and the file storage are described as local.

Finally, the README warns against exposing API keys, reference audio and job directories in issues, logs, screenshots or commit history, and points to SECURITY.md for private reporting. That warning exists because everything lives in .webapp/, including config.json with your keys.

cs-board against a hosted whiteboard animation service

The obvious alternative is a hosted whiteboard animation editor, where you upload a script and a voice track and the rendering happens on someone else's infrastructure. The difference is not quality; it is where the reference audio goes and who pays per render. A hosted editor typically wants your voice sample or a licensed voice from its own library, and it bills per minute or per export. cs-board keeps the reference audio on your machine and reuses checkpoints so that re-rendering after a settings change does not re-invoke the image model, but it moves the cost to your own hardware and to your OpenLux account.

A second alternative is assembling the same output from separate tools: a TTS or voice cloning service for narration, an image model for illustrations, and a video editor or a scripted renderer for the stroke animation and subtitles. That gives you full control over each stage and no opinionated scene decomposition, but you own the timing problem yourself. cs-board's dynamic infographic mode is precisely the part that is tedious to rebuild, since it derives a phrase timetable from the narration and gates content on speech start, with the rules written down in docs/semantic-timing-contract.md. If that timing behaviour is what you need, rebuilding it is the expensive path. If you only need a static whiteboard look with your own narration, the separate-tools route is more flexible and has fewer moving parts.

The honest comparison is this: cs-board is opinionated about the pipeline and unopinionated about the models, as long as the text and image models speak the OpenLux API and the speech service speaks IndexTTS. That constraint is the whole architecture.

Maintenance, upgrade cost and the MIT licence

The repository is not archived, and the last push was on 2026-09-05, with v1.0.0 released on 2026-09-03. That is a young project with a single tagged release. The version number says 1.0.0, but the README still documents a growing template set and the front end already ships 12 templates where an earlier count was 11, which is the kind of detail that tells you the surface is still moving. Expect template additions and timing-contract changes rather than a frozen interface.

Upgrade cost concentrates in three places. The Python backend has its own requirements file, the front end installs with npm ci, and the video renderer is a separate Remotion package with its own build step. The README's development verification section runs three commands, one per layer, which means a version bump can require touching all three. The dynamic infographic path additionally prepares Remotion and Whisper.cpp resources on first run per platform, so a platform or version change can trigger that preparation again.

On licensing, the repository carries an MIT licence, which permits commercial use and modification with the licence and copyright notice preserved. That covers cs-board itself. It does not cover your IndexTTS deployment, your OpenLux usage, or the models you call through it, and the README does not address the licensing of cloned voices. Cloning a voice from a reference clip raises consent and personality-rights questions that an MIT licence on the code does not answer, so check that separately before publishing anything built from someone else's recording. This is not legal advice.

Editorial conclusion

Adopt cs-board if you already run an IndexTTS service, have FFmpeg on PATH and want a reference voice plus Chinese copy turned into a whiteboard MP4 without sending source audio to a hosted editor. Do not adopt it if you need Linux support, if you cannot supply an OpenLux API key, or if you expect the illustration step to render Chinese text inside images; the README routes that job to a local overlay of 4 to 10 character phrases instead. Verify three things before committing: that your IndexTTS endpoint answers on the Gradio or FastAPI port you intend to point at, that a 10 to 30 second single-speaker reference clip clones acceptably, and that Remotion renders on your macOS version, since the README states macOS 14 and lower can start the UI and API but are not guaranteed to finish video rendering.

Frequently asked questions

Official sources

1. ChenShuo2004/cs-board on GitHub
2. Issues
3. License: MIT
4. README
5. Releases