<p align="center"> <img src="assets/NN.svg" alt="NarrativeNode" width="128" /> </p>

NarrativeNode

A visual plot planner for writers. Built like a node editor, designed for storytellers.

<p align="center"> <img src="docs/help/v2/main-app.webp" alt="The NarrativeNode canvas: scene nodes with entity chips, connected by wires" width="800" /> </p>

Welcome to NarrativeNode!

Hey! NarrativeNode is the first project of this scale that I've put out publicly. I'm a new solo developer, and I've been building it for months, so releasing it is equal parts exciting and nerve-wracking.

I really hope you find it useful, and I'd genuinely love to hear what you think. Thanks for taking a look! 😄

~ Carasibana

---

What is it?

NarrativeNode is a planning tool for writers who are building complex stories. Instead of juggling separate character sheets, timeline spreadsheets, and scattered notes, you plan your entire story in one visual workspace: a canvas where each scene is a node, and the lines connecting nodes show exactly how characters, objects, and locations move through the narrative.

Think of it as a flowchart for your story, where every box knows the state of every person and thing inside it -- and where recording a change in scene 3 automatically carries that change forward to every scene after it.

If you have used tools like ComfyUI or Blender's node editor, the interface will feel immediately familiar. If you haven't, the core idea is simple: each element of your story lives in its own node. You connect the nodes to show how the story flows. You can see the whole plot at once, zoom into a single moment, or follow any single character's thread from their first appearance to their last without losing sight of the rest.

---

What problem does it solve?

Planning a story with one character and a simple timeline is straightforward. Most stories are not like that.

The moment you add a second point-of-view character, a flashback, a faction with competing loyalties, or an item that changes hands three times, the whole thing starts to slip. Traditional tools were not built for this:

• Character sheets capture who a character is at the start, not how they change. You have to manually update every document every time something happens to them -- and manually cross-reference those changes against every later scene.
• Index cards and outlines show the plot structure but not the state of the world at each scene. Who is in the room? What do they know? What are they carrying?
• Spreadsheets can track state changes in theory, but they show no shape, they fall apart the moment timelines go non-linear, and they tell you nothing about relationships between entities at any given moment.
• Prose writing apps are for writing, not planning. Using the same tool for both makes each harder.

NarrativeNode treats your story as a living graph. The state of every character, location, and item is computed automatically at every scene by following the chain of changes you have defined from the beginning. You define an entity's starting state once, then record what changes at each scene where they appear. Every downstream scene automatically reflects those changes, and if two changes contradict each other, the app flags it for review rather than silently breaking your continuity.

The other core problem NarrativeNode solves is the gap between temporal order (what actually happens in the story world, and when) and narrative order (the sequence a reader experiences). The canvas always shows temporal order, so you can plan the full world timeline visually. The POV system lets you route the narrative through that timeline however you want: flashbacks, non-linear cuts, scenes that happen off-screen. When you export, the output follows the POV sequence, not the canvas layout, so the reader gets the order you intended.

---

Core concepts

Three ideas make the rest of the app click into place.

1. The canvas shows time. The POV path defines the story.

Scenes on the canvas are arranged in temporal order: the order things happen in the story world. Parallel events sit side by side. You can see the whole timeline at a glance.

The POV system is separate. You mark which character is carrying point-of-view at each scene. That sequence defines the narrative order: the order a reader encounters events. Export follows the POV order, not the canvas layout. A flashback that is chronologically the earliest event in your story can be placed in chapter six just by where you route the POV character through it.

Scenes with no POV character are off-screen: they are part of the world timeline, but the reader does not witness them directly.

2. Entities have history, not just state.

Every character, location, item, faction, and custom element in your story is an entity. Each entity is defined once, at a Setup Node on the canvas: name, colour, description, and whatever custom attributes you want to track.

After that, entities do not have a global state you go back and edit. Instead, you record what changes at each scene. A character gets injured: add that change at that scene node. An item changes hands: record it there. A name change, a new relationship, an attribute removed: all of it is recorded at the scene where it happens, not retroactively.

The app computes each entity's effective state at any scene by walking from its Setup Node forward through the connection graph, applying changes in order. You can look at any scene and see exactly what every entity looked like at that specific moment in the story.

3. Changes propagate forward, and conflicts surface automatically.

When you record a change to an entity at a scene, it flows forward to every subsequent scene. If you later realise that change should have happened one scene earlier, you move it and the propagation updates itself.

If a downstream scene already had its own version of that change recorded, it is flagged with a warning indicator. Nothing is blocked or broken: the flag just says "this might need a second look." You address flags at your own pace.

---

Features

Canvas and scenes

• Infinite zoomable canvas for arranging scenes in any layout
• Scene nodes with a title, a short summary visible directly on the node, and a full rich-text content area in the sidebar
• Entity chips: each scene node holds coloured sub-sections, one per entity present at that scene; chips show the entity's state at this point in the narrative
• Wiring: drag from any entity chip to connect it to the next scene; each wire can carry a transition note (travel method, time skip, motivation, anything relevant to the transition)
• Each entity follows a single linear path: one outgoing connection per chip, one scene to the next; entities can skip scenes freely, but each entity chip can only continue forward to one scene at a time
• No restrictions on which entity types can appear together in a scene, or how many scenes any entity can appear in
• Chapters and Acts: group scenes into chapters using column dividers across the canvas; chapters can be organised into acts; groups are used as scope for export
• Readability controls: switch between wire-visibility modes, auto-tidy wire routing, preview a wire's transition note inline, and dock or rearrange the side panels

Scene time

Scenes can optionally record when they happen: time of day, date, season, and duration, against a configurable calendar. This information is available to the timeline views and to any AI context built from a scene.

Entities

Five built-in entity types, plus a fully configurable custom type:

| Type | What it represents | |---|---| | Character | Any person or being in the story | | Location | A place; supports parent/child hierarchy (e.g. City > Tavern > Back Room) | | Item | An object that moves through the narrative (a sword, a letter, a map) | | Faction | A group, organisation, or allegiance | | Custom | Anything else; organised by user-defined categories (e.g. "Spells", "Ancient Artefacts", "Goblins") |

Each entity gets:

• A user-chosen colour that flows through the entire canvas (wires, chips, and setup nodes all use it)
• A profile image (uploaded and cropped in-app)
• A description
• Any number of aliases (alternative names the entity is known by)
• Any number of custom attributes
• Relationships to other entities

Custom attributes

Attributes can be one of five types:

| Type | Description | |---|---| | Text | Free-form text, as long or short as needed | | Media | Any supported file: image, audio, or video; uploaded and embedded in the project file | | Preset | A selection from a user-defined list (e.g. a "Species" list containing Human, Elf, Dwarf) | | Text list | A list of text values (e.g. a list of nicknames, titles, or tags) | | Entity list | A list of other entities from the story (e.g. A list of friends, a character's inventory, a location's known inhabitants) |

Attributes can be added, modified, or removed at any scene node as part of that scene's change record. The change flows forward from that point.

Preset lists are defined at the story level and shared across any entity or attribute that needs them.

Relationships

Relationships are first-class objects linking entities: an alliance, a rivalry, a family tie, a chain of command. Like an entity, a relationship is defined at an origin and then evolves along the narrative: participants join or leave, perception between participants shifts, roles and hierarchy change. Each change is recorded at the scene where it happens and propagates forward, with the same review-flag system as entity changes. A relationship's state at any scene is shown on the relevant entity chips and in the Detail Panel.

Knowledge and awareness

NarrativeNode tracks not only what is true in the story but who knows it. Knowledge items are discrete facts, secrets, or pieces of information in the world. Awareness records which characters are aware of something, and how strongly, at each point in the narrative. Awareness can be tracked against knowledge items, entities, relationships, individual attributes, and names or aliases. Like everything else it is recorded as changes at scenes and computed forward, so you can ask who knows a given secret at a given scene and get an exact answer.

Circumstances, motivators, and perspectives

Characters can carry richer narrative state than plain attributes:

• Circumstances and motivators: situational conditions and driving forces, each with a description and an intensity, recorded where they apply.
• Perspectives: how a character regards another character or a situation, captured as a described, directed stance.

All three are tracked along the chain like any other change, and they feed the AI chat and character-card features described below.

Tags

Entities and scenes can be tagged, and a tag filter narrows the canvas and library to what carries a given tag. Tags can be defined per project or kept in a reusable program-level pool.

Change tracking

At each scene node, every entity chip can record a change layer for that entity at that scene:

• Name changes
• Colour changes
• Description changes
• Profile image changes
• Attribute additions, modifications, and removals
• Relationship additions and removals

Visual indicators on each chip show what kind of change happened at a glance: green for additions, red for removals, amber for modifications. Changes propagate automatically to all downstream scenes.

If a later scene already carries its own change for the same field, that scene gets a review flag. All flags are informational and non-blocking. An Alerts panel gathers every outstanding review flag in one place so none get lost.

POV system

POV is tracked at the character level, not the scene level