Visit Homepage
Skip to content

Creating a book series “bible” using Scrivener, Scapple, and Aeon Timeline

Posted in Just for Writers

Introduction

Puzzled writer
Puzzled writer – where did I first mention his broccoli phobia?

[UPDATED 9/19/2014 to reflect comments & suggestions from Scrivener support.]

A recent discussion on a Scrivener Facebook group put me together with another systems engineer type (Ronnie Darby), and the two of us had a long Q&A about the process mechanics of creating a book series bible based on Scrivener but utilizing the strengths of Scapple as well as Aeon Timeline. Ronnie was already doing this, and I bounced off his concepts to create a process for my own work.

A series “bible”, for those not familiar with the term, is a reference document that contains everything about a series (book or TV) except for the actual text/content. Think of it as meta-content.

For readers who don’t know all of these tools, here’s a very quick summary.

  • Scrivener is considered by many to be the premiere tool for writers. It provides a platform for not just book content, but also for research materials, character templates, and a whole lot more.
  • Scapple is a freeform note-creation tool, by the same folks who created Scrivener. People use it to create, for example, maps of character relationships.
  • Aeon Timeline is a product that allows you to lay out events, subplot arcs, characters, etc., along a timeline grid. It’s used for various scheduling activities but also for organizing the timeline of  narrative works.

Each of these products is reasonably priced, with an extensive uncrippled free trial period. They run on both Mac and Windows.

For the purposes of this post, I will assume you have some familiarity with Scrivener.  There are other products that do much of what Scapple does, and there are other timeline products, but these are the best I’ve found for supporting narrative writing.  The principles and structure I lay out here are suitable for other tools used in conjunction with Scrivener.

I am running on Windows, and my discussions of file structures will therefore be a bit different than for Mac users.

Basic Assumptions

The primary goal is to facilitate finding what was said or described in other books in the series, combined with the ability to brainstorm as part of the creative process, in order to achieve consistency among the books in the series and to save time researching past work.  To that end, it is useful to separate the written words of the books produced (content) from the supporting material (meta-content).

The process described below assumes you will:

  1. Use a Scrivener Project for each Book in the Series that contains only the book content, e.g., Scenes and Chapters.
  2. Use a Scrivener Project Bible for the Series that contains everything else, for the entire series (Character templates, Research, etc.)
  3. Use Scapple to create & maintain networked Character (and other entity) relationships.
  4. Use Scapple to brainstorm character relationships and important events.
  5. Use Aeon Timeline to keep track of important events.

Important note about file folder structures (Windows).

Scrivener maintains its material for a project in a folder whose natural extension is SCRIV (the “.SCRIV” is not always visible). Within that folder are some project folders, such as FILES, SETTINGS, SNAPSHOTS, (which have their own subdirectories) and the master file for the project, whose natural extension is SCRIVX.

Scrivener warns that the structures within the SCRIV folder and lower are under software control and not a safe area to store other material. On the one hand, you would like to add folders for /Scapple or /AeonTimeline files and have them backed up with Scrivener’s mechanisms. On the other hand, even if those folders are local to the SCRIVX file, any links between the Scrivener project and, say, a Scapple file are absolute path links, which means if they are moved or a folder name is changed, those links will break. Since storing the files locally doesn’t help with that problem, I recommend a directory (folder) structure like this, to stay out of Scrivener’s way but still keep all the files together:

C:/…/…/Series A (top level of everything associated with the series)
C:/…/…/Series A/Scapple (for Scapple files)
C:/…/…/Series A/AeonTimeline (for Aeon Timeline files)
C:/…/…/Series A/whatever (for other files from other applications, e.g., photos, research)
C:/…/…/Series A/Bible(.scriv) (Top level Scrivener folder for the series bible)
C:/…/…/Series A/Book 1(.scriv) (Top level Scrivener folder for the 1st book in the series
C:/…/…/Series A/Book 2(.scriv) (Top level Scrivener folder for the 2nd book in the series, etc.

Each SCRIV folder has special backups from Scrivener. The C:/…/…/Series A/ folder and its contents should be backed up like any computer file.

(click to enlarge)
(click to enlarge)

(Same image is in this PDF file: Coordinating Scapple and Scrivener for Book Series Bible.)

Scrivener – Story Bible for the entire series

Start by creating the Story Bible as a Scrivener project.  This project will contain everything except manuscript material.

Exception: if you maintain an index of names, you may want to store the master (maximum length version with all names) here in the Manuscript area, with a separate cut down version for each series book.  The latter can be incorporated into the actual manuscript at publication time. I like to copy the master version for each new book in the series, change the color of all of its content, and then, as each character is mentioned in the current work, change the color back to black (or add new names to the current list and the master one). At the end, I can easily eliminate any series characters not mentioned in the particular book because they will still be colored.

The primary content will be character templates, templates for other entities (place, setting, objects, etc.), and various research materials.

Scapple – Character (Entity) Relationship canvas for the entire series

Think of Scapple as providing a large canvas. In one place, you list a character’s name. You connect him to a series of notes about his background. You connect him to another series of notes about his relationships with his mother.  You connect him to a series of notes about his girlfriend, etc.  A little ways off, you list his girlfriend’s name.  You connect her to a series of notes about her ex-boyfriend, and so forth.  Each of these clusters of notes is typically connected to a central note identifying the character that acts like an anchor or hub to a spoked wheel.

As you might imagine, a character’s relationships change over time. A note might say “Hated broccoli (book 1) but began to waver when his girlfriend insisted he try again (book 3)”.  When you want to reference the character’s attitude to broccoli in book 5, you would want to be able to find not only your note about it (in Scapple) but also the actual words in your books (in Scrivener).

Other entities can populate the canvas.  The “grand hall in Fantasy Town” is owned by some character’s uncle (relationship).  You noted that it has a fireplace (book 2) but what material was the fireback? The actual words you used in the book would be handy.

With Scapple you can search and zoom in on any of these note clusters. The devil is in the details (of course).

To begin with, your character might be named “Tom”.  A search on “Tom” in Scapple would turn up entries all over the place as he appears in various relationships, not to mention “tommy-guns” and “tomtoms”.  What you usually want, instead, is the anchor or hub where most of those references link.

In the Scrivener Story Bible, you have a character document for Tom. Only the very basic information belongs there, since all the rich detail will be in Scapple.  How to connect the two?

In Scrivener, create a custom metadata field for the character document.  We’ll call that a “tag”.  It will operate like a keyword across projects (not like Scrivener’s “keywords” which are restricted to the project). To remind us that it’s like a hashtag, I adopt the convention of putting a hashmark (#) at the start.  So, the #tag for Tom’s character document is “#tom”.  Custom metadata can be viewed both in the Scrivener Inspector and in the Scrivener Outliner, as a custom column.

Over in Scapple, add “#tom” to the note that serves as an anchor or hub for Tom in his relationship network. Now, when you search on “#tom” in Scapple, you are taken directly to the center of Tom’s network of notes.  If you want to create a link back to the character document in Scrivener for Tom, you can add a link to the “#tom” note in Scapple and point to Scrivener (see next section for how to do that), then search the bible for #tom, which should only occur once: in the custom metadata for the character document.

Note that if you have a character named “Tom” and one named “Tomas”, you will want #tags that are unique enough that searching on #tom doesn’t find the #tomas anchor, too.

If you have a series with a large cast, you might want to divide the Scapple file into two, where one contains all the bit parts and walk-ons, while the other has the rest of the entities, to cut down on the clutter.  If you do that, you might want an external link to the appropriate Scapple file in the Scrivener Document Reference for each entity document in Scrivener, to point you at the right canvas.

Scrivener – Project for each series book

Make a Scrivener project for each series book.  When you create the Scrivener project for each series book, you will only use the Manuscript portion of the project.  Everything else goes into the Story Bible (ideally).

What about the words Tom used to talk about his troubled relationship with broccoli in series book 2? You would like the broccoli notes to link to the words in the Scrivener scenes. Ideally, you’d like to mark the text within the scene using an annotation (a note or comment, not an inline annotation, because this is a long-term mark) and point to that. What could be easier? (NOT!)

In the Mac version of Scrivener (but not yet in Windows) you can get an absolute path link to the Scrivener scene document, but that suffers from a dependency on an absolute path which makes for a non-robust link. The front of the path is a variable (good), but the rest is absolute from there, and thus brittle.  Example: x-scrivener-item:///Users/lnlsupport/Outbox/sample_project.scriv?id=4

Meanwhile, in Windows, it’s possible to identify the underlying RTF file that Scrivener stores each scene in and to link to that, but that has many issues. First, it’s a nuisance to figure out which file it is.  Second, Scrivener warns that the structures are subject to change. Third, such a link would require an absolute path identifier, which would be at risk of breaking when folders are moved.

A better solution is to:

  • Select the text you want to get to in Scrivener, and add a Comment (aka Note) using the Comments & Footnotes part of the Inspector. The default comment-name inside the comment is your username and a timestamp.  Example: KarenMyers, 9/19/2014 11:09:36 AM
  • Modify that comment-name to contain the entity tag #tom and the series book id #book1, and leave the timestamp alone.  Example: #tom #book1 9/19/2014 11:03:01 AM.  The timestamp portion ensures that the particular comment-name is, to all intents and purposes, unique.
  • In Scapple, go to the text in the note where you want the link.  Paste in the comment name (e.g., #tom #book1 9/19/2014 11:03:01 AM) and use Edit/Add Link to add the link…

Here’s where it gets tricky. What are you going to link to?  We’ve already established that absolute paths are brittle, but absolute paths are all we can use. So we want to use the least-brittle absolute paths we can.  I don’t want to link to a particular Scrivener project, because the folders where they live might move around (what if I swap to a different drive letter, for example?).

I don’t want to link directly to Scrivener.exe either, since we’re in the middle of the migration from 32-bit to 64-bit, and Windows has decided to use peculiar directory names for that.  On my computer, Scrivener lives here: C:\Program Files (x86)\Scrivener\Scrivener.exe.  Later on, it might live in a 64-bit program directory. I can tell that’s not going to be robust as an absolute pathname.

So, what’s left? I can link to a shortcut. My desktop shortcuts on Windows today live here: C:\Users\KarenMyers\Desktop\Scrivener.lnk .  That’s not entirely robust — Windows could do a once-per-decade major change in how it stores user information, but I’ll live in the belief that it’s pretty long-term.  If Scrivener.exe changes location, all I would need to do is update the shortcut on the desktop to point there. And what’s the worst that can happen? The links might break, but with the #tom tag and the #book1 tag, the information is still recoverable (I know where to look), the comment name will still work as a search text inside Scrivener, and the links could be easily recreated if necessary.

Continuing the bullets from above…

  • In Scapple, add the link to a shortcut invoking Scrivener (from the shortcut’s properties menu).  Example: C:\Users\KarenMyers\Desktop\Scrivener.lnk.
  • To execute the link from Scapple, double-click on it to select it and copy the text, move until the cursor changes to a pointing finger, then click to execute the link. That will open Scrivener (if not already open) wherever you happen to have left off, which may not be the Scrivener project you want.
  • Use Scrivener’s project menu to open the project represented by the series book id tag (#book1), and paste in the comment name from the Scapple file that you copied. Scrivener’s Search bar will find it (use Search All Documents).

Aeon Timeline – Timeline for the entire series

Your books in the series cover a period of time, but their world extends far beyond that.  Your characters and their referenced ancestors have birth and death dates, events in the distant past effect current events, and alibis may require intricate timing.  A timeline program collects both Events (which have a date) and Characters (who are sometimes related to Events: the birth of a character is an event, and so is the day he embraced broccoli when the villain choked to death on it, just in the nick of time).

Your world history, even if you never refer to it with date precision, will benefit from being plotted against a timeline.

Not all timeline events are scenes in a particular book (e.g., the birth of a character prior to series start).  Not all Scrivener scenes are events important enough for a timeline (e.g., they kissed and made up). But there are many important events that are both Scrivener scenes and timeline entries.  Some events have multiple scenes (two different points of view, or talking about it in two different series books).  Some scenes have multiple events (e.g., he won the battle, killed the king, and married the alien.)

Aeon Timeline lets you store #tags with characters or events, and you can use external references, too.  The same considerations about links apply as for Scapple.  Either you will want to link to some specific text, or to an entire scene.  If the latter, just create one more comment for the start of the scene, and add whatever additional info you think might be helpful.  If you wanted to know what different characters said about the same event, you might be grateful that there are tags for that event, and live links, to the different scenes in different books.

Brainstorming in Scapple

There are a great many ways to brainstorm in products like Scapple.  For the process I’ve outlined, tailored to my work habits, I’ve made some assumptions. Your mileage may vary.

For characters, I don’t just brainstorm about them before I start writing. I want that brainstorming to become “real” as the work solidifies, so that it can serve as a permanent reference over time.  Hence the character docs in Scrivener contain only very basic data — all the real material is in Scapple, with note clusters for each character that include “back story”, “description”, etc.

On the other hand, I treat events while brainstorming quite differently. I don’t look upon those as permanent at all. I think of them as fodder for scene outlines in Scrivener, soon outmoded and modified. The yellow on the diagram above indicates areas where I don’t think any #tag or linking formalism is really needed. But if you feel differently, you can treat events in Scapple just like characters (entities), with #tags, live links to Scrivener, and so forth.

Subscribe to My Newsletter

...and as a free bonus gift, you'll receive an ebook version of The Call, a short story that precedes the start of The Hounds of Annwn.

15 Comments

  1. This was excellent Karen. Thanks for putting a long, complex discussion into such a concrete and understandable form, and make available for other’s. IMO, it’s a tremendous service to other writers.

    September 15, 2014
    |Reply
    • Couldn’t have done it without your advance work helping me flesh out the concepts. Thanks, again.

      September 15, 2014
      |Reply
  2. I think that it’s only proper that I point out that my own creation and use of a Story Bible was not my idea. The Story Bible has been used for some time by screenwriters, especially of TV series. What sparked my own creation and use of one was a blog post by David Hewson. http://bit.ly/1xaGNi3

    September 15, 2014
    |Reply
    • No, of course not. We’re all familiar with the concept (I assume) from decades of series writing, both for books and TV.

      I saw that Hewson article, but it was the specificity of our discussion, what with links to external files, custom metadata, etc., that made it all actionable for me.

      September 15, 2014
      |Reply
  3. This is really useful – thanks! I’m a big fan of Scrivener and have already started to build some of the structures you mention, but this will save me a lot of trial and error.
    Cheers!

    September 23, 2014
    |Reply
  4. David Hewson makes a very good point in his Pingback. The approach described here is quite complex, and that complexity carries the risk of a too difficult to follow story. I’ve experienced this myself. One must be very careful to avoid the behind-the-scenes complexity from spilling over into the story. This is particularly true when creating a long series, resulting in a difficult to follow story. Personally, my story bible for a series is extensive, with an elaborate back story and important character relationships. The thing is, though, that perhaps only five or ten percent of that material ends up being explicitly incorporated into the story. It gets incorporated into the writer’s mind. It comes out in subtle ways with only a few, but important words in the right places. It comes out by the much simpler story being consistent (that’s a biggie). Again, this is a very difficult thing for the writer, that the reader never notices as long as the writer has devised a means to ensure consistency. However, you can lay down money that if the writer fails to get the story consistent, the reader will pick it up, and come to a confused screeching halt. There is an incredible amount of work that a writer does behind the scenes in order to produce a good book or series of books.

    September 27, 2014
    |Reply
  5. I feel it to be important to follow up my previous comment with a bit of elaboration regarding character relationships. I am working with a series, at the moment (actually years), that has a cast of hundreds of characters that can be thought of as being members of a network of characters and events. That is, characters know, and interact with other characters. They know of, but don’t interact with other characters. Those relationships not only can, but usually are important within the story. They show up in the pros in subtle ways, such as when character 1 asks character 2 if character 2’s friends grandmother has recovered from her surgery. Character 1 is scheduled for the same type of surgery, so remembers that character 2 made a comment about his friend’s grandmother. It’s such things as this that make for a rich story.

    September 27, 2014
    |Reply
  6. Thanks for this – always glad to find more uses for Scrivener (it’s amazing, isn’t it?). Have linked to this piece and bookmarked, will definitely be back to read again and again.
    Regards
    Lee

    February 24, 2015
    |Reply
    • Glad you find it useful. My understanding of what works best for me is constantly evolving.

      February 24, 2015
      |Reply
  7. Markus Ende
    Markus Ende

    Regarding the absolute paths I have another idea that could by useful (did not yet try it myself). In Windows you can use the “subst” command (or “net use” for network drives) to map a drive letter to a directory.
    So, for example, you could map drive A: to C:/…/…/Series A by using:
    subst a: C:\…\…\Series A

    To automatically do that after booting, just copy it to a batch file and add that one to the autostart folder.

    This comes pretty close to a relative path in my opinion.
    If you move your working directory, You just have to change your A: mapping.

    Regards
    Markus

    May 24, 2015
    |Reply
    • Well, now, that’s an interesting idea. I’d be fine as long as I didn’t have more than, say, 15 series (running out of available letters). I’ll have to give that some thought.

      Thanks!

      May 24, 2015
      |Reply

Leave a Reply

Your email address will not be published. Required fields are marked *