Mind Map Maker turns any indented text outline into a deterministic, standalone SVG diagram using two simple rules — one root line at the top, then two spaces or one tab for each nesting level — capped at 80 nonempty nodes, 12,000 total characters, and 120 characters per label. Every label is XML-escaped before it enters the SVG, so ampersands, angle brackets, quotes, and apostrophes render as plain text rather than as markup. The output is a left-to-right tree drawn with simple rectangles, text, and cubic paths, and the downloaded file contains no scripts, foreignObject elements, external images, or remote fonts. Because parsing, layout, preview, and download all happen in the current browser tab, the original outline never leaves your machine. This cheat sheet collects the exact syntax the parser accepts, the hard limits it enforces, and the contents of the exported file, so you can paste an outline and get a clean diagram on the first try.
Mind Map Maker Cheat Sheet: The Quick Reference
The fastest way to describe this tool is as an outline-to-SVG converter with strict input rules. You write a plain-text outline, the parser reads indentation to decide who belongs under whom, and a deterministic layout engine places each node at a fixed column based on depth and at a row based on source order. No force-directed physics, no drag handles, no snapping heuristics — the same outline always produces the same diagram, which is why a one-page cheat sheet is enough to drive it confidently.
Keep the original outline alongside the exported SVG and treat the outline as the editable source of truth. The SVG is a presentation artifact, not a round-trip project file, so the only way to change the diagram is to change the text and regenerate. That separation is what makes the cheat sheet approach practical: the rules in your text and the rules in the parser line up exactly, so a brief reference card is enough to cover most cases.
Outline Syntax Rules You Must Follow
The parser is deliberately strict so that parent-child relationships stay unambiguous and an outline cannot silently attach to the wrong branch. Five rules cover nearly every valid input.
- First nonempty line is the root. The first line that contains text becomes the central topic. It cannot be indented.
- Indentation sets depth. Each level of nesting is exactly two leading spaces or exactly one leading tab. Four spaces equal two levels, six spaces equal three levels, and two tabs equal two levels.
- Never mix tabs and spaces in the same prefix. A line that starts with a tab and then spaces is not parseable, and the reverse is not either. Pick one style and stay with it across the whole outline.
- Indentation cannot skip a level. A child at depth 3 needs an ancestor at depth 2 directly above it; jumping from depth 1 to depth 3 leaves no parent for the parser to attach to.
- Bullets are stripped from labels. Hyphen, asterisk, and plus signs at the start of an indented line are removed once indentation is read, so "- Budget" and "Budget" end up as the same label.
Blank lines are ignored and line endings are normalized locally, so Windows CRLF, macOS CR, and Unix LF outlines all parse the same way. Each indented line attaches to the nearest preceding node one level above it, which is why source order in the outline controls the left-to-right branching on the canvas. This deterministic parent assignment is the single biggest reason the cheat sheet fits on one page.
What a Valid Outline Looks Like
A correct outline reads top-to-bottom like a table of contents. The root sits flush left, children sit two spaces in, grandchildren sit four spaces in, and so on. If you mentally reformat the outline as nested bullet points, the hierarchy should look obvious before you even click Generate; if it does not, the indentation is almost certainly the cause.
Hard Limits the Parser Enforces
Each limit is a guardrail against malformed input and oversized output. The cap of 80 nonempty nodes keeps the layout readable and the SVG small. The 12,000-character outline cap covers indentation, bullets, and all labels combined. The 120-character-per-label cap is a presentation limit; very long phrases can overflow their boxes because the tool does not measure text wrapping.
| Limit | Why it exists |
|---|---|
| 80 nonempty lines | Keeps the diagram compact and prevents runaway trees |
| 12,000 total characters | Bounds the parser workload and the resulting SVG size |
| 120 characters per label | Labels are not word-wrapped; longer text may exceed box width |
| Root must not be indented | Guarantees a single, unambiguous central topic |
| No skipped levels | Stops children attaching to the wrong parent |
| No mixed tabs and spaces | Keeps indentation parsing deterministic |
Editing the outline invalidates the previous result and releases its Blob URL, so the preview always matches the current text. If you paste a much longer outline and then shrink it back, the regenerated SVG reflects the new structure without caching stale branches from the earlier run.
How to Turn an Outline Into an SVG Mind Map
Open the Mind Map Maker, paste or type your outline, and follow the steps below. The whole flow runs locally in your browser, so nothing is uploaded to a server at any point.
- Enter a root line, then indent child lines with two spaces or one tab per level. Write the central topic flush left. Press space twice (or press Tab once) to mark a child, four times to mark a grandchild, and so on. Keep all prefixes consistent — either spaces-only or tabs-only — and never skip a level.
- Select Generate mind map and inspect the parent-child connections in the local preview. The parser normalizes line endings, drops blank lines, strips leading bullets, escapes labels for XML, and draws cubic SVG paths between every parent and child box. Read the preview top-to-bottom and left-to-right to confirm each branch lands where you expected.
- Download the standalone SVG and keep the outline if you want to edit the structure later. Click the download control to save a single SVG file with no scripts, foreignObject elements, external images, remote fonts, or network references. The preview and download come from a local Blob URL; when you edit the outline, the previous URL is revoked.
If the preview looks wrong, the first place to look is indentation. A node that hangs from the wrong branch almost always traces back to a missing level, a mixed tab-space prefix, or a bullet that was not stripped as expected. Fix the text, regenerate, and the diagram updates deterministically without any further input.
What the Exported SVG Contains (and Omits)
The downloaded file is a plain SVG document built from rectangles, paths, and text. Every label is XML-escaped before it enters the markup, so characters that would otherwise be interpreted as SVG or HTML — ampersands, less-than, greater-than, double quotes, single quotes — render as literal text. The SVG canvas expands to include every generated node, so nothing gets clipped at the edges of the viewBox.
| Included in the SVG | Deliberately excluded |
|---|---|
| Rectangles for node boxes | JavaScript or event handlers |
| Text elements for labels (XML-escaped) | foreignObject elements |
| Cubic path connectors between parents and children | External images and remote fonts |
| Expanded viewBox sized to fit the tree | Network references (no http/https fetches) |
| Deterministic left-to-right layout | Force-directed physics or animation |
The Blob URL used for the preview and download is revocable. As soon as you edit the outline, the previous result is invalidated and its URL released. The SVG file itself is portable: open it in any browser, drop it into a slide deck, or paste it into a document as a vector image. For the underlying mechanics of how browsers expose Blob URLs for local file generation, MDN's Blob reference walks through the same APIs this tool uses internally.
When the Cheat Sheet Stops Helping
The deterministic outline-to-SVG path is built for quick planning, study notes, and lightweight communication artifacts. It is not a replacement for a full diagramming application. Reach for a dedicated diagram tool when you need any of the following.
- Drag-and-drop rearrangement of nodes after generation
- Collapse and expand of branches in the diagram itself
- Import of proprietary mind-map formats such as XMIND, MindManager, or FreeMind
- Real-time multi-user collaboration on the same outline
- Long-term project storage, version history, or saved sessions
- Freeform spatial editing on an infinite canvas
- Accessible semantic documents (the SVG here is visual only)
For those workflows, export the SVG as a static insert and keep editing the original outline for the things this tool does well. Students who want a structured way to turn a textbook chapter into a study diagram can pair this cheat sheet with the chapter-to-mind-map study walkthrough and then drop the resulting SVG into their notes for a quick visual recap.
If you're weighing options, Pie Chart Maker API Alternative for Fast PNGs covers this in detail.