Writing Mind Maps in Plain Text: An Introduction to the Mind Elixir Text Format

Most mind map tools rely on a graphical interface. To draw a map, you open an app and add nodes, links, and styles one by one with the mouse. This is not convenient in every situation. When you want AI to quickly generate a map outline, or save a map as plain text in your note library, or simply jot down the tree structure of an idea, the graphical interface becomes an obstacle rather than a help.

Mind Elixir offers a plain text format to solve this. A few lines of indented text describe an entire mind map, and you can import it into Mind Elixir for rendering whenever you need a visual view.

Basic Structure

Here is the simplest example:

- Root Node
  - Child Node 1
    - Child Node 1-1
    - Child Node 1-2
  - Child Node 2
    - Child Node 2-1

The syntax matches a Markdown list. The root node starts with -, and each level deeper indents by two spaces. Anyone familiar with Markdown can pick it up almost instantly.

The strength of this format is its universality. Any text editor can write it, and any tool that outputs text can generate it. By contrast, proprietary formats like .xmind and .mm are essentially binary files that cannot be read without their specific software.

Node IDs: Giving Nodes a Reference

A tree structure alone is sometimes not enough. When you need to link two nodes that are not in a parent-child relationship, you need a way to reference a specific node. Mind Elixir uses the [^id] syntax to tag a node:

- Root
  - Node A [^id1]
  - Node B [^id2]

The ID is written after the node text, wrapped in square brackets. The name is up to you, as long as it stays unique within the document.

Links: Connecting Any Two Nodes

With IDs in place, you can draw a link between any two nodes. Mind Elixir supports both bidirectional and unidirectional links.

Bidirectional link:

- Root
  - Node A [^id1]
  - Node B [^id2]
  - > [^id1] <-Link Label-> [^id2]

It starts with >, followed by the source node ID, then the link label, and finally the target node ID. The <- and -> on either side of the label indicate a bidirectional relationship.

A unidirectional link replaces <- with >-:

- Root
  - Node A [^id1]
  - Node B [^id2]
  - > [^id1] >-Forward Link-> [^id2]

The full format also supports coordinate parameters to control the curvature of the link, written as > [^id1] (10,20) <-Label-> (-10,-20) [^id2]. You can omit the coordinates when writing by hand, and Mind Elixir will calculate a reasonable placement automatically. When a map is exported back to text, the coordinates are written out so that any link shapes adjusted manually in the interface are preserved.

Styling: Color and Font Size

Nodes can carry style information using a JSON-like syntax appended after the text:

- Root
  - Styled Node {"color": "#e87a90"}
  - Another Node {"color": "#3298db", "background": "#ecf0f1"}

Supported properties include color (text color), background (background color), and fontSize (font size), all accepting either a hex color code or a numeric string. This is practical enough for marking important nodes.

Summary Nodes

When a group of sibling nodes needs a one-line summary, you can use a summary node that starts with }:

- Root
  - Node 1
  - Node 2
  - Node 3
  - } Summary of all above nodes

} summarizes all sibling nodes before it. If you only want to summarize the last few, add a number:

- Root
  - Node 1
  - Node 2
  - Node 3
  - }:2 Summary of Node 2 and Node 3

:2 means summarizing only the last two nodes. When organizing study notes, this syntax keeps the structure clearer without creating an extra node just for the annotation.

A Complete Example

Combining the features above, here is a practical example:

- Project Planning
  - Phase 1: Research [^phase1]
    - Market Analysis {"color": "#3298db"}
    - Competitor Study {"color": "#3298db"}
    - }:2 Research Summary
  - Phase 2: Development [^phase2]
    - Frontend {"color": "#2ecc71"}
    - Backend {"color": "#2ecc71"}
    - Testing {"color": "#f39c12"}
    - } Development Summary
  - Phase 3: Launch [^phase3]
    - Marketing
    - Deployment
  - > [^phase1] >-Leads to-> [^phase2]
  - > [^phase2] >-Leads to-> [^phase3]

This map contains three phases, each with color-coded subtasks and a summary for the research and development phases. The three phases are connected by unidirectional links that express their sequence. The entire structure is expressed in plain text, with no graphical interface operation required.

When This Format Helps

AI-generated map outlines. Large language models produce text naturally, but asking them to generate data matching a specific JSON structure tends to introduce errors. The plain text format is simple enough that models almost never get it wrong. Give the model a format example in the prompt, and it can produce a well-structured map that you then import into Mind Elixir to view and refine.

File storage and note archiving. Maps saved as .txt or .md files do not depend on any specific software. Even if you stop using Mind Elixir later, your notes remain readable. Compared to locking data into a cloud service's proprietary format, plain text storage is more reassuring and easier to fold into an existing note management system.

Cross-tool collaboration. Plain text is inherently easy to diff and merge. When two people edit the same map, a version control tool shows the difference as a few lines of text rather than an entire binary file that cannot be merged. This is genuinely useful for teams maintaining a shared knowledge structure.

Writing Notes

• Indentation must use exactly two spaces. Do not use tabs or four spaces. The parser counts hierarchy by the number of spaces, so wrong indentation breaks the structure.
• When using IDs, they must stay unique within the document, or links will point to the wrong node.
• Link statements can appear anywhere, but placing them near the related nodes keeps the file readable and maintainable.

Summary

The Mind Elixir plain text format is a pragmatic design. It does not try to reproduce every feature of the graphical interface in text. Instead, it focuses on the core structure of a map: nodes, hierarchy, links, styling, and summaries. These elements are expressed clearly in a few lines of text.

The value of the text format lies precisely in its simplicity and universality. If you use mind maps to record and organize information but find opening an app to draw every time a bit heavy, try writing in plain text first and importing into Mind Elixir when you need a visual.

For reference, here is the full syntax table:

Feature	Syntax	Example
Plain node	- Topic	- My Node
Node with ID	- Topic [^id]	- Node A [^id1]
Node with style	- Topic {"prop": "value"}	- Node {"color": "#ff0000"}
Bidirectional link	> [^id1] <-Label-> [^id2]	> [^a] <-connects-> [^b]
Unidirectional link	> [^id1] >-Label-> [^id2]	> [^a] >-leads to-> [^b]
Summary (all)	} Summary text	} Overview
Summary (N nodes)	}:N Summary text	}:3 Last three items

Using It in Obsidian

If you take notes in Obsidian, the Mind Elixir Obsidian plugin lets you write and preview mind maps directly inside your notes. Write the plain text in the format above within a Markdown file, and the plugin renders it into a visual map automatically, keeping text edits and the map view in sync.

Plugin page: https://app.mind-elixir.com/obsidian-mindmap