The Outliner

MojoPad has a full outliner built into every formatted page — and a dedicated Outline page for when you want a document that's nothing but the tree. If you think in nested bullets, fold to declutter, focus in on a branch, and restructure from the keyboard, this chapter is home. If you never touch it, nothing changes: it only appears where you already have bullets.

A wiki that is nothing but outlines

If outlines are how you think, you probably don't want to ask for one each time. In the Info palette, set New Page Format to Outline and every new page in that document opens as one — pages you make with ⌘N, pages a [[link]] creates for you, and your daily note. Set it once and the whole wiki is an outline wiki, which is the tidiest way to keep all your outlines in one place.

It is per document, so one wiki can be outlines end to end while another stays prose. And it changes nothing about what an outline is: an outline is an ordinary formatted page shown a particular way, so search, links, export, the graph and everything else treat it exactly like any other page. You can turn any single page into one at any time with View ▸ Outline View, and turn it back the same way.

Your first five minutes

Click the New outline button in the left icon rail — or choose File ▸ New Outline — name it, and type. The rules are simple:

• Return makes a new row, at the level you are already on. On a row that has rows tucked under it, the children stay where they are and the new row opens below the whole branch — pressing Return is never a way to lose a level. On an empty row, Return promotes it one level out, so pressing it twice is how you climb back to a main bullet after finishing a nested thought. Ordinary bulleted lists on any page follow the same two rules.
• Tab tucks the row under the one above it; ⇧Tab promotes it back out. A whole subtree travels with its row, and rows below a promoted row become its children — the classic outliner rule, so the order you read is always the order you meant.
• Hover a parent row and a small triangle appears left of the bullet — click it to collapse that branch behind a ⋯. ⌥-click the triangle and the whole branch folds or opens — every nested level at once. Collapse is saved with the page: reopen the document and your branches are exactly as you tucked them. ⌥⌘. toggles from the keyboard, and View ▸ Collapse All Rows / Expand All Rows works the whole page.
• Click a bullet (the dot itself) to focus in: that branch becomes the whole view, with a breadcrumb across the top — page ▸ ancestors ▸ here. Click any crumb to step back out, or use Focus In on Item (⌘.) on the caret's row and Focus Out of Item (⇧⌘.) to step out one level. Focusing is a way of looking, not an edit — it never changes the page, and it shows the item and its children, nothing else. You can write normally while focused — everything saves as usual — and the branch you're standing in is protected: MojoPad politely refuses to move, delete, or outdent the focused row itself (Focus Out first). Navigating to another page always focuses back out. (This is a distinct feature from Focus Mode (⇧⌘F), which dims the page around the line you're writing.)
• Drag a bullet to move a row anywhere: drop on another row's top or bottom edge to land beside it (you'll see a thin line), or on its middle to nest inside (a filled box). A row can never be dropped into its own branch.

Every page is a little bit outliner

None of the above is exclusive to Outline pages. Any nested list on an ordinary formatted page collapses, focuses in, Tab-restructures, and drags exactly the same way — your existing notes gained these powers without changing a single byte of their content. An Outline page is just a page that commits: every line is a row, marked with an ≣ in the page list.

Two commands convert between the worlds, both under View:

• Outline View turns the current formatted page into an outline — paragraphs become rows. Toggle it off and the page returns to ordinary editing with the same content: bullets are still bullets, nothing is lost either way. Think of it as two lenses over one page. (A storyboard declines: it is already its own kind of page, and flipping the lens would take the board apart. Its Send to… button makes an outline page from it instead, leaving the board where it is.)
• Prose Mode reads an outline as a document without changing it — see below.
• On a Markdown page, Outline View offers to convert the page into a formatted outline first — your text is kept, and it gains folding and nesting.

Prose Mode — the same rows, read as a document

You have planned a chapter as an outline and now you want to read the chapter. Or you are drafting a paper section by section and need to know whether it flows, not whether it is tidy. Or a supervisor wants the argument, and what you have is a tree.

View ▸ Prose Mode puts the bullets and the indentation away. Each row's own line becomes the heading for what sits under it, and the note attached to that row — the prose you wrote beneath it — becomes the body. Rows nested one level deep read as smaller headings, so the shape you built is still visible, in the way a document shows shape rather than the way an outline does.

Nothing about the page changes. Not a character of it. Prose mode is a way of looking, like focusing in — the file on disk is byte-for-byte the same whichever way you are reading, and you can write in either one. Reorder a row in the outline and its prose travels with it, because the row and its prose were always the same thing.

Turn it off the same way. It is remembered per page, so a chapter you read as prose opens as prose next time, and the outline beside it opens as an outline.

Rows that name themselves

Write first and name later. If you have been writing under a row without giving the row a line of its own, MojoPad shows a label for it anyway — the opening sentence of what you wrote, in italics and a little faded, sitting where the heading would be. It is there so a page you drafted quickly still reads as something with structure.

It is not yours and it does not pretend to be. It is never saved — nothing goes into your page, your exports, or the published site — it is worked out fresh each time the page is drawn, and it disappears the moment you type a name of your own. A row you have named is never touched, never re-worded, and never marked. What you write stays written.

Writing in prose mode

• Return inside a paragraph makes another paragraph, not another row — you are writing a document, so the keyboard behaves like one.
• ⌥⌘N on a row adds the prose underneath it (the same command as in the outline), and Esc steps back out to the row's own line.
• To give an unnamed row a name, switch back to the outline for a moment: its line is empty, and an empty line is easier to click when the bullet is there to aim at.

How the outliner keeps its promises

• Collapse lives in the page. A tucked-away branch is part of the document — it survives quitting, syncing the file elsewhere, even opening the page years later. (Heading folds, by contrast, are a personal view and stay on your Mac.)
• Focus is only a view. Nothing about focusing in is ever written to the page — a page saved mid-focus is byte-for-byte the page you'd save without it.
• Every structural move is one undo. Tab, ⇧Tab, a drag, Move Row to…, Duplicate, Delete — each is a single ⌘Z away from never having happened, and the caret stays where you were typing through all of them.
• Parents show their state. On Outline pages, rows with children wear their triangle all the time — ▾ open, ▸ tucked — and top-level rows sit a little heavier, so the structure reads at a glance. On ordinary pages the triangle appears on hover, keeping prose pages quiet.
• A branch draws its own spine. On Outline pages a faint line runs down the bullet column from a parent through the rows beneath it, in the theme's own ink. It is drawn wherever a row shows a triangle, stops clear of every bullet at both ends, and disappears with the branch when you tuck it away — so on a deep outline you can see which rows belong to which parent without counting indents. Ordinary prose pages stay plain.
• The row you click stays where you clicked it. Collapsing a branch takes height out of the page, and at the end of a long document that used to drag the whole page down under the pointer. Now the row holds its place — collapse and expand from the same spot, as many times as you like, without the page moving underneath you.
• The tree stays a tree. Wherever a list arrives from — old pages, web clips, other apps — MojoPad quietly repairs the one malformed shape browsers love to produce (a branch floating beside its parent instead of under it), so every row always knows its parent. Repairs never touch the file until you actually edit the page.
• Old friends still work. The ⠿ block handle still serves a list as a whole — hover any row but the first and it's there for dragging the entire list, Turn into…, or Send to Canvas. And multi-row selections still indent and outdent together with ⌥⌘] and ⌥⌘[ — Tab is the one-row-with-subtree gesture.

Work the outline

• Done and hidden. ⌘Return (Mark Row Done / Not Done, also in the command palette) marks the caret's row done — it gets a ☑ and a strike-through, and clicking its checkbox toggles it too. It works on formatted and Markdown pages: on a Markdown checklist the row round-trips as - [x]. View ▸ Hide/Show Completed Rows sweeps finished rows (and everything under them) out of sight while you work the remainder; toggle again to bring them back. Done-ness saves with the page; the hiding is just your current view.
• Sub-tasks that add up. Nest a checklist under a checklist item and that item becomes a parent: it shows a running count — like 4/6 — of the tasks beneath it, and ticks itself off the moment they're all done. Check or uncheck a parent and its whole group follows. Sub-tasks can hold sub-tasks of their own; the count rolls up the lot.
• Move Row to… (⇧⌘M) teleports the caret's row — subtree, checkmarks and all — to the end of another page, picked from a fuzzy list. Triage a brainstorm into project pages without touching the mouse.
• Jump to Row or Heading… (Go menu) is a fuzzy list of every row and every heading (▸) on the page; pick one and the caret lands there, opening any collapsed branches on the way. It scales to outlines far too big to scroll — and doubles as a section jump on any prose page, this manual included.
• Link or mirror any row, one trip. Insert Link to Row… (⌥⌘K, Edit menu) is the fast path: pick a page, pick one of its rows from a fuzzy list, and choose what lands at your caret — a link (click it to jump straight to that row, even on another page) or a mirror (a live embed of the row and its subtree, always showing its current state). The long way still works too: visit a row, Copy Link to Block, and paste the ![[…]] anywhere. One row, many places.
• Selection that understands the tree. ⇧⌘B selects the caret's branch — the row and everything under it — ready to cut, copy, or restyle in one stroke. ⌃⌥↑ expands the selection a level at a time (word → the row's line → its branch → each parent branch → the whole page) and ⌃⌥↓ contracts back down the same steps.
• Duplicate and delete by keyboard. Edit ▸ Duplicate Row drops a copy of the row and its subtree just below (the copy never inherits block links, so mirrors stay unambiguous); Edit ▸ Delete Row removes a row and everything under it. Both are unassigned by default — give them keys in Settings ▸ Shortcuts if they earn a place in your hands.
• Add the next row in one keystroke. Return already gives you a sibling below. Three companions under Edit handle the other directions without the Return-then-Tab shuffle, and the caret lands in the fresh row so you keep typing: New Row as Child nests a row one level in (a Return then a Tab), New Row at Parent Level starts a row one level out, after the current branch (a Return then a ⇧Tab), and New Row Above opens a sibling directly above the one you're on. All three ship unassigned — bind them in Settings ▸ Shortcuts (a builder's pick: ⌃⌥I for child, ⌃⌥O for parent level — both free, whereas ⌥⌘O already moves you between panes) and a tree grows as fast as you can name its rows.
• Give a row a note. ⌥⌘N on any row opens a note — prose that belongs to the row itself, not to its children. It's the OmniOutliner/Workflowy convention: quieter and indented under the row's line, as many lines as you like (Return inside the note stays in the note — it never makes a new row). esc drops you back on the row's line. A note folds with its row: collapse the row and the note tucks away with the children. Notes live on formatted (outline) pages, travel with the file, and export as indented text beneath the bullet.

✦ The bridge between outline and prose

This is the part no other outliner has. Two commands under View, both running on your AI — on this Mac, unless you have set up a model elsewhere and permitted this wiki:

• ✦ Outline This Page reads the current page and distills it into a nested outline on a new page (named after the original), opened in outline view. The original is untouched. Use it to find the skeleton of a long note, or to turn pasted research into something you can restructure.
• ✦ Draft from This Outline goes the other way: it walks your outline's tree and writes a flowing first draft on a new page — top-level rows become sections, nesting becomes the flow of each section. Outline first, then let the draft write itself, then edit like an editor instead of staring at a blank page.

Round trips are fair game: outline a draft of an outline as many times as helps. Every generated page is marked with a ✧ so you always know what the machine wrote.

Answers to the questions you'll have

• Is my outline a special format? No — it's the same page format as every formatted note, so search, export, links, the graph, encryption, and AI all treat outline pages like any other page. Turning outline view on or off never migrates anything.
• What happens when I paste text into an outline? It arrives as rows — one per line, nested by indentation. An outline exported from Workflowy, Logseq, or Kosshi pastes in as the same tree.
• Can a row hold more than a line? Yes — rows are ordinary rich text: bold, links, tags, even images. Keep rows short for the outliner feel, but nothing stops a longer thought.
• Why won't Tab indent my first row? A first child has nothing above it to nest under — every outliner refuses this, and MojoPad does too, so the tree always stays a tree. Likewise a top-level row can't outdent any further.
• Where did my Enter go in a table or the “/” menu? Nowhere — tables and the insert menu keep their own Tab behavior; the outliner only claims Tab inside list rows.
• What about Markdown pages? Restructuring (Tab/⇧Tab, drag), focus, and Jump to Row all work on Markdown lists too. Collapse and row completion live on formatted pages — Markdown files have no place to keep those marks, and MojoPad won't pretend to save something it can't.
• Why isn't a page in the Move Row to… list? Destinations are formatted pages — a row is formatted content. Encrypted pages are deliberately absent: a moved row must never sit readable beside a locked page's contents.
• What do the ✦ commands need? A local AI model (Settings ▸ AI — the same setup every ✦ feature shares — see Local AI, where the two model settings are told apart). No model configured, no problem: the commands simply say so; nothing is ever sent anywhere else.
• What does ⌥⌘. do outside an outline? Exactly what it always did — fold the heading section you're reading. On an Outline page it collapses the caret's branch; on an ordinary page with no heading above the caret, it falls back to the branch too.
• Does hiding completed rows stick? It's a view for the current sitting — switch pages and everything shows again. The ☑ marks themselves are saved; only the hiding is temporary.