ArcReel: a self-hosted pipeline that turns novels and scripts into storyboards, clips and CapCut drafts

The gap ArcReel targets: long text in, consistent shots out

Most text-to-video tools take a prompt and return a clip. ArcReel takes a different input: a novel, a finished script, or product material. The README frames the output as short video with three properties that a single prompt cannot guarantee. Characters stay visually consistent because asset images are reused as reference images across storyboards. The process is interruptible and reviewable, with key stages open to confirmation and individual assets open to redo. Cost is visible before and after generation. The intended users are named explicitly in the README: AI comic drama and novel adaptation, narrated or commentary short video, and advertising or product shorts. That list matters, because every one of those formats is episodic. You produce many shots that must look like they belong to the same world, and you produce them repeatedly. ArcReel's value proposition is not the quality of any single generation. It is the bookkeeping between generations.

The pipeline is a chain of named stages, not a single generation call

The README's flow diagram is the clearest statement of the architecture. Input (novel, finished script, or product material) goes to content analysis and project planning. That produces character, scene and prop assets. Those feed episode splitting and a structured script. The structured script feeds storyboard images and multi-panel storyboards. Those feed video clips and narration audio tracks. The final stage branches two ways: finished-video compositing, or Jianying draft export. Each stage, per the README, can be orchestrated by an Agent or reviewed, adjusted and regenerated by the user in the workspace. The documentation links an architecture page describing an Agent Runtime, a task queue, a provider abstraction layer and a data layer, so the staged diagram maps onto real components rather than being a marketing sketch. What the README does not specify is the queue implementation, the retry semantics, or how a partially completed project is represented in storage. Those are the details you would need to read the architecture page for, and they are not in the supplied material.

Asset reuse is the actual consistency mechanism

Cross-shot consistency in ArcReel is not achieved by a special model. It is achieved by treating character, scene and prop images as first-class assets that later stages reference. The topics list on the repository includes reference-to-video alongside text-to-video and image-to-video, which is consistent with that design: the video stage can be driven by a reference image rather than a fresh prompt. The practical consequence is that consistency failures are diagnosable. If a character drifts between two shots, the question is which reference image the second shot used, and the README states that individual assets can be redone and historical versions rolled back. That is a different debugging workflow from re-rolling a prompt and hoping. It also means the quality of your asset stage sets a ceiling on everything downstream. A weak character image propagates into every storyboard that references it. The README offers no automatic consistency scoring, so detecting drift is a manual review step.

Getting it running: Docker Compose, port 1241, and a settings page

The README gives a four-command start from a checkout. Clone the repository, change into the deploy directory, copy .env.example to .env, and run docker compose up -d. The workspace is then at http://localhost:1241. The default username is admin. If AUTH_PASSWORD is left empty, the README states the first startup generates a password and writes it back to deploy/.env. That auto-generation is convenient and also the first thing to check, because it means the credential lives in a file on disk. The README adds an explicit warning that the default Compose publishes port 1241 on all host network interfaces, and that the service should not be exposed directly to the public internet; remote access should go through authentication plus HTTPS, a VPN or a secure tunnel, with a linked page on reverse proxy and HTTPS. After login, you go to the Settings page to configure the ArcReel Agent and the text, image and video generation capabilities, then create a project. The README also documents a local development path with uv run pre-commit install, and links a providers page covering Agent, text, image, video and TTS provider selection.

Provider abstraction is the selling point and the configuration burden

ArcReel does not ship a model. It ships a provider abstraction layer, and the topics list confirms multi-provider as an intended feature. The README's Settings page covers the Agent plus text, image, video and TTS capabilities separately, which means at minimum four or five distinct provider decisions before your first project. The documentation has a dedicated providers page for choosing and configuring them. This is the trade-off in plain terms: you get model portability and the ability to swap a video provider without touching your project data, and in exchange you own the integration work and the failure modes of every provider you wire in. The README's sponsor block illustrates the kind of endpoint you might configure (a MiniMax H3 video API advertised at 768P for 0.09 yuan per second and 2K for 0.15 yuan per second, with OpenAI-compatible API and ComfyUI support), but that is a sponsor placement with a referral link, not a default. Treat it as an example of the shape of a provider, not a recommendation.

Cost tracking is a first-class stage, which is unusual and useful

The README states that text, image, video and TTS capabilities are configured in one place and that costs and actual usage can be viewed before and after generation. For video generation specifically this is not a minor feature. Per-second video pricing varies by resolution and provider, and a project with dozens of shots can accumulate real spend quickly. Pre-generation estimates let you decide whether a storyboard is worth rendering before you render it. Post-generation usage figures let you reconcile against provider billing. The README does not specify the accuracy of the estimate, whether it accounts for retries, or how usage is recorded per provider. Those are the numbers to verify yourself before you rely on the estimate for budgeting, because an estimate that ignores regeneration is optimistic by exactly the amount you regenerate.

Where it stops: Jianying export, unverified CapCut support, and AGPL-3.0

The README is direct about the export boundary. ArcReel can composite a finished video, or export a Jianying draft so you can continue adjusting subtitles, dubbing, pacing and transitions. The export targets the mainland China version of Jianying, and the README states that compatibility with CapCut has not been verified. If your post-production is in CapCut, that is an unproven path, not a supported one. The licensing boundary is equally explicit. ArcReel is AGPL-3.0 with additional terms in a NOTICE file, and the README says that organizations which cannot adopt AGPL-3.0, or which want commercial deployment, white-labeling or redistribution without AGPL obligations, should contact the maintainers. The network-copyleft nature of AGPL means the trigger is typically offering the modified software to users over a network, but the exact scope of your obligations depends on your deployment and your counsel, not on this article. The other hard constraint is operational: the default deployment is SQLite, with a documented migration path to PostgreSQL. The README links that migration page, which implies SQLite is the starting point and PostgreSQL is the answer when a single-file database stops fitting your workload.

Alternatives, and the difference that actually matters

The obvious comparison is a hosted text-to-video service. Those collapse the pipeline into one prompt-to-clip call. You lose the asset stage, so you cannot reuse a character image across shots by reference, and you lose the pre-generation cost estimate because there is no project-level accounting. You also cannot self-host, which for anyone handling unpublished manuscripts or client product material may be the deciding factor. The second comparison is a general node-based generation tool such as ComfyUI. That gives you finer control over each model call and a much larger ecosystem of custom nodes, but it gives you no notion of a project, an episode, a character asset, a cost ledger, or a resumable multi-stage pipeline. You would be building ArcReel's bookkeeping layer yourself on top of it. The third comparison is a conventional NLE plus manual generation: you generate clips one at a time and assemble them in an editor. That is fully controllable and requires no new software, but consistency across shots becomes your memory and your file naming, and there is no rollback of a single asset version. ArcReel's specific bet is that the orchestration layer is worth more than the marginal control you give up.

Editorial conclusion

Adopt ArcReel if you are producing episodic short-form video from long text, you need per-shot redo and asset reuse across shots, and you are willing to run Docker plus configure at least a text, image and video provider yourself. Do not adopt it if you want a hosted service, if your target editor is CapCut rather than the mainland Jianying build (the README states CapCut compatibility is unverified), or if AGPL-3.0 obligations are a blocker for your deployment model. Before committing, verify three things on your own machine: that your chosen image and video providers are reachable from the container, that the export path produces a draft your editor version actually opens, and whether SQLite is sufficient for your project count or you need the documented PostgreSQL migration.

Official sources

1. ArcReel/ArcReel on GitHub
2. License: AGPL-3.0
3. Project website
4. README
5. Releases