Skip to content
Untitled

Everything it is meant to be, and how much of it exists.

1.0.0-beta.1 is the first build anybody but the maker installs. This is the whole of what stands between here and there, including the parts that have not been started.

32%

53 of 165 steps built

  • Built· 53 steps
  • In progress· 1 step
  • Planned· 111 steps

A step is one piece of a feature, and steps are what this page counts. An item is a promise about a group of work, and finishing the first piece of it is not the same as finishing it. Nothing on this page is a promise of a date. It says what is done, not when the rest will be.

Show which features

Workspaces

2 of 7 steps · 29%

One book and several ways to work on it. The strip that moves between them, and this list.

  • PlannedThe workspacesPlotter, Structure, Write, World and Book, each with the tools that belong to it, so a screen is never shared by two jobs at once.
    • PlannedThe five workspaces, and the strip that switches
    • PlannedEach one keeps its own columns and widths
    • PlannedA project reopens in the workspace it was left in
    • PlannedSwitching from the keyboard
  • In progressRoadmapThis list: what is built, what is not, and how far the first build has got. Open it when you cannot tell whether something is missing or simply not written yet.
    • BuiltThe areas, the progress and the filter
    • BuiltAnything called built names the files that prove it
    • PlannedWhat changed since the last version

Plotter

0 of 18 steps · 0%

Where you work out what happens, before there is a manuscript to write it in. The workspace the planning tools land in, one at a time.

  • PlannedSynopsisA sentence on a row saying what happens in it. Everything else here rests on it: there is no card, no table and no grid without one.
    • PlannedA synopsis on any row
    • PlannedWritten in the inspector, beside the document notes
    • PlannedShown under the row in the manuscript
  • PlannedCorkboardThe synopsis cards of one subtree as index cards. Scrivener's word and Scrivener's shape — open it to see the run of a Part rather than the sentences inside it.
    • PlannedCards for what is under the selected row
    • PlannedDragging a card reorders the manuscript itself
    • PlannedHow large a card is, and how much of it shows
  • PlannedOutlinerThe same tree as a table: synopsis, words, status, label, POV, when and where. Open it when the question is about the whole book at once.
    • PlannedThe tree as sortable columns
    • PlannedEdited in the cell
    • PlannedWhich columns show, remembered
  • PlannedStatus and labelsWhat state a row is in (First draft, Revised) and what it belongs to: a POV, a plot line. Project vocabulary like the section types, never an enum in the code.
    • PlannedA status and a label on a row
    • PlannedBoth edited where the section types are
    • PlannedRead by the corkboard, the outliner and the grid
  • PlannedPlot linesRows are the threads, columns are the chapters, and a card sits wherever a thread does something. The view that answers what happens to a subplot between chapter twelve and chapter twenty.
    • PlannedThe grid, and cards at the crossings
    • PlannedA card knows which row it happens in
    • PlannedA template's beats drawn over the grid
  • PlannedMood boardThe loose end of the workspace: images, links, music, documents and stray notes, with nothing imposed on them, because the beginning of a book is not an outline yet.
    • PlannedA canvas that takes images, links and notes
    • PlannedFiles kept beside the project
    • PlannedGrouping, and a name for a group

Structure

14 of 21 steps · 67%

The vocabulary a project is built from: what a Chapter is, what may hold what, and what a writer is told when the book stops agreeing with it.

  • In progressProject templatesThe structure and the words a project starts with, so a serial says Arc and Episode where an epic says POV Chapter. Chosen when the project is made, and copied into it.
    • BuiltFifteen built-ins, grouped by genre and by structure
    • BuiltA project's own copy, in its .book
    • BuiltCapture the open project as a template
    • PlannedShare one: export and import a template file
  • BuiltTemplate editorThe screen that draws a vocabulary. Cards for the types, lines for what holds what, and the tree a project starts with. The same screen edits a template file and the open project's own copy.
    • BuiltThe shape canvas, with auto layout
    • BuiltThe starting tree
    • BuiltUndo and redo, one step per card
    • BuiltA backup of every save, and named ones that outlive the cap
  • BuiltSection typesWhat a row is in this project (Chapter, Scene, Part), carrying its icon, the prompt a writer opening it is told, and the rules the book preview reads.
    • BuiltIcon, name and prompt
    • BuiltFolder or section, with the cost of changing it said out loud
    • BuiltThe print rules: in the book, starts a page, heading level
    • BuiltRecommended children, which is what the Add menu offers
  • BuiltNotesWhat the manuscript and its vocabulary no longer agree about. A count at the foot of the sidebar, a mark on the row that caused it, and never a refusal.
    • BuiltThe list, with every row an entry is about
    • BuiltA mark on the row, opening the list narrowed to it
    • BuiltThe same idea in the template editor
  • PlannedEntry typesThe Codex's half of the same idea: what kinds of thing this world has and what each kind records. The same editor, pointed at a different vocabulary.
    • PlannedEntry types in a project's vocabulary
    • PlannedThe fields a kind carries
    • PlannedEdited on the canvas the section types use
  • PlannedTypesetting in the templateThe look of the finished book kept with the vocabulary that describes it, one set per output format, so a project carries how it prints and a template can ship a look.
    • PlannedPage formats become project data
    • PlannedOne set of settings per output format
    • PlannedBuilt-in templates ship a look of their own

Write

16 of 31 steps · 52%

The manuscript, the page it is written on, and everything a writer needs within reach of the words.

  • In progressManuscript treeThe book as a tree of parts, chapters and scenes. The column every other view in this workspace answers to.
    • BuiltThe tree, with a menu on right-click and on the keyboard
    • BuiltDrag and drop, and a selection of many rows
    • BuiltMove to…, Change type…, and a delete that counts what goes with it
    • PlannedTrash: a deleted row waits somewhere first
    • PlannedUndo in the manuscript
  • In progressThe editorRich text over one row of the tree, saved as you write. The formatting a novel actually uses, and nothing else.
    • BuiltTiptap, stored as ProseMirror JSON
    • BuiltAutosave, with the save state on screen
    • BuiltWord count
    • BuiltThe format bar
    • PlannedComments on a stretch of text, never printed
  • In progressThe writing pageThe surface the words sit on: a measure of about sixty-six characters, a paper colour instead of screen-white, and an edge that says whether the keyboard is in it.
    • BuiltA fixed measure, centred in the pane
    • BuiltIts own paper colour, and an edge that follows focus
    • BuiltThe section type's prompt, drawn over an empty page
    • PlannedA measure and margins the writer chooses
    • PlannedFocus mode: full screen, typewriter scrolling
  • BuiltDocument notesWhat you want to remember about a section rather than what you have written in it. A list and not a pad, because the question you come back with is which of eleven ideas you have dealt with.
    • BuiltA list of notes on any row, folders included
    • BuiltRich text, from the manuscript's own format bar
    • BuiltA title when it is worth one, the first line when it is not
    • BuiltCrossed out: kept, read-only, one press back
  • In progressInspectorThe right-hand column and the strip that opens it. What you consult about what you are writing. It splits when a second panel opens, and the writer arranges the strip.
    • BuiltThe column, the strip, and the split
    • BuiltArranged by drag, by menu, or by Alt and an arrow
    • PlannedA panel for the Codex entries this row mentions
  • PlannedFinding thingsWhere a word is, in a book nobody can hold in their head: the open section, the whole project, and a replace with the results in front of you.
    • PlannedFind in the open section
    • PlannedFind across the project, with results by row
    • PlannedReplace, one at a time or all at once
  • PlannedWord targetsA target for the manuscript and a target for today, with how far along you are visible without stopping to work it out.
    • PlannedA target for the manuscript
    • PlannedA session target, and where it shows
    • PlannedTargets per row, read by the outliner
  • PlannedSpelling and the lexiconA spellchecker that has been told about your world, so invented names stop being underlined — and a misspelt invented name still is.
    • PlannedSpellcheck in the editor
    • PlannedA dictionary the project carries
    • PlannedCodex names and aliases added to it

Revise

7 of 12 steps · 58%

Going back over what is written, and getting back what was there before it.

  • BuiltSnapshotsA copy of one document, kept because you asked for one — never automatic. Take one before a rewrite you are not sure of.
    • BuiltTake one, rename one, throw one away
    • BuiltNamed for when it was taken
    • BuiltA space of its own, opened over the writing
  • BuiltCompareWhere a snapshot is read: the document on the left, the snapshot on the right, unchanged stretches folded away. Nothing reaches the manuscript until Save.
    • BuiltTwo panes that line up, in one scroll
    • BuiltA prose diff, sentence by sentence
    • BuiltRestore this paragraph, staged into a draft
    • BuiltRoll back to this snapshot, with undo
  • PlannedProject backupsThe project's own .book file, copied without your having to remember. What the template editor already does for a vocabulary, done for the manuscript.
    • PlannedAutomatic copies, capped
    • PlannedNamed ones, which outlive the cap
    • PlannedA way back that goes through a comparison first
  • PlannedProofing viewThe manuscript as one continuous read instead of a row at a time, for the pass where you are reading and not writing.
    • PlannedThe book, or one subtree, in a single column
    • PlannedRead-only, with a way into the row you stopped at

World

0 of 32 steps · 0%

The Codex: everything true about the world that is not a sentence in the book. The largest area, and the one that grows with whatever a writer invents.

  • PlannedCodex entriesA card for a thing in the world (a character, a house, a god, a sword) in rich text, with pictures. Novelcrafter's word for the same idea.
    • PlannedEntries in rich text, with images
    • PlannedFiled by kind, searchable and sortable
    • PlannedAliases, so one thing can be called several things
  • PlannedWhat kinds of thing a world hasCharacters, locations, organisations, religions, creatures, objects, magic systems. The ones a fantasy project starts with, and whatever else you invent.
    • PlannedThe starting kinds, as template data
    • PlannedCharacter sheets first, with a portrait
    • PlannedNew kinds, with fields of your own
  • PlannedMentionsThe Codex noticing itself in the manuscript: a name or an alias found in the text, a card when you hover it, and per entry the list of chapters it appears in.
    • PlannedNames and aliases found in the text
    • PlannedThe card, on hover and from the keyboard
    • PlannedEvery mention of an entry, listed
    • PlannedAn explicit link where finding it is not enough
  • PlannedRelationshipsWho is whose, drawn: family trees, houses, factions, political and working ties, with the kinds of tie decided by you rather than by us.
    • PlannedA canvas of entries and the ties between them
    • PlannedRelationship kinds the writer defines
    • PlannedSeveral trees in one project: a house, a guild, a pantheon
    • PlannedAuto layout, as the template shape already has
  • PlannedMapsYour map, with things on it, and the one thing every other tool here needs from it: a distance that means something.
    • PlannedAn imported image, panned and zoomed
    • PlannedPins and areas drawn as polygons, styled by kind
    • PlannedLayers
    • PlannedMaps inside maps (continent, city, house, dungeon), and travel between them
    • PlannedA pin or an area tied to a Codex entry
    • PlannedA scale, in kilometres or miles
  • PlannedCalendar and chronologyTime in a world that does not use ours: months, weeks and eras you invent, and the story laid out along them.
    • PlannedA calendar the project defines
    • PlannedDates written on that calendar
    • PlannedThe story as a timeline
  • PlannedWhen and whereWhich day and which place a chapter happens on, so the book can be read in the order it happened as well as in the order it is told.
    • PlannedA date and a place on a row
    • PlannedThe places come from the map
    • PlannedRead by the outliner and by the timeline
  • PlannedTravel timesDistance on the map against days on the calendar — three hundred and forty kilometres in two days, on foot. It says so and refuses nothing: your world may have horses, or portals, or a mistake.
    • PlannedA chapter's route, drawn on the map
    • PlannedThe distance, from the map's scale
    • PlannedTravel paces the writer defines
    • PlannedWhat does not fit, said as a note on the rows it is about
  • PlannedStory mapEntries against chapters as a graph: who appears where, what connects to what. Filters, so the picture answers one question at a time.
    • PlannedThe graph, built from the mentions
    • PlannedFilters by kind, by entry and by part of the book

Book

3 of 20 steps · 15%

What the manuscript becomes: pages that look like a printed novel, the decisions behind them, and the files you send out.

  • In progressBook previewThe same content in fixed, print-accurate pages, never reflowed. Open it to see where the chapters fall rather than how a sentence reads.
    • BuiltA paginator of our own, measured against real text
    • BuiltThree trims, with a novel's typography
    • BuiltZoom by scale, so nothing reflows
    • PlannedDevice previews: e-reader, tablet, phone
  • PlannedTypesettingWhere the look of the finished book is decided: trim, margins, type, leading, running heads, chapter openers. The industry's word for the inside of a book.
    • PlannedTrim, margins and type
    • PlannedRunning heads and folios, and where they stop
    • PlannedChapter openers, drop caps, scene-break ornaments
    • PlannedWidows and orphans
    • PlannedKept in the project's template, per output format
  • PlannedFront and back matterEverything that is the book but not the story: half-title, copyright, dedication, the map plate, appendices, a glossary. A fantasy novel without them is not finished.
    • PlannedFront matter as part of the tree
    • PlannedImages in the manuscript, and the map plate
    • PlannedA table of contents built from the tree
    • PlannedAppendices and a glossary, from the Codex
  • PlannedExportThe files that leave: print-ready PDF, EPUB, DOCX, Markdown, and the printer.
    • PlannedPDF, from the same paginator as the preview
    • PlannedEPUB
    • PlannedDOCX and Markdown
    • PlannedPrint
  • PlannedImportThe way in for a writer who already has a manuscript, split into a tree instead of dropped in as one long file.
    • PlannedMarkdown, split on its headings
    • PlannedDOCX
    • PlannedA Scrivener project

The application

11 of 24 steps · 46%

The parts that are not about one book: how it looks, how it is driven, and how it keeps itself up to date.

  • In progressThemesWhat the application looks like, as data rather than as code. Two palettes shipped, and a checker that will not let either drift out of contrast.
    • BuiltBindery Light and Bindery Dark
    • BuiltA contrast check that runs with the tests
    • BuiltAppearance: the writer chooses, and it survives a restart
    • PlannedA theme editor, and themes as files
  • In progressOne button, one menu, one popoverThe shared pieces every screen is built from, so a control behaves the same way wherever a writer meets it and a restyle is one file.
    • BuiltButton, IconButton and Segmented
    • BuiltMenuSurface: every popover menu goes through it
    • BuiltInfoPopover: the second layer of help
    • In progressThe screens still drawing their own controls
  • In progressProjectsMaking a book, opening one, and finding your way back to one, including one whose file has moved since you last saw it.
    • BuiltNew, open, close, and a list of recent ones
    • BuiltA project whose file has gone, kept on the list with a way back
    • PlannedMore than one project open at once
  • PlannedDriving it from the keyboardEverything reachable without a pointer, and something on screen that says how. The half of an interface that decides whether it is fast.
    • PlannedShortcuts for what is used every day
    • PlannedA reference that teaches them
    • PlannedA command palette
    • PlannedDrawing a link on the shape canvas, which is pointer-only today
  • PlannedGetting startedThe first ten minutes: what this is, where the manuscript lives, and what a template does, said once, beside the thing it is about.
    • PlannedA first run that explains itself
    • PlannedHelp that stays out of the way afterwards
  • In progressReleases and updatesGetting the next version without going to look for it, and being told what changed when it arrives.
    • BuiltInstallers for the three platforms, built on a tag
    • PlannedUpdating from inside the application
    • BuiltWhat changed, where you are standing
    • BuiltA version number that tracks this list
  • PlannedLanguageThe application in the writer's own language. English today. The later this is decided, the more of the interface has to be taken apart to do it.
    • PlannedThe copy out of the components
    • PlannedSpanish
    • PlannedA language the writer chooses