This is the full developer documentation for Coloring Book Engine # Documentation > Learn how to plan, create, color, and export KDP-ready coloring books with CBE. ## Still have questions? [Section titled “Still have questions?”](#still-have-questions) This handbook walks through every stage of production, from the first idea to the KDP upload. If you can’t find what you need: * **[Contact support](https://coloringbook.dev/support)** — questions, license recovery, and feedback * **[coloringbook.dev](https://coloringbook.dev)** — download the app and see what’s new # Design a KDP Cover with Automatic Spine Width > A full design editor for your cover — draw it yourself, or let AI design the whole front. Click the big cover card to open the **Cover Editor** — a full canvas editor working on the real printable cover layout: back cover, spine, and front cover in one spread, with the spine width already computed from your page count.  ## The Toolbox [Section titled “The Toolbox”](#the-toolbox) | Tool | What it does | | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Select (V)** | Move, resize, rotate any object. | | **Text (T)** | Title, subtitle, author name — with font, size, bold/italic, alignment, and three sizing modes (fixed / fit box to text / shrink text to box). | | **Rectangle / Ellipse / Triangle / Line** | Shapes with fill, stroke (solid/dashed/dotted), opacity, rotation, and layer ordering. | | **Page Preview Layout (P)** | The classic coloring-book back cover: a grid of your actual pages (1–3 × 1–3), with card shadows, overlap, and random-rotation options — the “look inside” collage in two clicks. | | **Art from Project (A)** | Place any of your colored pages or sketches on the cover, with flip and mask editing. | | **Guides (G), Zoom (F / R)** | Safe-area guides and view controls. | ## Let AI Do the Design [Section titled “Let AI Do the Design”](#let-ai-do-the-design) Select a cover section (front, back, or spine) and the properties panel offers AI generation, in two scopes: * **Generate Background** — a backdrop image for that section, optionally guided by a prompt (there’s even a **Suggest prompt** button). * **Design Full Front Cover** — describe the cover you want and the AI composes the entire front: hero illustration, composition, the works. Supports `#` character mentions, and a special `{art_objs}` token that tells the AI to incorporate the art pieces you’ve already placed on the canvas. Both are credit-spending actions (marked with the wand icon). You can regenerate freely and keep editing on top — AI output lands as editable objects, not a flattened image. ## Exporting the Cover [Section titled “Exporting the Cover”](#exporting-the-cover) Close the editor (your design saves automatically) and press **Export Cover**. The PDF is produced as a single full-wrap file at exact KDP cover dimensions — back cover + spine + front cover, with the spine width computed from your final interior page count using KDP’s per-page spine factor (a number you should never have to round by hand), and the barcode clearance zone kept clear on the back. Wrong full-wrap dimensions and miscalculated spine width are the two most common reasons KDP rejects covers; here they’re derived, not typed. This is why matter and page selection come first: they fix the page count the spine depends on. If you open the editor before the matter exists, *“Book Details Not Complete”* warns you that the spine can’t be final yet — **Continue Anyway** works, just re-check before export. # Export a Single-Sided, KDP-Compliant Interior PDF > One click produces a KDP-compliant interior — with optional digital and review (ARC) editions. With matter and cover in place, the interior export is the easy part — the app already knows your trim size, bleed, and page structure. The **Interior** section lays the whole book out as three cards — front matter, coloring pages, back matter — with the export controls on top. Note the automatic blank pages (4, 6, 44, 46 below) keeping the print spreads correct:  ## Reviewing What Goes In [Section titled “Reviewing What Goes In”](#reviewing-what-goes-in) Click the middle **coloring pages** card to open **Review Coloring Pages** — a grid of every page as it will print, including the automatic blank pages. KDP offers no single-sided printing option, so a proper coloring book simulates it: artwork on every right-hand page, a blank on every left-hand page, in strict alternating order — the standard defense against ink bleed-through ruining the next drawing. Doing that by hand for a 50-page book means inserting and ordering dozens of blanks without a single slip; Coloring Book Engine lays out the single-sided interior automatically. Confirm and you’re set. ## Export Options [Section titled “Export Options”](#export-options) | Control | What it does | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Auto fit contents** | Scales page content to sit inside the KDP safe area automatically. Leave it on unless you have a reason not to. | | **Add N % safe margin** | Extra breathing room (0–10%) inside the safe area, on top of auto-fit. | | **Export ARC & Digital** | When checked, the export also produces a **Digital** edition (for PDF sales/Etsy) and an **ARC** (advance review copy for your review team) alongside the print-ready **Paperback**. | | **Export Book** | Runs the export. | ## What You Get [Section titled “What You Get”](#what-you-get) The export writes into your project’s book folder and pops a summary — *“Export Complete!”* with per-edition page counts (e.g., *Paperback: 108 Pages, Digital: 54 Pages, ARC: 54 Pages*) and an **Open Folder** button. No credits are spent here; it’s pure assembly. Next stop: [validate everything](/book/validate/) before it goes anywhere near KDP. # Upload Your Coloring Book to Amazon KDP > A practical walkthrough of publishing with the files Coloring Book Engine produced. You leave Coloring Book Engine with exactly what KDP’s paperback flow asks for: a print-ready interior PDF and a one-page cover PDF at the correct spine width — both already validated. ## The Short Version [Section titled “The Short Version”](#the-short-version) 1. At [kdp.amazon.com](https://kdp.amazon.com), create a **Paperback**. 2. **Book details** — title, description, keywords, categories. (Your brainstorm answers — audience, theme — are good raw material for keywords. Avoid stuffing generic terms like “book” or “gift” into the title; KDP’s metadata rules prohibit it.) 3. **Content** — set the trim size to your project’s book size, **no bleed** (your PDF is already sized correctly), and upload the interior PDF, then the cover PDF (“Use a cover you already have”). 4. Run KDP’s **Print Previewer**. Because you validated locally, this should be a formality. 5. Set your price and publish. If you exported a **Digital** edition, the same book can go up on Etsy or your own store; the **ARC** edition is for your advance readers. ## AI-Generated vs. AI-Assisted: How to Answer KDP’s Disclosure [Section titled “AI-Generated vs. AI-Assisted: How to Answer KDP’s Disclosure”](#ai-generated-vs-ai-assisted-how-to-answer-kdps-disclosure) During publishing, KDP asks whether your book contains AI-generated content. Under KDP’s official definition, artwork whose *first version* was produced by an AI tool is **AI-generated** — even if you substantially edited it afterwards. So a book made with Coloring Book Engine’s generation stages should be declared **AI-generated: answer Yes.** Two things worth knowing before that makes you nervous: * **There is no penalty for answering Yes.** The disclosure isn’t shown to buyers. The account-level risk is in answering No and being caught — image-heavy categories like coloring books get extra scrutiny. * If you **imported your own hand-drawn artwork** and only used the local pipeline (processing, vectorizing, assembly), that’s **AI-assisted** under KDP’s definition — no disclosure required. One practical timing note: reviews of AI-disclosed, image-heavy books are commonly reported to take several days rather than hours — leave a buffer before any announced launch date. *(Draft note: this chapter will get screenshots of the actual KDP flow and pricing guidance in a later pass.)* # Front & Back Matter, Generated in Your Book's Style > Title, copyright, and closing pages — generated by AI in your book's own art style, or uploaded as your own PDFs. Matter pages are the non-coloring pages that make a book feel finished: the title page, an ownership/nameplate page, a farewell page. Coloring Book Engine generates them **in your book’s art style** — hand-lettered title art, themed decorations — instead of the generic typeset pages most self-published books settle for. ## Generate with AI [Section titled “Generate with AI”](#generate-with-ai) Click the wand button on the **front matter** or **back matter** card. The generation dialog is pre-filled from your project’s brainstorm — edit anything before generating: | Field | Notes | | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------- | | **Book Title** *(front only)* | Baked into the FM-1 title page as hand-lettered art. | | **Theme** | e.g., *forest animals, vintage botanical*. | | **Art Style** | e.g., *bold rounded cartoon line art*. | | **Mascot Description** | Optional. Supports `#` mentions of your Image Pool characters, so your hero can appear on the title page. | | **Cover Hero Composition (FM-1)** *(front only)* | Art direction for the title-page illustration. | Press **Generate** (this spends AI credits — front matter is 4 pages, back matter 2, with blank pages costing nothing) and watch the progress grid: each page moves through *Generating image → Vectorizing → Composing PDF page → Saving*. The result is saved as a matter PDF and appears as page thumbnails on the card. The standard set: **FM-1** title echo, **FM-2** page-protection note, **FM-3** ownership/nameplate, **FM-4** blank — and **BM-1** farewell, **BM-2** blank. The trailing blanks are intentional: they keep the book’s left/right page parity correct for printing. ## Or Upload Your Own [Section titled “Or Upload Your Own”](#or-upload-your-own) Each card is also a drop zone — drop (or click to pick) any PDF to use as your matter. Page thumbnails render on the card; the X button removes it. ## “make it even” [Section titled ““make it even””](#make-it-even) If your front matter ends up with an odd page count, a dashed **make it even** button appears — one click adds a blank page so your first coloring page starts on the correct side of the spread. If you’re unsure whether you need it: you do. # Book Stage Overview: Assemble a KDP-Ready Book > The Book stage — assemble, export, and validate a KDP-ready book. The Book stage turns your pages into a publishable book. It has two tabs: **Make** (assemble and export) and **Validate** (audit the PDFs and preview the physical book in 3D).  ## The Make Tab at a Glance [Section titled “The Make Tab at a Glance”](#the-make-tab-at-a-glance) The Make tab is organized around two sections: * **Covers** — the cover editor card (with a completion checklist: Sketch, Colored, Front Matter, Back Matter) and the **Export Cover** button. See [Cover Design](/book/cover/).  * **Interior** — three cards side by side: [front matter](/book/matter/), your coloring pages (click to review the full set), and back matter — plus the **Export Book** controls. See [Export to PDF](/book/export/). ## The Order That Works [Section titled “The Order That Works”](#the-order-that-works) 1. Generate (or upload) [front and back matter](/book/matter/) — the cover needs them to compute the spine. 2. Design and export your [cover](/book/cover/). 3. [Export the book PDF](/book/export/). 4. [Validate both PDFs and flip through the 3D preview](/book/validate/) before uploading to [KDP](/book/kdp/). You can jump around — the app warns rather than blocks (e.g., opening the cover editor without matter shows *“Book Details Not Complete”* with a **Continue Anyway** option) — but the order above avoids re-doing the cover when the page count changes. # Validate Your KDP PDFs & Preview the Book in 3D > Catch every common KDP rejection before you upload — then flip through your book in 3D. KDP rejections cost days: upload, wait for review, get bounced with *“text or images outside the margin”* or a cover dimension mismatch, guess at a fix, re-upload, repeat. The **Validate** tab is a local preflight check — it runs the same class of checks in seconds, before Amazon ever sees the file. ## Interior PDF Audit [Section titled “Interior PDF Audit”](#interior-pdf-audit) Drop your exported interior PDF (or any interior PDF) onto the **Interior PDF** panel. Three checks run immediately: 1. **Page count** — at least KDP’s minimum (*“Only N pages (KDP requires ≥ 24)”* if not). 2. **Dimensions** — every page must match your project trim size exactly; mismatches are counted and the first offender identified. 3. **Safe area** — content that overflows KDP’s printable safe area is flagged **per page**, with a clickable list that jumps straight to each offending page in the viewer.  ## Cover PDF Audit [Section titled “Cover PDF Audit”](#cover-pdf-audit) Same drill on the **Cover PDF** panel: 1. **Single page** — a cover PDF must be exactly one page. 2. **Dimensions vs. KDP cover spec** — checked against the spine width for your actual page count, with expected-vs-got sizes shown on failure. 3. **Spine consistency** — if the cover was built for a different page count than the interior you loaded (*“Cover spine assumes 108 pages but interior PDF has 96”*), you’ll know before Amazon does.  ## The 3D Preview [Section titled “The 3D Preview”](#the-3d-preview) With both PDFs loaded, **Open 3D viewer** unlocks: a physically-sized 3D book you can rotate, pan, zoom, open, and page through — front cover, spine thickness, page flips, all of it.   It’s the closest thing to holding the proof copy without ordering one, and it regularly catches things audits can’t express: a spine title that’s too tight, a back-cover collage that feels crowded. When everything passes, you’re ready to [upload to KDP](/book/kdp/). # Colorize: Batch-Color Your Pages with AI > Batch-color your pages — every toolbar option, card action, and warning explained. The Colorize tab (API mode) works just like Sketch’s Make tab: press **Run Rest**, and every page without a colored version is queued and generated using its **Color Prompt** from the plan. ## Toolbar Reference [Section titled “Toolbar Reference”](#toolbar-reference) | Control | What it does | | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Import images** (icon button) | Bring in externally colored images instead of generating. | | **Cost / Quality** toggle | Generation quality tier for coloring, independent of the Sketch toggle. In most cases **Cost** already produces satisfying results; switch to **Quality** when a page deserves the best possible pass. | | **Run Rest** | Colors only the pages that don’t have a colored version yet — never re-bills finished pages. Your default button. | | **Run All** | Colors every page with a valid prompt. Skips nothing, so use it deliberately. | | **Stop** | Appears during a run; aborts the queue. Queued pages return to empty; pages already generated are kept. | ## Working the Grid [Section titled “Working the Grid”](#working-the-grid) Cards move through the same states as Sketch: **In Queue → Generating… → done**, with a red **Retry** state on failure. * **Click an empty card** to color just that page. * **Hover a finished card** for two buttons: **edit** (opens the edit dialog below) and **retry** (regenerate from scratch). * **Amber warning triangle on an empty card** — that page has no Color Prompt. It can still generate (the AI picks colors on its own), and the app will ask first: *“This page has no color prompt — the AI will choose colors on its own. Generate without one?”* with **Write a Color Prompt** (jumps to the plan) or **Continue Anyway**. * **Right-click any card** → **Show in Explorer** to find the file on disk. ## Editing a Colored Page [Section titled “Editing a Colored Page”](#editing-a-colored-page) The **Edit Image with AI** dialog works exactly like the Sketch one: describe changes in **Additional requirements** (e.g., *“make the colors more vibrant, change the sky to sunset”*) to refine the current image, or unlock and rewrite the Color Direction to regenerate from scratch. `#` mentions of Image Pool characters are supported in both fields. ## Local Mode [Section titled “Local Mode”](#local-mode) When Coloring is routed to **Local AI**, this same **Colorize** tab runs the model on your own GPU instead of the cloud — **Run Rest** and **Run All** behave exactly as above, but generate on-device with no per-image API cost. The first local run checks that the model is present and offers a one-time **Start Download** (**\~7.4 GB**, three files); after that the grid, states, and editing are identical to API mode. Local AI is the zero-cost default. For a cover or preview you’ll sell, the API still gives the cleanest reproduction of your line-art — see the [stage overview](/coloring/overview/) for how to route each pass. # Finalize: Composite Preview & the Color Editor > Preview the final artwork — color and line art composited — and hand-fix any segment in the Color Editor. Finalize is where the colored set becomes official: each card shows the processed color layer **composited with its line art**, so what you see is the finished artwork exactly as your cover, previews, and videos will use it. ## Controls [Section titled “Controls”](#controls) | Control | What it does | | ------------------------------- | ----------------------------------------------------------------------------------------------------------------- | | **Load All** | Copies every processed page into the final set, one-to-one. The fast path when you’re happy with the whole batch. | | **Import images** (icon button) | Bring in outside images for specific pages — final creative control stays with you. | | **Click a card** | Opens the **Color Editor** for that page — see below. | ## The Color Editor: Hand-Finish the Details [Section titled “The Color Editor: Hand-Finish the Details”](#the-color-editor-hand-finish-the-details) Clicking any page opens the **Color Editor** — a simple, purpose-built image editor with two tools: an **eyedropper** and a **paint bucket**. It preserves the palette your pages were processed with, so recolors stay consistent with the rest of the book: pick a color from the swatch row (or lift one straight from the artwork with the eyedropper) and fill the region that needs fixing. When a detail calls for something new, the **+** button adds a color to the palette.  It’s where you hand-finish the final details the earlier stages missed — no regeneration, no credits, and your palette stays intact. **Save** writes the result; **Reset** returns to the processed original. With the final set assembled, the Coloring stage is complete — on to [Book](/book/overview/). # Coloring Stage Overview: Local or API > The Coloring stage — colored versions of your pages for covers, previews, and promo content. The Coloring stage produces colored versions of your line-art pages. These aren’t for the book interior (readers color that themselves) — they’re for everything that *sells* the book: the cover, marketing previews, and the coloring timelapse videos.  ## Two Ways to Color [Section titled “Two Ways to Color”](#two-ways-to-color) Coloring — like every stage — can run on **Local AI** or a cloud **API**, and both share the exact same flow and tabs (**Colorize → Process → Finalize**): * **Local AI** *(the default)* — runs the coloring model on your own GPU. No API key, no credits. It needs a dedicated GPU (roughly **8 GB+ VRAM**) and a one-time **\~7.4 GB** model download; the app offers **Start Download** the first time you color locally. * **API** — cloud AI colorizes your sketches from the Color Prompts in your plan, spending credits like sketch generation. It’s the pass to reach for on a cover you’ll sell, where the cleanest reproduction of your line-art matters most. Which one runs is set by your global **Coloring** routing (**Model per task**), not a per-project choice — change it anytime in **Connect Your AI** or **Settings → AI**. On first visit the app also asks right here whether to color locally or via the API, and sets that same routing for you. Both paths converge on the same flow: color the pages ([Colorize](/coloring/colorize/)), rework them into a real-marker look ([Process](/coloring/process/)), and pick the final set ([Finalize](/coloring/finalize/)). ## Prerequisite [Section titled “Prerequisite”](#prerequisite) Coloring works from your **processed sketches**, so finish the Sketch stage first. If you jump ahead, the app tells you exactly what’s missing (e.g., *“Binary sketch images aren’t ready yet — finish the Sketch stage first.”*). # Process: Palette Transfer to a Real Marker Look > The Process tab reworks the coloring layer into a clean, single-tone alcohol-marker look — palette transfer included, automatically. The Process tab takes your colorized pages and produces the final coloring layer: it isolates **just the color layer** of each image (the line art is untouched) and reworks it into a clean, single-tone alcohol-marker look. The palette transfer happens automatically — you pick the palette, the app produces the final layer. It runs locally and costs nothing. ## Controls [Section titled “Controls”](#controls) | Control | What it does | | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | | **Palette** checkbox | On (default): the color layer is transferred to the selected palette. Off: colors pass through as-is. | | **Palette** button | Opens **Select Color Palette** — see below. | | **Skip** | Skips processing entirely: copies the colorized pages straight to Finalize. Use it when the raw AI colors are already what you want. | | **Run All** | Processes every page and fills the grid. Re-running asks for overwrite confirmation. | Click any single card to (re)process just that page; the palette setting persists per project, so late redos match the rest of the book. ## Choosing a Palette [Section titled “Choosing a Palette”](#choosing-a-palette) The **Select Color Palette** dialog offers real product palettes — each preview shows the actual marker set’s character:  * **Copic 358** — the full professional marker range: broad, balanced coverage. * **Honolulu 216** — softer, warmer spread. * **Tombow 108** — compact, vivid set. ## Why Bother? [Section titled “Why Bother?”](#why-bother) Raw AI-colored images look digital. A palette-transferred color layer looks like someone colored the page with an actual marker set — which is exactly the look your cover, previews, and coloring videos should have, and a look competitors’ raw AI output doesn’t match. # App Conventions: Buttons, the Grid, and Runs > Three rules that hold everywhere in Coloring Book Engine — button colors, the page grid, and how runs work. Coloring Book Engine is **local-first**: its AI runs on your own device by default — no API key, no credits — and any task can be routed to a cloud API the moment you want extra quality. Set that up once (below); after that, three conventions hold across every stage — learn them and every screen reads instantly. ## Your AI: Local by Default, API When It Counts [Section titled “Your AI: Local by Default, API When It Counts”](#your-ai-local-by-default-api-when-it-counts)  Coloring Book Engine ships a full generative stack that runs **on your own machine**. **Local AI** needs no API key and spends no credits: if your device has a capable GPU (roughly **8 GB+ VRAM**), every stage can generate for free, offline. Cloud **API** providers — OpenAI and Google AI — are optional. Keep them for the passes that *sell* the book, where a top-tier model earns its small cost: the cleanest cover, the sharpest line-art. You choose this **per task**, not once for the whole app. The **Model per task** panel routes each of the four jobs on its own: * **Plan & Text** — the planning chatbot and every prompt suggestion. * **Sketch Generation** — the line-art pages. * **Coloring** — colored versions for covers, previews, and videos. * **Book** — cover art and front & back matter. A **budget tier** sets all four at once — **0 Cost** (everything local), **Efficiency**, **Quality** (the default), and **No Compromise** (everything API) — and you can still flip any single task afterward. The panel shows the **estimated API cost for a 50-page project** right there (about **≈$4** on the default tier), so nothing bills you by surprise. For a product you’ll sell, we recommend leaning on the API for the final pass. Everything below — button colors especially — is just the app reflecting the choice you made here. ## 1. Button Color Tells You What Costs Credits [Section titled “1. Button Color Tells You What Costs Credits”](#1-button-color-tells-you-what-costs-credits) * **Orange buttons** spend AI credits — a task you routed to the cloud API: image generation, AI edits, matter and cover generation. If a button is orange, pressing it calls your AI provider. * **Blue buttons** run on your machine for free — Local AI generation as well as processing, vectorizing, exporting, and rendering. You never have to wonder whether an action will bill you: the color answers before you click. 🟠 Spends AI credits Run Rest Run All Generate Background 🔵 Free — runs on your PC Run Rest Run All Export Cover Export Book ## 2. The Grid Is Your Book [Section titled “2. The Grid Is Your Book”](#2-the-grid-is-your-book) Every stage is built around the same grid, where **each grid item is one coloring page** of your book — page 001 is the same page in Sketch, Coloring, Assets, and Videos. Clicking an item opens whatever that stage needs for that page: an editor (masking touch-up, segment coloring) or a viewer (paths, compiled previews, videos).  The grid is also your progress display — each card shows its state (empty, queued, generating, done, error) so a glance tells you where the stage stands. ## 3. Three Ways to Run Work [Section titled “3. Three Ways to Run Work”](#3-three-ways-to-run-work) Every generation stage offers the same three actions — pick whichever the situation calls for: * **Single item** — click one empty card to produce just that page. * **Retry** — regenerate or reprocess one card that failed or came out wrong. * **Batch** — **Run Rest** fills only the empty slots (your default; it never re-bills finished pages), while **Run All** redoes everything (it warns first, and backs up existing work). 01 10 001  Single item — click an empty card  002  Retry — redo just this card Run Rest Run All  Batch — the whole grid at once Progressing through a stage is just combining these: batch to fill, single/retry to fix, and move on. Next: [Plan](/plan/overview/) — where your book takes shape. # Create Your First Coloring Book Project > Create a new project and learn to read the progress dashboard. A project in Coloring Book Engine is one coloring book — and one folder. The plan, the pages, the cover, the videos: your entire unit of work stays organized inside a single folder you choose, easy to back up, move, or archive as one thing. ## The Whole Journey at a Glance [Section titled “The Whole Journey at a Glance”](#the-whole-journey-at-a-glance) Here’s the road ahead — every stage and sub-step, and where AI is involved (yellow) versus what runs free on your device (white):  ## Create a New Project [Section titled “Create a New Project”](#create-a-new-project) From the **Projects** screen, choose **Start New Project**:  You only make three decisions here: 1. **Where it lives** — pick a workspace folder. Each book becomes a folder inside it, so your whole catalog stays organized in one place. 2. **How many pages** — anywhere from 20 to 200. Most coloring books sold on KDP land in the 40–50 page range, and 50 pages is the sweet spot: the most customer value you can offer without crossing into KDP’s higher printing-cost bracket. 3. **Book size** — pick one of the popular KDP trim-size presets: 8.5″ × 11″ is the classic coloring-book format, and the 8.5″ × 8.5″ square dominates today’s adult-coloring bestseller lists. (You can also enter a custom size in inches or centimeters.) Everything downstream — image dimensions, cover spine, export margins — is derived from this choice automatically, so you never have to think about trim, bleed, or gutter math again. That’s it. No style setup, no templates, no configuration — the creative decisions happen in the next stage, Plan. ## Reading the Progress Dashboard [Section titled “Reading the Progress Dashboard”](#reading-the-progress-dashboard) The Projects screen doubles as your production dashboard. Each project card shows a row of six status dots — one per stage (Plan, Sketch, Coloring, Book, Assets, Videos). Filled dots mean the stage is complete, so you can see at a glance which book needs what:  * A book with four dots filled is waiting on its cover and videos. * A freshly created book shows six empty dots — a to-do list in miniature. If you work on several books at once (most publishers do), this view is how you decide what to work on today. Opening any project drops you exactly where you left off. Before diving in, take one minute for the [app conventions](/get-started/conventions/) — three rules that hold on every screen. # Introduction to Coloring Book Engine > What Coloring Book Engine is — own your tool, ship a real book, and promote it with content made from your own pages. Coloring Book Engine is a desktop app that takes you from a rough idea to a finished, selling coloring book — planning, line art, coloring, a print-ready PDF, and the marketing videos to promote it — in one continuous workflow. You don’t need to be an artist, and you don’t need to know anything about print specifications. Everything it does comes down to three things that set it apart. ## Own It [Section titled “Own It”](#own-it) *No subscription — you control the costs.*  Coloring Book Engine is a tool you own, not a service you rent. There’s no subscription and no middleman markup — it’s strictly pay-as-you-go: costs occur only at the moment you generate with AI, and **if you’re not generating, you’re not paying**. Planning, editing, exporting, rendering videos — none of it costs a thing. Your API key stays on your PC, finished pages are never re-billed, and heavy work like video rendering runs free on your own machine. ## Ship It [Section titled “Ship It”](#ship-it) *From blank page to published book.*  Most AI tools hand you a pile of images and wish you luck. Coloring Book Engine runs a production line: **Plan** the book, generate consistent **line art** and **vectorize** it so every line stays razor-sharp at any print resolution, create **colored** versions, and assemble a **book** with a designed cover, styled title pages, and a KDP-compliant PDF — validated against the same checks Amazon runs, with a 3D preview of the physical book before you upload. Notice the fox above staying the same fox at every station: named character references keep your hero’s face identical from page 1 to page 50, which is the difference between a book that looks generated and a book that sells. ## Promote It [Section titled “Promote It”](#promote-it) *Every page becomes content that sells the book.*  Publishing is half the job — the other half is getting seen. Coloring Book Engine turns your finished pages into **coloring timelapse videos**: your line art coloring itself in, synced to music — prepared so you can put them to work on each platform. A 50-page book becomes 50 pieces of social content, rendered locally at no credit cost. No competing tool does this. ## What You’ll Build [Section titled “What You’ll Build”](#what-youll-build) This handbook follows one real project through all three: *Cozy Axolotl and Pond Pals*, a children’s coloring book. By the end you’ll have a complete set of consistent line-art pages, a designed cover with styled title pages, a validated KDP-ready PDF — and a folder of promo videos to launch it with. Next: [Activate & Connect](/get-started/setup/) — owning it starts here. # Activate Your License & Connect Your AI > Two one-time steps before your first book — activate your license, then connect your AI account. Setting up the app takes two one-time steps: activate it with a license key, and connect the AI account that powers generation. ## Activate Your License [Section titled “Activate Your License”](#activate-your-license) Coloring Book Engine runs on a license key — either a **trial key** (free, from [coloringbook.dev](https://coloringbook.dev)) or a **full license**. After a purchase, your key arrives by email, together with the download link:  When the app first starts, the **Activate Your License** dialog asks for that key:  1. Paste your **License Key**. 2. Optionally give this computer a **Device Name** (handy later if you use more than one machine). 3. Agree to the **End User License Agreement** and press **Activate**. Don’t have a key yet? The **Get a Trial Key** link in the dialog takes you straight to the free trial. Once activated, the license panel (Settings → **License**) shows your **Plan**, how many **Devices** are in use, and the expiry (**Lifetime** for a full license):  A few things worth knowing: * **Trial keys unlock the full workflow** with some limits (such as the number of pages per project). Everything in this handbook works on a trial. * **Device seats** — your license allows a set number of devices. If you hit *“Maximum Activations Reached”*, open **Manage Devices** and **Deactivate** a machine you no longer use, then activate the new one. Moving to a new PC is exactly this: deactivate old, activate new. * Upgrading from trial to full is the same dialog with your new key. ## Connect Your AI [Section titled “Connect Your AI”](#connect-your-ai) Coloring Book Engine runs its AI **on your device by default** — with a capable GPU you can generate every stage on **Local AI**, no key and no credits. Connecting a cloud provider is optional: add one for the extra quality of a top-tier model on the passes that sell your book. There’s no subscription and no middleman markup — you pay your provider only for what you actually generate. ([App Conventions](/get-started/conventions/) explains how each task is routed.) On the **Projects** screen, choose **Connect Your AI**, pick your provider, and paste your API key — **OpenAI** or **Google AI** for the image-generation stages (a **Get API Key** link takes you straight to your provider’s key page):  Don’t have a key yet? Grab one from your provider’s official page — it takes a couple of minutes: [**OpenAI (GPT)** Create an API key at platform.openai.com ↗ ](https://platform.openai.com/api-keys)[**Google Gemini** Create an API key at aistudio.google.com ↗](https://aistudio.google.com/apikey) Two things worth knowing: * **Your API key is stored locally on this PC** and used only to send requests directly to the provider you choose. * **Your own artwork can be the starting point of the workflow.** Connect a generative AI, though, and Coloring Book Engine becomes more than an image generator — it becomes the execution environment that turns the coloring book in your head into a ready product, starting at the planning stage. Because the AI can carry the work forward through every production stage, we recommend the latest top-tier model for the full workflow. With both keys in place, you’re ready to [create your first project](/get-started/first-project/). # AI Agents & MCP Automation > Connect a local MCP client, check CBE readiness, and run or resume a coloring-book pipeline. CBE’s `cbe-mcp` sidecar lets an MCP-capable desktop agent create a project, write its plan, and run Sketch → Coloring → Book → Assets → Videos. The agent writes the plan from your brief; CBE executes it in the desktop app. Keep the app and desktop session available while work runs. The in-app [AutoMate dashboard](/help/automate/) also automates production. Both run headless by default: no cursor or keyboard takeover, and the run continues while the CBE window is behind other windows or minimized. MCP uses an unattended pipeline with output checks and progress polling; its optional `simulate=true` is the same visible demo mode as AutoMate’s **Simulate** switch, for recordings only. ## Connect your client [Section titled “Connect your client”](#connect-your-client) Install CBE first so the bundled MCP executable is available. Add this local stdio server to your client’s MCP configuration, then reconnect the client: ```json { "mcpServers": { "cbe": { "command": "cbe-mcp" } } } ``` This is the **Windows packaged-install** configuration. If the command is not found, check the CBE app execution alias in Windows settings or use `%LOCALAPPDATA%\Microsoft\WindowsApps\cbe-mcp.exe` with the environment variable expanded to your actual user path. Do not use a versioned `Program Files\WindowsApps` path: it changes on updates. On **macOS**, use the installed bundle’s executable as `command`, normally `/Applications/Coloring Book Engine.app/Contents/MacOS/cbe-mcp`. Adjust the path if you installed elsewhere. Automatic installation and launch are implemented for Windows and macOS; **Linux installed-app installation and launch are not yet implemented in the sidecar**. Linux developer launches require a source checkout and `CBE_MCP_DEV=1`, not just the configuration above. The example is for clients accepting `mcpServers` JSON; other clients have their own registration format. CBE is a **local stdio server**, not a public HTTPS MCP endpoint. A browser-only assistant cannot connect to it without a compatible local bridge. No account keys belong in this configuration. ## Check readiness before spending credits [Section titled “Check readiness before spending credits”](#check-readiness-before-spending-credits) Ask the agent to call `cbe_status` first. This can attach to a running app, but does not launch one. If needed, `cbe_setup {}` launches or attaches; `cbe_setup {"install":true}` can install or update the app when the sidecar is already available. | Check | What to inspect | | ----------------- | --------------------------------------------------------------------------------------------------------------- | | Connection | `attached=true`, no `attach_error` | | Compatibility | `protocol_compatible=true`; update app and sidecar together if false or absent | | License | `onboarding.licensed=true`; `onboarding.trial` identifies Trial scope | | Selected AI route | Inspect `onboarding.taskModes` for the tasks you will run | | API route | Selected provider and its `onboarding.keys` entry; a stored key is not proof that the provider accepts requests | | OAuth route | `onboarding.oauth.ready=true`; follow its message if sign-in is needed | | Local route | `onboarding.localSupported=true` and `onboarding.modelsAllComplete=true` | | Project | Open the intended project and read its brainstorm, plan and image pool before modifying them | `onboarding.ready=true` means the bridge responded; it is **not an overall generation-readiness verdict**. Missing or unknown fields are not a pass. A small run is still needed to verify the selected provider or local runtime. Reuse existing settings. Prefer entering secrets in CBE settings; values supplied as MCP tool parameters may also be retained by the client in its conversation history. OAuth sign-in can require you to interact with the login flow. When setup starts onboarding, poll `cbe_setup_status` until `done=true`, or stop and resolve `error`. Then call `cbe_status` again. A model download can take a long time; do not start a second setup while one is running. ## Give the agent a brief [Section titled “Give the agent a brief”](#give-the-agent-a-brief) Include a project name, theme, audience, difficulty, style, special features, page count (20–200), trim size, output folder and desired stages. Reference images must be local file paths. A useful request is: > Create a 20-page woodland coloring book for ages 6–9, 8.5×11 inches, with bold simple outlines and one scene per page. Use my configured AI settings. Start with Sketch only, keep completed work when resuming, and report the project path, actual page scope and any errors. The agent should inspect status, create or open the project, add optional references, set the five brainstorm fields, write the page plan, then start the pipeline. Sketch prompts begin with a composition declaration such as `Single full-page scene.` and describe line art without color words. Entity references use exact `{Label}` tokens from the image pool. Color prompts can be omitted for automatic authoring. Valid Trial and paid licenses both support MCP. Trial content work is limited to pages **1–6**, with export watermarks; a 20-page project does not mean Trial generated all 20 pages. Read the plan response for editable scope and preserve locked rows. ## Run, poll and recover [Section titled “Run, poll and recover”](#run-poll-and-recover) Start a small first run: ```json {"stages":["sketch"],"skip_completed":true,"palette":1} ``` Pass this to `cbe_run_pipeline`. Supported stages are `sketch`, `coloring`, `book`, `assets`, `videos`; later stages need the earlier artifacts. Leave `simulate` out (or `false`) unless the user explicitly wants a visible demo: `true` drives the UI with a real cursor and keystrokes, takes over the mouse and keyboard, and needs the CBE window in front. Poll `cbe_pipeline_status` every 5–10 seconds with the previous `nextCursor` as `cursor` (start at `0`). * Success requires `done=true`, `running=false`, no `error` and no cancellation. A start acknowledgement or aggregate progress flag is insufficient. * On failure, use `errorDetails` and its next action. Fix authentication or licensing before retrying; do not loop on rejected credentials. * With `skip_completed=true`, valid completed outputs are preserved and missing or corrupt outputs are rebuilt. Rebuilding and in-flight provider requests can cost credits. `false` explicitly requests regeneration of the selected stages. * `cbe_cancel` requests cooperative cancellation. Keep polling until `running=false`; an in-flight operation may finish first. * After sidecar reconnection, attach and continue polling. After an app restart, reopen the project and run with resume enabled to reconstruct work from disk. The latest run log is at `.cbe/pipeline-run.json` in the project. Check `logPath` and `logError`; a failed log write is worth reporting even if generation succeeded. Output validation checks structural integrity, not artistic quality or publishing acceptance. Review the actual PDFs, images and videos before distribution. CBE does not upload or publish to KDP through this workflow. ## Cover editing [Section titled “Cover editing”](#cover-editing) For separate cover work, use `cbe_cover_templates` and `cbe_cover_design`. Read state before changing templates; follow any template-change confirmation returned by the tool. Poll individual generation jobs to completion, save, then export. Do not start a pipeline while cover generation is running. The MCP server supplies detailed cover instructions to the client. # AutoMate: Build a Whole Book Hands-Free > Hand the whole pipeline to Brushey the AutoMate and come back to a finished book. Once you’ve been through the workflow manually, AutoMate is the shortcut for every book after that: **Brushey the AutoMate**, an in-app agent that drives the same stages you would — Sketch, Coloring, Book, Assets, Videos — clicking the same buttons, respecting the same rules.  ## The Dashboard, Top to Bottom [Section titled “The Dashboard, Top to Bottom”](#the-dashboard-top-to-bottom) * **Project** — the brief, assembled from your open project (name, page count, trim size). * **Palette** — the marker palette the Coloring stage will use (**None**, **Copic 358**, **Honolulu 216**, **Tombow 108**). * **Masking** — the Assets-stage toggles (**Remove White**, **Object Mask**). * **Audio Sync** — point it at a music folder (with **Is Loop**) and the videos come out synced, same as in the Videos stage. * **Simulate Inputs** — off by default: Brushey works headless, never touches your mouse or keyboard, and keeps going while you use other apps or leave CBE minimized. Turn **Simulate** on only for a demo or a recording: Brushey then moves the real cursor and types like a person (with optional **Typing**/**Click** sounds), which takes over your mouse and keyboard and needs the CBE window in front for the whole run. The switch resets to off every time you start the app. **Close on Start** collapses the dashboard once the run begins. * **Stages to run** — pick any subset of Sketch / Coloring / Book / Assets / Videos. With **Skip done** on, stages and pages that are already complete are detected and skipped — never redone. * **Progress** — a stepper across the pipeline plus a live log of exactly what Brushey is doing. **Run** starts it; the same button stops and resumes. When the run finishes, the output notes tell you what matters: `book_cover.pdf` and `book_paperback.pdf` are the files you submit to KDP, and the MP4s are your full timelapse videos. ## Credit Safety [Section titled “Credit Safety”](#credit-safety) With Skip done enabled, AutoMate resumes unfinished work. For MCP, `skip_completed=true` preserves valid completed outputs; missing or corrupt outputs can be regenerated. Regeneration and in-flight API requests can cost credits, so resuming does not guarantee zero additional cost. ## When to Use It [Section titled “When to Use It”](#when-to-use-it) * **Overnight batch** — plan two or three books in the evening, run AutoMate, review finished drafts in the morning. * **Restarting stalled projects** — point it at a half-finished book with **Skip done** on, and it completes only what’s missing. ## AI agents and MCP automation [Section titled “AI agents and MCP automation”](#ai-agents-and-mcp-automation) Connect an external agent, check readiness, and run or recover the pipeline: [AI Agents & MCP Automation](/help/agents/). # How to Save on AI Credits > The habits — and the built-in protections — that keep your AI spending minimal. Coloring Book Engine is **local-first**, so wasted credits require deliberate effort: most tasks can run on **Local AI** for free, and credits are only ever spent where you choose. Here’s the full picture of where money goes — and how to spend less of it. ## Where Credits Go (and Don’t) [Section titled “Where Credits Go (and Don’t)”](#where-credits-go-and-dont) | Spends credits | Free (local) | | ---------------------------------------------------------- | ----------------------------------------------- | | Sketch generation & edits | Sketch Process and Vectorize | | Coloring via API (& edits) | Coloring via Local AI, palette/adjust, Finalize | | Matter & cover AI generation | Book export, validation, 3D preview | | Plan chat & one-time image analysis *(cheap — text-scale)* | The entire Assets & Videos pipeline | ## The Habits [Section titled “The Habits”](#the-habits) 1. **Run Rest is the default.** It only fills empty slots — finished pages are never re-billed. Reach for **Run All** only when you genuinely want to redo everything (and it will warn you and back up the old images first). 2. **Draft on Cost, finish on Quality.** Iterate your prompts and plan on the cheap tier; flip the toggle for the final pass on pages that earned it. 3. **Fix pages one at a time.** A page you dislike costs one credit to redo — click that card, don’t re-run the batch. 4. **Refine instead of regenerate.** The edit dialog’s “Additional requirements” mode adjusts the existing image; it’s more predictable than a fresh roll of the dice, so you converge in fewer attempts. 5. **Front-load the Plan stage.** Every hour in Plan (free) sharpens prompts that would otherwise burn credits on mediocre generations. Mention only the characters a page needs — each `{Name}` reference adds a little to the request. 6. **Let Local AI do the work.** If your device has a capable GPU (\~8 GB+ VRAM), route Sketch, Coloring, and Book to **Local AI** — it generates on-device for zero credits, and it’s the app default. Keep the API for the final, sellable pass, where line quality earns its small cost. ## The Built-in Protections [Section titled “The Built-in Protections”](#the-built-in-protections) Even if you ignore all of the above: finished pages are never silently regenerated, Run All always warns and backs up, two consecutive failures pause the queue instead of burning through retries, and generation is paced to respect provider rate limits. # Troubleshooting Coloring Book Engine > The most common issues, in the order you're likely to meet them. ## Generation Won’t Start [Section titled “Generation Won’t Start”](#generation-wont-start) * ***API Key Required* / Send button disabled** — no AI key is configured. Projects screen → **Connect Your AI**. * ***Prompt is required for generation*** — the page has no prompt; fill it in Plan. * **Run Rest is disabled** — there’s nothing to fill: every page is done or already queued. * ***Prerequisites Not Ready*** — a stage is missing its input (e.g., coloring needs processed sketches). The message names the stage to finish first. ## Generation Stops or Fails [Section titled “Generation Stops or Fails”](#generation-stops-or-fails) * ***Generation Stopped* (after 2 consecutive failures)** — the queue pauses to protect your credits. The usual causes are provider rate limits or a temporary outage; wait a minute and press **Run Rest** to continue where it stopped. * **429 / rate-limit errors** — the app already paces requests, but other tools sharing your API key count against the same limit. Pause the other tool or wait it out. * ***Organization Verification Required*** — gpt-image-2 needs a one-time verification on your OpenAI account; generation continues automatically on dall-e-3 meanwhile. Retry affected pages after verifying (style anchors need a reference-capable model). * **A single page keeps failing** — retry it individually; if it persists, slightly reword that page’s prompt (occasionally a specific prompt trips a provider’s content filter). ## Output Looks Wrong [Section titled “Output Looks Wrong”](#output-looks-wrong) * **Character looks different on some pages** — make sure those pages’ prompts actually mention the character (`{Name}`), and that the pages weren’t generated during a dall-e-3 fallback (the card shows a notice if so). * **Style drifts across the book** — set a style anchor in Sketch’s toolbar (needs a style image in your Image Pool). * **Mask leaks color into the background** — open that page in the Masking Editor and flood-fill the leak; two clicks usually fix it. * **Video card shows “Missing: …”** — that page skipped an Assets step; the message names which one. ## Still Stuck? [Section titled “Still Stuck?”](#still-stuck) [Contact support](https://coloringbook.dev/support) — include the exact message text and which stage/tab you were on, and we can usually pinpoint it immediately. # Brainstorm Your Coloring Book with AI > Answer five key questions — with an AI assistant that can fill the form for you. The Brainstorm tab is a five-question form. Your answers become part of every image prompt the app builds later, so specific answers here directly improve every generated page. ## The 5 Key Questions [Section titled “The 5 Key Questions”](#the-5-key-questions) 1. **“Who is your target audience?”** — e.g., *Children aged 5-10, adults seeking stress relief*. This drives line thickness and complexity downstream. 2. **“What theme or concept would you like to create?”** — e.g., *Forest animals, sea creatures, geometric patterns*. 3. **“What level of difficulty and detail are you planning?”** — e.g., *Beginner level - thick lines, large coloring spaces*. 4. **“What style do you prefer for the coloring designs?”** — e.g., *Cute cartoon style, detailed botanical art style*. 5. **“Do you have any unique features or special concepts?”** — e.g., *Motivational quotes on each page, frame-ready designs*. Optional, but this is where books differentiate themselves. Every field supports `#` mentions: type `#` to reference a named character from your [Image Pool](/plan/image-pool/) — it’s inserted as `{Name}`. ## The Brainstorm AI Assistant [Section titled “The Brainstorm AI Assistant”](#the-brainstorm-ai-assistant) The chat panel on the left (“Brainstorm AI Assistant”) is there so you never face a blank form: * **Ask for ideas** — “What are popular themes for kids?”, “Suggest ideas for animals”. * **Let it fill the form** — when the assistant proposes a direction you like, it can write the answers straight into the five fields; you’ll see them populate automatically. * **Attach images** — drop an image into the chat (paperclip button or drag & drop) to discuss it; the assistant can even suggest cropping characters out of it into your Image Pool. * **Pick the chat model** — the dropdown in the chat header selects which text model answers (e.g., a fast/balanced/strong tier from your provider). Chat usage is billed by your provider like any other text API call — orders of magnitude cheaper than image generation. * **Clear Chat** — the reset button clears the current conversation (with a confirmation) without touching your form or files. The Send button stays disabled until an API key is configured and a project is open. **Shift+Enter** inserts a newline; **Enter** sends. # Image Pool: Consistent Characters & Style Anchors > Register a style anchor and named characters — the mechanism behind a consistent book. The **Reference Image Pool** (on the Brainstorm tab) is where you teach the app what your book should look like:  It holds two kinds of images, and the distinction matters: ## Style [Section titled “Style”](#style) Upload one or more images whose *visual style* you want — line weight, proportions, mood. The subject of the image doesn’t matter; only the style is used. * Each style image is analyzed **once** by a vision model on upload (you’ll see a small badge when the cached description is ready). After that, generations reuse the cached description — no repeated vision cost. * In the Sketch stage, you pick one of these as the **style anchor**, which locks the whole book’s art style. With reference-capable models (gpt-image-2, Gemini) the image itself is also attached for the strongest effect. ## Elements (Named Characters & Objects) [Section titled “Elements (Named Characters & Objects)”](#elements-named-characters--objects) Register characters, objects, animals, or scenes that recur across the project — your book’s cast: * **Upload and name each one.** Names are limited to 15 characters with no spaces (e.g., `Sunny`). A name field with an amber border means the name is missing; red means it duplicates another element. * **Use them anywhere with `#`.** In any prompt field across the app — brainstorm answers, planning table cells, edit dialogs — typing `#` opens a picker, and the reference is inserted as `{Sunny}`. That page’s generation then receives Sunny’s reference image, so the character looks the same on page 3 and page 43. * **Break into elements** — the scissors button on an uploaded image opens a cropping tool: box or lasso each subject in a group image, name the crops, and they become separate pool entries:  A practical note shown in the app is worth repeating: each element mentioned in a prompt slightly increases API usage (the reference image rides along with the request). Mention the characters a page actually needs, not the whole cast. ## Upload Rules [Section titled “Upload Rules”](#upload-rules) PNG, JPEG, and WebP up to 10 MB per image, via the **Upload images** button or drag & drop directly onto the Style or Elements section. Hover any thumbnail for a delete button. # Planning Your Coloring Book — Plan Stage Overview > The Plan stage — where your book takes shape before any image credits are spent. Plan is where “I want to make a coloring book” becomes a page-by-page blueprint. No image-generation credits are spent here — the only AI usage is the text chat assistant and a one-time analysis when you upload reference images, both a tiny fraction of the cost of generating pages. This is the stage to iterate freely.  ## How the Page Is Laid Out [Section titled “How the Page Is Laid Out”](#how-the-page-is-laid-out) Plan has two sub-tabs, with an AI chat assistant always docked on the left: * **[Brainstorm](/plan/brainstorm/)** — answer five key questions about your book, and register reference images in the [Image Pool](/plan/image-pool/). * **[Planning](/plan/planning-table/)** — the page-by-page table of subjects and prompts that drives every later stage. The chat assistant is context-aware: on the Brainstorm tab it helps you develop the concept (and can fill the form for you); on the Planning tab it can draft or revise the entire table. ## Why This Stage Matters [Section titled “Why This Stage Matters”](#why-this-stage-matters) Everything you write here is reused downstream automatically: brainstorm answers are woven into every image prompt, Image Pool characters keep their appearance across pages, and the planning table is the source of truth that Sketch and Coloring read. Ten good minutes in Plan save hours of regeneration later. # The Page-by-Page Planning Table > The page-by-page table that drives your whole book — let AI draft it, then refine it like a spreadsheet. The Planning tab holds the **Page-by-Page Planning Table**: one row per page of your book, with everything later stages need to generate it. ## The Columns [Section titled “The Columns”](#the-columns) | Column | What it’s for | | ----------------- | ---------------------------------------------------------------------------------------------------------- | | **Index** | The page number (001, 002, …) — fixed, one row per page of your project. | | **Subject** | What’s on the page, in a few words (e.g., *Axolotl reading under a mushroom*). | | **Sketch Prompt** | The generation prompt for the line art. Supports `#` mentions of your Image Pool characters. | | **Color Prompt** | The color direction used by the Coloring stage (e.g., *soft pastel pond tones*). Optional but recommended. | ## Let AI Draft It [Section titled “Let AI Draft It”](#let-ai-draft-it) The **Planning AI Assistant** (left panel) can fill the entire table: ask it to “plan all 50 pages” based on your brainstorm, and the rows populate directly in the table — you’ll see them appear as the response streams. You can also ask for partial changes (“make pages 10–20 about nighttime scenes”) and only those rows update. Your job shifts from writing 50 prompts to editing a draft. ## Editing Like a Spreadsheet [Section titled “Editing Like a Spreadsheet”](#editing-like-a-spreadsheet) The table behaves the way you’d expect from Sheets: * **Click** selects a cell; **double-click or Enter** edits it; **Esc** cancels. * **Tab / Shift+Tab** and **arrow keys** move around; **Shift+arrows** extends the selection. * **Ctrl+C / Ctrl+X / Ctrl+V** copy, cut, and paste tab-separated ranges — pasting from a real spreadsheet works. * **Delete** clears the selected cells; **Ctrl+Z / Ctrl+Y** undo and redo (up to 50 steps). * **Drag the ⋮⋮ handle** to reorder rows. Content moves; page numbers stay fixed. * Type `#` in any Subject or prompt cell to insert a `{Name}` character reference. Every change is saved automatically — there is no save button. ## Getting the Plan In and Out [Section titled “Getting the Plan In and Out”](#getting-the-plan-in-and-out) * **Copy table** — copies all rows to the clipboard (tab-separated) for pasting into a spreadsheet. * **Export to CSV** — writes a standard CSV file wherever you choose. * A collapsible **Brainstorm Summary** strip above the table lets you tweak your five answers without leaving the tab. When the table looks right, move on to [Sketch](/sketch/overview/) — generation reads exactly what’s written here. # Assets: Masking, Path, and Compile > Prepare pages for animation — Masking, Path, and Compile, with every option explained. The Assets stage computes how each page gets “colored in” for the videos. Three tabs run in order — **Masking → Path → Compile** — and an **About** tab explains the pipeline in-app. Everything is local and free; **Run All** on each tab (or **Run Rest** where available, to fill only what’s missing) is usually all you need.  ## Masking [Section titled “Masking”](#masking) Masking decides *which regions* of each page receive color. | Control | What it does | | --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Remove White** toggle *(default: on)* | Excludes the white paper background from the mask, so color lands only inside the artwork. | | **Object Mask** toggle *(default: off)* | Isolates the main object and blacks out the background entirely — for pages where only the subject should animate. The **?** button shows a visual before/after explainer. | | **Run All** | Masks every page (asks before overwriting existing masks). | Clicking a finished mask opens the **Masking Editor** — a full-screen touch-up tool with flood fill (click any region to paint it black), wheel zoom, right-drag pan, **Zoom to Fit (F)** / **1:1 (R)**, and **Reset** to return to the original. Use it when a mask leaks into a background gap; usually a couple of clicks fixes it.  A yellow card means the page’s processed sketch is missing — finish Sketch › Process for that page first. ## Path [Section titled “Path”](#path) Path turns each mask into the actual coloring strokes. | Control | What it does | | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Fill pattern** dropdown | **In & Out** *(default)* — strokes work from the region edges inward, like careful pencil work. **Spiral** — a continuous spiral fill, a different visual personality. | | **Run Rest / Run All** | Generate paths for missing pages / all pages. | Path generation is the heaviest local computation in the app, so it automatically paces itself when your machine is busy (it waits if free memory or CPU headroom gets tight) — you may see items briefly queue on a loaded machine. That’s normal. Click a finished item to inspect its paths — the rainbow rendering visualizes stroke order across the page:  ## Compile [Section titled “Compile”](#compile) One **Run All** bundles the masks and paths into the final animation assets the video renderer consumes. Click any compiled preview to inspect the composition full-screen — a mid-coloring snapshot of exactly how the animation will paint the page:  When this grid is full, you’re ready for [Videos](/promo/videos/). # Promote Your Coloring Book with Timelapse Videos > Turn your book's pages into the marketing content that sells it. Publishing the book is half the job — the other half is getting anyone to see it. This is the pipeline competitors don’t have: Coloring Book Engine turns your own pages into **coloring timelapse videos**, the single best-performing content format for coloring books on social media. Watching a page color itself in is inherently satisfying, algorithm-friendly, and it *shows the product*.  ## The Pipeline [Section titled “The Pipeline”](#the-pipeline) Two stages, both running locally on your machine — **no AI credits are spent anywhere in this pipeline**: 1. **[Assets](/promo/assets/)** — prepares each page for animation in three steps (Masking → Path → Compile). This computes *how* each page would be colored, stroke by stroke. 2. **[Videos](/promo/videos/)** — renders the actual videos: your line art being colored in, stroke by stroke, optionally synced to music, at any resolution from square posts to 4K. ## What You Do with the Output [Section titled “What You Do with the Output”](#what-you-do-with-the-output) Each page becomes a video file ready for Reels, Shorts, TikTok, and Pinterest — plus Amazon A+ content on your book’s own listing. A 50-page book is 50 pieces of content; posting daily, that’s nearly two months of marketing material from work you already did. # Render Coloring Timelapse Videos with Music > Render coloring timelapse videos — audio sync, and per-platform social formats (16:9, 9:16, 4:5, 2:3, 1:1) each rendered natively. Every setting explained. The Videos stage renders the finished product: your pages coloring themselves in. Press **Run Rest** (fills missing videos) or **Run All** (re-renders everything, with an overwrite confirmation) and watch the grid fill with live progress. Rendering is local — GPU-accelerated when available — and costs nothing. Finished cards autoplay as you scroll. Click one for a full-screen preview with sound; hover for a **regenerate** button; right-click → **Show in Explorer** for the files.  ## The Settings Panel [Section titled “The Settings Panel”](#the-settings-panel) The gear button opens the render settings.  | Setting | What it does | | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **HW Encoder** *(read-only)* | The hardware video encoder auto-detected on your machine. | | **GPU Rendering** *(default: on)* | Renders the coloring-animation frames on the GPU. Turn off only if you hit driver issues. | | **Video Resolution** *(default: off)* | Off = videos match your page resolution. On = set your own **W × H** (snaps to even pixels), with an **aspect lock** that keeps your project’s ratio, and a **Layout** choice — **Contain** (scale to fit, letterbox on aspect mismatch) or **Cover** (scale to fill and crop the overflow). This is how you make a one-off custom size like 1080×1920. For the standard platform sizes, use **Export for social** below instead. | | **Audio Sync** *(default: off)* | The killer option — see below. | ## Audio: Videos That Color to the Music [Section titled “Audio: Videos That Color to the Music”](#audio-videos-that-color-to-the-music) Turn on **Audio Sync** and the pen strokes are driven by the music itself — reveals land on the audio’s onsets, and the track is muxed into the final video. | Setting | What it does | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Path** | A folder of tracks (mp3/wav/flac/ogg/m4a/aac). | | **Mapping** | How tracks pair with pages: **A↑** alphabetical, **Z↓** reverse, or **dice** — random but deterministic (each page keeps the same track across re-renders). Fewer tracks than pages? They loop around. | | **Per-page override** | A music button on each card assigns a specific track to that page (hover it to clear). Overrides beat the mapping rule. | | **Looping Sound** *(default: off)* | Tailors the animation to a seamlessly looping track — for posts that replay endlessly. | ## Export for Social [Section titled “Export for Social”](#export-for-social) One coloring page, one shape — but every platform wants a different frame. **Export for social** renders your pages a second time in each aspect ratio you pick, straight into `005_videos//`, ready to upload. Turn on the ratios you want in the settings panel. Each one is a **full, separate render** — not a crop or a resize of the main video — so the line quality stays razor-sharp at that platform’s exact pixel size: | Ratio | Role | Output size | Folder | | -------- | --------- | ----------- | ---------------- | | **16:9** | Landscape | 1920 × 1080 | `Landscape_16_9` | | **9:16** | Vertical | 1080 × 1920 | `Vertical_9_16` | | **4:5** | Feed | 1080 × 1350 | `Feed_4_5` | | **2:3** | Pinterest | 1080 × 1620 | `Pinterest_2_3` | | **1:1** | Universal | 1080 × 1080 | `Universal_1_1` | Because each format is its own render, selecting all five multiplies your render time by five. The batch counter and timer account for every variation, and selecting the full set can take up to **several hours** — the settings panel warns you before you commit. ### Layout, and the smart cover retiming [Section titled “Layout, and the smart cover retiming”](#layout-and-the-smart-cover-retiming) The **Layout** toggle next to Export for social sets how each page fills the new frame — **Contain** (letterbox) or **Cover** (crop to fill, the default). Cover is the interesting one. When a wide 16:9 page is cropped into a tall 9:16 frame, big slices of the drawing fall outside the visible box. A naive crop would still spend animation time coloring those hidden regions — the pen would vanish off-screen and the visible area would just sit there, stalling. CB Engine instead **retimes the animation to the crop**: strokes that live outside the frame are filled instantly, and the full runtime is spent on what the viewer actually sees. Every format stays lively end to end. ### On each card [Section titled “On each card”](#on-each-card) Once a page has social renders, small buttons appear in the card’s bottom-right — one per format (`16:9`, `9:16`, …). Click one to preview that exact render. While a format is rendering you’ll see a progress ring in its place; a failed format shows a ⚠ chip you can click to retry just that one. A small grey **`*`** means the render is stale — the settings changed since it was made — so re-run to refresh it.  **Run Rest** fills in every missing render, including social formats you enabled after the main videos were already done. **Run All** re-renders everything (main + every selected format) behind the overwrite confirmation. ### Which format for which platform? [Section titled “Which format for which platform?”](#which-format-for-which-platform) Each platform has the ratios it’s built for. ⭐⭐ = the platform’s native, full-screen format; ⭐ = supported/usable; blank = pick a better ratio. | | 16:9 | 9:16 | 4:5 | 2:3 | 1:1 | | -------------------------------------------- | ---- | ---- | --- | --- | --- | |  YouTube | ⭐⭐ | | | | | |  Shorts | | ⭐⭐ | | | | |  X | ⭐⭐ | ⭐ | ⭐ | | | |  TikTok | | ⭐⭐ | | | | |  Instagram | | ⭐⭐ | ⭐ | | ⭐ | |  Facebook | | ⭐⭐ | ⭐ | | ⭐ | |  Threads | | ⭐⭐ | ⭐ | | | |  Pinterest | | ⭐ | | ⭐⭐ | ⭐ | Want the widest reach from the fewest renders? **9:16 Vertical** alone lands well on almost every feed; add **16:9** for YouTube and **2:3** for Pinterest to cover the rest. ## Reading the Grid [Section titled “Reading the Grid”](#reading-the-grid) * **Bottom-right format buttons** — jump to each social render; a progress ring means it’s still rendering, a ⚠ chip means it failed (click to retry), a grey `*` means it’s stale. * **Yellow card, “Missing: …”** — that page’s assets aren’t compiled yet; go back to [Assets](/promo/assets/). * **“Failed” with a reason** — hover for the full error, click retry. * **Batch timer** in the header shows the count (main + every variation) and elapsed time for the current/last run. * **Explorer shortcut** — under **005\_videos** in the project explorer, a row of gold ratio chips (`16:9`, `9:16`, …) opens each format’s output folder in one click.  ## From the Automate panel [Section titled “From the Automate panel”](#from-the-automate-panel) The **CBE Automate** dashboard has its own compact **Videos** row of ratio toggles. They’re wired to the same app-wide setting as this page, so switching a format on there — or here — keeps both in sync for hands-free batch runs. # Import Your Own Images into the Pipeline > Use your own artwork instead of (or alongside) AI generation — every import option explained. You don’t have to generate your pages — the import dialog brings your own images into the pipeline, where Process and Vectorize treat them exactly like generated ones. Open it from the first-visit dialog (**Import Images**) or any time later via the **Import images** toolbar button on the Make tab. ## The Import Dialog [Section titled “The Import Dialog”](#the-import-dialog)  * **Adding files** — drag & drop onto the drop zone or click **Browse Files** (JPG, PNG, WebP). * **Slot grid** — each slot is one page of your book. Drag thumbnails between slots to control which image lands on which page. Slots already holding a generated image show an *Overwrite* tag when you assign a replacement. * **Crop Mode** — how images that don’t match your book’s aspect ratio are fitted: **Contain** fits the whole image and may leave white borders; **Cover** fills the page and crops the edges. * **Clear All** — empties every slot; **Import (n)** runs the import (the count shows how many pages will be written). Imported images replace existing pages only in the slots you filled — everything else is untouched. # Make: Generate Coloring Book Line Art with AI > Generate every page's line art in one run — with every toolbar option, the edit dialog, and generation errors explained. Click **Run Rest** and let it work. Every page that has a prompt and no image yet is queued and generated one by one — you’ll see each card move through **Queued (3/50) → Waiting → Made**. Generation is paced at roughly one image every 12 seconds to respect provider rate limits, so a 50-page book takes about 10 minutes. You can leave the app alone; an **Abort** button is available if you need to stop (pages already made are kept). When the run finishes, review the grid: * **A page you don’t like?** Hover it and click the **edit** button — see [Editing a page](#editing-a-page) below. * **A page failed (Error)?** Click it to retry just that one. * **An empty page?** Click it to generate just that one (it shows *Click to generate*). ## Run Rest vs Run All [Section titled “Run Rest vs Run All”](#run-rest-vs-run-all) * **Run Rest** *(recommended)* — fills only the **empty** slots. Pages that are already made are never touched and never re-billed. This is the button you should reach for 99% of the time, including when resuming an interrupted run. * **Run All** — regenerates **every** page, including finished ones. Because this re-spends credits on pages you already paid for, it first shows *“Overwrite existing images?”* telling you how many images exist. If you proceed, your current images are automatically backed up first (the dialog links to the backup folder), so nothing is ever silently destroyed. A *Don’t ask again* checkbox disables this confirmation — leave it unchecked unless you know what you’re doing. ## Editing a Page [Section titled “Editing a Page”](#editing-a-page) Hovering a finished page and clicking the edit button opens **Edit Image with AI**, which supports two different kinds of fixes: * **Refine the existing image** — type what you want changed in **Additional requirements** (e.g., “remove the second frog, make the pond larger”). The current image is sent along as a reference, so the page keeps its composition and only the requested change is applied. * **Regenerate from a new prompt** — the original sketch prompt is shown locked; click the lock to edit it. If you change the prompt (and leave the requirements field empty), the page is regenerated from scratch with your new prompt. The edit is also written back to your Plan table, so the plan stays the source of truth. In both fields you can type `#` to mention a named character or object from your Image Pool — it’s inserted as `{Name}` and attaches that character’s reference image to the generation, keeping their appearance consistent. ## Toolbar Reference [Section titled “Toolbar Reference”](#toolbar-reference) | Control | What it does | | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Import images** (icon button) | Reopens the [import dialog](/sketch/import-images/) at any time — you can mix imported and generated pages. | | **Cost / Quality** toggle | Per-image generation quality. **Cost** (default) is cheaper and great for drafting; **Quality** costs more per image and is worth it for the final pass. Applies to generation from the moment you flip it. | | **Model** dropdown | Which image model generates your pages. With an OpenAI key: **gpt-image-2 (Latest)** — best quality and supports style/character reference images — or **dall-e-3 (Standard)**. With a Google key: **Gemini 3.1 Flash Image**. | | **Style anchor** badge | Pick one style image from your Plan Image Pool to lock the whole book’s art style. Choose **None** to turn it off. Only appears once your Image Pool contains at least one style image. | | **Run Rest / Run All / Abort** | Batch generation controls — see above. | **A note on gpt-image-2:** it requires a one-time organization verification on your OpenAI account. If your account isn’t verified, Coloring Book Engine automatically falls back to dall-e-3 (you’ll see *“Switching to Standard Mode”*) so your run never stalls — but treat that strictly as a stopgap. **We don’t recommend producing your book on dall-e-3**: its quality and capabilities are far more limited, and it can’t read reference images, so style anchors and character references are skipped (affected cards show a notice). Verify your organization and redo those pages with gpt-image-2, or use Gemini. ## If Something Goes Wrong [Section titled “If Something Goes Wrong”](#if-something-goes-wrong) | Message | What it means / what to do | | ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *API Key Required* | No AI key is configured — set one up via **Connect Your AI** on the Projects screen. | | *No Images to Generate* | Nothing left to do: every page is made or currently in the queue. | | *Prompt is required for generation* | The page you clicked has no sketch prompt — fill it in Plan (or via the edit dialog). | | *Generation Stopped* | Two generations failed in a row, so the queue paused to protect your credits. Check the error shown (often a rate limit or provider hiccup) and press **Run Rest** to continue where it left off. | | *Organization Verification Required* / *Switching to Standard Mode* | Your OpenAI org isn’t verified for gpt-image-2. Generation continues on dall-e-3 automatically; verify your organization to unlock gpt-image-2. | | *Style anchor was ignored (DALL-E 3 fallback)* | Shown under pages generated during a dall-e-3 fallback: they couldn’t use your style anchor. Retry them with gpt-image-2 or Gemini for consistent style. | # Sketch Stage Overview: Make, Process, Vectorize > How the Sketch stage works — Make, Process, and Vectorize, in that order. The Sketch stage turns your page plan into actual line art. It has three sub-tabs that you run in order — **Make** (generate images), **Process** (convert to clean black & white), and **Vectorize** (convert to crisp, print-ready vector art). Each tab reads the previous tab’s output, so a page must be *made* before it can be *processed*, and *processed* before it can be *vectorized*.  ## First Visit: Two Ways to Start [Section titled “First Visit: Two Ways to Start”](#first-visit-two-ways-to-start) The first time you open Sketch, a dialog asks **“How would you like to create your sketches?”**:  * **Generate with AI** — create pages from the prompts you wrote in Plan. This is the standard path this handbook follows. Continue with [Make](/sketch/make/). * **Import Images** — bring your own images instead; they join the pipeline exactly like generated pages. See [Import Images](/sketch/import-images/). ## What Completes This Stage [Section titled “What Completes This Stage”](#what-completes-this-stage) The vectorized pages are what the **Book** stage binds into your interior PDF, and what the **Assets** stage animates for promo videos — finishing the [Vectorize](/sketch/vectorize/) tab is what marks Sketch complete on your dashboard. # Process: Pure Black-and-White Line Art, No Grayscale > Convert every generated page into clean, pure black-and-white line art — free and local. AI image generators are notorious for slipping gray shading, gradients, and off-white backgrounds into pages that were prompted as line art — and gray tones print muddy. The **Process** tab removes the grayscale from every made page and normalizes it to **pure black-and-white line art** in one click, preserving line integrity instead of destroying thin lines the way a blunt threshold filter does. Press **Run All** and watch the grid fill in — no AI credits are used here; it runs entirely on your machine, no external cleanup tools or per-page editing required. Process also runs built-in **anti-leak segmentation**: it detects unclosed shapes and seals gaps in region boundaries — broken lines are what let color spill outside the lines in later stages. It doesn’t succeed on every image — if a page comes out with unclear, leaky color regions, the best fix is to go back to [Make](/sketch/make/) and regenerate that page rather than fight the segmentation. ## Controls [Section titled “Controls”](#controls) * **Run All** — processes every made page. Re-running over existing results asks *“Overwrite existing images?”* first (no backups needed here — this step is free to redo). * **Click any single card** to (re)process just that page. * A card with a **yellow warning** means its source page hasn’t been made yet — go back to [Make](/sketch/make/) and fill it first. ## If Something Goes Wrong [Section titled “If Something Goes Wrong”](#if-something-goes-wrong) | Message | What it means / what to do | | --------------------- | -------------------------------------------------------------------------------------------------------- | | *Binarization Failed* | The local conversion hit an error — the message includes details; retry the affected pages individually. | # Vectorize: 300 DPI Print-Ready Line Art > Convert black-and-white pages into crisp, print-ready vector artwork. **Vectorize** converts the black-and-white pages into vector artwork (SVG) — lines stay perfectly crisp at any print size, which is exactly what a printed book needs. Like Process, it’s one **Run All** click, free, and local; single cards can be redone individually. This step is also how Coloring Book Engine guarantees print resolution. KDP expects **300 DPI** interiors (2550 × 3300 pixels for an 8.5″ × 11″ page) — well above what AI generators output natively, which is why most workflows bolt on a paid upscaler and risk waxy, over-sharpened artifacts. Vector pages sidestep the problem entirely: they rasterize at exactly the resolution your book needs, whatever the trim size. Click any finished card to inspect the vector result — the checkerboard background shows it’s pure line work on a transparent canvas, ready for print layout:  ## Controls [Section titled “Controls”](#controls) * **Run All** — vectorizes every processed page; asks *“Overwrite existing images?”* when re-running over existing results. * **Click any single card** to (re)vectorize just that page. * A card with a **yellow warning** means the page hasn’t been processed yet — finish [Process](/sketch/process/) first. Completing this tab marks the Sketch stage done on your dashboard: the vectorized pages feed both the [Book](/book/overview/) interior and the [promo video pipeline](/promo/overview/). ## If Something Goes Wrong [Section titled “If Something Goes Wrong”](#if-something-goes-wrong) | Message | What it means / what to do | | ---------------------- | -------------------------------------------------------------------------------------------------------- | | *Vectorization Failed* | The local conversion hit an error — the message includes details; retry the affected pages individually. |