Show Me The Story: a Go binary that writes novels chapter by chapter

The gap between a chat window and a 30-chapter manuscript

A general chat interface will happily write you a chapter. It will not remember that the innkeeper lost his left hand in chapter three, or that you planted a locked chest in chapter five and need it opened by chapter twenty. Show Me The Story exists to hold that state. It is a local application, in the project's own words, for writing long fiction with AI, and the unit of work is not the prompt but the project: a directory under storys/<project>/ that carries characters, worldview entries, organizations, relationship graphs, story knowledge, extracted facts with source references, and foreshadow tracking. The audience is narrower than the topic list suggests. If you write one short story a month, the setup cost of configuring genre, target chapter length, style and point of view will not pay for itself. If you are drafting something book-length and you care about who said what in chapter nine, the per-chapter accept step is the feature you are actually buying.

Outline, draft, review, accept: the loop the app enforces

The flow is staged and mostly manual by default. You enter a synopsis and a chapter count between 1 and 36 for the first batch, generate an outline, and review it. If the page offers Confirm outline, the README says to confirm before writing. Then you move to Writing, generate one chapter, read and revise it, and accept it before continuing. Auto-confirm exists but is optional, and the first-run instructions explicitly suggest leaving it disabled while you check voice, characters and model behaviour. Consistency is handled by extraction rather than by a separate checker: the app pulls facts out of the prose with source references, proposes setting changes, and tracks foreshadowing. There is a mechanic worth noting for anyone who has fought retrieval systems: when you save knowledge and revise a chapter, the selected entries enter that request in full, while later writing retrieves relevant entries. That is a deliberate split between exact injection and approximate recall, and it is the kind of design choice that only shows up when you read the guide rather than the feature list.

Running the binary and where your manuscript actually lives

There is no server to provision. You download a release, extract it into a directory you intend to keep, and launch it. The default data directory is the working directory at launch, or you can pass an existing one: ./show-me-the-story /path/to/existing/novels. On Windows the equivalent is .\show-me-the-story.exe "D:\Novels". The project directory is printed at startup, and an invalid directory argument silently falls back to the working directory, which is the sort of behaviour worth checking rather than assuming. The UI is served at http://localhost:48090, and the port is overridable with the PORT environment variable. Model configuration is three fields in Configuration: API address, model identifier, and API key, followed by a test connection and save. The README is emphatic that you use the exact model identifier supplied by your provider. Keys are stored in api.json, and the README advises inspecting shared files and logs for sensitive information and running the app in a trusted local environment rather than exposing it to the public internet.

The v4-only format and the recovery journal

Two constraints deserve attention before you invest hours in a project. First, this release only opens v4 projects, and the README says not to edit the format number manually. If you have an older project, you are expected to use the version recommended by the project list. That is a real migration tax on a tool whose selling point is persistence. Second, durability is handled by a rollback journal rather than version history. After an interrupted prose or progress save, reopening the project attempts to restore the last complete save. If chapter files are damaged or recovery fails, the project will not open and you get diagnostics instead. The README tells you to preserve the entire project directory, including progress.json.rollback if present, then fix file access problems or restore a backup. It also states plainly that the rollback journal is not version history and not a replacement for regular backups, and that you should not run multiple writers against the same project. Treat that last line as a hard boundary, not a suggestion. The Back up ZIP button in the project list downloads a complete project, and Restore a project backup restores it as a new project without overwriting the original, but global API configuration and user Skills are excluded from that archive and must be preserved separately.

Where the model stops and your judgement has to start

The README contains a sentence that undercuts a lot of marketing around this category: consistency checks primarily use your story context; they are not online research, and authors still need to review model output. There is no external fact database behind the fact-check feature. If your novel involves real geography, real law, or real history, nothing in this tool verifies it against a source. The extracted facts are facts about your own manuscript, cross-referenced against your own chapters. That is a coherent scope, and stating it is more useful than pretending otherwise, but it means the feature labelled fact-check is an internal-consistency tool. The same applies to foreshadowing: the app tracks what you planted, not whether the payoff lands. Everything downstream of generation is still your reading. If you want a tool that decides whether chapter twelve is good, this is not it, and no configuration in the app will make it one.

How it differs from a general writing assistant

The obvious comparison is a general-purpose assistant like a chat interface or an editor plugin that generates prose on request. The difference is where state lives. A chat assistant keeps continuity inside a conversation window, which degrades as the manuscript grows and disappears when the session ends. Show Me The Story externalises that state into project files on disk: characters, worldview, organizations, relationships, knowledge entries, extracted facts, foreshadow records, and per-chapter progress. It also inserts an accept gate between chapters, so a bad draft does not silently become canon for the next twenty chapters. The trade is friction. You will click through more screens than you would with a chat window, and you will read more output. For a novella, that friction is pure overhead. For a serialised web novel where chapter forty must be consistent with chapter four, the externalised state is the entire point, and the MIT licence means you can read the Go source when the behaviour surprises you. The frontend is Vite 5, Svelte 4, Tailwind CSS 4 and DaisyUI 5, with assets and built-in skills embedded in the executable, so the shipped binary is the whole application.

Building from source, upgrading and the real running cost

If you build it yourself, the toolchain is Go 1.25.1 with the standard library, plus Node.js for the frontend. With Task installed, task build does the work. Manually it is cd frontend, npm install, npm run build, then go build -o show-me-the-story . from the repository root. Development uses task dev for the backend and task dev:frontend for the frontend server on port 5173, proxying API requests to 48090. The repository ships verification commands: go build ./..., go test ./..., go vet ./..., and two Node check scripts, node frontend/src/lib/projectRestore.check.js and node frontend/src/lib/forceGraphLayout.check.js. On the upgrade question, releases are frequent enough that the changelog matters: v4.0.0 landed on 2026-09-10, nine days after v3.0.3, which followed v3.0.2 by about three weeks. A major version bump that changes the on-disk project format is the upgrade risk to plan for, because older projects need the version recommended by the project list rather than the newest binary. The licence is MIT, which permits commercial and private use and modification; that is a statement about the repository's licence file, not legal advice, and if you redistribute a modified binary you should read the LICENSE text yourself. The cost that does not go away is the model bill: AI operations send relevant prose, settings and prompts to your configured service, which may charge for usage.

Editorial conclusion

Adopt it if you already have an OpenAI-compatible endpoint and want chapter-level control over a long manuscript that stays on your own disk. Skip it if you want a one-click finished book, or if multi-writer access to the same project matters, since the README warns against running multiple writers against one project. Before committing a real novel, verify three things on a throwaway project: that your provider accepts the exact model identifier you paste into Configuration, that the v4 format matches the release you downloaded, and that your backup routine copies the whole data directory including progress.json.rollback. The whole stack is MIT-licensed, so the cost question is your model bill, not a licence fee.

Official sources

1. Issues
2. License: MIT
3. Nigh/show-me-the-story on GitHub
4. README
5. Releases