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.
Your first five minutes
Choose File ▸ New Outline, name it, and type. The rules are simple:
Return makes a new row.
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.)
- Prefer prose for a while? That off-switch is prose mode.
- 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.
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) 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 local AI — nothing leaves your Mac:
- ✦ 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.