Show Me The Story: a self-hosted Go binary for long-form AI fiction

What Show Me The Story is for, and who it is not for

The README describes it as a local application for writing long fiction with AI. The problem it addresses is continuity: a chat session forgets what it established three hundred pages ago, and pasting a growing manuscript into a prompt stops working once the book outgrows the context window. Show Me The Story keeps the book on disk as a project, then feeds the model only what the current request needs.

It is aimed at one author working on one long work, in Chinese or English, with their own API key. The interface language and the writing language are separately switchable, so a Chinese-speaking author can run an English UI or the reverse. The README is explicit that consistency checks rely on your story context and are not online research, and that authors still need to review model output. That sentence is the honest scope statement: this is a drafting and bookkeeping tool, not an autonomous author.

If you want a hosted editor with collaboration, this is the wrong shape. If you want a one-shot story generator, the batch and review machinery is overhead you will click past.

How the pipeline moves from synopsis to a finished chapter

The mechanism is a staged pipeline over a persistent project. You create a project, fill in genre, target chapter length, style and point of view, then add characters and worldview entries. In Outline you supply a synopsis and a chapter count between 1 and 36 for the first batch, and generate the outline. The README notes that some pages offer Confirm outline, and that you should confirm before writing.

Writing then proceeds one chapter at a time. You generate a chapter, read and revise it, and accept it before continuing. Alongside that loop the project accumulates story knowledge: characters, worldview, organizations, relationship graphs, extracted facts with source references, setting-change proposals and foreshadow tracking. The README describes the retrieval rule directly: entries you select when saving knowledge enter that request in full, while later writing retrieves relevant entries. That is the core design decision. Selection is manual and explicit for the current chapter, automatic and approximate for everything after.

The repository layout matches the description: a Go module named showmethestory with main.go and internal/, and a frontend/ directory built with Vite, Svelte and Tailwind. Frontend assets and built-in skills are embedded in the executable, which is why the shipped artifact is one file. Later stages add separate final proofreading, anchored reports, per-chapter proofreading undo, and continuation projects for sequels.

Running the binary and getting the first chapter out

Installation is a download, not a package manager. The README's first-run steps say to download a release for your system, extract it into a directory you intend to keep, and launch it. There is no npm or go install path documented for end users; building from source is a separate developer workflow.

The default data directory is the working directory at launch, and you can pass an existing directory instead:

./show-me-the-story
./show-me-the-story /path/to/existing/novels

The README says to check the project directory printed at startup, and that an invalid directory argument falls back to the working directory. On Windows the equivalent is a double-click or:

.\show-me-the-story.exe "D:\Novels"

Then open the UI. The default port is 48090, overridable with the PORT environment variable, and the README gives the address to open on first run:

http://localhost:48090

In Configuration you enter the API address, model identifier and API key, test the connection and save. The README warns to use the exact model identifier supplied by your provider. After that, save genre, target chapter length, style and point of view, add essential characters and worldview entries, and move to Outline. The README recommends starting with a small batch and auto-confirm disabled to check voice, characters and model behavior before trusting the pipeline with a longer run.

Where the design bites: single writer, v4-only projects, local trust

The sharpest constraint is concurrency. The README states plainly: do not run multiple writers against the same project. There is a rollback journal, progress.json.rollback, that lets a project attempt to restore the last complete save after an interrupted prose or progress save, but the README also says the rollback journal is not version history and not a replacement for regular backups. Damaged chapter files or a failed recovery prevent the project from opening at all and display diagnostics; the documented recovery path is to preserve the entire project directory including progress.json.rollback, fix file access problems, or restore a backup.

Format compatibility is the second constraint. This release only opens v4 projects, and the README says to use the version recommended by the project list for older formats rather than editing the format number manually. Upgrading an old manuscript therefore means opening it in an older build first.

Third, privacy is local-only in the narrow sense. Files stay on disk, but AI operations send relevant prose, settings and prompts to your configured model service, which may charge for usage. API keys live in api.json, and the README tells you to inspect shared files and logs for sensitive information and to run the application in a trusted local environment rather than exposing it to the public internet. Backups have a gap too: the Back up ZIP action downloads a complete project, but global API configuration and user Skills are excluded, so a migration that relies only on ZIPs loses them.

How it differs from SillyTavern-style chat front ends

The obvious alternative is a chat front end such as SillyTavern, which also connects to OpenAI-compatible endpoints and also runs locally. The difference is the unit of work. A chat front end treats the conversation as the artifact and asks you to manage context with prompt templates, character cards and manual summarization. Show Me The Story treats the book as the artifact: chapters, batches, extracted facts, foreshadow entries and proofreading reports are first-class objects with their own pages and persistence.

That shifts the work. In a chat front end you spend effort on prompt engineering and context trimming. Here you spend it on reviewing generated chapters and curating the knowledge base, because the retrieval is only as good as what you saved and selected. The trade-off is flexibility. A chat front end can be bent to any task; this pipeline assumes you are writing a long novel in Chinese or English and gives you a narrower set of controls. The README's own feature list, with batch outlines, ending intent, relationship graphs and import of existing text, describes a tool that has opinions about your workflow.

Building from source, licence and the real upgrade cost

The project is MIT licensed, which permits commercial and private use with the usual requirement to keep the copyright and permission notice with copies or substantial portions. That is a statement about the licence text, not advice about your situation; if you plan to redistribute a modified binary, read LICENSE and go.mod rather than this paragraph.

Building is documented and pinned. The README lists Go 1.25.1 with the standard library, Vite 5, Svelte 4, Tailwind CSS 4, DaisyUI 5 and @xianii/design-system, and go.mod confirms the module name and Go version. With Task installed, the documented build is:

task build

The manual equivalent compiles the frontend first, then the binary:

cd frontend
npm install
npm run build
cd ..
go build -o show-me-the-story .

The README also lists the checks to run before trusting a build: go build ./..., go test ./..., go vet ./..., plus two Node scripts, node frontend/src/lib/projectRestore.check.js and node frontend/src/lib/forceGraphLayout.check.js. For development, task dev runs the backend and task dev:frontend runs a frontend server on 5173 proxying API requests to 48090. Upgrade cost is mostly the project format: the last push was on 2026-09-10 and v4.0.0 shipped the same day, so if you are on v3 you are crossing a format boundary, and the README's advice is to open old projects with the version the project list recommends.

Editorial conclusion

Adopt Show Me The Story if you already have an OpenAI-compatible endpoint, you write in Chinese or English, and you want the manuscript to live in a directory you control rather than in a hosted editor. Skip it if you need a hosted service, if you want the tool to research facts online, or if you expect the model to produce publishable prose without a human reading every chapter. Before committing a real book, verify three things: that your provider accepts the exact model identifier you type into Configuration, that the project directory printed at startup is the one you intend to back up, and that you can open a v4 project in this release, since the README states it only opens v4 projects and older formats need the version recommended by the project list.

Frequently asked questions

Official sources

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