Scrapbook - Developer Edition

Scrapbook is a complete, self-hostable AI narrative engine that works right out of the box. You describe a world and Scrapbook builds it from scratch, narrating it back to you, scene by scene, as a living illustrated scrapbook. Photographs develop in the margins. The story types itself onto the page. Characters remember everything.

Eleven game templates ship with it, spanning genres from Victorian mystery to cyberpunk thriller and beyond. Or describe your own world from scratch. Pick one, hit start, and you're playing tonight.

(Important: Scrapbook requires your own LLM / image API key, or hardware strong enough to run your own! NSFW content is available if your chosen AI provider supports it; Scrapbook does not censor.)  

---

A world that actually remembers

Most AI game engines forget. Scrapbook doesn't.

Every character you meet has a full profile: a name, a face, a personality, a backstory, secrets they're keeping, and a consistent portrait that updates when those secrets surface. Every location has an atmosphere, a history, and a painted background image. Every choice you make is tracked — not as a log, but as living narrative threads that open, deepen, and close as the story demands.

By turn 20 the world feels inhabited. Characters refer back to things you did three acts ago. A subplot you thought was resolved resurfaces. The estate manager you clashed with in act one is quietly making moves in act three. The engine isn't improvising — it's running a multi-act story arc it planned before the first scene, and it's keeping score.

---

The characters are the game

Scrapbook's NPCs aren't props. Every character is forged with:

• Appearance — detailed, consistent, portrait-matched
• Personality — motivations, fears, pressure responses, contradictions
• Backstory — history that informs how they act in the present
• Secrets — hidden facts that can surface dramatically mid-story
• Relationship blurbs — how they see your protagonist specifically

When Seline tells you "Well. There's a great deal you'll need to know, and the bank's letter on the table won't wait" — that line came from a character who knows she's been holding the estate together for four years, resents having to explain herself to an outsider, and is quietly afraid of what happens if you fail. The engine wrote it that way because it knows who she is.

Browse the full cast any time in the Character Gallery. Read their profiles, edit your own notes, and regenerate any portrait on the spot.

---

Open threads. Real stakes.

Every meaningful development in the story is tracked as a narrative thread — open, unresolved, and visible to the engine on every subsequent turn. Threads have sub-threads. Sub-threads can be resolved, archived, or pulled back into focus.

The Thread Steward agent watches the scene after every turn, decides what changed, what it implies for open storylines, and whether any new threads should open or existing ones close. When you read the story, you can pull up the live thread tracker and see exactly what's in play.

This is what makes long-form play feel coherent rather than like a series of disconnected scenes.

---

A UI worth playing in

Scrapbook looks like nothing else in this space. The interface is built around the scrapbook metaphor end to end:

• Text types itself live as the engine streams it — skip the animation with spacebar
• Polaroid photographs develop in the margins as images generate, playing a brief wash as they resolve
• Atmospheric painted backgrounds cross-fade as you move between locations
• Per-character dialogue — every speaker gets a consistent colour and avatar, so conversations read like a graphic novel
• Page-turn transitions when moving between home, game, and act breaks
• Two themes — Classic (editorial serif on cream paper) and Modern (dark glass) — switchable live

---

Build your world your way

Every new game starts with a rich setup form: genre, setting, tone, your protagonist, the opening cast and scene. Choose an art style from a visual gallery of illustrated examples — Webtoon, Anime, Oil, Kitsch, Marker, Pixel Art, Leyendecker, or write your own. Pick a writing voice from a set of screenwriter presets, each with its own personality and prose style.

(Hint: Alice is the best screenwriter!)

Save any setup as a reusable template. All eleven included templates were built this way.

---

Runs everywhere

• Browser — open localhost:8080, play immediately
• Desktop app — an included Electron shell launches the server and opens a native window. One command, no browser needed
• Mobile & tablet — run the server on your machine and expose it over Tailscale, then install as a PWA on iOS or Android and play from your home screen with a dedicated mobile layout. The mobile UI is a first-class experience, not an afterthought
• Fully responsive — the mobile layout swaps the scrapbook stack for inline photos and collapses panels into drill-down navigation

---

Your saves, your story

• Rewind — saved snapshots at every act boundary, presented as a contact sheet. Pick any point and branch from there
• Fork — split any save into an independent new game. Explore the path not taken
• Replay — play back any completed game page by page in read-only mode, with jump-to-page
• Everything on disk — no cloud sync, no account, no data leaving your machine. Your game state is a plain JSON file you own

---

What's under the hood

For the developers: Scrapbook uses a multi-agent framework with up to 11 LLM agents per turn, coordinated by two orchestrators.

Module 1 — World Builder constructs the world before the first scene: World Architect → Story Weaver → Protagonist Forge → Character Forge → Location Forge. By the time you read the opening line, the full world bible exists — setting, lore, a multi-act arc, a cast with secrets, a location hierarchy.

Module 2 — CYOA Engine handles each turn: Master Writer → Scene Extractor → Time Resolver → Narrative Agent → Visual Director, with a concurrent back-half running Consequence, Thread Steward, Memory, Act Judge, Change-Up, Blurb, and Image Generation in parallel. An SSE cut-line means you start reading before the images finish generating.

The codebase is clean and well-documented. Adding an inventory system, HP, skill checks, or relationship meters is a matter of extending the world state model and feeding it to the relevant agents — the architecture is designed for it.

---

What you can build

The Developer Edition includes full source. Developers have already asked about:

• HP / stamina driven by consequence outcomes
• Inventory tracked in world state and visible to the writer
• Relationship / affection meters per character
• Skill checks that gate certain choices
• Roguelite death with legacy runs
• Entirely new games in new genres sold independently

The licence permits building and selling derivative games.

---

Cost to run

Running on xAI Grok 4.3 (recommended):

• New game / world build: ~$0.02-0.08
• Per turn: ~$0.01–0.05
• A 30-turn playthrough: ~$2.00

Running on Anthropic Claude (Sonnet/Opus): ~$3–6 for the same.

Running locally (Ollama + Forge): $0, if you have the hardware.

---

Requirements

• Python 3.11+ supported; Python 3.10 recommended
• At least one LLM API key — Anthropic Claude, xAI Grok, or a local Ollama install. The engine runs up to 11 agents per turn concurrently, so your API tier needs to support multiple simultaneous requests. For local LLM models, sequential call mode is used by default (which increases turn latency).
• An image provider — WaveSpeed, xAI Aurora, or a local Automatic1111 / Forge install (optional but highly recommended)
• A modern browser or use the Electron path documented

Setup takes 10–15 minutes. Full documentation included: SETUP.md, CONFIGURATION.md, and an agent pipeline reference for developers.

---

Scrapbook — Developer Edition. Every choice leaves a mark.