CharacterArc (弧光): a local-first Electron workbench for long novel projects

What CharacterArc solves for long-form fiction writers

The stated audience is creators who need to maintain project settings, character relations, plot structure and chapter text over a long period. That framing matters, because the hard part of a novel is not producing one paragraph. It is remembering, three hundred pages in, that a side character's sister was already named, that a foreshadowing line was planted in volume one and has to pay off in volume three.

CharacterArc answers that with project isolation. Each novel keeps its own settings, chapters, knowledge base and AI run records, and the README states that project data lives in a local SQLite database in the main process rather than behind an online service. Nothing about your manuscript leaves the machine unless you send it to a model endpoint you configured yourself.

The unit of work is the chapter. The README says the outline, inspiration, knowledge and AI capabilities all land on chapter creation. So the app is not a general note tool with an AI panel bolted on. It is a chapter pipeline with worldbuilding attached.

How the Electron, Vue and SQLite stack is arranged

The stack table lists Electron with Vue 3 and TypeScript, Pinia for state, Naive UI for components, electron-vite on Vite 7 for the build, TipTap for rich text, Cytoscape for the relationship graph, and SQLite in the main process for persistence. The AI layer is the Vercel AI SDK for OpenAI and Anthropic protocols, plus the local Codex CLI as a separate path.

That split explains the data flow. The renderer holds the editor and the panels. The main process owns the database and the outbound HTTP calls. The repository layout matches this: electron/ for main-process code, renderer/ for the UI, and a large set of .test.mjs files under electron/main/ai/ covering protocol adapters, proxy fetch, knowledge retrieval and background task coordination.

Two mechanisms are worth naming. First, reasoning isolation: the README states the app handles reasoning fields from MiniMax, DeepSeek, Tongyi, Kimi and GLM, and strips common thinking markers before text is written to disk. Second, the Agent Loop mode, where the model cycles through a Skill index and a tool registry, and the v2 variant matches Skills to a conversation automatically. Both are places where a wrong implementation would be visible in the manuscript, which is presumably why they have dedicated test files.

Installing CharacterArc and configuring your first model

The README lists Node.js 18+ and pnpm 10+ as requirements, and Windows or macOS as the supported platforms. Packaging must run on the target platform: Windows produces an NSIS installer, macOS produces DMG and ZIP. The commands below are the ones the README gives, in the order it gives them.

pnpm install
pnpm run dev
pnpm run build
pnpm run dist:win
pnpm run dist:mac

The first command installs dependencies. The second starts the Electron main process and the Vite renderer together, which is what you want for a first look. The third runs type checking and a build. The last two produce installers and must be run on the matching operating system.

After the app opens, model configuration happens in the settings panel, not in a config file. The README describes maintaining several endpoint profiles and switching between them from the title bar. For each profile you supply a protocol type (OpenAI-compatible or Anthropic), a Base URL, an API key and a model name. The Base URL takes a domain or path prefix only, because the app appends /v1 itself. The README notes that OpenAI-compatible relays default to Chat Completions while official OpenAI uses the Responses API, and that model names can be pulled from the endpoint automatically.

The Codex CLI path is different: the README says it reuses your existing local login, so no API key is needed, and the app can locate the binary, list models and set a reasoning effort. The README does not document a command-line entry point for the app itself, so there is nothing to run from a terminal beyond the pnpm scripts above.

The first real task is the new project wizard. You fill in genre, length and a synopsis, and the README says the wizard can call AI to generate the first batch of settings and an outline. From there, creating a chapter starts by picking an outline node, which carries the title, summary and word-count target into the chapter and binds the two together.

Where CharacterArc is the wrong tool

The platform badge says Windows, and the environment section says Windows or macOS. There is no Linux target in the README. If your writing machine runs Linux, this is not a packaging inconvenience you can work around with a flag; the documented distribution paths are NSIS and DMG/ZIP only.

The macOS situation is more specific. The README states that macOS artifacts are ad-hoc signed and not notarized, suitable for internal installation and testing, and that distributing to ordinary users requires an Apple Developer certificate and notarization. The GitHub Actions workflow in .github/workflows/release.yml builds arm64 on macos-26 and x64 on macos-26-intel and uploads to Actions artifacts, but the README says the current configuration is ad-hoc signed without notarization. To do a real release you would add CSC_LINK, CSC_KEY_PASSWORD, APPLE_ID, APPLE_APP_SPECIFIC_PASSWORD and APPLE_TEAM_ID as secrets and enable the Developer ID signing and notarization flow.

There is also a category mismatch. If you want to paste a chapter into a chat window and get suggestions, this app is heavier than that. It asks you to build a project, a cast, an outline and a knowledge base before the AI features have much to work with. The README is explicit that it is not a conversational shell, and the setup cost is the price of that position.

CharacterArc compared with Scrivener plus a chat window

The obvious alternative is a binder-style writing app such as Scrivener with a browser tab open to a model. The difference is where the context lives. In that setup, the model sees only what you paste in that turn, and the setting notes stay in the binder where the model cannot read them. CharacterArc instead keeps the knowledge center, the creation-memory panel and the outline in the same database the AI tasks query, which is why the repository has a dedicated knowledge-retrieval module and tests for it.

A second alternative is a general agent framework driving a plain markdown folder. That gives you full control over files and version history through git, which CharacterArc does not offer in the same form; it offers automatic save, manual snapshots and rollback inside the app. The trade-off runs the other way too: a markdown folder has no relationship graph, no outline-to-chapter binding and no task progress panel, and you would be writing the prompt plumbing yourself.

Neither alternative is strictly better. If your work is already a git-tracked markdown repository and you like it that way, CharacterArc's SQLite store is a step backwards in portability. The README does mention exporting a workspace as a JSON snapshot, which is the escape hatch, but that is a snapshot rather than a working format.

Maintenance, licence and what upgrading costs you

The repository is not archived, and the last push was on 2026-09-10. The release list shows v1.19.0 and v1.19.1 on 2026-09-08 and v1.19.2 on 2026-09-09, so the project is shipping patches within days of each other. That cadence is the maintenance signal available here; the README's version badge still reads v1.14.2 while package.json says 1.19.2, which tells you the badge is not the thing to trust when checking what you installed.

The licence is MIT, declared both in the README badge and in the license field of package.json. In practical terms that permits commercial and private use, modification and redistribution with the copyright notice retained. It says nothing about the models you connect: your provider's terms, your relay's logging policy and the cost of each generation are separate agreements you make outside this project. Nothing here is legal advice, and if you plan to ship a novel written through a relay endpoint, read that provider's terms rather than this paragraph.

Upgrade cost is mostly the model layer. Because the app supports OpenAI-compatible relays, Anthropic protocol endpoints and the Codex CLI behind one settings panel, a provider change is a profile switch rather than a code change. The friction sits in the reasoning-field handling: the README notes that whether thinking content is visible depends on the model and on whether the relay passes the reasoning field through. A relay that changes its behaviour can alter what you see in the AI sidebar without any version bump on your side.

Editorial conclusion

Adopt CharacterArc if you run a long project with a stable cast and outline and you want the draft, the setting notes and the AI run log in one local SQLite file. Skip it if you write on Linux, if you need a finished signed macOS installer, or if you only want a chat box. Before committing, run pnpm run dev on your own machine, point the settings panel at your provider, and confirm that reasoning output from your model does not leak into a chapter body.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. uu201/character-arc on GitHub