Mind Map

See the shape of a note instead of scrolling through it. The mind map draws the note's title as the root and branches through its headings, lists, tasks and containers.

Opening the Map

Press the hierarchy icon in the note header, next to the reminder and bookmark actions. The title, properties, tags and body are replaced by the map. The header, the breadcrumb, the note's overflow menu and the outline panel all stay where they were.

The map opens on the section you were reading. Scroll to a heading halfway down a long note, press the icon, and the map is already looking at that part of the tree rather than at the whole picture from a distance. If you were at the top, or the note has no headings, it frames the whole map instead.

Press the same icon again to return to the note.

The map is a view of the note, not a document. Nothing is saved, nothing is edited, and the note is untouched by opening it.

What Gets Drawn

• The note title is always the root — never the first heading.
• Headings branch by level: an H3 under an H2 under an H1 nests three deep.
• A skipped level (an H1 followed by an H3) does not invent a missing heading in between; the H3 simply nests one step deeper.
• A note whose first heading is a deep level attaches that heading straight to the root. Relative depth is what places a heading, not the number you wrote.
• Bullet, numbered and checklist items branch off the heading they sit under. Numbered items keep their numbers, and a list that restarts in the editor restarts in the map.
• Nested list items branch off their parent item, so the indentation you already wrote is what you see.
• Tasks are nodes of their own, so commitments are part of the note's shape instead of being buried in it.
• Toggles and callouts open into their children. Content you collapsed in the editor is still discoverable in the map, and a callout holding a checklist is not reduced to one node.
• Wiki links become nodes of their own — see below.
• Content before the first heading belongs to the root.

A note with no headings opens on the root alone, with a hint that adding a heading will branch it.

Ticked Items

A checklist item or a task you have already completed is drawn dimmed, with a rule through its label. The map shows what is written, not what should have been.

Wiki Links

A [[wiki link]] points at another document, which is a real branch rather than a word in a sentence — so the map draws it as its own node, in blue and with a dashed outline, hanging off whatever held it.

• A link written in a heading or in a list item branches off that node.
• A link written in a paragraph branches off the node the paragraph belongs to, usually the heading above it. Paragraphs are still never nodes, but what they reach out to is not lost with them.
• A list item that is nothing but a link becomes the link itself, so a list of links is a fan of links rather than a row of empty boxes each holding one.
• A link node shows what the note shows: its alias when it has one, the target otherwise. Clicking it opens what the whole target names, heading and all.
• Link nodes are always leaves. What is inside the note a link names is the graph view's question, not the map's.

Tags and Counter Badges

Some things are content rather than structure, and drawing a node for each of them would bury the shape of the note under it. They are counted instead, never dropped:

• Tags written inside a heading or a list item become a small badge on that node rather than nodes of their own, so a heavily tagged note does not drown the map.
• Tables, code blocks, images, quotes, embeds, bookmarks and file blocks are not drawn. The node above them — usually the heading they sit under — carries a badge saying what is there, such as 2 tables · 1 code block.
• Paragraphs are never nodes. Date mentions, link mentions and inline pictures stay as plain text inside the label of the node that holds them — a [[wiki link]] is the one inline thing that does not, because it points somewhere else.

When a Note Is Big

A map that draws everything stops being readable, so the map has limits. The rule that governs all of them is that nothing disappears quietly: every omission is visible on the map, and most of them you can open back up.

• Too many items under one heading. The first dozen are drawn and the rest stand behind a +N more node. Click it — or select it and press Enter — and that branch opens in place, right where it was. Nothing else on the map moves. Wiki-link nodes count towards this like anything else, so a section packed with links folds the same way rather than sprawling.
• Branches nested very deep. Anything past six levels folds into the deepest node still drawn, and that node carries a +N more badge saying how much is behind it. Click that node to open the note at that block and read the rest there.
• Very long labels are clipped with an ellipsis — a very long note title included, since the root is a box like any other. The node still opens the block, where the full text is.
• A very large note. The map draws at most 200 nodes. When it reaches that, a one-line notice appears above the map and whatever is left over is counted on the nearest node that is drawn, in the same +N more badge.

Opening a branch is not a way around the 200-node limit: if opening one fills the map, the notice appears and the rest folds onto the node above it.

Branches you open are remembered for as long as the map is open and no longer. Close the map and open it again and it is back to its folded shape — the map is rebuilt from the note each time, and a note that has been edited would not have the same branches to open anyway.

Clicking a Node

The map is navigation, not just a picture.

• Click a heading, list, toggle or callout node and the map closes and the note reopens at that block.
• Click the root — the note's title — to come back to the top of the note.
• Click a task node and the task opens, so you can act on it rather than merely find where it was written. A task block written before memrynote gave tasks their own identity has none to open, and lands at its block instead.
• Click a wiki-link node and the linked note — or file — opens, in a new tab or this one according to Settings → General → Open Pages in a New Tab, the preference you have already set. The map invents no tab behaviour of its own: it goes through the same path as clicking that link in the note body, so it also creates a missing note and reports a missing file exactly the way the body does.
• Opening another note leaves the map where it was. It is a view of this note, so the tab you came from is still on the map when you return to it.
• Click a +N more node to open that branch in place. This is the other node that does not take you back into the note: a fold is undone where it is.
• The outline panel stays available while the map shows, and while the map is open it steers the map rather than leaving it. Click a heading there and the map slides to that heading's node, at whatever zoom you are on, with a brief ring around the node it landed on so you can see where you arrived. On a map too big to see at once, this is how you reach a far branch. If the heading is not drawn — it is behind a +N more, or past the 200-node limit — the click opens the note at it, the way it does when the map is closed.

Nodes work from the keyboard too. Tab into the map, move between nodes with the up and down arrows (Home and End jump to the ends), and press Enter or Space to open the one you are on.

Where a Node Goes

Point at a node and a small card appears under it naming what the click opens: the last two steps of the path, such as … → Q3 Risks → Hire a designer. A wiki-link node names the note it points at rather than the one you are in, and says that it leaves the note. A +N more node names the branch it stands for.

Nothing marks a node the rest of the time, and deliberately. Every node on a map is a link, so a marker on each of them would mark nothing and bury the shape the map is for. The whole node is the target either way — click anywhere on the box.

The Map's Own Toolbar

A small toolbar sits at the top of the map, and only there — the note's overflow menu is never repurposed, so the same button in the same place always does the same thing.

• Fit to view frames the whole map again after you have panned or zoomed.
• Copy as image puts the map on the clipboard as a PNG, ready to paste into a note, a message or a slide.
• Copy as vector puts the map on the clipboard as SVG markup, which design tools paste as editable artwork.
• Save as canvas keeps the map: it becomes a real canvas you own. See Saving the Map as a Canvas below.

Both copies contain the map as you are looking at it, so anything you have opened up in the map is in the copy too. They are exported on a transparent background and always in the map's light colours, so the same note copies the same way whichever app theme you are in. If a copy cannot be made, memrynote tells you rather than failing quietly.

The map's camera is not remembered. Close the map and open it again and it is back on the section you are reading, and Fit to view frames the whole thing from there.

Saving the Map as a Canvas

Save as canvas turns the map into a canvas document — one you can rearrange, extend and build on like any other.

The new canvas appears at the top level of Canvases in the sidebar, named after the note. If a canvas at that level already has that name, the new one gets a number after it (Roadmap 2, Roadmap 3), exactly the way the vault names any other file whose name is taken.

Three things are worth knowing about it.

It is yours from the moment it exists. Nothing regenerates it and nothing overwrites it. Edit it freely — memrynote will never come back and change it.

Saving twice gives you two canvases. The second save never replaces the first, because the first might be an hour of your work by then. If you want one canvas, delete the one you do not want.

It says when it was taken. The root node carries the date the map was generated, so a canvas you find months later announces itself as a snapshot of the note rather than a live view of it.

Every node in the saved canvas keeps its link back into the note, and those links keep working on your other devices: they point at the heading a node sits under, which is something the note carries everywhere, rather than at an internal identifier that only exists on the machine that made the map. A list item links to the nearest heading above it. Nodes above the first heading — and the root — open the note at the top.

Wiki-link nodes open the note they name. A [[link]] node in the saved canvas is resolved when the canvas is written, so it opens the linked note — at its heading, if the link named one — on any of your devices. If the link points at a note that does not exist yet, the node opens the source note at the section the link is written in instead, so it is never a dead box.

The saved canvas reads like the map it came from. Nothing marks a node until you point at one, and then the same small card appears under it naming what the click opens — … → Q3 Risks rather than the address behind it, including on a device that has never opened the note the map was made from. Click the card to go there. (On a canvas, unlike on the map, the box itself stays yours to select, drag and restyle; only the card opens the link.)

A "+N more" node stays in the saved canvas, even though there is nothing for it to open in a document. It is what tells you the canvas is not the whole note, and how much is missing; clicking it takes you to the section in the note where those items actually live. The same is true of the counts on other nodes: if the map folded something into a node, the saved canvas still says so.

Nodes are saved as plain shapes with links on them rather than as live memrynote cards. A card is around ten times the size of a map node, and a dozen of them would make the map unreadable. Add real cards by hand wherever you want them — it is your canvas.

The connectors are real bound arrows, so dragging a node around takes its branches with it.

The note itself keeps no record of the canvas. The relationship only runs one way: the canvas points back at the note, and the note knows nothing about the canvas.

If a canvas cannot be created, memrynote tells you rather than failing quietly.

Coming Back to the Note

Your work is exactly where you left it. The editor is only hidden while the map shows, never torn down, so undo history, the cursor, the selection and the scroll position all survive the round trip.

Per Tab, and Across Restarts

The map is remembered per tab. Switch to another tab and back and the map is still open; quit and reopen memrynote and it is still open. Opening the same note in a different tab starts in note view, because the map belongs to the place you are working, not to the note.

Reading Direction

In a right-to-left language the tree grows with your reading direction rather than against it.

Accessibility

The drawing sits beside a real tree in the page, so every node is announced by a screen reader with its nesting level, its badges, and — for a checklist item or a task — whether it is ticked, and every node can be reached and opened with the keyboard. A wiki-link node says in words that it leaves the note, because the blue dashed outline that says so in the picture cannot be heard. The map takes a single tab stop: arrow keys move between nodes from there. The map region itself is labelled with the note's name and how many nodes it holds.

Turning It Off

The mind map rides on the Spatial Canvas feature. Turn that off in Settings → Features and the toggle disappears from the note header.