How to Write What If Branching Multiverse Stories with InkWeave

Tip

Here is a small secret: this may be InkWeave’s most powerful free “add-on.” It is called Git. It works with the free version of InkWeave, requires no subscription, and places no plan limit on the number of What If timelines you create. Strictly speaking, it is not installed inside InkWeave; it is a free tool that preserves different universes for your whole book. InkWeave writes the story, while Git makes sure every “what if” has somewhere to live, with no interdimensional management fee.

Eileen stands before the sealed gate. Drawing the sacred sword could save the capital, but the sword’s guardian would brand her a traitor.

In canon, she draws the sword. But you also want to know: What if she refuses? What if she accepts the enemy crown instead?

Ordinary document copies can preserve several versions of your prose. InkWeave and Git can preserve a complete world for every choice: chapters, characters, items, locations, factions, and the causal events that truly happened in that timeline.

You do not need programming experience or a GitHub account for this guide. Every timeline can remain entirely on your computer.

Translate Git into an author’s language

Git term	Meaning in your story
main	The canon universe
branch	A What If universe born at a choice point
commit	A save point in that timeline
git switch	Travel to another universe
InkWeave	Where you write and track causality

You do not need to learn every Git feature. This guide uses only the few commands needed to create save points, create branches, switch branches, and check where you are.

Free and subscription versions: who remembers causality?

For this guide, Git creates the multiverse and InkWeave is where you write. Whether you subscribe does not determine whether you can create branches. Both the free and subscription versions can use the Git workflow in this article, and InkWeave does not impose a plan limit on the number of timelines.

The difference is who checks whether the current universe still makes sense:

In this multiverse workflow	Free version	Subscription version (Pro)
Create and switch timelines	Yes. Use Git to create, save, and switch as many branches as you can manage.	Yes. The Git commands and safety rules are exactly the same.
What returns after a switch	Git restores the complete project recorded on that branch, not merely a different chapter.	The same complete branch returns, including the InkWeave records stored in it.
Detect story contradictions	No automatic causality check. The author must remember who owns an item, who is alive, where everyone is, and which events occurred.	InkWeave can compare the current branch’s cards, events, states, and causal records, then warn about contradictions supported by those records.
What the author maintains	Notes, outlines, and a “causality engine built into the brain.”	The author still defines the facts, cards, and causal events; InkWeave helps remember and verify them.

Caution

Git protects the difference between universes; it does not understand the story. On the free version, switching to timeline A correctly restores the prose where Eileen refused the sword. But if you later write that she hands the sacred sword to someone, Git will happily save the sentence. The author must notice that she never acquired it.

With a subscription, if you recorded that Eileen did not acquire the sword and built the relevant card, state, or causal event, InkWeave can evaluate later events against timeline A and expose the contradiction. It does not read the author’s mind: an important fact that was never written or recorded cannot be checked automatically.

In short, a subscription does not buy more universes. The free version already has the Git multiverse; Pro lets InkWeave help maintain each universe’s causal ledger so the author does not have to carry all of it in memory.

Why does causality in the subscription version stay correct after a switch?

Git does not switch a single document. It switches the complete project for your book.

Suppose canon Eileen possesses the sacred sword, the guardian is dead, and the kingdom is hunting her. In the “refuse the sword” timeline, the sword remains on the altar, the guardian is alive, and the kingdom has no reason to hunt her. Each branch keeps its own version of those consequences.

When you close InkWeave, switch branches, and reopen InkWeave, the app reads the chapters, cards, and causal records stored in the current timeline. In the subscription version, if the author has recorded the relevant facts, InkWeave can detect Eileen trying to give away a sword she never acquired according to that timeline’s history.

Note

Each branch is a complete universe, not merely a few alternate paragraphs. That is what makes InkWeave and Git especially useful for What If stories.

The one rule to remember before switching timelines

Danger

Always use this order:

Close InkWeave → inspect the current universe → commit unsaved changes → confirm a clean status → switch branches → reopen InkWeave

Do not run git add, git commit, or git switch while InkWeave is open. InkWeave saves automatically. If you switch first, content still held in the app’s memory could be written into the wrong branch.

Do not switch and then immediately close InkWeave, either. Closing the app may itself trigger a save. The order is always: close first, then use Git.

1. Make an external backup first

Before using Git for the first time, copy the complete project folder for this book to an external drive, USB drive, cloud drive, or another safe location.

Git can protect you from many accidental edits, but local Git is not an external backup. InkWeave’s Git history lives inside the book’s folder. If the whole folder is deleted, its history is deleted too.

Only copy the backup. Do not move the original project or directly edit its JSON files.

2. Find the real project folder for this book

Open the book you want to branch in InkWeave, then go to:

Project Settings → General → Open Project Folder

This button opens InkWeave’s application data folder. It contains all your books, but it is not yet the folder for the current book. Continue into:

InkWeaveProjects → your book's folder

The folder normally uses the name the project had when you created it. If you later changed the title inside InkWeave, the folder on disk may still have the original name.

Leave Finder or File Explorer open at the book folder, then close InkWeave completely.

Caution

Use one Git repository per book. Do not initialize Git in the parent InkWeaveProjects folder, or every book will be tied to the same set of timelines.

The actual location on macOS

Release builds of InkWeave store books under:

~/Library/Application Support/net.inkweave.studio/InkWeaveProjects/<project-folder>/

For example:

/Users/your-name/Library/Application Support/net.inkweave.studio/InkWeaveProjects/Eileen and the Sacred Sword/

macOS hides the Library folder by default, so clicking through folders may not reveal it. The quickest route is:

1. Open Finder.
2. Choose Go → Go to Folder from the menu bar.
3. Paste this path:

~/Library/Application Support/net.inkweave.studio/InkWeaveProjects

4. Press Return, then open your book’s folder.

net.inkweave.studio is InkWeave’s application identifier. This is a system application-data location, not the InkWeave app inside /Applications. Learn how Tauri resolves application data paths.

The actual location on Windows

Release builds of InkWeave store books under:

C:\Users\<your-name>\AppData\Roaming\net.inkweave.studio\InkWeaveProjects\<project-folder>\

Windows hides AppData by default. You do not need to make hidden folders visible:

1. Open File Explorer.
2. Click the address bar at the top.
3. Paste:

%APPDATA%\net.inkweave.studio\InkWeaveProjects

4. Press Enter, then open your book’s folder.

%APPDATA% expands to the current Windows user’s AppData\Roaming folder. Do not go to Program Files, the InkWeave installation folder, or a desktop shortcut. Your writing projects are not stored there.

3. Install and verify Git

Tip

Git and GitHub are different things. Git is the local timeline tool used in this guide. GitHub is an optional website for hosting Git projects. You do not need a GitHub account, a subscription, or an internet connection after Git has been installed, and nothing in this guide uploads your story.

The commands in this section only install Git or display its version. They do not enter or modify your InkWeave project, so InkWeave may remain open while you complete this section.

macOS

1. Open Terminal

Press Command + Space to open Spotlight, type Terminal, and press Return. You can also find it in Finder → Applications → Utilities → Terminal.

The Terminal window may look unfamiliar, but you only need to enter the commands shown in this guide. Do not type sudo, and do not enter your Mac password directly into Terminal for any step in this article.

2. Check whether Git is already available

Enter:

git --version

This asks your computer, “Is Git available?” The --version option only displays a version. It cannot change your story.

If you see something similar to this, Git is ready:

git version 2.x.x

If you see a version, Git is already ready. Continue to section 4.

3. Install Apple’s Command Line Tools if prompted

If macOS says that developer tools are required, choose Install, accept the license, and wait for the download to finish. If the dialog also offers Get Xcode, you do not need that option. This guide only needs Apple’s much smaller Command Line Tools, not the full Xcode application.

The installation requires an internet connection. macOS may ask for an administrator password or Touch ID through a normal system dialog. You do not need Homebrew, GitHub Desktop, a GitHub account, or any programming experience.

If no installation dialog appears, or Terminal reports xcrun: error: invalid active developer path, enter:

xcode-select --install

This asks macOS to open the same official Command Line Tools installer. A message such as install requested for command line developer tools means the request was accepted; wait for the system dialog and complete the installation instead of repeatedly entering the command.

After installation, close Terminal, open it again, and run:

git --version

Seeing git version 2.x.x means installation is complete. If macOS still says the tools are missing, open System Settings → General → Software Update, finish any listed Command Line Tools update, and try once more. See the official Git installation guide for macOS if the system installer still cannot complete.

Windows

1. Download the correct installer

Open the official Git installation page for Windows and download the Standalone Installer:

• Choose x64 for most Windows computers with Intel or AMD processors.
• Choose ARM64 only if Settings → System → About → System type says your computer has an ARM-based processor.
• Do not choose the Portable edition for this guide; the normal installer adds the Git Bash Here menu used later.

Caution

Download Git only from the official page linked above. If Windows displays a security warning, first confirm that the installer came from that page and that Windows shows a valid publisher. If the source or publisher cannot be confirmed, cancel instead of disabling Windows security, then download the installer again from the official page.

2. Choose beginner-friendly installer options

Open the downloaded installer. Most screens can keep their defaults, but check the following choices if they appear:

• Select Components: keep the defaults and make sure Git Bash Here is selected. Git LFS and a desktop icon are not required for this guide.
• Choosing the default editor: choose Notepad or another editor you already know if one is offered. This guide normally supplies the commit message in the command, so the editor should rarely open.
• Adjusting your PATH environment: choose Git from the command line and also from 3rd-party software, the recommended middle option.
• Choosing the SSH executable: keep Use bundled OpenSSH.
• Choosing HTTPS transport: keep the bundled OpenSSL option.
• Configuring line ending conversions: the installer default may remain selected. Section 5 will add a setting that applies only to this InkWeave book and prevents its project files from being converted unexpectedly.
• Choosing the terminal emulator: keep the default MinTTY terminal used by Git Bash.
• git pull, credential helper, and extra or experimental options: keep the defaults. This guide does not connect to GitHub or use remote repositories.

If Windows asks for administrator approval, follow the normal system prompt. You never need to turn off antivirus protection or paste an administrator password into Git Bash.

3. Open Git Bash and verify the installation

When setup finishes, open the Start menu, search for Git Bash, and open it. Enter:

git --version

Git Bash is the command window used by this Windows guide. A result such as git version 2.x.x.windows.x means you are ready. You do not need to sign in when Git Bash opens.

If Git Bash was already open during installation, close it and open it again before retrying. If the Start menu has no Git Bash entry or the command still says command not found, run the official installer again and confirm that the Git Bash component is selected.

4. Put the terminal inside the correct book

macOS: drag the folder into Terminal

1. Open Terminal.
2. Type cd followed by one space. Do not press Return yet.
3. Drag the book folder from Finder into the Terminal window.
4. Terminal fills in the complete path. Press Return.

cd means change directory. In story terms, it says, “Take me to the entrance of this book’s universe.” Dragging the folder avoids mistakes caused by spaces, non-English characters, or account names.

Windows: open Git Bash in the book folder

Open the book folder in File Explorer, right-click an empty area, and choose Open Git Bash here. On Windows 11, you may need to choose Show more options first.

“Here” matters: Git Bash starts directly inside the book you opened, so you do not have to type a long Windows path.

Verify the location on either system

Enter:

pwd

pwd asks, “Which folder am I standing in?” It only displays a location and does not modify files. The final part of the path should be this book’s project folder.

Next, enter:

ls

ls asks, “What is inside this folder?” At the correct location, you should directly see:

inkweave.json
chapters

You may also see other InkWeave data such as characters, items, locations, factions, assets, or inventory.index.json.

If ls shows many different book names, you are still in InkWeaveProjects. Enter one book folder before continuing. If you cannot see both inkweave.json and chapters, do not run the next command yet.

5. Establish the current story as canon on main

Confirm that InkWeave is completely closed and the terminal is inside the correct book folder. Then enter:

Danger

Close InkWeave completely first. Run the Git command below only after the app window has closed. Do not use Git first and return to close InkWeave afterward.

git init -b main

This command has three parts:

• git: ask Git to do the work.
• init: begin timeline management inside this book.
• -b main: name the first timeline main, your canon universe.

It does not rewrite your story or upload anything. Git creates a hidden .git folder inside the book to store history. Do not manually edit or delete .git.

Set the author name for this book

Enter these two lines, replacing the first quoted value with your pen name:

Danger

Keep InkWeave closed. These author settings are written into this book’s Git data. Do not reopen InkWeave until this setup is complete.

git config user.name "Your Author Name"
git config user.email "author@localhost"

The first line labels save points with an author name. The second supplies an author field required by Git’s save format. author@localhost is only local text; it does not send email or upload data.

Because these commands do not use --global, the settings apply only to this book and do not change your other Git projects.

Keep InkWeave project files unchanged by Git

Enter one more setting:

git config core.autocrlf false

Windows and macOS represent line endings differently. This setting tells Git to preserve this book’s InkWeave project files exactly as they are instead of automatically rewriting their line endings. It does not modify the story content already on disk.

This command also omits --global, so it applies only to the current book. It will not change the behavior of another writing project or programming repository on your computer.

Exclude operating-system clutter

Paste this complete line into the terminal once:

Danger

Confirm that InkWeave is still closed. This command creates or updates .gitignore inside the book folder. Do not let autosave write to the project at the same time.

printf '%s\n' '.DS_Store' 'Thumbs.db' 'desktop.ini' '*.tmp' >> .gitignore

This creates .gitignore and tells Git not to record desktop clutter generated by macOS or Windows. >> means append, so it does not erase existing settings.

Do not add inventory.index.json, .inkweave, snapshots, or *.bak.* to .gitignore. They belong to the complete world and should switch with its branch.

See what Git discovered

Enter:

Danger

Do not begin this save sequence while InkWeave is open. The first git status is read-only, but git add and git commit immediately follow it. Close InkWeave completely before starting.

git status --short

This asks, “What in the current universe has not entered a save point yet?” The first time, you will see many files beginning with ??. That is normal. ?? means Git has just discovered those files, not that anything is wrong with them.

Next, enter:

git add -A

add gathers all additions, edits, and deletions for the next save point. -A means every change inside this book. Think of it as placing the chapters, cards, and causal records into one save box. The box is not sealed yet.

Create the first save point:

git commit -m "Establish the canon universe"

commit seals this point in time. The quoted text after -m is the save-point name. In story terms, this command says, “Preserve everything here as the first stable point in canon.”

Finally, check it:

git status --short
git branch --show-current

If the first command prints nothing, the current universe is fully saved. The second command should print main, confirming that you are standing in canon.

6. Preserve the choice point shared by all three universes

For three timelines to split from the same place, do not begin by writing three endings. First preserve the final moment before the choice.

Return to InkWeave and write canon up to this scene: Eileen stands before the sealed gate, the sacred sword remains on the altar, the guardian is alive, and she has not accepted the enemy crown. Place the cursor where she is about to decide.

At this moment, all three universes share the same state:

• Eileen does not possess the sacred sword.
• The sword’s guardian is alive.
• The sealed gate has not opened.
• Eileen still belongs to her original Gatekeeper faction.
• The enemy crown has not been given to her.

Close InkWeave, then enter:

Danger

Close InkWeave completely first. This sequence preserves the crossroads shared by all three universes. Autosave must not change that crossroads while Git is committing it.

git status --short
git add -A
git commit -m "Eileen reaches the sealed gate"
git status --short

This commit is the crossroads shared by all three universes. It does not preserve one answer. It preserves the moment when Eileen has not answered yet.

If the final line prints nothing, confirm that you are still in canon:

git branch --show-current

It should print main. You can now grow timeline A, timeline B, and canon from the same clean choice point.

Note

If your story was already paused at the sealed gate when you created the first Git save point, the “Establish the canon universe” commit can serve as this shared crossroads. You do not need another commit with identical content.

7. Timeline A: Eileen refuses the sword

Keep InkWeave closed and create timeline A from the shared crossroads:

Danger

Confirm that InkWeave is completely closed. git switch replaces the complete project for this book. Never switch first and close InkWeave afterward.

git switch -c what-if-refuse-sword

• switch: travel to another timeline.
• -c: create a timeline that does not exist yet.
• what-if-refuse-sword: the name of the refusal universe.

Git should display Switched to a new branch 'what-if-refuse-sword'. Then enter:

git branch --show-current

After it prints what-if-refuse-sword, reopen InkWeave and begin timeline A:

Eileen releases the sword’s hilt and trusts the guardian’s warning. She leads her companions away through the underground waterway, leaving the sealed gate closed.

Make the causal events in InkWeave agree with this version. Do not give Eileen the sacred sword, do not mark the guardian as dead, and do not open the sealed gate. If she escapes through the waterway, record the location she actually moves to.

After writing part of timeline A, close InkWeave and save it:

Danger

Close InkWeave completely first. Wait for its window to disappear before running status → add → commit, so autosave and Git do not write timeline A at the same time.

git status --short
git add -A
git commit -m "Timeline A: Eileen refuses the sacred sword"
git status --short

The first line shows which chapters and causal data changed in A. The second gathers every change, the third seals this future, and the final line checks that nothing was missed.

Timeline A should now contain:

World state	Timeline A result
Sacred sword	Remains on the altar; Eileen does not possess it
Guardian	Alive
Sealed gate	Closed
Eileen’s faction	Keeps her original identity
Next story	Escape through the underground waterway

If a later chapter makes Eileen give away the sacred sword, InkWeave can inspect A’s event history and discover that she never acquired it.

8. Timeline B: Eileen accepts the enemy crown

Timeline B must also be born from the shared choice point, not from the future written in timeline A.

Keep InkWeave closed, confirm that git status --short prints nothing on A, and return to main:

Danger

InkWeave must remain closed. The next command returns from timeline A to the shared crossroads. Do not switch while A is still held in the app’s memory.

git switch main

At this point, main is still paused at the crossroads where Eileen has not answered. The refusal story was committed only to timeline A.

Create timeline B from here:

Danger

Confirm that InkWeave has not been reopened. Create timeline B only while the app is closed and main has a clean status.

git switch -c what-if-take-the-crown
git branch --show-current

The first line creates and enters the crown universe. The second should print what-if-take-the-crown. Once confirmed, reopen InkWeave and write a different answer:

Eileen does not touch the sacred sword. She turns toward the enemy envoy and accepts the black crown, then orders the sealed gate to remain closed as the new queen.

In this version, the sword remains on the altar and the guardian may live, but Eileen receives the enemy crown and joins or leads a new faction. Add item and faction events in InkWeave that agree with the prose.

After writing part of timeline B, close InkWeave and enter:

Danger

Close InkWeave completely first. These commands preserve B’s chapters, cards, and causal events. Do not let autosave run at the same time.

git status --short
git add -A
git commit -m "Timeline B: Eileen accepts the enemy crown"
git status --short

Timeline B should now contain:

World state	Timeline B result
Sacred sword	Remains on the altar; Eileen does not possess it
Guardian	Alive
Sealed gate	Remains closed by her order
Eileen’s faction	Joins or leads the enemy power
Special item	Eileen possesses the enemy crown

If later chapters still treat Eileen as an ordinary member of her former faction, or give the same unique crown to someone else, InkWeave checks the problem against timeline B’s own causal events. It does not borrow state from A or canon.

9. main: complete the canon where Eileen draws the sword

Timelines A and B now both begin at the shared crossroads. Keep InkWeave closed, confirm that B is clean, and return to canon:

Danger

InkWeave must be completely closed. The next command replaces the entire B project with main. Do not reopen the app until switching is complete.

git switch main
git branch --show-current

The second command should print main. Reopen InkWeave and you will once again see the final moment before the choice: the sword is on the altar, and Eileen has not answered. Nothing from A or B appears here.

Now write canon:

Eileen draws the sacred sword. The guardian dies trying to stop her, the sealed gate opens in the swordlight, and her original faction casts her out.

Record the matching events in InkWeave: Eileen acquires the sword, the guardian dies, the sealed gate changes state, and Eileen leaves her original faction. Git does not invent these consequences. It preserves the different facts you write into InkWeave for each universe.

When finished, close InkWeave and save canon:

Danger

Close InkWeave completely first. Let InkWeave finish saving canon and exit before Git creates the canon save point.

git status --short
git add -A
git commit -m "Canon: Eileen draws the sacred sword"
git status --short

main should now contain:

World state	main canon result
Sacred sword	Possessed by Eileen
Guardian	Dead
Sealed gate	Open
Eileen’s faction	Has left her original faction
Next story	Enters the world beyond the gate with the sword

The same choice point has now grown into three complete universes that do not overwrite one another.

10. Make a complete tour through all three universes

Now travel through main → timeline A → timeline B → main. At every stop, close InkWeave, inspect the status, switch, and only then reopen InkWeave.

From canon to timeline A

Close InkWeave and enter:

git status --short

Continue only if it prints nothing. If files appear, preserve the new canon changes with git add -A and git commit first.

Now switch:

Danger

Confirm again that InkWeave is closed. Switch to timeline A only when git status --short prints nothing.

git switch what-if-refuse-sword
git branch --show-current

The first line has no -c because timeline A already exists. You are returning to it, not creating it. When the second line prints what-if-refuse-sword, reopen InkWeave.

You should see the refusal world: the guardian is alive, Eileen does not have the sacred sword, and the sealed gate is closed. Moving the cursor or checking later chapters also uses timeline A’s own causal history.

From timeline A to timeline B

Close InkWeave again. Ask Git whether timeline A is fully saved:

git status --short

After confirming an empty result, enter:

Danger

InkWeave must remain closed. You are replacing the complete A project with timeline B. Do not open the app midway between universes.

git switch what-if-take-the-crown
git branch --show-current

When the second command prints what-if-take-the-crown, reopen InkWeave. Eileen should now possess the enemy crown instead of the sword, and her faction identity should be the B version. The underground-waterway future from A does not follow her here.

From timeline B back to canon

Close InkWeave and perform the final check and switch:

Danger

Close InkWeave completely first. If the first line lists any files, stop before git switch main; save timeline B before switching.

git status --short
git switch main
git branch --show-current

Run the final two lines only when the first prints nothing. After main appears, reopen InkWeave. Eileen again possesses the sacred sword, and the guardian returns to the dead state recorded in canon.

InkWeave has not forgotten or re-guessed the story. You have switched the complete book back to a different event history.

11. Continue writing in any universe

Suppose you return to A and write three chapters about the underground waterway. Those chapters exist only in A. Save them in the usual way:

Danger

Close InkWeave completely first. Every new save point in every universe must be created while the app is closed.

git status --short
git add -A
git commit -m "Timeline A: Eileen reaches the underground city"
git status --short

When you return to main, canon does not suddenly gain those chapters. When you enter B, Queen Eileen does not remember A’s escape. The three stories can grow independently and do not need to remain the same length.

12. View the three-branch multiverse

Show only the current universe:

git branch --show-current

List every universe:

git branch

You will see three branches, with a * beside your current one:

main
what-if-refuse-sword
what-if-take-the-crown

To see where they separated, enter:

git log --oneline --graph --decorate --all

• --oneline: show each save point on one line.
• --graph: draw all three branches with lines.
• --decorate: label main, timeline A, and timeline B.
• --all: include all three universes.

You should see “Eileen reaches the sealed gate” as the shared ancestor, followed by three paths: “Canon: Eileen draws the sacred sword,” “Timeline A: Eileen refuses the sacred sword,” and “Timeline B: Eileen accepts the enemy crown.” That is the current multiverse map for this book.

Why this guide does not use merge

Software branches often need to be merged. Story universes do not.

“Eileen draws the sword” and “Eileen refuses the sword” are both complete futures. Forcing them together could collide mutually exclusive chapters, character states, and causal events. This guide teaches you to preserve, switch, and continue each universe independently. It never requires you to merge them back into main.

If a What If timeline becomes your favorite version, simply continue writing on that branch. A branch name does not decide canon. The author does.

Common messages and what they mean

fatal: not a git repository

Git is saying, “I cannot find timeline data here.” Use pwd and ls to confirm that you are inside the correct book folder. If you have not run git init -b main, return to the canon setup step.

Please tell me who you are

Git does not yet know how to label the save-point author. From the current book folder, run:

Danger

Close InkWeave first. Even when only correcting Git’s author settings, keep the same safety habit and reopen the app only after committing.

git config user.name "Your Author Name"
git config user.email "author@localhost"

Then run the previous git commit again.

Your local changes ... would be overwritten by switch

Git is protecting an unsaved universe from being overwritten by another one. This is protection, not a failure.

Do not add -f or force the switch. Confirm that InkWeave is closed, then run:

Danger

Confirm that InkWeave is completely closed. This sequence rescues the current unsaved timeline. Do not let InkWeave autosave while Git creates the commit.

git status --short
git add -A
git commit -m "Save the current timeline"
git status --short

When the final command prints nothing, run the original git switch again.

a branch named ... already exists

A universe with that name already exists, so you do not need -c. For example:

Danger

Close InkWeave and confirm a clean status first. Even an existing branch replaces the complete set of files when you switch to it.

git switch what-if-refuse-sword

This switches to an existing universe instead of creating one. Close InkWeave and confirm a clean status before switching as usual.

You switched while InkWeave was open? This is not a death sentence

Tip

Take a breath: your multiverse is probably still there.

Switching branches does not automatically delete commits on other branches. The likely problem is narrower: InkWeave still remembered the universe that was open before the switch, so autosave may have written some old content into the working files of the current branch.

Starting to use Git was one of the smartest creative decisions you could have made. Because main, timeline A, and timeline B already have commits, you can preserve the accident first and then return each universe to its proper save point.

Do not erase anything immediately. Use this order:

Close InkWeave → create a rescue branch → commit the accident scene → create a complete Git bundle → confirm the current branch → only then reset

Step 1: stop writing and close InkWeave completely

Stop typing immediately and do not switch again. Close InkWeave completely and wait for its window to disappear.

Closing may trigger one final autosave, but do not panic. The next steps place every resulting change on an independent rescue branch instead of deleting it.

Danger

Do not run git reset --hard yet. Without a rescue commit, resetting now could discard new writing that had not been committed before the accident.

Step 2: record which branch you are currently on

After InkWeave is closed, enter:

git branch --show-current
git status --short

The first line identifies the universe you were on after the accident. Write that name down. If it prints what-if-take-the-crown, timeline B is the branch that may have received stale content.

The second line lists files left by the accident:

• If it prints nothing, InkWeave probably did not write stale content to disk. You can switch normally to the branch you want; no reset is needed.
• If you see M, ??, or other files, continue with the rescue procedure below.

Step 3: seal the accident scene on a rescue branch

Danger

Confirm that InkWeave is completely closed. The commands below do not commit the mixed content to timeline B. They create an independent rescue branch to hold it.

Enter:

git switch -c rescue-forgot-to-close
git add -A
git commit -m "Rescue: InkWeave was open during a branch switch"
git status --short

Each line has one job:

1. git switch -c rescue-forgot-to-close: create a rescue branch from the accident scene. The pointers for main, A, and B do not move.
2. git add -A: gather every modified, added, and deleted file, including new files created by autosave.
3. git commit: seal the accident scene. Anything later discarded by reset now has a place where it can be recovered.
4. The final git status --short: should print nothing, confirming that the rescue scene is fully preserved.

If Git says rescue-forgot-to-close already exists, use a new name such as:

git switch -c rescue-forgot-to-close-2

Use the actual rescue branch name in all later commands.

Caution

rescue-forgot-to-close is an accident vault, not necessarily a complete universe you should continue writing. It may combine files from the current branch with content held in InkWeave’s memory. Never merge it into a formal timeline.

Step 4: seal every universe into one Git bundle

An ordinary file backup may miss the hidden .git folder. To guarantee that main, A, B, the rescue branch, and every commit are preserved, create Git’s own complete rescue file:

Danger

Keep InkWeave closed and confirm that the rescue commit succeeded. A Git bundle contains committed history only, so the previous step cannot be skipped.

git bundle create "../InkWeave-multiverse-rescue.bundle" --all
git bundle verify "../InkWeave-multiverse-rescue.bundle"

The first line creates InkWeave-multiverse-rescue.bundle one folder above the book:

• bundle create: package Git history into one file.
• ../: place the rescue file outside the book folder so later branch switches cannot affect it.
• --all: include every branch and every reachable commit, not only the current branch.

The second line verifies the bundle. Continue only after seeing messages similar to:

InkWeave-multiverse-rescue.bundle is okay
The bundle records a complete history.

This .bundle does not rely on a visible copy of the original project’s hidden .git folder. Even if the repository must later be reconstructed, the bundle contains the multiverse history preserved at this point.

If a bundle with that name already exists, keep the older file and add a number to the new name, such as InkWeave-multiverse-rescue-2.bundle.

Step 5: return to the contaminated branch, then reset

Use the branch name you wrote down in step 2. The example below assumes the accident left you on timeline B, what-if-take-the-crown. Replace it if your recorded branch was different.

Danger

Run git reset --hard HEAD only after the rescue commit succeeded and the bundle verified as okay.

reset --hard discards uncommitted working files on the current branch. It is safe here only because the accident has already been preserved in both the rescue branch and the bundle. Confirm the branch name before resetting.

git switch what-if-take-the-crown
git branch --show-current
git reset --hard HEAD
git status --short

Read it line by line:

1. git switch what-if-take-the-crown: leave the accident vault and return to the real B branch.
2. git branch --show-current: must print the branch you intend to repair. Stop if the name is wrong.
3. git reset --hard HEAD: restore B’s working files to B’s latest formal commit. HEAD means only the latest save point on the current branch; it does not delete other universes.
4. git status --short: should print nothing, confirming that B is clean again.

The commits on main, A, and B have not been rewritten. Only the uncommitted content accidentally mixed into B’s working folder has been removed.

Step 6: confirm that every universe still exists

git branch
git log --oneline --graph --decorate --all

You should still see:

main
rescue-forgot-to-close
what-if-refuse-sword
what-if-take-the-crown

rescue-forgot-to-close is the new accident vault. The other three universes remain at their original commits. Only now should you reopen InkWeave and confirm that the current branch looks correct.

Tip

If all three formal branches and the rescue branch are visible, this was not the end of your world. Git did not punish you for forgetting to close InkWeave. It simply lets you separate committed universes from the working files created during the accident.

Step 7: recover important uncommitted prose from the rescue branch

If you had written paragraphs that were not committed before the accident, they may exist only on the rescue branch. Do not merge the entire rescue branch because it may be a mixture of two universes.

The safest approach is to retrieve the prose manually:

1. Close InkWeave and switch to the rescue branch.

Danger

Close InkWeave completely first. The rescue branch is still a complete branch switch and must not be entered while the app is open.

git switch rescue-forgot-to-close

2. Reopen InkWeave only to find and copy the paragraphs you need. Place the text in a plain-text file or notes app outside the project. Do not continue writing on the rescue branch.
3. Close InkWeave again. If opening and closing changed rescue files, preserve that rescue state once more:

Danger

Confirm that InkWeave is completely closed again. Preserve the inspected rescue state before leaving this accident vault.

git status --short
git add -A
git commit -m "Rescue: preserve the inspected state"
git status --short

4. Switch to the formal branch where the prose originally belonged. This example assumes timeline A:

Danger

Keep InkWeave closed. Switch to formal timeline A and reset only after the rescue branch is committed and clean.

git switch what-if-refuse-sword
git branch --show-current
git reset --hard HEAD

5. After confirming what-if-refuse-sword, reopen InkWeave and paste the recovered prose into the correct chapter. Close InkWeave and make a normal commit:

Danger

Close InkWeave completely after pasting the prose. Wait for autosave to finish and the app to exit before committing the recovered content.

git status --short
git add -A
git commit -m "Timeline A: recover uncommitted prose from before the accident"
git status --short

This recovers the author’s actual prose without merging indexes, snapshots, cards, or files from the wrong universe that may also exist on the rescue branch.

Keep both the rescue branch and the .bundle until you have opened main, A, and B separately and confirmed that every universe is correct. Do not rush to delete either layer of protection.

The final idea to remember

Git cannot write your story, and it does not know why Eileen drew the sword. It preserves a door that you can reopen for every choice.

InkWeave takes care of the world behind that door: who possesses the sacred sword, who is still alive, which location has fallen, which faction a character belongs to, and whether those results agree with that universe’s causal history.

As long as you keep this order, you can travel safely between canon and What If:

Close InkWeave → inspect and commit → switch branches → reopen InkWeave

Further reading

Want to keep exploring how different choices can truly change a character and their world?

Read “Character Choices Must Cost Something” →

Browse all Journal notes