Arbor

Think in branches. Keep one note.

Arbor is a writing-first branching editor for Obsidian. It lets you build a note as small Markdown blocks arranged left-to-right while keeping the note itself as a normal .md file.

No export step. No separate canvas file. No sidecar database.

The core idea:

• write in short blocks instead of one long wall of text
• see the current branch, nearby alternatives, and next steps at the same time
• reorganize ideas without copy-paste chaos
• stay inside one note instead of splitting thoughts across many files

Arbor is desktop-only. It currently requires Obsidian >= 1.5.12 and was tested on Obsidian 1.12.4.

Why Arbor

Arbor is for notes where order matters, but thought does not arrive linearly.

Good fit:

• article and essay drafting
• study notes with branches and alternatives
• argument building
• structured brainstorming
• rewriting and rearranging long notes without losing the original Markdown

Arbor is not a canvas, mind map, or whiteboard. It is still note editing, just with a branching spatial view.

Core Features

• Left-to-right branching editor for one Markdown note
• Stable block tree with inline editing
• Normal readable Markdown body as the source document
• Visible block markers plus hidden in-note metadata for exact recovery
• Selected block panel with focused preview and inline editing
• Context-aware dimming so the active branch stays readable
• Drag-and-drop reorder and reparent
• Keyboard-first navigation and structure editing
• Search overlay for block-level search
• Zoom, breadcrumbs, view menu, and context menus
• Auto-open managed Arbor notes in Arbor view
• Safe rebuild when the note changed in plain Markdown mode

Install

Community Plugins

Once Arbor is approved in the Obsidian community catalog:

1. Open Settings -> Community plugins -> Browse.
2. Search for Arbor.
3. Install it.
4. Enable it.

Manual install

If you want to install Arbor before it appears in the community catalog:

1. Download manifest.json, main.js, and styles.css from the latest GitHub release.
2. Create this folder in your vault:

.obsidian/plugins/arbor

3. Place those three files inside it.
4. Open Obsidian.
5. Go to Settings -> Community plugins.
6. Enable Arbor.

Quick Start

1. Open any Markdown note.
2. Run Open view for current note.
3. Create a root block.
4. Press Enter on a selected card to edit it.
5. Use Ctrl/Cmd + Arrow to grow the structure.
6. Use the right-click menu to duplicate, move, delete, or continue a branch.
7. Turn on Selected block panel from the Arbor menu if you want a focused preview/editor panel.

Support

If Arbor is useful to you, you can support development here:

• Buy Me a Coffee

Built-In View Shortcuts

These work inside Arbor itself. They are not command-palette bindings.

Navigation

Editing

Structural creation

Notes:

• Ctrl/Cmd + ArrowLeft is intentionally conservative and does nothing when the selected block is already at the root level.
• Arbor uses event.code for view-level shortcuts where needed, so layout-dependent bindings like search remain stable across keyboard layouts.
• Delete subtree shows a confirmation modal. Normal Delete block does not.

Search and zoom

Command Palette Actions

All of these are exposed as normal Obsidian commands. By default, they have no bound hotkey unless you bind one yourself in Obsidian.

View Menu

Arbor includes a compact view menu in the top-right corner of the editor.

Current menu actions:

• toggle Selected block panel
• toggle breadcrumb path
• toggle breadcrumb flow
• toggle Ctrl/Cmd + wheel zoom
• reset zoom to 100%
• open Arbor settings

Settings

How Notes Stay Normal Markdown

Arbor does not move your note into a database or sidecar file.

Each Arbor note contains:

• the visible Markdown body
• machine-written block markers before each block in the visible body
• one hidden metadata block at the end of the same note

Example shape:

<!-- arbor:block:v1 id="root-1" parent="" order="0" -->
# A visible markdown note

This text is still readable in normal Obsidian.

<!-- arbor:metadata:v1
BASE64_ENCODED_JSON
-->

Important behavior:

• frontmatter is preserved
• the visible body stays readable if the plugin is disabled
• Arbor keeps stable block IDs in both visible markers and hidden metadata
• if hidden metadata is stale, Arbor can recover the exact block tree from the visible markers
• if you open an older Arbor note without visible markers, Arbor upgrades it automatically to the precise marker format
• if you edit the note in normal Markdown mode, Arbor will safely rebuild the tree from the visible note body instead of silently dropping content

Beautiful blocks in the > [!note] style are still normal Markdown callouts. In the screenshots and demo notes, that styling comes from Callout Manager.

Privacy and disclosures

• No account is required.
• No telemetry is collected.
• No ads are shown.
• Arbor does not make network requests for its core functionality.
• Arbor stores plugin settings with Obsidian's plugin data system.
• Arbor stores branch structure inside the note itself as hidden metadata comments.
• If you paste an image into a block, Arbor writes that image into your vault as a normal attachment.

Demo Notes

Arbor ships with a built-in demo note generator.

Use the command palette action:

• Create demo note

The command creates a new Arbor-managed demo note in the current note folder, or in the vault root if there is no active note.

Compatibility

• Desktop only
• Obsidian >= 1.5.12
• Tested on Obsidian 1.12.4
• Plugin ID: arbor
• Current version: 0.1.9

Known Limitations

• Arbor is intentionally desktop-first.
• Plain-Markdown rebuild is conservative by design. It protects content first and structure second.
• Undo and redo are Arbor view history, not native editor history.
• Very large notes can still benefit from future virtualization work.

Roadmap

• richer block search navigation
• stronger conflict handling when Arbor view and plain Markdown both change the same note
• more refinement for very large note trees

Development

Contributor workflow:

npm install
npm run dev

Release checks:

npm run lint
npm run build
npm test

Arbor includes a local eslint-plugin-obsidianmd setup so the same reviewer-facing checks can be run before submission updates.

Manual interaction checks live in:

• docs/manual-qa.md

Repository Layout

arbor/
  assets/
  demo/
  docs/
  src/
    model/
    storage/
    view/
  tests/
  manifest.json
  package.json
  styles.css