Manifold

A Mac app that works like a wiki rather than a set of windows. Terminals (drawn by libghostty), files, notes, folders and web pages are blocks, and everything is linked: a space links the blocks it shows, a note the blocks it mentions, and what you do leaves links behind (this terminal opened that file). The spaces are the roots: each stays until you remove it, and keeps what it shows, what's pinned in it, and what those link to by hand. What no space reaches any more is collected, after a while to bring it back. A space is itself a block you can name and come back to, and anything reachable can be found and followed, with its history. Light or dark, in SF Pro and Menlo as Notes sets them, or in Monaspace and Mona Sans (bundled). DESIGN.md says where it's going, and §12 where Manifold parts from the Mac's conventions on purpose.

Using it

• The sidebar is the spine of the window: the window buttons, New (+) and ⋯ along its top, then one browser over everything you have, organized two ways (Spaces · Files, below), narrowed at a key to the blocks with a status (⌥⌘., below). It sits beside the content; ⇧⌘/ or ⌃⌘S (or the button at its top right) makes it slide out over the content when the mouse goes to the window's left edge instead. Drag its right edge to resize it, and its top to move the window. Along the bottom of the sidebar run Spaces and Files, the lighthouse (the filter, ⌥⌘.), and, at the right, counts of what needs you, is working and is done and not yet read, which turn the filter on. The window sits on a wash of soft colour (Look, below). Under Spaces the tree is one shape, always: a host's heading, then each of its spaces, then every tile in it, in order. Nothing folds by itself; the current space wears a bar at its left edge, and a space's chevron closes it until you open it again (remembered). Only tiles have icons; a space's label is its name and a count of its tiles, a block's row has a second line for what it says. Above the bar at the foot sits a quiet row, Recently Closed, with a count; clicking it pushes that list over the tree, the header showing a back button, the list's name and what it holds, as Safari's Bookmarks does; it isn't in the tree itself. Under Spaces, the sidebar is the table of contents of the screen: a space's tiles in order, a stack's tiles together under its top — nearest first, as it fans, the titles of those behind a step dimmer, a dotted rounded line round the stack's rows. A pinned tile in a stack is listed both at the top and in its stack; the pointer on either lights the other too. Click a tile to focus it (one behind comes to the top of its stack), a space to go to it, double-click one to name it; drag a block from anywhere in the sidebar onto a tile to bring it in beside, onto a space for its active column, or between spaces for one of its own, and drag spaces to reorder them (among their host's, under its row) and hosts' rows to reorder the hosts (an order of this Mac's own, in Spaces and Files).
• A space is a grid (DESIGN.md §3.1): columns of tiles, every tile a block, all of them visible, as acme tiles its windows. A space is what you made it: a block brought in stays until you take it off (⌘W), and nothing is tidied away. A new tile lands below the biggest tile of the active column, taking its lower half; room goes back where it came from — close it, or move it away, and the tile that made room for it has its room back (one moved elsewhere borrows there, and gives it back there when it closes), so opening and closing leaves the space as it was, unless you resized them meanwhile; a new column takes its width from every column in proportion and gives it back the same way; Tile ▸ Grow (⌃⌘=) takes a step from its neighbors; Fill the Column (⌃⇧⌘=) gives it the whole column and stashes the others. A stash is a stack behind any tile: the sheets behind it peek out above its card, as a stack of paper — each a card of its own, with an edge and a shadow, stepped in further the deeper it is, within the gap between tiles, so a stacked tile takes no more room than a tile alone — and its bar's stack button wears how many are behind. A stack just made (or grown) has its sheets drop into place; the pointer on the stack button raises them into tabs at once — on the sheets, once it rests there a moment with no button down, as the sheets are in the gap where a drag resizes the tiles (passing through, or pressing, they stay down, and a press in the gap always resizes) — one for each tile behind, its symbol and title, over whatever is above (or, at the top of a column, below the bar), staying while the pointer is on them: click one to bring its tile to the top, or drag it out to put the tile anywhere, as a fanned card is dragged (past four, the count fans the stack). Click those sheets, or the stack button on the tile's bar (beside maximize), or press ⌃⇥, and in the tile's place the stack opens as a column of summary cards, as iOS opens a stack of notifications: the top first, then those behind it, nearest first, each its symbol, title and where it is, when it last did something (or its state, in its color), and two or three lines of what it holds — a terminal its last command and the last lines of its screen, an agent what it was asked and what it said, a note its first lines, a diff its files and lines changed, a search its hits — with a picture of a page, a PDF or an image. Scroll through them; the one chosen is ringed. With ⌃⇥, each ⇥ moves the choice a card down (⌃⇧⇥ back up), and letting go of control brings it to the top (Escape leaves things be; ⌃⇥ is the stack's in every tile, a terminal's too, so tmux and Emacs don't get it) — and as with ⌘⇥, a ⌃⇥ let go quickly (within some 150 ms, a touch before macOS's switcher would appear; ⌥⇥ the same) goes to the tile behind with no cards shown at all (⌃⇧⇥, the farthest), the cards coming only for a ⌃⇥ held; move the pointer over the cards and the card under it is chosen from then on, a click bringing it to the top and a ⌘-click taking it out of the stack, beside it (as ⌘ takes a stack's top alone when dragged). A click away from the cards leaves things be. Either way, drag a card to take that tile out of the stack: the cards fold away, the stack as it was, and the tile goes where it's dropped as a tile dragged does (between tiles, onto one, ⌥ over one), on its own — the top dragged out, the next behind it shows. The same summary is everywhere a block is shown small. A tile shrinks in steps, one ladder — its content, its summary card, its bar alone, stashed behind another — as a presentation of the room it has, not a state of its own (Maximize stands apart): under 80 points of content, its summary stands in for it in its body, under its bar — its lines, as many as fit, when at the right (a click goes to it and grows it a little), squared off under its bar and rounded below as a tile is. Shrink to Summary (⇧⌘M, or the bar's menu) takes a tile down to that itself, giving its room to its nearest neighbour showing its content; again (Show Content), it's back as it was. Under 24, it's down to its bar, its summary's line in the bar where the folder was ("$ make test · exit 2 · 4m"); a sidebar row's hover card has it under its picture; in ⌘O a block's row is its card, and what it says is found; mani ls, info and context print it. A bar peeking out above its stack, clicked, comes to the top; ⌘-clicked, it comes out of the stack. The peek's tabs go the same way. A stack is one thing: drop its top tile's bar on another's and the whole stack goes behind that tile; move the top tile and the stack moves with it. Unstack in the bar's menu (or Tile ▸ Unstack) lays the whole stack out in the column; Close Stack takes the tile and its stack off the space (from a maximized tile, Close Column takes the column). Opening a block that isn't in the space always makes it a tile of its own (below the biggest tile, after that tile's stack, never into it); going to one that is — a link, the sidebar, Open Quickly, ⌘J, ⌘P, Back, a found line, opening it again — goes there: a tile on its own is focused, one in a stack comes to the top of it (the rest behind it, as they were), and the pointer follows (only while Manifold is the app in front: in the background, or switched away from before it moves, the pointer is left alone). Going to a tile squeezed down to its bar — by a link, the sidebar, Open Quickly, ⌘J, Back, or opening what's already there (Browse This Folder on a folder shown), or down to its summary — grows it a little, to show some of what's in it (160 points, or a quarter of the column), taken from its neighbours as growing takes it, and the pointer goes to it, as apex does. ⌥ with any click that opens something puts what opens over the tile clicked in, that tile going behind it (as ⌥-drag stacks): a link or a block's link in a note, a bar's link, a sidebar row, a listing's file or folder, ⌘⌥-click on a terminal's link, a page's, or a symbol in an editor (its definition stacked over the editor). Drop a bar on another's to stash it there; ⌥-drag it instead and it goes on top, the target (and whatever was behind it) stashed behind — the outline while you drag is the target tile's shape, to say so; ⇧-drag a bar, or drag it by its icon (the pointer on the icon swings it out of the bar toward you, hinged at its left edge, growing a little so it shows past the hand, to be taken — a terminal's prompt stepping into a window that draws itself round it, a note's corner peeling further up; clicked, it's the menu as before), and it's not the tile you carry but the block itself — a thing, as everything else you drag is without ⇧: an outline's item (a command, a heading, a page), a listing's file or folder, a search's hit, a commit (a git tile's history, a project's sidebar, a commit's diff ⇧-dragged), a PDF's page (its sidebar's thumbnails), a shell command by its dot, a notebook's cell by its gutter (its command, the notebook), a block at work in a project (its homepage's Here now), a block on the neighborhood map (the map stepping aside for the drop), a file from the Finder, a page's address, a picture, words. Several at once: ⌘- or ⇧-click rows — a git tile's changes and commits, a folder's files (in its columns, one folder's; in its tree, any), a search's hits, a project's sidebar and its search, a tile's outline — and drag any of them to take them all, each landing as it would alone (on a terminal, one line, a space between). Right-click one of them for what can be done with them all: a folder's Open Beside (a column of their own), Reveal in Finder (or Download), Copy Paths; a git tile's Open Diffs, Open Files, Reveal in Finder, Copy Paths, Copy SHAs — the menu of a row not chosen is its own alone. Where a thing lands decides what's done with it, as Star's printer took a document: on a terminal a file's path is typed, quoted for the shell (this Mac's files sent first to a shell on another host), a command again by its words, a commit by its sha, a block by its reference; on an agent, a reference to a block or a place in one (a heading, a command, a function), so the agent reads what's there through mani and can point back to it, a file's path, words selected in code as they are; on a shell notebook, it goes in the cell under it, or outside the cells a cell is made for it; in a note (the editor, the outline, the preview), a link to it — a file opened as a block for it, a commit as its diff — a picture kept and shown, a page's link; in code, a file's path, a place's words; on a folder, a copy (its own host's entries moved, as the Finder moves them); on the grid, a tile of its own where it lands — a file opened, a page, a picture, a note of the words, the block brought — or, a block over a tile, the tile linked to it (below); on another app, as a file or text. The pointer is a closed hand from the moment a drag begins to its end, whatever it was. What you drag shows as a pill — its icon and name — wearing at its corner by the pointer a badge with the symbol of what dropping does there (the palette's), changing as you go (⃠ where nothing can be done); a quick drop does it. Only what works is offered: a file Manifold doesn't open (a film) goes into a note as its path, and on the grid opens in its own app. Rest the pointer a moment (or hold ⌃) and a palette opens there of what else it can be — the usual one under the pointer, so dropping without moving still does it, the others below to move onto and drop on, moving away closing it, as a folder in the Finder springs open as you hold a file over it: its link ([name](manifold:…), as a note shows it), its reference (manifold:host/id, a place after # — what an agent and mani take as its name: drop a block on an agent as its reference and the agent can read it, change it and point back to it), its path, its text, its contents (what it holds, as text), inline (in a note: a picture, or the block's card), a tile of its own, a link to the tile, a copy or a move — a path onto a note, say, where a link is the usual. A block put in is linked from where it lands (below). ⇧⌘C (Edit ▸ Copy Contents) copies the focused block's content as text, whatever it is — a file's or note's text, a terminal's whole history, a page's or PDF's text, a diff's patch, a listing, a search's hits, a notebook's cells — as mani read prints it. Stash (⌘M, or Stash in a bar's menu) puts the focused tile behind its nearest tile — the one above it, else the column's first — and focuses that one. Dragging the line between two tiles past one's least height stashes it, in the direction it was pushed (pushed up, behind the tile above it; pushed down, behind the tile below it), and goes on against the next, until all above or below are put away. Double-click the line between two tiles, or two columns, and the two share their room evenly, the line gliding there with the pointer on it. Maximize (⇧⌘↩, or the ⤢ at the right of a bar) puts a tile over the whole space until it is restored, or until you go to another tile. A bar's title is as wide as it needs and never more than half its tile, so what's under the band stays reachable at the sides; the focused tile's is plain, the others' quieter. The focused tile's title fades out while what's under it is in use — the text cursor on its line in an editor or a terminal, a page's address or the process list's filter taking the keyboard — and comes back when that's done, or when the pointer rests where it would be; the other tiles' titles stay, whatever is under them. A title can also become a field: a web page has no address bar of its own — click the address in its bar (or ⌘L) and it becomes one, there, the title left as it is and the address selected to type over, or words to search for (the rest of the bar grows the tile, as any bar does); ⏎ goes, ⎋ leaves it. ⌘[ and ⌘] go back and forward, ⌘R reloads (⇧-click the bar's reload button to reload from the server, the cache passed over). The bar's menu (its icon) carries the view's own verbs first: a page's Back, Forward, Reload and Copy Address; the process list's Refresh Now and Filter. The focused tile has a ring around it. ⌘Z undoes the space's last change at your hand (a tile placed, taken off, moved, stashed, resized, maximized), ⇧⌘Z redoes, a hundred deep per space, when nothing else takes the key (an editor undoes its own text). Undo doesn't rewind the log, which only grows: it appends the earlier state as one entry, so the history keeps what was undone. In the sidebar, ⇧-click (or ⌥-click) a chevron to open or close the whole subtree. Every lens shows its scroll bar; a terminal's comes from Ghostty's own account of the screen and its history. Going somewhere (⌘O, ⌘P, a found line) brings the pointer along, to the text cursor or the middle of the tile. Overview (⌘', below) shows every block in the space at once; ⎋ comes back. Drag the lines between tiles and columns to resize them. Each tile is a card with a bar across its top: its symbol and title (its name), where it is in grey, its links (the linked blocks' faces, stacked), the program its status names in a grey capsule, its status's pill when it needs you, and maximize and close (×) at the right. The bar is always there; as a tile narrows it gives things up in order — the place, then the program, then maximize, then the links — so the symbol and some of the name always show. The content runs beneath it, rounded, with room between cards and the window's wash showing through. Drag the bar to move the tile; click it to grow the tile a step (the pointer follows the bar, so a click again grows again), ⌘-click it to fill its column, its corner to maximize; click its symbol, or ⌃-click the bar, for the tile's menu; ⇧-click it for where the block is, folder by folder up to the root (a terminal's working directory likewise), each browsing that folder here, as ⌘-clicking a document's title does in the Finder. ⌥⌘ and an arrow moves the focus to the tile that way (Go ▸ Focus), ⌥⌘[ and ⌥⌘] to the next and previous; ⌥⇧⌘ and an arrow moves the focused tile a step that way (Tile ▸ Move), its stack along: up or down past the tile beside it, left or right into the next column about as far down as it was, or into a column of its own at the edge.
• Keys mean the same thing everywhere. ⇧ is the bigger one or the way back: ⌘W closes a tile, ⇧⌘W a space; ⌘F finds here, ⇧⌘F in files; ⌘/ shows the tile's sidebar (its outline), ⇧⌘/ the window's. Brackets go through a sequence, the modifier saying which: ⌘[ ⌘] the tile's own history, ⌥⌘[ ⌥⌘] the tiles, ⇧⌘[ ⇧⌘] the spaces. ⌥⌘ and an arrow is the focus going that way, ⌥⇧⌘ and an arrow the tile; ⌃⌘↑ ⌃⌘↓ moves what you're on — an editor's line, an outline's row, a notebook's cell. ↩ is how the tile shows (Tile menu): ⌘↩ its own thing — Edit or View for a text, Run Cell in a notebook, Toggle Checkbox in an outline, the menu titled so — ⌥⌘↩ as an outline, ⌃⌘↩ the other mode beside, ⇧⌘↩ maximized. ⌘. is cancel (a notebook's Interrupt). Every key is in a menu.
• Two verbs put a block in front of you. Go to finds it where it already is: the space it is in (this one if it is here, else the one most recently gone to) is selected and the tile focused. Bring here makes a tile of it in this space; if it is here already, that tile is focused. Anything clicked that names a block — a row in the sidebar or Open Quickly (⌘O), a link, a path, a search hit, a change in a git block — goes to it if a tile shows it, in any space; else it's brought below the tile clicked in, taking its lower half, and the two are linked. ⌘-click always brings it there, beside (one rule for every click: below); a definition (⌘-click a symbol) opens there too, and a drag onto the grid brings it where it lands (a drop between two tiles lands there). A preview going page to page and a listing going into a folder change in place, ⌘[ coming back. New things (⌥⌘T a terminal, ⌥⌘N a note, a search, an agent) are brought here, into the active column; with ⇧ too (⌥⇧⌘T), in a new column; ⌘T a new space with a terminal (Space ▸ New Space). A note is at home in the folder of the block it was made from: it is found there, and saved there by default. Open Folder… (File, from the menu) browses a folder you choose beside the focused block; a folder (⌥⌘O) its own (a terminal's working directory, a file's folder, the folder a search looks under). The block navigation stack: Go ▸ Back and Go ▸ Forward (⌃- and ⌃⇧-, as in VS Code — except in a terminal, where ⌃- is the shell's or Emacs's undo; or the mouse's back and forward buttons) go along every place you've been — the tiles focused and, within a block, where a jump took you from: a definition gone to, a found line, a heading, a command, an outline's entry, a PDF's page — back to the tile in its space (brought out if it was stashed) and the line, command, scroll or page it was at, the pointer with it. Going somewhere new from back there drops what was forward, as in VS Code. ⌘[ and ⌘] are for what has a history of its own: a web page's, and a folder tile's (the folders it showed, as a Finder window's Back goes); the mouse's buttons go there first in such a tile. A web page zooms with ⌘+ and ⌘− in Safari's steps (50% to 300%), ⌘0 back.
• ⌘` walks the spaces most recently gone to first, for as long as ⌘ is held; letting go settles on the one come to, as ⌘⇥ does apps: the next ⌘` goes back to where you were, and spaces only passed on the way don't count as gone to (with one space, it goes to Manifold's next window, as macOS has it). With the sidebar away, ⌘ held a moment names the space come to over the window (and which of how many), renamed at each ⌘` or ⇧⌘` until ⌘ is let go; with it out, the walk keeps the space's row in view. ⌘1–9 and ⇧⌘[ / ⇧⌘] switch spaces too, as does the Dock icon's menu: every space, under its host when there are several, the one shown checked. However you go, the space comes in as the sidebar has them — up from below for one lower in the list, down from above for one higher — and a band in the tint glides down the sidebar from the space left to the one gone to, and fades there. A file or folder dropped on the Dock icon opens in the space shown, as a path clicked there does: a tile of its own, or gone to where it is.
• ⌥⇥ walks the same trail tile by tile, in every space: the tiles most recently settled on first. Let go quickly and it goes to the one before, so a tap goes back and forth between two (⌥⇧⇥, the farthest); held a moment, the tiles come as a column of their summary cards over the space — the focused tile becoming the first, the rest coming out of their tiles here, their stacks' sheets, or — in another space — their rows in the sidebar, each one elsewhere naming its space — each ⇥ a card further, and letting go goes to the one chosen: its space comes in if it's another, its card becomes its tile there, and the rest go back to their tiles, sheets and rows (Escape, or a click away, leaves things be; a card clicked goes there). Tiles only passed on the way don't count as gone to, and one settled on settles its space for ⌘` too: the switchers are one trail at three scales — ⌘` its spaces, ⌥⇥ its tiles, ⌃⇥ a stack's (whose order is the trail's, the tile settled on brought to its top). Back (⌃-) is the other way over it: a stack of every place, within blocks too, walked one step at a time. ⌥⇥ is taken from a terminal too, as ⌃⇥ is (Meta-Tab, with Option as Meta).
• Drag a tile by its bar: between two tiles to put it there, near a column's side for a new column there, onto a space in the sidebar for its active column, or between spaces for one of its own. To another space it moves, as a file does; ⌥-dragged it is copied — shown there as well, the same block in both. Held over another space's row — a tile, or anything else dragged: a file, words, a link, a picture, from here or another app — a band in the tint fills the row from the left, blinks twice, and the space comes in under the drag, as a folder in the Finder springs open, to drop it exactly where it should go there (after the system's spring-loading delay, Accessibility ▸ Pointer Control, and not with it turned off); one left empty by a move stays, as every space does until it's removed. A stack's top takes the stack along; ⌘-drag it to take it alone, the next behind coming out in its place — a fanned-out card drags its tile out alone the same way. ⌘W on a stack's top takes it off and the next comes out. Spaces drag from the sidebar onto the grid the same way, their columns coming over.
• Links by hand: ⇧-drag any block's bar onto any tile and the dragged block links to the tile's block — one edge, read both ways. Both tiles show the link in their bar, as the linked block's face — its symbol (an agent's mark) on a small rounded square, with a chevron in it on the side it points (› links to, ‹ linked from). Several stack up, the most recent in front and the edges of two more behind it; the pointer on them fans them out along the bar — the title showing up to the first of them, fading out before it — and resting on one a moment shows its summary card under the bar, one at a time, moving along them. More than fit (or than eight), the last is a stack of the rest: the pointer over the title, left of it, scrubs through them, further back the further left, its face and its card following, a click there opening the one in front. A click opens a link by the one rule (⌘ beside, ⌥ over, ⇧⌘ the system's app); ⌃-click or right-click for its menu — Go To, Show Beside, Show Over, Remove Link (both ways at once), the Neighborhood Map. A note made with a block focused (⌥⌘N) is linked the same way, from the block to the note, as if the block had been ⇧-dragged into it. Dropped into a note (or any Markdown text) the block also lands in the text, [title](manifold:…), shown as a link — the block's symbol, name and status, live, as its tile's bar shows them — in the editor and in the preview, clicked to go to the block; the note then mentions it too. A reference written bare (manifold:host/id, as an agent writes one) shows the same. On a line of its own as an image, ![name](manifold:…) (what the palette's Inline puts in), a block shows as its summary card instead, live — its symbol, title, state, a few lines, a picture of a page — in the editor (the Markdown back on the caret's line), the outline (under its row) and the preview; a place's card for a place in it: a command's line and how it ended, a heading's section, a PDF's page. So a web of annotations grows: notes about blocks, blocks in notes, blocks linked to blocks.
• Images in notes: paste one (a screenshot, a picture copied — from a browser or a chat too, whose Copy Image puts its address beside it: the image is taken over text that only says where it's from), drop image files, or right-click ▸ Insert from iPhone or iPad (a photo, a scan, a sketch) in a note or a Markdown file, and it's kept as an image block on the text's host — beside a Markdown file, named so any Markdown reader finds it (![](image-2026-10-21-225841.png)), or for a note in Manifold's own folder (![](manifold:…)) — and shown where the caret was: in the preview and the outline as the picture, in the editor as its link. In the outline a picture shows a grip in its corner while the pointer is over it: drag it to make the picture larger or smaller (the width goes into the note, so every Mac and the preview show it so); double-click it for the picture's own size. The text embeds it, a strong link: the image is kept while a text shows it, and once none does it's collected like anything else nothing keeps (a note's own copy with it).
• Notes are Markdown, shown richly as you write, the markers out of sight as in Prism: headings bold, **bold** and *italic* in their faces, `code` in its font on a tint, fenced code blocks in the code font edge to edge, list markers and quotes set off, links as their words, clicked to follow (the pointer over one is the hand), an address pasted over words making a link of them; a block's link shows as it, live. Every character stays where it is — the line the caret is on shows as written, markers dimmed — and the file is plain Markdown; a note shows no line numbers. ⌘B, ⌘I, ⌘⇧X and ⌥⌘C wrap the selection in bold, italic, strikethrough and code marks, or take them off (Edit ▸ Format). Return in a list carries it on — the next marker or number, an empty box in a task list — a quote with its mark, and on an empty item ends it. The bar's menu has Show Raw Markdown, kept per tile. Markdown files get the same.
• Blocks with a status (⌥⌘., View ▸ Show Only Blocks with a Status, the lighthouse at the sidebar's foot, or its counts) narrows the sidebar, whichever way it's organized, to the blocks that are working, need you, or are done or failed — and the way to each: its host and space in Spaces (a tile behind in a stack with the stack's top, the two in the stack's outline), its folders in Files — every row on the way open, each count of what's shown. The lighthouse fills, lit, while it's on; ⌥⌘. again, or a click, shows everything as it was, what you had open and closed kept. Nothing to show says so. The filter is one of a kind that may grow: it tests each block, and the trees it narrows don't know which. The Inbox is the blocks whose status wants attention — done or failed and not yet read, or needing you — by host and space; reading a block (focusing it) takes it out, and there is nothing to clear by hand. ⌘J (Go ▸ Next in Inbox) goes through it in that order, from anywhere: to the next block after the focused one (or the first), in whatever space holds it, the pointer warped to its tile and the block marked read — a block that needs you stays until it's answered; with nothing in it, a beep.
• ⌘W closes the focused tile; a tile's × closes it and moves the pointer onto the × of the tile that takes its place (the one behind it, else below, else above), so clicking again closes that one — a column emptied a click at a time. Spaces stay until you remove one (⇧⌘W, Space ▸ Remove Space, or its row's menu): named or not, emptied or not, nothing removes one for you. With none at all, the window says what a space is and offers New Terminal, Open Folder… and Open Quickly. A block is kept while a space reaches it — shows it, pins it, or reaches it through a link by hand — and once none does it waits half an hour in Recently Closed, the list at the foot of the sidebar (and in ⌘O, marked recent), then is collected: gone, with its history. A space removed goes the same way — any space, named or not, empty or not — and what only it kept (its tiles' blocks, its pins) with it. ⇧⌘T reopens the last thing closed where it was. Closing takes with it whatever only the closed block reached; when any of that has unsaved edits, a note's words or a job running, a toast at the foot of the window names each (a note tied to nothing — no link, no edge from it, nothing linked to it by hand — just goes), with Undo while a bar along its foot runs down (held while the pointer is on it); ⇧⌘T after. Removing a space always says so, in the same toast — gone to Recently Closed, with Undo. A reference to a block that's gone says so: its host remembers for a month what it threw away, so the pointer over a link to one — in a terminal (⌘ held, or a program's own link), a note, a preview — shows a line by it, "“Claude” (agent) was deleted, today at 10:41" (or closed and collected; or on a host that isn't attached, or isn't reachable now; or no such block), and clicking it anyway says the same; mani answers so too.
• The Inspector (View ▸ Inspector, ⌥⌘I, again or its close button to put it away) shows the focused block's properties in a window of its own, as a Mac app's inspector does — a small panel floating over every window (other apps' too), up while Manifold isn't in front, never taking the keyboard, its place and size kept — and follows the focus, as Star's property sheets did for whatever was selected. It's as compact as the Finder's Get Info: a row a line (Label: value), only what a thing is at a glance open — its About, what its kind has at a glance (a text's lines, words and language; a terminal's command and last command; a space's name, focus and what it holds), a host's versions — and the detail folded (a kind's Details: a text's size, version, encoding and line endings, a terminal's process and title…; a space's layout and tiles; a host's machine and server; ids, links, history), each section opened or folded by its triangle and kept so, its annotations under its name as Get Info's tags. What it is and where (its host, its path, a page's address, a terminal's folder, each with its copy button; when it was made and last seen); for tools, its reference, block id, tile id and space id and its annotations (mani annotate), each with a copy button at its right (the row clicked copies it too; a check says it's copied); its status as its record has it (state, what it's blocked on, progress, who said, message, since, read); this tile — its lens, column and place, size, when placed, stacked or maximized, what the lens keeps for it (scroll, selection, a mode) and where its caret is; what only its kind has (a text's lines, words, size, language, version and unsaved edits, places referred to; a terminal's process, title, agent, running and last command with how it ended and how long it took; a search's query, kinds, hits, symbols and files; a folder's entries and project; a repository's version control, branch, scope, changes, staged, untracked, commits and when it looked; a diff's subject and +/− lines; a notebook's shell, cells, runs and queue; a space's tiles, columns and focus; errors where there are); where it is — each space it's placed or pinned in, a click going there; what keeps it, or that nothing does and it will be collected; its links, either way, the latest first, each opened by the one rule; its history — how long its log is and what changed last (each kind of change, how long ago, from its host's log), how often it's been gone to and when last, the tile's way back (⌘[) and forward — and what can be done with it (Copy Contents, Copy Link, Copy Path, Reveal in Finder, the Neighborhood Map, Pin in This Space). A host's row in the sidebar clicked, it shows the host instead, until the focus moves: its machine and how it's reached, its link, its home; versions — the protocol its server speaks and the app's, and what each was built from (the git revision, -dirty and a hash of the changes when the tree had any, from scripts/stamp-build.sh) and when, the server's as it said on welcoming the app (a server from before says none); its server's process, how long it's been up, what it can do, and the link's round trip and last drop; and its host id. A space's heading clicked (or Show in Inspector in a space's or a host's menu, which opens the window too), it shows the space, until the focus moves — and a space with nothing in it is shown by itself: its name, where it is among its host's spaces, whether it's shown; its columns and their widths, what's stacked, maximized and focused; what it holds by kind ("4 terminals, 2 notes"), from which other hosts, what's unsaved, running, and the statuses; its tiles, column by column, a click going to one; what's pinned in it; its reference, id and annotations; what keeps it; its log; and Go to Space, Name…, Remove Space.
• ⌘D deletes the focused tile's block (Tile ▸ Delete Block, or the bar's menu), with nothing asked: every tile of it taken off at once, in every space, and a toast — "Deleted “…”" — with Undo while a bar along its foot counts down (four seconds, six when it has something to lose: a note's words, unsaved edits, a job running, which the toast names). When it runs out, every link to and from it is broken, on every host, and the block itself gone, its history with it; Undo, or ⇧⌘T, or the block put back anywhere meanwhile, and it's kept. What only it reached isn't deleted with it — it goes to Recently Closed, collected after the half hour unless something reaches it again, and the toast says how many.

Finding and following

Every block has a log: its edits, where it was placed, what it was named. Whatever the graph still reaches can be found, by name or by what's around it, and comes back with its history.

• Making a block, of any kind, three ways that agree, in one language: ⌥⌘ and the kind's letter makes one below the focused tile, ⌥⇧⌘ and the letter in a new column — terminal T, agent A, note N, web page W, search S (⇧⌘F too, as editors have it), folder O (⌥⌘F stays Find and Replace, as on every Mac), shell notebook B, source control G, smartlog L, processes P (File ▸ New ▸ lists them, the ⇧ ones with ⇧ held). New Block… (⌘N) takes it typed — the kind's letter or name (or its start), then what it takes: w example.com, search TODO, t make test, note buy milk — each row showing its letter; ↩ makes the first (⌘N ↩ a terminal, ⌘N N ↩ a note) below the focused tile, ⇧↩ in a new column, ⌘↩ below it and linked, ⌥↩ over it; and mani new <kind> [what] reads the same words in a shell. One table of kinds makes all three, so none is missing from one of them. It makes spaces too (New Space, one row for each connected host), and a kind typed is offered on every host (t lists New Terminal, then New Terminal on devbox); @devbox in what's typed picks the host.
• The Mac's own keys mean what they do in every Mac app, beside Manifold's: ⌘K is a terminal's Clear Screen and, in a note, Link… (as in Notes, Pages and Mail; one item, named for what's focused); ⌥⎋ (or F5) completes in an editor, as ⌃Space does; Edit ▸ Spelling and Grammar (⌘; the next misspelling, ⌘: the panel); ⇧⌘U checks a row done, as Notes' Mark as Checked; Paste and Match Style (⌥⇧⌘V) pastes the clipboard's text as text — in a note, no picture kept, no link made of an address over words; and in a terminal ⌘↑ and ⌘↓ go to the command before or after, as Terminal.app's marks do (past the last, to the bottom; a full-screen program keeps them).
• The menus go by what a command is about: File makes things (New ▸, New Block…, a terminal in a new column or space, a note from the selection) and holds Source Control (the project's, its smartlog, the last commit, a file's history); Edit, text; View, how things look (and a tile's own Back and Forward, ⌘[ ⌘]); Go, finding a place and getting there (Open Quickly, the outline, Back and Forward through the places you've been, the Inbox, the spaces, the tiles); Tile, the focused tile (close, grow, fill, maximize, shrink, stash, its stack, its pin); Space, the space (name, overview, remove); Window, the window and Agents. Help ▸ Search finds any menu command by name, as in every Mac app.
• Open Quickly (⌘O) finds what's in the space shown — its tiles, its pins, what was closed from it, its agents' turns, and the files on disk of every project its tiles are in, as their hosts list them (remote too), marked in the project — and the other spaces, by name, to go to (what they hold isn't found from here; this space's tiles come before them, with nothing typed and among matches as good); ⌘O again looks in all spaces: every block and space the hosts keep, a row elsewhere saying which space, and every project's files on the desk (⌘O a third time, back to the space). Where it's looking is always shown at the field's end — Space or All Spaces, a click switching — and when the space has nothing for the query, one row says how many all spaces have, ↩ going there. Other files are found by Find in Files (⇧⌘F), a search block of their own. In a project, its blocks and files come first among equals: the space's of it before the rest of the space's, then its others before what's elsewhere — and in ⌘P's whole-space outline, its tiles' places before others named as well. It ranks off the main thread as you type, each keystroke giving up on the last, so typing never waits; the panel grows to fit and doesn't shrink under you. What the query names comes first: a title it is, or starts, or starts a word of, then one it's found in, then one with its letters in order, then a match only in what's around a block (its folder, its program). Among equals, the nearest to where you are over the graph — this space, then what's linked to the focused block, then step by step outward — and the most recently seen; with nothing typed, that is the whole order. Each row says at the right where the block is — here, linked, near, or recent for one closed and not yet collected, which choosing brings back — and, in a pill, how long since it was last seen (nothing, for just now). A block's row is its summary card — its title and where it is, two or three lines of what it holds under them ("$ make test", "exit 2"), so the many "Terminal"s are told apart — and what the summary says is found as well as the name, every word of the query in it (a command run a while ago, an agent's last words), ranked with the names the query is only scattered in (a found line's row, in In Blocks, stays as found). A space is found by its own name only — what it holds is found as itself. An agent is found by what it is: a block running Claude Code, Codex or another known agent answers to "claude", "codex" as surely as to its own title, and says so ("Terminal in ~/src · Claude Code"). Choosing a block opens it by the one rule (below) — ↩ goes to it, ⌘↩ beside, ⌥↩ over; choosing a space shows it. Find in Blocks (⇧⌘O) is the same panel over what blocks say rather than what they're called (⌘O and ⇧⌘O switch between them while it's open, the query kept), and the same reach: the space's blocks first, ⇧⌘O again every space's. First it looks through every outline (as ⌘P shows one, below): each command a terminal ran (a command run again, once, its latest), each heading of a note or Markdown file — shown or not — and what only a tile knows, a source file's symbols from its language server, a PDF's contents, a page's headings, in the tiles on the desk. A row is the place, its block and where it is beside it, how a command ended and when; ↩ goes to the place itself — the terminal scrolled to the command, the text at the heading, the caret on the symbol — ⌘↩ beside, ⌥↩ over, as its tile's outline would. Then the texts of the blocks — the space's first, then every note and file kept as a block — listed as a site's search does: a row a block, its name, where it is, and the lines that hold the words, two lines' worth, each match marked; ↩ goes to the first of them. It looks only at what's held as a block; Find in Files searches the files on disk. A typed URL opens as a web page. Either narrows to kinds: type a kind's name or its start and ⇥ — te⇥ — and it becomes a chip before the query, Terminal; only terminals are found. ⇥ again offers the next kind the word begins (t: Terminal, then Turn), and ⌫ at the query's start takes the chip away (the word back, if ⇥ only just made it). More chips find any of their kinds. The kinds: terminal, agent (a terminal an agent works in is one too), note, file, folder, web, space, turn, search, notebook, git, smartlog, diff, output, image, pdf, panel. Once something's typed or chosen, the panel's foot counts what each kind found — a symbol and a number — and a click on one narrows to it, or no longer.
• ⌘P goes through an outline, as Prism's Move to Heading does — first the focused tile's own, where you are in it; ⌘P again (or ⇥) widens it to the whole space's (and back), Tile or Space shown at the field's end: its tiles by column, and under each its outline, set in by level — a Markdown tile's headings, and whatever else has one (§7.5): a terminal's commands (how each ended beside it), an agent's turns, a source file's symbols from its language server, a PDF's contents, a diff's files; type words to narrow them — ranked, then, by how well each says them: one named exactly first, then one that begins with them, one with a word that does, one that has them anywhere, one found by its tile's name alone; the shorter first — ↩ to focus the tile or go to the place in it, as a click in its own outline goes. A terminal's row says where it is, what runs in it and what that reports, so "claude" finds the terminal running it. ⌥↑ and ⌥↓ move a page up or down through its list (as in ⌘O's), as they page anything that scrolls outside text — a folder's list, the sidebar, a PDF — the Mac's way; in text they move by paragraph, in a terminal they're the shell's. It's instant however long the outlines are: each space keeps an index of them, updated as they change, so a word is found among tens of thousands of symbols in about a millisecond — and all of a terminal's commands, not only its last 500.
• Naming a space (⇧⌘R, or double-click it in the sidebar) calls it that in place of what it holds; it keeps nothing more than any space does. Named spaces wear a bookmark in the sidebar.
• Terminals go dormant, not away: a terminal off screen with an idle shell for eight hours (Settings ▸ Terminals) has its shell ended and its transcript kept. Brought back, it starts a new shell under the old transcript, with a line across it saying when the last one ended and after how long idle, so it's never a surprise. Open Quickly says dormant before you go to one.
• Blocks are linked by what you do: ⌘-clicking a file in a terminal links the two, and ⌘O ranks what's linked to the focused block first.

Blocks

• Terminals are streams of their host's one connection, attached to a shell the server owns, so quitting and reopening the app brings every terminal back with the same processes still running. A terminal whose host goes away keeps what it showed and picks up where it was when the host is back, what was typed meanwhile not lost. By each remote host's name in the sidebar, a sparkline of its ping times over the last five minutes (resting the pointer on any host shows it at a glance: how long its Manifold server has been up, a remote's link, its ping times plotted, over the machine — CPU, memory, network, disks and its busiest processes, the last five minutes of each); a host gone quiet wears a broken amber ring there, and its link is made again by itself. On a slow link what's typed shows at once, as mosh's does, before the host echoes it. A terminal's menu (right-click) has, under Copy, Paste and Clear, the tree of what runs under its shell, each process a submenu of End, Force End and what runs under it. (How the screen, its history and what's typed travel: DESIGN.md §11.)

• Text blocks are files on the host, or notes (text with no file; ⌘S on one asks where to save it). A note has its own symbol (a note, not a file's page) wherever it's listed, and a name without being saved: its first line's words, kept as that line changes, whoever changes it and across restarts (heading and list marks, emphasis and images left out); or one of your own — Name… in its bar's menu or Tile ▸ Name Note… turns its bar's title into a field (⏎ names it, and it keeps that name; emptied, it's called by its first line again); saved, it's offered under its name, and its file's name names it from then on. A file's text is the file's: one shown whose text hasn't come in is asked for until it does (whatever went astray on the way), says "Reading the file…" and can't be typed into or saved meanwhile, and a file opened again is looked at on disk again. Edit as Outline (⌥⌘↩, again to go back — Edit as Text; both too in a note's tile menu and its row's in the sidebar) shows a note — any Markdown — as an outline, as Prism's notes are, and edits it as one: Return a new row, Tab and ⇧Tab in and out with its children, ⌃⌘↑ ⌃⌘↓ to move it, ⌘↩ a checkbox (open, checked, none), #, >, [ ] or 1. typed at a row's start its kind, ``` (a language after it, or not) then Return a code block, the caret in it (Return past its closing fence, a row after it), a bullet clicked to fold what's under it (← and → fold and unfold rows, ⌃⌘9 ⌃⌘0 too, ⌥⌘9 ⌥⌘0 all of them; View ▸ Collapse and Expand), a bullet dragged to move a row with its children, in or out as it's dropped; Escape selects rows (↑ ↓, ⇧ to extend, Space checks them off, Delete deletes them, Return or Escape back to the text); emphasis, code, strikethrough and links styled, their markup hidden (the caret steps over it, the file keeps it), a link clicked opened; checklists, headings, numbered lists, quotes, code and rules each drawn as they are. Prism's other actions are on Edit ▸ Outline and a row's menu (right-click it): a task (+ , round), Move Done to Bottom (⌃⇧⌘D), Duplicate and Delete (⇧⌘D, ⇧⌘K), Indent and Outdent (⌃⌘→ ⌃⌘←), Bullet (⇧⌘8), Horizontal Line (⌥⌘-, or --- ), Code Block (⇧⌥⌘C), Turn Into, Select Branch (⇧⌘B), Expand Selection (⌃⌥⌘↑), Format's bold, highlight (⇧⌘H) and Link… (⌥⌘K), an address pasted over words a link; Focus In (⌃⌥⌘→, or ⌥-click a bullet) shows a row alone, its path above to go back by. A fold shows as a pill after the row (click it to unfold), a bullet over checkboxes as a ring of how many are done, a heading a faint bullet to fold its section by. What's on screen is the Markdown: each change is written back as it reads (unedited, byte for byte), and a change made anywhere else shows at once, its folds kept; a note the outline couldn't write back as it is (tab indents, say) is shown read only. In any lens, a note's outline (its ticks, its sidebar, ⌘P) is its headings and its top-level items. The editor lens is Manifold's own text view (the bar's menu switches a tile between the fixed-width and variable-width font, kept per tile): the file's text laid out with Core Text, line numbers, several cursors (⌥⌘E selects the next occurrence, Xcode's key; ⌃⇧↑/↓ add carets; ⌥-click adds one), find and replace (⌘F, ⌥⌘F; every match marked; see Find, below), Go to Line (⌘L, or ⌃G as code editors have it, editing or viewing: a capsule where find's is, a line or line:column and how many there are, the text going there as it's typed, ↩ to stay, ⎋ to go back), line operations (move ⌃⌘↑/↓, duplicate ⇧⌘D, delete ⇧⌘K or ⌃⇧K, join ⌃J, comment ⌥⌘/ (⌘/ is the outline), indent and outdent with Tab and ⇧Tab over a selection — Edit ▸ Lines and Edit ▸ Selection list them), brackets and quotes paired, new lines indented like the last, undo as entries in the block's log (undone back to what was saved, it's clean again). Page Up and Down move the view a screenful, the caret along at the same place on screen. Files keep their encoding, line endings and permissions. One changed on disk reloads if clean, or shows a banner over unsaved changes. A tile with unsaved changes has a dot in its bar: grey, clicked to save; amber when the file also changed on disk beneath them, clicked to choose between reloading the file and overwriting it with the edits.

• Viewing and editing: a file opens to be viewed (unless $EDITOR opened it, to be edited) and a note to be written in; ⌘↩ (Tile ▸ Edit or View, or the bar's menu) goes between the two in the same tile, the line at the top staying at the top and an editor's caret going along. How a file is viewed goes by what it is: Markdown by its extension, code by the one table of languages (Languages.swift, by a file's name or extension — types.pyi, Makefile, .zshrc — the same table tree-sitter's grammars, the language servers, a folder's groups and ⌘/'s comment go by), anything else plain text: Markdown rendered (cmark-gfm), a note's too, following the text as it's edited on the same block or saved by another program; code and plain text as they are, not taken in, set exactly as they're edited — face, size, lines, colors, line numbers — on the pale grey of a page of code, so going between the two changes only the page under the text; Markdown as go.dev sets the Go spec, in its colors, heading sizes and spacing, its links, and its code blocks, each with a copy button at its corner on hover — in the theme's fonts, code in its fixed-width one (as are a terminal's commands in its outline, and a commit's hash). A Mermaid diagram (a ```mermaid block, or one that starts with a diagram's kind, as flowchart LR) is drawn in its place, light or dark as the page is — tried again with plain quotes and dashes if smart ones kept it from parsing, else left as code with why. (Mermaid 11.4.1 is bundled, MIT; the page's own scripts still don't run.) Code is set in the fixed-width font when edited too, unless the tile's menu says otherwise. ⌃⌘↩ puts the other mode beside the tile, so you can type on the left and read on the right; opening a file shown already, in either mode, goes to its tile. A link followed in a Markdown view opens another Markdown file in the same tile, as a browser goes page to page (⌘[ and ⌘] go back and forth along them); ⌘-click it to open it beside instead. A web address, or any other file, goes as every link does; #anchors scroll.

• HTML files open as web blocks, read from the file with their folder (so their images and stylesheets work), from a terminal, the Open Quickly, a folder listing, a link in a preview, or the mani command.

• Fonts: besides the interface's system font, a theme has four: a monospaced one for terminals and code, a technical one beside it — proportional, for what's said about code: in an editor set monospaced, a doc comment's words are set in it, its /// or /** left in the monospaced, and other comments stay monospaced. What's a doc comment is the language's: /// and /** */ in Swift, Rust's own, Doxygen's in C and C++, Javadoc, KDoc and JSDoc, the comments just above a declaration in Go and Ruby, Python's docstrings and Elixir's @doc — found in its tree-sitter grammar's parse, kept as it's typed (in two dozen languages by extension; elsewhere nothing is set apart) — an editing one for what's edited (notes, text in an editor — or, Settings ▸ Appearance ▸ Editor Text, the monospaced one), and a reading one for previews (a Markdown preview). Each theme sets them — face, size, line height (a multiple of the size), letter spacing and OpenType features — and no fonts are shipped: System (SF and SF Mono, SF beside it, as Xcode has them), Apple (the default: Avenir Next 15 to edit, New York 16 to read — the system's serif — and Menlo 13, with Lucida Grande 13.5 beside it, meeting Menlo's x-height), and Humanist (Hoefler&Co.'s ScreenSmart faces: Ideal Sans Book 14.5 to edit, with lining, tabular figures and ligatures, lnum, tnum, liga; Chronicle 15.5 to read, at 1.55, with ligatures; Menlo 13, with Whitney Medium 13.5 beside it — SF where Whitney isn't installed), which is offered only where Ideal Sans SSm and Chronicle SSm are installed (without them, a saved Humanist is set as Apple, and it comes back when they are). Headings in a preview take the reading role's heading weight, as the family's nearest face (Humanist's a step below Bold: Chronicle has no Semibold, so Medium). In the dark, what's read and edited at length — an editor's text, a preview's body — is 86% white, against glare over a long read, with headings and bold brighter (97%) to do emphasis's work. Code spans are marked by their face alone; only fenced code blocks sit on a tint. Settings ▸ Appearance ▸ Enable advanced typography adds a Typography pane and a fourth theme, Custom, set there a role at a time: any installed family (the monospaced role's list leads with those of fixed pitch; New York too) and its face (by weight), the size, the line height, letter spacing (thousandths of an em), and OpenType features by tag (ss01, zero, -liga, cv05=2, or checked off a menu of those the font has); the reading role also its measure (the longest line in a preview, in characters) and the space between paragraphs (and its headings' face); the technical role no line height — it's set on the monospaced's lines, its size where the monospaced is 13 pt, and its sample is code with comments. Bold and italic come from the family's own faces, by their weights: bold a face about three hundred heavier (Regular's Bold) — or the face a role names (its Bold menu: Humanist's editing role names Semibold, Ideal's Bold being heavy beside Book, and its weights too close together to say so) — italic the slanted face of the weight, in editors, previews and terminals alike. A sample shows the role as it's set; changes apply as you make them (and choose Custom); Start From copies a theme's, all of it or the role's. Fonts installed while Manifold runs are taken up at once.

• Language servers run on the file's host, one per language and project root, started when a file of theirs is placed: what they say is underlined, marked in the gutter and spelled out along the bottom when the caret is on it. Right-click a name in code for the symbol's own: Go to Definition, Find References, Show Callers, Show Documentation, Highlight Uses, Rename (the caret put on it). A symbol gone to lands below what's pinned over the top, not behind it; ⌥↑ ⌥↓ page up and down. Edit ▸ Code: Complete (⌃Space, or ⌥⎋ where ⌃Space switches the keyboard), Go to Definition (⌃⌘J, or ⌘-click — ⌘⌥-click stacks it over the editor: with ⌘ held, everything there's somewhere to go to — by the server's semantic tokens — shows in go.dev's link color, glowing softly in it, the one under the pointer on a soft band — a step in lightness, not a hue, as a chosen row's), Find References (⌃⇧⌘R: a block of every use, beside, as a search's hits are shown — this file's first, each line previewed), Show Documentation (⌃⌘H), Rename Symbol… (⌃⌘R; other files change through their blocks, or on disk when they aren't open), Format Document (⌃⌥⌘F). Manifold ▸ Settings ▸ Language Servers is the table: the languages by extension, the command (sourcekit-lsp, gopls, rust-analyzer, pyright, typescript-language-server, clangd and zls by default), the files that mark a project root, on or off; it's a setting for every host at once, so every host runs the same — unless the host says otherwise. Above the table, All Hosts or one host (This Mac too; or Preferences for host… ▸ Language Servers… in its menu): set for one host, the same table shows what that host runs, and a command or root markers changed there are its own (in the accent color), as apex's settings are — ~/.apex/fblsp-server rust for Rust there, say; set back to all hosts' value, they're let go of. Below it, a root marker for every language on that host: .hg makes the folder holding it every language's project root (a monorepo one root). A host's own settings are its preferences, shared by every Mac attached to it. A change restarts the servers it touches, their open files with them.

• Insert Path (⌃⌘I, Edit ▸ Insert Path…), in a terminal or an agent's, opens a menu over the cursor of the paths where its shell is: the folder's own folders and files, and under them, nearest the field at its foot, the last three put in on that host (a clock at their right). Type to find any file or folder under the folder, however deep — the best nearest the field. Nothing waits for anything: the folder's own entries show as they come (a moment, even on a slow remote), and what's under them is looked for only once you type, nearest folders first, eight at a time, the rows ranked again (off the main thread) as more is found, a spinner and how many folders so far at the field's right — and only as far as it helps: once there's a screenful of strong matches (a name that is, or starts with, what's typed, or a word of it that does) it stops, nothing further away being able to come before them; ↑ past the top looks for another screenful. A folder you go into (⇥) is listed, alone. Closed, or emptied, it stops. What's been found is kept a couple of minutes, so it's there at once next time. Hidden folders, what the repository ignores, dependencies, packages and a home's Library are listed but not gone into. ↑↓ choose, ⇥ goes into a folder, ↩ types the path at the cursor, ⎋ leaves. It's typed as the shell would have it: relative to the folder when it's under it, else from ~, quoted where it must be (a ~/ left outside the quotes); a folder with its slash, a file with a space after. On another host, its files are the host's, listed there.

• ⌘-click a file's name in a terminal to open it below the terminal, in its column: Markdown in a preview, folders in a listing (a folder's bare name too, as ls prints it, if there's a folder by that name where the terminal is), text to edit; path:line:column (as grep and compilers print it) goes to that place — read from the word's start for as long as it goes on as a path and a line and column, so bootstrap.py:177:1:def run( and DESIGN.md:3:Manifold is… each go to their file's line. A path with a line needs a dot or a slash; without one, the look of a path (./x, ~/a, a name with an extension); a bare name, to be there. A name is from where the command that printed it ran: after ls and cd sub, the names ls listed are still the folder's it listed, and open as that folder's files. A link the terminal wrapped onto the next row (it ran out of columns) is one link, whichever row is clicked; a path a program broke over two lines itself (the next maybe indented) is joined when a file is there by the joined name. Hold ⌘ over a terminal and what can be clicked shows, its text in the link color an editor shows ⌘'s links in, with the same glow around its letters, the one under the pointer on the same soft band. On another host the files are looked for there as ⌘ goes down: what looks like a path shows at once, without the glow, until the host says it's there (it glows) or not (it goes), and a bare name shows once it's found — usually before anything shows at all. A click on one not answered for yet waits a moment for the answer. Holding ⌘ for shortcuts shows nothing: links wait a moment after ⌘ goes down, and once a key goes down with it (⌘G and ⇧⌘G through a search, ⌘C) they're put away, in a terminal or an editor, until ⌘ is let go. mani open (see The mani command) does the same from a shell: mani open README.md src/.

• Folders open as one tree, as Claude Code's file panel shows one: flat, in the system font, each folder opening in place (a click on its row or its chevron, ⏎), a file a small symbol in its type's colour; the file chosen is previewed at the right by Quick Look with its kind, size and date, as the Finder's columns do (the divider dragged as you like; a narrow tile shows the tree alone) — Markdown rendered as a preview tile renders it, scrolling, its links followed as there. A folder's README (README.md first, else a plain README or README.txt) is shown under its files, as GitHub shows one: a click on its bar collapses it to the bar (and opens it again; the tile keeps it, and a new one takes the choice made last), the bar dragged sets its height; read again when it changes, out of the way of a filter's matches, the bar alone when the tile's too short for both. What the folder's repository ignores (git's or Sapling's rules) and hidden files are left out; ⇧⌘. (View ▸ Show Hidden Files) shows them, dimmed. Or in columns, as the Finder's (the switch at the field's right; the tile keeps it, and a folder gone into or a new tile takes the one chosen last): each folder chosen opens in the next column, the file chosen is previewed after the last, in the tree's rows — a folder's chevron at its row's end — and ← → go between columns, ⏎ into the folder chosen. A column's files are in groups, as the Finder's Use Groups has them, but code by its language: folders first, then Notices (README, LICENSE, AGENTS.md, CHANGELOG.md — a name in capitals is usually a project's own, there to be read), Documents, PDF Documents, each language (C, Python, Rust, Swift, …), Build (Makefile, Dockerfile), Configuration (JSON, TOML, YAML, lock files), Spreadsheets, Presentations, Images, Movies, Music, Archives and Other, each under a small grey header and in the sort's order (View ▸ Use Groups, ⌃⌘G, turns them off; the tile keeps it). The field at the top (⌘F, or / from the list; ⇥ goes between it and the list) is a search in the tree and a filter in columns: there each column keeps only the files that match and the folders on the way to them, in its own order, the first match chosen if what was chosen is gone (⏎ opens it). In the tree it looks through the whole tree beneath as it's typed, less what's ignored, and lists the files that match — their letters in order, as Open Quickly matches — best first, the letters matched in bold and the folder each is in beside it; ⏎ opens the best, ↓ goes to the list, ⎋ clears it. "?" and some words, then ⏎, searches inside the files instead, in a search beside. The arrow, or ⌘↑, goes up to the enclosing folder; ⌘↓ goes into the folder chosen, in the same tile. A double-click (or ⏎) opens a file as a link does — gone to, else beside; a double-click on a folder opens it, as its menu's Open does — in this tile (⌘ beside, ⌥ over). Drag an entry out and it's the file, a thing as anything dragged is (above): a terminal types its path, a note links to it, a folder takes it in, the grid opens it where it lands (on its host, another's too), another app takes the file (one of this Mac's); rest the pointer for the rest. The selection, the folders left open, the divider and the filter are kept with the tile, and the listing keeps current as files come and go. On the folder's own host, remote or not (a remote file is fetched for its preview).

• Projects: a folder made one (Make Project, in its tile's menu, or the quiet button its header offers where the folder looks like a project's root — a repository's own folder, a Cargo.toml, a go.mod, a package.json…) is kept as a project on its host, so everything there finds it: the project of a path is the nearest one at or above it. Its tile shows the project's homepage, as GitHub shows a repository's, round its files (in columns at first; the house beside the views turns the homepage off and on, kept with the tile): a line under the header with the branch (how far ahead and behind), its changes and how its index stands (indexed 5m ago · rust, indexing…, failed and why — the indexer not installed, stopped, writing none, or the error it gave, all it said in the chip's tip; clicked, made again), and at the right its own changes and recent commits, each opened as a diff beside — the project's alone, where it's a folder deep in a repository (git's and Sapling's alike), as are the commits in the git tile its branch and All commits here open. A new project is indexed at once, if its language has an indexer. A folder inside a project shows the project's name in its header (⤒ app): clicked, the tile goes up to the project's homepage, the folder chosen there. No Longer a Project in the menu takes it back. On the homepage its field searches the project as you type, in the files' place: symbols by name (from its index and the language servers running there, each marked by which — index, server — the index's at once), files by name, and, two letters on, the files' text, each under its heading, best first. ↓ goes into them, ⏎ opens the one chosen (the best, from the field) beside, ⎋ clears it; sym:, file: and text: look for one alone. Open in a Tile puts the same search beside, to keep — its symbols and files above the text, previewed as hits are. A project is the scope of what's done in it: its index is made at its root (an index of a folder deep in a repository is the folder's), and made again when its working copy moves — a checkout, a commit, a rebase — as when a file of it is saved; Source Control for This Project (⌥⌘G) in it shows its own changes and commits; Expand to Project in a search under it widens to it, not the whole repository. Project Settings… (the tile's menu) chooses its indexer (or none) and its command, and whether its working copy moving indexes it again, for every Mac attached to its host. mani project says which project a folder is in — its root, its branch and changes, how its index stands; --make makes the folder one, --remove takes it back. The homepage's sidebar also shows its languages, counted as GitHub counts a repository's (a bar of its code's bytes by language, the first few named): programming and markup languages, not data or prose; what Linguist takes as vendored (vendor/, third_party/, node_modules/, dist/…), documentation (docs/, examples/ at the top, READMEs…) or generated (protocol buffers' output, lock files, source maps, a file whose first lines say so, minified scripts) left out; and as the project's .gitattributes say otherwise (linguist-vendored, linguist-generated, linguist-documentation, linguist-detectable, linguist-language) and what's here now: terminals and agents working in it (what each is doing, and where) and notes about its files — each gone to when clicked. Its index's line says when files have changed since it was made (indexed 5m ago · 3 files changed since; clicked, made again), as mani project does.

• Files cross between hosts as they would between folders: drop files from the Finder (or entries from another folder's tile, another host's too) on a folder's tile and they're copied into it, there — what's there already asked about before it's replaced; drop this Mac's files on another host's terminal and they're sent to its shell's folder (a name of their own if one's taken) and their paths there typed. Drag another host's file to the Finder, the Desktop or Mail — a folder's entry, a tile by its bar, a search's or ⌘O's row, a change, an outline's row — and it's fetched there (shown going with the other copies). An image or PDF from another host says how much of it has come, with a bar, while it's brought to be shown. Right-click an entry (or a file tile's menu) for Open With — on another host, Open Locally With: a copy opened by the app here, sent back each time it's saved — and Download, to Downloads. Every copy shows at the foot of the sidebar while it goes — what, where to, how much of how much, how fast and how long is left, a bar filling — and × stops it, leaving nothing half-written; a failed one stays, red, until it's dismissed, and a finished download's row shows it in the Finder. With the sidebar away, a badge at the window's lower left says copies are going and brings it out. A drop of many things is one row. (How copies are paced: DESIGN.md §11.)

• Another host's ports come here: open a localhost address from its tiles — ⌘-click http://localhost:3000 in a remote terminal, a dev server's banner — and it opens as the host's own page (below), its port forwarded through the host's own link to this Mac's localhost (the same port when it's free here, else another): no ssh -L. Forward a Port from host… in the host's menu asks for one, for any app here (⇧⌘-click forwards one for the system's browser, the toast saying where); each forward asked for is listed there, to open or stop. A forward keeps listening while the host is away, and its connections go again when it's back. (How: DESIGN.md §11.)

• A block's address, manifold:host/id, opens it from any app on the Mac — pasted in Slack, a note in Notes, a commit message, or open manifold:… in a shell — going there as a link in a note does (a terminal's #command=N to that command). Copy Link in a tile's menu puts it on the clipboard: a link where links are taken, named for the block; text elsewhere; the block's link in a note. Copy Path and Reveal in Finder are beside it. Closer in, the editor's menu has Copy Link to This Line (#line=N), an outline's heading or a PDF's page menu Copy Link to it (#line=, #page=), and a terminal's command or turn Copy Link to This Command; followed, each goes to that place.

• Places (§2.5 of DESIGN.md): a reference to a place in a file — a declaration, a Markdown heading, else a line — names it by an anchor the file keeps, manifold:host/id#k7q2mx, not by its line: the function moved, renamed back, or the lines above it changed (in an editor, or by another program), it still leads there; gone, it says so ("“Card.save” is no longer in Card.swift"). An outline's item dragged or Copy Link'd, or a line dragged from an editor's gutter (the line numbers), makes one — the declaration or heading on that line, else the line — and so does a selection dragged out of the text (a function's name: the function; anything else: that stretch), carrying its words for other apps — and the same place gives the same reference (a terminal's command and a PDF's page are anchored the same way). Links carry places at either end, and what they mean (a relation: describes, annotates, explains, step, any word); mani info lists a file's places and what links to each. Agents make them with mani symbols (a file's declarations, by path), mani ref <file> --symbol Type.method and mani link <note> <ref> --as describes. A note that describes a Markdown heading shows under it in the preview too. In an editor, a place with links has a mark in the gutter (clicked, what links to it and from it, each followed when chosen), and a note that describes, annotates or explains it shows under its line, in the technical font beside code (the tile's menu hides them). A reference written bare shows the place's name on its pill.

• Indexes (SCIP): a project (above) is indexed when it's made; elsewhere mani index (or Code ▸ Index Project) has the project's indexer make its SCIP index on its host — rust-analyzer for a Cargo crate; scip-typescript and scip-python, fetched by npx when first used; scip-go, scip-clang (with a compile_commands.json) and scip-java where installed — in the background, kept in the host's folder. Then mani refs <file> --symbol Type.method lists every place a symbol is used across the project (--markdown: each a reference, for a walk), and Find References uses it when no language server answers. An anchor at a declaration keeps its index name, so one moved to another file is followed there where the indexer keeps its name (Go within a package, C and C++; rust-analyzer and scip-typescript name a symbol by its module or file, so moving it renames it). Once a project has an index, saving a file of it indexes it again (20 seconds after the last save); a git tile says how its project's index stands beside the branch (indexing…, indexed 12m). mani callers <file> --symbol f [--depth n], and Code ▸ Show Callers (a note of them beside the editor, walked with ⌃⌘]), list the functions that call a symbol — found by the index, named by each file's grammar — and their callers, each a reference.

• Reading code: the pointer resting on a name shows what it is under it (peek): its definition's line and documentation, from the language server, else at once from the project's index, gone as the pointer leaves the name (to anywhere), a key or a click. Code ▸ Highlight Uses (⌃⌘E) keeps a symbol's uses tinted in its own colour — four at once, again to unpin, Clear Highlights for all; the caret on a name tints its other uses in the file. Both are that symbol's uses as its language server knows them (a parameter data, not a property data), else the name's whole words, not in comments. The tile's menu's Open with Bodies Folded opens it as an outline of its functions, their notes showing (kept with the tile).

• Folding: in an editor, Collapse (⌃⌘9) folds the declaration the caret is in (its body, by the language's grammar; a Markdown section, in a note or Markdown file) under its first line, a chip where it went (clicked, it opens); Expand (⌃⌘0) opens it, Collapse All (⌥⌘9) folds every function's body, Expand All (⌥⌘0) opens them all. A folded function with a note describing it shows the note in its body's place. A caret come into what's folded (gone to, found) opens it.

• Asking an agent about code: Describe, Explain and Walk Through with an Agent (an editor's menu, Code ▸) hand the place — the selection's, else the declaration the caret is in — to the agent in the space most lately used (else a new one beside), asking it for a note that describes it (linked --as describes, so it shows under the function and in its folded body's place), one that explains how it fits (--as explains), or a walk: a note of references a step each. What it makes is graph like anything else; Manifold shows it.

• Walks through code: a note of references in order, a sentence each (one an agent writes with mani ref), is walked with ⌃⌘] (Go ▸ Next Step) and ⌃⌘[: each step shown beside the note in one tile, at its place, the note keeping the keyboard with the step chosen in it.

• Notes from what's at hand: New Note from Selection, in an editor's or a terminal's menu (and ⇧⌘P's), makes a note of the selected text, quoted as code when it came from code, linked from where it came; New Note from Clipboard makes one of what was copied (a picture, an image block), and a terminal's Save Scrollback as Note keeps its whole transcript.

• Links go by the click, every kind alike — a web address, a path, a block's link in a note or a bar — in a terminal, an editor, a preview or a page: a plain click goes to what it names where a tile shows it (else opens it below); ⌘-click opens it in Manifold beside (a page in its web lens), ⌥-click (⌘⌥) over; ⇧⌘-click gives it to the system — an address to your browser, a file of this Mac to the app that opens it. A plain click in a page follows the link in the page, as a browser does, and one to a Markdown file in a preview previews it in the same tile; in a terminal ⌘ is what makes a click a link's. In an editor ⌘-click follows a link, and on anything else goes to its definition. File links in a Markdown preview go where the file leads: another Markdown file is previewed in the same tile, a folder is listed, an image or PDF shown, anything else edited.

• Find is a small field at a tile's upper right (⌘F): the query, how many matches, ↑ ↓ for the previous and next (↩ and ⇧↩, ⌘G and ⇧⌘G too), Aa for case, and ×; ⌥⌘F adds a row to replace with. ⌘E (Use Selection for Find) finds the selection, or the word at hand, and goes on to its next occurrence; ⇧⌘E (Use Selection for Replace) puts it in the replace row. Editors, Markdown previews, web pages, diffs and terminals are searched this way; in a terminal, Ghostty itself finds through the screen and its history and marks every match.

• Copy on Select: text selected with the mouse in a terminal is on the clipboard at once, the highlight pulsing once with the glow typed-ahead keystrokes have — around it, as if lit from behind — to say so (not in full screen, where selecting is for reading); off and on from the terminal's bar menu, for every terminal.

• Every tile prints (File ▸ Print…), as it best goes on paper: a text or code as text, in its font; a Markdown preview or a web page as rendered; a PDF's pages and an image, fitted; a command's output, a terminal's transcript, a diff's changes and a notebook's cells as text. ⌘C copies an image (or a PDF's selected text) as other views copy theirs, and every tile's menu has Copy Link and, where it has a place, Copy Path and Reveal in Finder.

• Outline ticks: a tile whose block has an outline — a Markdown text's headings (in the editor or the preview), a source file's types, functions and methods (as its language server says, nested as they are, each with its kind, not a function's locals or a type's fields), a PDF's contents, a diff's files and changes, a web page's headings, an agent's turns — shows it as a few short ticks at its content's upper right (five at most, however long the outline), the one nearest where you are longer and darker (in a terminal, the last command whose output shows, so it follows the scrolling); they take no room of their own, and stand aside while the tile's find (⌘F) is open, which does the same job there. Rest the pointer on them and the whole outline opens over them, indented by level, where you are marked: click an item to go there, or its ⋯ (or right-click it) for what else it can do — copy a link to a heading or a page, a turn's changes, undo a turn. Drag an item and it's that place in the block, a thing (above), by its words (#line=, #page=, #command=): into a note it's a link to that heading, page or command; on a shell, its words (a command typed again); on an agent, what's there (a heading's section, a command's output); on a tile, the blocks are linked; rest the pointer for the rest. A diff's file carries itself, as a file dragged from a listing does. A shell's commands have a dot each too, beside the prompt (red for one that failed, the accent for one still running): rest the pointer on a dot for Copy Command and Output and Open as Block, or drag the dot itself: the command, as its row in the outline drags (its line typed again in a terminal, a link to it in a note, its output given an agent).

• A tile's own sidebar: the same outline — a terminal's commands (an agent's turns), each with how it ended, how long it took (a second or more: "2.4 s", "2m 13s") and when, clicked, the terminal goes there (its ⋯ shows the command's output, or the turn, as a block); a Markdown text's, a source file's, a PDF's, a diff's or a web page's — as a list at the tile's left — the sidebar button in the tile's bar, or View ▸ Show Outline (⌘/) — listing the headings (a PDF's table of contents), each clicked to go there (the pointer staying where it is), the one you're in marked as you scroll; a PDF's has its pages too, as thumbnails (the two buttons at its top), clicked to go there, ⌘- or ⇧-clicked to choose several, and dragged out as pages — a link to each in a note, a reference for an agent, the page itself as a PDF to the Finder or Mail. Shown or not, it's kept with the tile.

• Filter Outline (⇧⌘P — ⌘P's outline, in the tile — or the bar's menu): the focused tile's own sidebar — its commands, headings, symbols, contents or files — shown if it wasn't, the pointer going to the filter field at its top, what was typed there last still there; type to narrow it (every word somewhere in an entry, the matches listed flat), ↑↓ and ⏎ to go there, as clicking one does; Escape clears what's typed, then leaves; ⇧⌘P again leaves. Either way the tile has the keyboard back, and a sidebar opened for it is put away again; the filter stands until cleared. (A tile with an outline but no sidebar gets ⌘P.) A command in a terminal's outline, right-clicked (its row, its entry in the ticks' list): Run Again types it at the prompt with a return, Type at Prompt types it to be changed first — the tile focused, neither while a command is running (it'd go to that program). A command's output (Open as Block in its ⋯, or on its dot) opens as a block of its own: the command line, how it ended and when, and what it printed as the terminal drew it — its colours, faces and carriage returns, in the terminal's palette and font — read-only, with Copy (the command and its output, as text), ⌘F to search it, and Show in Terminal (back to the command, the terminal scrolled to where it began). The bytes are the host's, kept from the command's start to its end, so a command scrolled off the screen or run before the window opened still shows whole; one from before the host kept them shows the screen's text instead. One per command; clicked again, the same block comes back.

• A terminal's, an editor's and a preview's scroll bar is a knob down the tile's right edge where you are, on no track of its own (as macOS's overlay scroll bars and Manifold's lists): drag it, or click beside it to scroll there, as ever. (Where things are in what it holds is the outline's, above.) It shows as macOS shows its scroll bars: while you scroll, while the pointer rests on it, and a moment after, fading otherwise (and staying, if your scroll bars are set to always show).

• Shell notebooks (File ▸ New ▸ Shell Notebook, ⌥⌘B) are Jupyter's notebooks for a shell: a column of cells, each a command (as many lines as you like) with what its last run printed beneath it, all run in one shell that lives on — your zsh or bash, with your rc files, on the notebook's host, TERM=dumb — so a variable exported, a directory changed into or an alias made in one cell is there in the next. ⌘↩ runs a cell; ⇧↩ runs it and goes to the next (made if it's the last); ⌥↩ runs it and makes one below; ↑ and ↓ past a cell's first or last line go to the cells beside it; ⌃⌘↑ and ⌃⌘↓ move it, as an editor moves a line; ⌘. (Tile ▸ Interrupt) stops it (the bar's menu lists them, for the focused cell). A run's output streams in as it comes and replaces the last; beneath it, the sidebar's status glyph (turning while it runs, a check once done, red when it failed) with how it ended (Done, Exit 1, Interrupted), how long it took and when; the gutter numbers the runs as the editor numbers lines. The focused cell wears the accent's bar at its left, as a selected row does, and a light ring, as a focused tile does; ▶ and the cell's menu (also on a right-click) show under the pointer. The header groups its buttons in capsules, as the folder view's modes are: run, run all, stop (red while there's something to stop); a new cell, restart, more. Cells run one at a time, in the order asked (Run All runs them all); one that fails stops those waiting. ⌘. (or the stop button) interrupts the running cell with ^C and drops those waiting; again kills its program, for one that ignores ^C. Restart Shell starts a fresh one. ⌘-click a path or an address in an output to open it — a name from where the shell is now, file:line:column at that place. The header says what the shell is doing and where; the notebook's status (working, done, failed) shows in the sidebar and the Inbox as a terminal's does. Cells, outputs and counts are kept in the notebook's log; the shell itself goes with the host's server, and the next run starts a new one. A cell's menu has Open as Block: what it printed, as a command's output block, beside the notebook and linked from it.

• Searches are blocks too: Find in Files… (⇧⌘F, from the editor's selection if there is one) makes one on the focused block's host under where it is — a terminal's directory, a file's folder — placed beside it. The folder is a field under the query: edit it (~, or a path from where it was) and ⏎ searches there; Expand to Project beside it, shown when the folder is inside a repository (git or Sapling) it isn't the root of, widens the search to the repository — the host finding it, on a remote host too. The host runs rg (or grep) and the hits arrive grouped by file as they're found, matches marked, each file's name staying at the top while its hits scroll under it until the next file's takes over. ⏎ in the field asks again (Aa for case, .* for a regular expression); ↓ then ⏎, or a double-click, opens the file at the hit beside the results. The hit chosen (the first, before one is) is previewed as the column browser previews a file — beside the hits when the tile is wide, beneath them when it's tall: the whole file in the code face with its line numbers, the hit's line lit in the middle, its match boxed and every other match marked; a double-click in it opens the file at that line. A search is found again by its query in ⌘O. A folder's menu (in a folder tile or the sidebar) has Find in This Folder…, for the same search under it.

• Git and Sapling repositories get a block each (File ▸ Source Control for This Project, ⌥⌘G, for the focused block's; the nearest .sl, .hg (a Sapling checkout as Meta's are) or .git up from it says which, Sapling first; with none, the tile goes and says so): the branch or bookmark (with how far ahead or behind), what's changed, and the last 200 commits, looked at again when shown, when a file is saved from Manifold, or when the index (or Sapling's dirstate) changes. Sapling is spoken to as sl on the host's PATH. The change or commit chosen shows in a pane under the list, as a mail reader shows the message chosen (the split kept with the tile; a short tile, the list alone); a commit's message is rendered as Markdown there and in its own diff — its subject a paragraph like the rest (not a heading), who and when above it. ⏎ or a double-click on a change opens a diff block beside it — the file against HEAD, context folded (click to unfold), double-click a row to open the file there; on a commit, the whole commit; on All changes as one diff (first under the changes, or in the tile's menu), every outstanding change at once, as plain git diff (sl diff) shows it, read again as the repository moves. Compare with Last Commit (⌥⇧⌘D; ⌥⌘D is the system's, hiding the Dock) does the same for the file being edited. A diff shows old and new side by side when its tile is wide enough for two columns, unified when it isn't. A diff's row or file has a menu: Open This Version (the file as it was at the commit, from git show, a block of its own beside), Open the Version Before, This File's Changes Alone (from a whole commit's diff) and Open the File. The editor's gutter shows how its lines stand against HEAD: a green bar for added lines, blue for changed, a red wedge where lines were taken out. Diff blocks keep the texts they compared in their logs, so they're records.

• Interactive Smartlog (File ▸ New ▸ Smartlog, ⌥⌘L): Sapling's own smartlog for the repository the focused block is in — its commits and stacks, to commit, amend, rebase and split by hand — as a block of its own, beside, like any other: the host runs sl web (or finds the one running), and the tile shows what it serves, with nothing of a browser about it; a link out of it (a pull request) opens in the browser. A file you open from it (clicking one in a commit's or the working copy's files, or Open File in its menu) opens here, beside it, as any file does — at the line, when it names one — and Open Containing Folder opens the folder's listing, not the host's editor or the Finder (Sapling's isl.open-file-cmd isn't used, or changed). On another host it comes through the host's connection; its theme follows the app's. It works on a git repository as well as a Sapling one; outside any repository, or with no sl, the tile says so. The servers look for tools (git, sl, rg, language servers) where they're commonly installed — Homebrew's and Linuxbrew's folders, ~/.local/bin — as well as on the PATH they were started with.

• The sidebar organizes the same graph three ways (View ▸ Organize By, ⌥⌘1–2; the words in every block are found with Open Quickly's In Blocks): Spaces — every space, each named by what it holds unless you name it (its blocks' folder, with the branch when a git block is there); Files — every block with a path under its folders — and every block that is at a folder, under it by its title: a terminal in its working directory (moving as it moves), a note at home there, a patch against it — across hosts, as a sparse tree; in every folder, what is on a space now is listed first, what's kept otherwise after it, dimmed; what's closed and not yet collected is only in Recently Closed (repositories, ~ and / at the top; runs of single folders one row; counts beneath; rows fade as they go unseen). The filter (⌘.) narrows either to the blocks with a status (above). The rows work the same everywhere, by the one rule for opening things (below); rest the pointer for a card — after a moment, a picture of the block, as Safari previews a tab (out of sight, as it was last seen; a terminal, its screen as it holds it) — and under the picture, the block's summary card, as a stack's column has it (its title, where it is, when it last did something, its few lines). The card is drawn in the window, and goes when Manifold isn't in front; right-click for Go To, Show Beside, Show Over and the Neighborhood Map. Links written in a text — [[title]], [words](file.md) — become edges the moment they're typed, so the map shows a note's backlinks whether or not anyone followed them. A row says what its block's status adds to its pill (its title, its message — not "Done" or "Permission"); an untitled note goes by its first words, as its links name it; a text with unsaved edits has its bar's dot after the name; a page has its site's icon.

• Pin in Space (⌃⌘T, as the Finder's Add to Sidebar; a tile's bar menu, a terminal's or an editor's right-click menu, or a sidebar row's): the block stays at the top of its space in the sidebar, above a hairline, in the order pinned — and stays there with its tile closed, dimmed, to click for the tile back in that space. A pin is an edge from the space to the block, a strong one: the space keeps the block — a pin is how a block stays without a tile. Unpin from the same menus. (What Manifold kept before, by a Keep, a name or a pin outside the spaces, is brought into them once: a kept block nothing else reaches is pinned in a space named Kept.)

• One rule for the modifiers, wherever a click opens a block — a sidebar row, a link, a path, a search or git hit, a tile's links, a listing's entry, a card in Overview, a row of Open Quickly chosen with ⏎ (⌘⏎, ⌥⏎ and ⇧⌘⏎ alike): plain goes to it where a tile shows it, in any space (or opens it beside, if none does); ⌥ puts it over the tile you clicked in, which goes behind it, as ⌥-drag stacks; ⌘ puts it beside that tile; ⇧⌘ gives it to the system (the browser, the file's app). ⇧ alone is about the path: ⇧-click a bar for where the block is, folder by folder; ⇧-drag a bar to link. In a terminal, ⌘ is what makes a click a click on a link at all, so there ⌘⌥ is over and ⌘ alone beside. Three views go on in place on a plain click, as a browser does — a page's link, a preview's link to another Markdown file, a listing's folder — ⌘[ coming back. The map is a graph: a click re-centres it, a double-click goes.

• Links are two kinds: by hand (⇧-drag a bar onto a tile, a note made beside a block), which keep what they point at; and by the way (a file ⌘-clicked in a terminal, a hit followed, a diff of a file, a [[mention]] in a note, a diff to the open files it changes, a block's link followed from a terminal, an output or a page), which are history and keep nothing; each says what made it ("followed", "subfolder", "chosen in ⌘O", "⇧-dragged in"), and the same link said twice in a moment is made once. The tile's links show the ones by hand, and a note's images (the note, on an image's), which go when the note stops showing them rather than by ×; the Neighborhood Map (Tile ▸ Show the Neighborhood Map, ⌥⌘M, or a link's or a row's menu) draws a block's surroundings in graph form, two steps out — what it's joined to on a ring around it, what those are joined to beyond, with what made each link shown when a block is pointed at, and what you went to before and after it, from the trail. Click a block to look around it instead (Back returns), double-click or ⏎ to go there, arrow keys move, Space re-centers, ⎋ closes. The trail — every tile focused and every space gone to, which the host keeps — orders ⌘`'s round of the spaces and the map's before and after.

• Every block has a status (DESIGN.md §3.7), in the schema of OSC 7501: idle, working (with progress, or without), done, blocked (waiting for permission, an answer, or a sign-in), or failed, with the program's name and a line about it. Terminals and agents get theirs from the program — the host reads OSC 7501 out of the byte stream it owns, so remote hosts work the same; OSC 9;4 progress counts until a 7501 report arrives; a new prompt or the process ending clears working and blocked; done and failed stay, read once you attend to the block by focusing it — or at once, when it finishes while you're looking. A busy terminal that says nothing is working. Searches, git and diff blocks report as the host works for them. A block's name says it wherever it's shown — its tile's bar, its sidebar row, its card in the Overview — and adds something only when the block needs you: while it works, the name shimmers, a wide faded band sweeping across it every three seconds, every working name in step (with the program's percent beside it in grey, when it says how far, as OSC 9;4 progress does; with Reduce motion, the name holds still, a little dim, a dot beside it); what needs you, done or failed and not yet seen, has a word in a pill at the right — Permission, Question, Sign in or Needs you in amber, Done in grey, Failed in red — exactly while it's in the inbox (⌘J), after how long ago in the sidebar; once seen, nothing. In a bar short of room the word gives way to a dot in its color before the name gives way; in a bar it's left of the links and the buttons, by the name. An inactive terminal's name is dim. A host's states keep their glyphs. The counts at the sidebar's foot, and the Open Quickly, are as quiet; the Dock badge counts the blocks that need you or are done and unread. Out of sight — Manifold not in front, or the tile not showing — the Mac's notifications say so: a terminal, agent or notebook that comes to need you, finishes or fails, and a terminal's command that ran ten seconds or more ending (how long, and its exit status if it failed); clicked, one goes to the block, and the command. The sidebar's filter (⌘., above) shows only the blocks with a status, and ⌘J goes to the next that wants attention. Overview (⌘') shows a space's blocks themselves, live, as a state view — or, with its filter on Agents (Window ▸ Agents, ⌃⌘A), every agent on every host: a list, stacked down one scrolling column as Prism's notes are, each under its bar; or an overview, all of them in one grid at once, as Mission Control lays out windows: as big as they can be with every one in the room (from about square to twice as wide as tall); or summaries, a summary card each, in columns — what it shows by itself past ten blocks, live views of so many being small (the buttons at its top right choose, and it opens next time as it was left). Nothing is placed: click a card or a bar to go to the block, ⌘-click to open it beside the tile you were on, ⌥-click over it, ⎋ (or ×) to go back. Clear Status, in a block's row menu in the sidebar or the tile's bar menu, forgets what a block reported until it reports again; a group's row offers Clear All. From a shell:

  status() { printf '\e]7501;state=%s:msg=%s\e\\' "$1" "$(printf '%s' "$2" | base64 | tr -d '\n')"; }
  status working "Syncing photos"; rsync -a ~/Photos backup:/photos && status done "Photos synced" || status error "rsync failed"

• Every lens comes back as it was. Each placement keeps its lens's state in the block's log — the editor's selection and scroll, a preview's scroll and selection, a web page's history and scroll, a folder's or search's or git block's selected row and scroll, a diff's scroll and whether it was unfolded, an image's zoom, a PDF's page, the process list's filter and sort — so a restart, a move between lenses or a reload shows exactly what you left. The block keeps what it was last left at through each lens too, so a tile made for it again (recalled after it was closed, brought to another space) starts there.

• History of This File (⌥⌘Y, File ▸ Source Control, or an editor's right-click) — for a file in git or Sapling, a strip along the editor's foot: each commit that changed it a tick (renames followed), the oldest at the left, the file as it is at the right end. Click or drag to one, or step with the arrows ([ and ] while back in time): the text as that commit left it, read-only, in place, on a tinted page — a past version, not the file as it is — what that commit changed marked in the gutter, and the view kept on the same lines as it goes back and forth. Now (or ⎋) comes back. Blame (⌃⌘B, the same places): each line's commit in a column beside the line numbers — its author and age on a run's first line, shaded darker the newer it is, a line not yet committed (edits not saved too) said so; the pointer on one says the commit, a click goes back to it. Blame follows the strip: as of the commit shown. For a file in no repository, ⌥⌘Y scrubs it through every change it's had in Manifold: Restore This Text puts a version back (one undoable edit); Compare with Now opens a diff block of then against now. Open This Version opens the text as it was then as a block of its own, beside.

• Web pages open in an embedded browser when a URL is ⌘-clicked in a terminal, typed in Open Quickly, or made with File ▸ New Web Page: the page has the whole tile, its bar has the address (click it, or ⌘L — Go to Line's key in an editor, the address's elsewhere), and back, forward and reload (stop, while it loads) are buttons on its bar as well as ⌘[ and ⌘]; its pages are in its log. The address works as Chrome's: localhost:3000, 10.0.0.5, any name:port are addresses (not searches); host:port, an attached host's name (slowbox:3000/api) is that host's own localhost — the port forwarded here and opened, the bar showing it as slowbox:3000 still; words, a search. As you type, completions come under it: the page you've been to that begins with it, filled in inline (the rest selected — type on, or ⌫ it away), else what you typed (to go to, or search for); pages you've been to that match it by address or title; the attached hosts (slowbox:, and their ports you've been to); a search. ↑↓ or ⇥ move through them, ⏎ goes, ⎋ closes them (a second ⎋ leaves the address), ⇧⌫ forgets a page. The pages any web tile shows are kept for this, with their titles, in web-history.json in the app's folder. It's known to sites as the Safari that's installed (a site that doesn't know it by WebKit's name alone — Google — would serve an old, plain page). A link that opens a new window (target=_blank, window.open) opens a web block beside, linked from the page; a page's alerts, confirmations and questions are sheets over the window, and a file input opens the Open panel.

• Another host's pages load through it: a web page made from one of its blocks — a URL ⌘-clicked in its terminal, a link opened from one of its pages, File ▸ New Web Page or the New Block picker's web with one of its tiles focused, mani new web in its shell — is that host's, and loads as it would in a browser there. The host makes its connections and looks up its names, so a site on a network only the host is on (an office's, behind a VPN the host is on) opens here, and localhost:3000 is the host's own (its port forwarded here, the bar showing the address as the host has it; another host's name:port typed there opens as that host's own page, beside). The button before back says how it's loaded (a server: through the host; a laptop: from this Mac) and, clicked, loads it the other way; the tile's menu has Load Through host too. Its cookies and sign-ins are the host's own, kept from launch to launch apart from what's loaded here; Clear Website Data for host… in the host's menu forgets them (This Mac's, what's loaded here). A page the host can't reach says why (the name unknown there, refused, no way there), and one that failed for the host being away loads again once it's back. (How: DESIGN.md §7.6, §11.)

• Images and PDFs open in their own lenses, their bytes from the file's host: images fit the view and zoom (⌘+/−, a pinch; double-click for actual size). PDFs show as Preview shows them: along the top the page (type a number to go there) of how many, ‹ › back and forward, the zoom (− + and ⌘+/−), and a menu of layouts — single page or two, scrolling or not, as a book — with Actual Size, Zoom to Fit and rotating; ⌘F finds in the text, every match a strong yellow and the one gone to blue, apart for colour-blind eyes too. A file named .pdf is one, whatever is inside it.

• Agents (File ▸ New Agent, ⌥⌘A) are terminal blocks that run the agent command (claude unless the settings say otherwise) in a login shell where the focused block is; their transcripts are kept like a terminal's, and they come back after a restart the same way. An agent at work in a block — an agent block, or a terminal running one — shows its maker's mark wherever the block's symbol shows (Claude Code, Codex, Gemini CLI, Cursor, Goose, opencode, Amp, Pi; Meta AI's for Muse), from Lobe Icons (MIT) and pi.dev, in Resources/AgentIcons, each in one color, tinted as the symbols beside it are (a colored tile or gradient lost at a bar's size); the marks are their makers' trademarks. An agent started in a git repository has the working tree noted as it starts — all of it, untracked files too, without touching the index — and Changes Since It Started in its tile's menu shows everything it has changed since as a diff block of its own, linked from it: edits, new files, commits, but nothing that was already changed before it began. Each turn is noted too (with the hooks Manifold installs, mani skill install): what was asked, the working tree as the turn began and as it ended (a checkpoint, in a git repository), the files it changed, its last words. Its item in the terminal's outline (its ticks, or its sidebar) goes to the turn; its ⋯ opens the turn as a block of its own: what was asked, what it did (its words and each tool it used, from Claude Code's transcript), what it said, the files it changed and Changes in this turn as links — a block linked from the agent and to each of them. Right-click the turn (or the agent's menu ▸ Last Turn) for Changes in This Turn and Undo This Turn: what the turn changed taken back, later work kept — or, where later work touched the same lines, nothing touched and Manifold says so. Turns are found with ⌘O — by what was asked among the names, by what was asked or said In Blocks — each opening as its block. Window ▸ Agents (⌃⌘A) is Overview (above) filtered to the agents — every agent on every host at once, those that need you first, then those at work, done, idle — each bar saying what it's on, for how long (or how long it took) and how many files it changed; click one to go there, ⎋ to come back. An agent's to-do list (Claude Code's) is a checklist note of its own, linked from it and kept by it, rewritten as the list changes: done ticked, the item at work in bold. Launch Agent Here (in the File menu or a tile's menu) offers each agent Manifold knows (Claude Code, Codex, Pi, Muse, Gemini CLI, opencode, Amp, Cursor Agent, Goose, Aider) that the focused block's host has: the host looks for them through your login shell (the shell its preferences name, if any) when a Mac attaches, when its shell preference changes, and again as the menu opens.

• Agents' hooks (mani skill install, on any host, in one of its terminals or not) let an agent that doesn't speak OSC 7501 (Codex, say) show its status, and give every agent an outline: each prompt is an item in the terminal's outline, found on the screen where the agent echoes it, until the turn ends. The hooks run mani agent <event> --agent <name> (start, prompt, working, waiting, stop, end), which tells the host over its socket and does nothing outside Manifold's terminals; status goes working on a prompt or a tool, blocked on a permission, done (with the agent's last words) when the turn ends. Each hook runs the mani that installed it, by its full path (the app's Helpers, a remote host's ~/.manifold/bin), never another mani an agent finds first on its PATH. Hooks put in when the command was manifold are moved over to the mani of the same copy of Manifold once it has one, as the app and each host's server start. Installed for whichever of these are found (or those named): Claude Code (~/.claude/settings.json; MetaCode reads these too, and is told apart), Codex (~/.codex/hooks.json; Codex asks to review new hooks once), Muse (~/.config/muse/settings.json), and Pi (an extension, ~/.pi/agent/extensions/manifold.ts, as Pi has no command hooks). Installing again replaces Manifold's hooks and keeps the rest of each file (a copy of it as it was is left beside it, .before-manifold); mani skill uninstall takes them out.

• Processes (File ▸ New Processes, or mani new process) is a block per host listing what ps sees, again every few seconds while shown, each block on a panel of its own: its summary card (a click on it goes there; its lines cut to one, or its title alone, where they wouldn't all fit in the tile), its processes under it as a tree: filter, sort by column, select any number (⇧, ⌘, ⌘A) and End them (SIGTERM; ⌫) or Force End them (SIGKILL; ⌥⌫, after asking), from the buttons or a row's menu, which also goes to the row's block. Its controls sit under the bar, and stack as the tile narrows. Machine (beside Blocks at its top, or its pill's Show the Machine) shows the whole host, macOS or Linux, as btop does but drawn: CPU over the last five minutes with each core a cell, memory, network and disks, each with its history, over every process on it — the busiest first, or by any column's header; its user, threads, CPU and memory; a process under one of your terminals marked, a double-click going there. Point at a graph to read it at that moment, or at a core. The host keeps the last five minutes, so the graphs are full as soon as they're shown.

Look

One flat style throughout, in the system font. A field or a button has no bezel: a hairline on a faint fill, darker under the pointer; a field outlined in the accent while it has the keyboard, a magnifier at its left when it filters and a cross at its right to clear it (⎋ clears it too). A toggle (Aa, .*) that's on is in the accent; the one thing to do (Attach) is filled in it. A choice of a few (Open Quickly's scopes, the state view's modes) is a row of words or symbols, the chosen one on a band of the accent. Every list's chosen row is a thin band of the accent, a faint grey one under the pointer. Panels floating over the window (hover cards, toasts, history, the sidebar sliding out) are rounded alike with one soft shadow; Open Quickly is plain, not glass. The sizes, radii, shadows and motion are a few named measures (DESIGN.md §11). The system's own alerts are left as they are.

Things move where moving says something, briefly, and never what you type into: a tile placed grows in where it lands as the edges of the others slide aside for it, one closed shrinks away where it was as their edges slide into its room, one moved (⌥⇧⌘ and an arrow, or dragged and dropped) goes over the rest, its bar and all, from where it was to where it's put as theirs slide out of its way, one gone to has its focus ring swell and glow a moment; one too short for its content crosses over to its summary card, and back; Maximize slides the tile's edges out from its place over the rest, Restore back in — what any tile shows held still as its edges pass, never stretched; with ⌃⇥ the tile becomes its card, shrinking as it goes, and the rest of its stack slide out from under it, each a whole card, down to their places; the one chosen becomes its tile again as the rest slide back up under it (a quick ⌃⇥, let go at once, just swaps); Overview turns each tile into its card where the card is, as Mission Control sends windows, those in stacks pulled out of their sheets, and back; a toast rises from the window's foot (and shakes when it's said again to what didn't take); a block just finished has its glyph land and settle; hover cards fade in; segments slide their band; Machine's meters ease between readings. With Reduce motion on (System Settings ▸ Accessibility ▸ Display) nothing travels or grows: it fades, or is there at once.

The window sits on a wash of soft colour — a few pools of pastel light, deep tints in the dark — placed afresh each day, with what's behind the window blurred beneath it, and lit by the hour: the sun's height where your time zone's city is gives its light's colour temperature, so the wash is a touch warmer while the sun is low, morning and evening, a touch cooler when it's high, and a dim cool blue at night, looked at again every five minutes and eased into over a few seconds.

Contrast correction

Text in a program's own colors that can't be read on its background (a dark terminal's greens on light paper) is moved in lightness until it can, its hue kept — for deuteranopia too, by default (Settings ▸ Appearance ▸ Contrast). (How: DESIGN.md §11.)

Settings (⌘,) holds every setting, a pane each: Appearance (light or dark, the theme, the accent color, the fonts, the editor's text, contrast), Terminals (copy on select, ending idle shells), History, Remoting and Language Servers. The accent color — Theme (the theme's own), System (the macOS one), Blue, Orange (Overcast's), Purple, Pink, Green or Graphite — colors the app's own marks: the focus ring, what's chosen or toggled, the selection bands, progress, the caret and selected text in editors and terminals, and one of the backdrop's pools of light. Each is set for light and for dark (in the light, deep enough to read as a thin line on white). Colors that say something keep their own: links, find matches, status, diffs, a terminal's palette. Every color is a theme's — the chrome, the texts, the tints, the colors that say something, a terminal's palette in light and dark (all 256 colors: the sixteen, the 6×6×6 cube, the greys), the preview's page, and the backdrop under the tiles (Paper's pastel wash, Newsprint's off-whites, Classic's pale blue into cream, the Financial Times' pink into its paper) — so a theme recolors all of it at once. Settings ▸ Appearance ▸ Theme shows each as a small Manifold window in its own colors — a sidebar with a block chosen and their states, a file being edited (its line numbers, the caret's line lit, changes marked) and a terminal, focused, running tests in its palette, a word selected: Paper, Manifold's look, and Newsprint, ink on a faintly warm grey paper with muted inks (a brick red, sage, ochre, slate blue, plum, teal), and by night the same paper unlit; and Classic, apex's: acme's cream paper with its tags a pale blue and a yellow selection, in go.dev's colors (its ink, Go blue), by night go.dev's own dark, and as apex has it for a colour-blind reader, blue for what's added or passed and orange for what's removed or failed; and Financial Times, github.com/mariusae/financial-times-theme's: the FT's paper and ink, wheat selections, teal links, its terminal palette, and by night its inverse on slate. A theme has its own accent (Paper's blue, Newsprint's red, Classic's Go blue, the FT's teal), which the Theme accent follows — a terminal's caret and selection then the theme's (Newsprint's red caret on a grey selection); any other accent is set over the theme's everywhere, terminals too, in the theme's own shade of it. Newsprint's 256 colors are made from its own: its cube's corners are its paper, its six colors and its ink, the steps between taken evenly to the eye, so a program's colors sit in the theme.

Host and app

Everything lives in manifoldd, a server (one per host) the app starts when it isn't running and that outlives it. Every block is a shard with its own append-only log, kept in ~/Library/Application Support/Manifold/ logs with snapshots beside, plus a registry of the host's blocks (kind, title, last seen, held or dormant), their links, and its spaces (which there are, in order). The app mirrors the host's shards and leads the ones it edits — spaces, text, web pages — appending entries locally first, so nothing waits on a round trip; the host leads terminals and folders and does the file system work (reading, writing, watching) on proposal. Both apply the same entries with the same code, so they agree. State from before blocks (state.json) is migrated into logs on first run.

• End All Sessions and Quit (in the app menu or the sidebar's ⋯ menu) stops the server; everything is kept, and terminals start fresh shells next time. Manifold ▸ Restart Server… restarts it (offered when the app finds a server from another version). A remote host's server from another version is restarted on its own: the app has installed its own there already, so it stops the old one and comes back through a bridge that starts the new; its shells start again, each in its directory, under their recent output.
• Remoting (Settings ▸ Remoting) is a table of providers: a name and a command that runs a command line on a destination with stdio connected, %h the destination and %c the command (appended when there is no %c), such as my_special_script.sh %h; ssh is built in. Attach to a host (Manifold ▸ Attach to Host…) with a provider and a destination it understands, or type provider:target. A provider not in the table is still looked for on your PATH as manifold-remote-<provider>.
• Remote hosts (Manifold ▸ Attach to Host…) work as apex's do: a destination ssh understands, or provider:name for a manifold-remote-<provider> command on the PATH that takes a destination and a command to run there. Manifold asks the host what it is, installs the bundled manifoldd for it in ~/.manifold/bin if the one there differs (stripped, gzipped on the way when the host has gunzip, into a file of that upload's own and put in place only if it hashes as what was sent; given up on only once nothing has moved for a minute, its progress in the host's tooltip), and runs manifoldd bridge, which pumps the same frames between the pipe and the host's own server (started if need be). Blocks are host/ulid, so a remote terminal, file or folder is placed, linked and found like a local one; its terminals attach through the same provider. Their shells are told they're in Ghostty (TERM=xterm-ghostty), as here, and find out what that is from Ghostty's terminfo, which the server carries and writes into its own folder (TERMINFO): nothing is installed into the host's terminfo, or yours.
• A host's environment (mani env, or the host's inspector ▸ Environment, edited in place — a name, a value, its scope from the menu at the right, Remove there too; Add Variable… or Add Environment Variable… in the host's menu for a new one): variables its server sets in what it starts, kept on the host whichever Mac it's reached from, each for everything, for its shells (terminals, notebooks, panels' commands) or for its tools (what the server runs itself: the code indexer and the packages npx fetches for it, language servers, git, Sapling). A proxy only the indexer needs: mani env set --for tools HTTPS_PROXY=http://proxy:3128. mani env set NAME takes the value from the shell it's typed in; mani env unset takes one away; mani env lists them (--show for what secrets hide). New shells and tools get them; a shell already running takes them by eval "$(mani env export)" (mani env export | source in fish).
• The ssh agent: a host's shells and tools are given SSH_AUTH_SOCK as a link (~/.manifold/agent.sock) to the newest agent forwarded to it that answers — one forwarded to Manifold's own connection (when ssh forwards it), to an ssh login of yours (sshd's /tmp/ssh-*/agent.*), or one named by mani env agent <socket>. When the connection whose agent it is ends, the link goes to the next, under shells already running: no more refreshing a stale socket. The host's inspector and mani env say where it points and how many keys it holds. A host with an agent of its own that its server wasn't started over a connection with (a Mac's, from launchd) keeps it. A space lives on a host too, among that host's spaces, which every Mac attached to the host sees: New Space (⌘T) makes it on the focused block's host, a host's row in the Spaces sidebar has New Space on host in its menu. What a Mac shows and settles on is its own. Two Macs on one host take turns at what they edit — a space, a note, a page: the one that last focused it holds it (focused on that Mac — the other Mac's focus following along takes nothing), and the other is told, in a toast naming the Mac that took it, that what it does there won't take, with Take Over. From then on it's watching: it doesn't take anything back by being clicked in, only by Take Over (in the toast, or the host's menu; its row wears an eye, and its card says who took it), which takes everything of that host's back, however long, and through the link going and coming back. Terminals take typing from both. With more than one host, the sidebar's rows are under each one's heading; scrolled past its heading, the host's stays at the top of the list, its rows fading out under it, until the next host's pushes it up — so which host you're looking at always shows (clicked, its own row scrolled back to; the pointer on it, its card, as on its row: its machine, its link, live). A host names itself: a session id minted once, which every block made there carries, so a block means the same thing from every Mac; what you see is its label. Hosts are remembered in hosts.json by session, with their destination and label, and attached again at start. A host stands in the sidebar from the moment it's attached to (a new one under its name until it says its session; gone again, with why, if it can't be reached the first time) and a remembered one from the start: a spinner and "connecting…" while it's being reached, a slashed ring and "unreachable" (dimmed) when it can't be — tried again after two seconds, then four, eight, up to two minutes between tries (the tooltip says when the next is; Try Again Now in the row's menu hurries it), and once connected, pinged every fifteen seconds so a bridge that hangs is noticed and made again. When the Mac wakes, or its network comes back or changes (another Wi-Fi, a VPN), every host is tried at once and every connected one asked straight away whether it's still there — given up on and made again in five seconds if not — so remote terminals come back as the lid opens. What waits on a host says so, a moment in (a quick answer shows nothing): a folder being listed, a file being read (in its editor or preview), a repository's status, the processes, a search match's file, a terminal being reached each show a spinner and "Reading…" (or "Connecting…") where their contents will be — on another host, once much has come, a bar going and how much ("Reading from devbox — 12 MB"); a diff, "Comparing…" so; a page loading, a line along its top as far as it's got; a subfolder opened in a listing, "Reading…" at its foot; a folder that's empty, hidden-files-only, missing or unreadable says which, rather than showing nothing. A click that waits for a host to make something (a command's output, a turn, a version, a notebook, a port forwarded) says what it's getting from where, and if the host doesn't answer in half a minute, that too. Detach from host… (in the row's menu) forgets it here, even while it's still being reached: it isn't attached again at start, and its server, shells and blocks stay there for attaching again. Reset Server on host… (the same menu) installs the server there again whatever is there, stops the one running and starts the new one: its shells end and its terminals start fresh ones, its blocks and spaces stay. Reset Graph on host… forgets every link between the host's blocks — opened from, found by, mentions, compared, made by hand — and its trail, leaving the graph empty (what's on each space stays; mentions come back as texts change) — only from the host's own row in the sidebar, and only once you've said so: it can't be undone. Delete Session on host… (the same row's menu) deletes the host's session for good — its spaces and blocks, notes (kept nowhere else), terminals' history, indexes, logs: every file Manifold keeps there, and on another host the server installed there — once you've said so, with what goes counted (This Mac's, its name typed too). Another host's is forgotten here; This Mac's, and Manifold starts afresh, as on its first launch, other hosts still attached. Links and tiles of it on other hosts are taken off, each as it's next reached. Files of your own stay. On the host itself, manifoldd erase does the same (asking first, unless --yes), for one no Mac reaches. Reset Server is in every menu of something on a host, under the host's name: a tile's, a terminal's or an editor's right-click, a space's or a block's row in the sidebar. A bridge that keeps dying before the host answers is taken as a server gone missing there, and the host is bootstrapped again. While a host is unreachable its blocks stay as last seen: each tile's bar wears the slashed ring, an editor there takes no edits, and nothing new reaches it until it's back. Click a host's row in Files (or Spaces) and its home folder opens as a listing on that host; a folder row with no listing yet opens one when clicked (the disclosure, or a double-click, unfolds it); a host with nothing of it yet shows just its ~. A tile whose block is on a host you aren't attached to at all is a placeholder that says so, with Attach. Two Manifolds may attach to one host and share it: each block a client can edit (a note, a file, a web page, a space) has one owner at a time, whichever focused it last; the other mirrors until it focuses the block again. Linux servers (x86_64 and aarch64, static) are bundled with the app (Building, below).
• $EDITOR in Manifold's shells is mani-edit, beside mani, which runs mani open --wait (on a remote host, manifoldd mani open --wait) — one program, as fish takes a variable as one word — and $VISUAL with it — set again once your rc files have run, in fish, zsh and bash, so one that sets EDITOR for other terminals doesn't take it (set MANIFOLD_KEEP_EDITOR in your environment to keep yours): git commit and friends edit in an editor over the terminal that ran them, the terminal stashed behind it, and return when the editor is taken off (⌘W) and the terminal comes back — ⇧⌘S (File ▸ Save and Close, in any editor) saves and then closes, once the file is written, so the command reads what you wrote. A file already a block when $EDITOR opens it is the same block, in a second tile over the terminal, unsaved edits and all. The block it edited in is ephemeral: once the command returns it is discarded, unless the file was a block already or the editor was moved somewhere else, so a commit message or an agent's prompt leaves nothing behind in the graph.
• git diff | mani diff shows a patch as a diff block, beside the terminal it ran in (--title "before lunch" names it; else it is "Patch, n files"). Double-click a line to open the file there, against the directory the command ran in. On a remote host the same, through its mani script.
• The mani command is Manifold from a shell, for you and for the agents in its terminals: mani <command> [flags] [args]. One table of its commands makes its parser, mani help and each command's --help, so what it says it does is what it does.

  • Names. A block is named by its id (as mani ls prints it), a path, a title, or a position: @here (the terminal it runs in), @focused, @selection (the last text selected anywhere but @here — an editor's, a terminal's, a PDF's, a page's — so "the code I highlighted" is mani read @selection, and mani info @selection says where: block, path, lines, page), @last (what mani last made), @space; @left, @right, @above, @below (the nearest tile that way from @here), @leftmost, @rightmost, @top, @bottom, @under (stacked under @here), @1…@9 (columns left to right, each top down). A kind narrows any of them: @right:diff, @:pdf (the one PDF shown). A name that could be more than one is an error that lists them, ids and all.

  • Looking. mani ls lists the space's tiles (--all, every space, and the blocks pinned in each); --json gives the whole layout — columns of tiles, each with its block, kind, title, path, frame (x, y, width, height as shares of the window), the tiles sharing each of its edges, the names it answers to, the tiles stacked under it, and its summary (title, place, lines, note — what a summary card shows; mani ls prints the lines under each tile). mani info describes a block (its summary, commands, links, outline); mani read prints what it holds as text — a note's or file's text as it is now, saved or not, a terminal's screen (--all, its transcript; --command -1, its last command's output), a page's or PDF's text (--pages), a diff, a listing, search results, a notebook — with --lines a-b. mani context says it all at once: the layout, the selection, the terminals' last commands and how they ended, unsaved files. Any command takes a block's reference as its name — manifold:host/id, or a note's [name](manifold:…) link — and a place in it after #: mani read manifold:…#command=7 reads that command's output, mani show manifold:…#line=12 goes to the line; mani info and mani ls --json give each block's ref and link, to hand back. A reference printed in a terminal is ⌘-clicked as a link is. The skill (mani skill install) teaches agents all of it.

  • Doing. mani open (files, folders, addresses), mani new note | terminal | agent | web | search | git | smartlog (a note's text from its input: … | mani new note --preview renders it, as an agent's note always is unless --edit; --run a terminal's command, typed in once it starts, or an agent's first prompt), mani show, mani close, mani write (a note's or file's text; --append, --save), mani rename, mani pin/unpin, mani link; what they show goes below @here unless told --above, --right, --left, --column or --over, by --at another tile, --size its share of its column (of the width, in a column of its own).

  • Spaces, by script. mani new space --title app --cwd ~/src/app makes a space with a terminal there, shows it and prints its id (@last is the terminal); --space — by name or id — has ls, open, new, show or run act in another space without showing it, and MANI_SPACE says it for every command after, so a script makes a space and fills it:

    export MANI_SPACE=$(mani new space --title app --cwd ~/src/app)
    mani new agent --right --size 0.6 --run "read the README and wait"
    mani new git --at @leftmost --below
    mani new terminal --at @leftmost --below --size 0.3 --run "make test"
    mani open ~/src/app/README.md --at @leftmost --over
    ``` `mani close` given a space (its name or id, or `@space`) removes
    it, as ⇧⌘W does: to Recently Closed, what only it kept collected
    after the half hour. `mani run <terminal> <command>`
    types a command into a terminal's shell (through its host, shown or
    not); `--wait` waits for it to end, prints its output and exits with
    its status (`--timeout`: 124 if it doesn't). A terminal with no shell
    running — dormant, or not shown since its host's server started —
    has one started for it, as showing it would: in its directory, at
    its last size (else 80×24), the command typed once it prompts; the
    tile, shown later, takes up that shell.

  • Annotations, for tools. mani annotate <name> key=value … keeps keys and values on a block or a space (key= takes one away; with none, it prints them) — a task's id, a role — that stay whatever its title becomes, and a name finds it by any of them anywhere a name goes: mani read task=T-123, mani ls --space space=review, 'key=*' for any value; the one in the space shown first, more than one an error naming them. ls prints them under a tile, info and ls --json have them, and the inspector (⌥⌘I) shows them.

  • Panels. mani ui new < widgets.json makes a panel: widgets an agent describes as JSON — labels and Markdown, buttons, fields, text, checkboxes, selects, sliders, progress, tables and lists, images, rows and groups, and an html widget (a page, with mani.emit(name, value)) for the rest — drawn with the system's controls, below @here unless placed elsewhere. mani ui set panel progress=0.4 status=Building sets values (go.label="Deploy now" a widget's property; widgets on the input replace them), mani ui get prints them, and mani ui wait waits for the next thing done in it — a click, a change — and prints it as JSON with all the values; what's done while nothing waits is kept for the next wait. A widget with "run": "…" runs that command on the panel's host when used (the panel as @here, the event in MANI_EVENT), so a button can answer in the panel itself. Values are kept in the block, and come back with it.

  • Watching. mani watch prints a JSON line for each thing that happens — focus, selection, a command started or ended (with its status), a block's status, a tile shown or taken off, a file saved, another space, something done in a panel — until it's interrupted (--only some).

  • For agents. mani skill show prints a guide to all this for coding agents: how to look before asking when the user says "this", "on my right" or "what I highlighted", what users say and what to run, the commands. mani skill install gives it to them along with the hooks: Claude Code as a skill (~/.claude/skills/manifold, loaded when it's in a Manifold terminal and the user means what's on screen), Codex as a few lines in ~/.codex/AGENTS.md that point to it (the rest of the file kept). Claude Code gets /block too (~/.claude/skills/block): typed, the agent shows its last response — or what's named after it, /block the plan — in a note beside its terminal, rendered as Markdown; it runs only when typed, and a block skill of your own is left as it is. A newer Manifold's guide (and /block) replaces the old as it starts.

  • mani diff, mani skill, mani agent (what agents' hooks run) and mani help are done by mani itself; the rest are passed to the app through the host, so they work alike from a remote host's terminals. It's strict: an unknown command or flag, a flag missing its value, too many or too few arguments are errors, with the command's usage, status 2 (a path given bare says to mani open it); failing to do what was asked is status 1. Manifold ▸ Install Command Line Tool… links it into /usr/local/bin (taking away the manifold link of before). On a remote host a mani script beside the server runs manifoldd mani.

• mani is first on the PATH in Manifold's shells, once your rc files have run: the app's Helpers folder here, the server's folder on a remote host (with a mani script standing in). zsh gets it through a .zshenv layer of Manifold's own that hands over to Ghostty's integration and then yours; fish through a command run after its configuration; bash through an rc file of Manifold's that sources the profile files and .bashrc. The same hooks tell Manifold each command the shell runs, for the terminal's dots and outline; and the shell says where it is (OSC 7, as zsh and fish do through Ghostty's integration and bash through Manifold's rc), so a terminal's folder follows a cd at once — a shell that doesn't say is asked through its process every couple of seconds. A shell on another machine, through ssh in the terminal, names that host and is left alone. Manifold starts the shell a host's preferences name (Preferences for host… in its row's menu: a name on its PATH or a path, kept on the host, so every Mac attached shares it, and refused if the host can't run it); else MANIFOLD_SHELL in the server's environment; else your login shell. Shells already running keep theirs.
• A memory watchdog samples the app if it grows past 6 GB and ends it (the server keeps everything) before it could take the machine down (DESIGN.md §11).
• Retention is tunable, in Settings ▸ History: how many days of text changes to keep (older ones are folded into a base state beside the log, once an hour; history and scrubbing start from the base), how long to keep the transcripts of dormant terminals, and how many undo steps an editor holds. Settings ▸ Terminals sets when off-screen shells go dormant.
• manifoldd state prints what the host has; manifoldd stop ends it.
• Protocol: length-prefixed binary frames over a Unix socket (Protocol.swift); the same Codable entries as the logs, raw bytes for terminal I/O.
• Secure Keyboard Entry keeps what you type from other apps (as Terminal's does): on by hand in the Manifold menu, and on by itself while the focused terminal's program reads a password — sudo, ssh, any prompt that turns the terminal's echo off — on this Mac or another host (its server says so), a lock at the terminal's lower right while it lasts. Only while Manifold is in front.
• When Manifold crashes, it leaves word: the system's crash report (in ~/Library/Logs/DiagnosticReports — Ghostty's own reporter, which quit quietly, no longer takes the crash first), and a report of its own in ~/Library/Logs/Manifold — the signal and a backtrace, written from a stack of its own, so a stack overflow is caught too — beside Manifold.log, the app's error output when it isn't started from a terminal (Swift's "Fatal error" says what went wrong). The next launch says a report was kept. If Manifold dies within half a minute of starting twice in a row, it asks to start safely: a new, empty space shown instead of the last one, and other hosts left until you attach them — everything else as it was.

Building

scripts/build-ghostty.sh    # once: fetches Zig and Ghostty into vendor/, builds Frameworks/
scripts/fetch-tree-sitter.sh  # once: tree-sitter and its grammars into vendor/tree-sitter
scripts/build-app.sh run    # builds build/Manifold.app and opens it
swift test

The web page, in docs/ (for GitHub Pages, served from main's docs folder), is drawn as Manifold is — tiles in columns, the one rule for links, stacks, the shrink ladder, Open Quickly — from one static index.html whose blocks are templates; docs/help/teardown.py draws its figure, light and dark (python3 docs/help/teardown.py).

Tree-sitter (the editor's parser, §7.1 of DESIGN.md) is built from source: scripts/fetch-tree-sitter.sh fetches its runtime and each grammar's generated C — pinned releases from crates.io and GitHub, checked against their SHA-256 — into vendor/tree-sitter, which Package.swift builds as CTreeSitter and CTreeSitterGrammars; scripts/build-app.sh runs it, and it fetches again when its list changes. A grammar is a line in that list and one in SyntaxLanguage.swift, which takes the files it parses from its language in Languages.swift.

The Linux servers come from scripts/build-linux.sh, which scripts/build-app.sh runs: they are built with a swift.org toolchain through swiftly (SWIFT_LINUX, 6.4.1 by default — installed, with its Static Linux SDK, if missing), since the SDK goes with the toolchain of its own version and not with Xcode's; LINUX=0 skips them.

The icon is the app's tiles. On macOS 26 and later it's an Icon Composer icon (Resources/Icons/Manifold.icon: each tile a layer, over a light background with a dark one for dark mode, and greys for the tinted style), which the system draws light, dark, clear or tinted as System Settings ▸ Appearance ▸ Icon & widget style says; Xcode's actool compiles it into the bundle. macOS 15, or a build without Xcode, has AppIcon.icns, drawn from Resources/Icons/manifold-tiles.svg. Icon Composer opens the .icon to adjust it by eye. The app is marked as built with the SDK it was built with (SwiftPM marks it 15.0, its deployment target): an app marked older keeps its plain icon in the Dock, and AppKit's controls their pre-26 look. MACOS_MIN=26.0 builds one that says it needs macOS 26 (its default, 15.0). Each build's version is when it was built, and a bundle built anywhere but this checkout's build/Manifold.app (APP's, a worktree's) has an identifier of its own, so macOS never takes an old or throwaway copy for the app.

MANIFOLD_DIR runs everything against another directory, for a second, throwaway instance (MANIFOLD_NO_WARP leaves the pointer alone, for one driven by a script); with MANIFOLD_DEBUG set too, the app listens on $MANIFOLD_DIR/app-debug.sock for scripted commands (see DebugControl.swift). MANIFOLD_NO_NOTIFY keeps such an instance from posting notifications (it shares the app's identity, and so its permission), and MANIFOLD_NO_OCCLUSION has its terminals and status glyphs drawn and turning when its window is behind others. Its busy start / busy stop time every turn of the main thread in between — the hitches a person would feel — and picker bench, layouts and spinners look at Open Quickly's ranking, the grid's layouts and the backdrop's drawings, and the turning glyphs.

Ghostty is pinned to v1.3.1 with a small patch: Metal shaders compile at runtime (no Metal toolchain needed), archives are merged in a way Apple's current libtool accepts, a surface can run a command directly (without login(1)), a surface can have its bytes carried by the app (a "manual" I/O backend: no pty, no process — output fed in, typing and sizes handed out), which is how terminals reach their hosts, and the contrast correction above. Zig 0.15 can't read the stubs of the newest macOS SDKs, so the build uses a cloned copy of the SDK whose stubs also name arm64.

Nothing needs to be set up by hand, and nothing in vendor/ needs to be cleared: scripts/build-ghostty.sh and scripts/build-manifold-vt.sh both start with scripts/ghostty-env.sh, which checks every time that Zig is there (checked against its SHA-256), that vendor/ghostty is the pinned release with the current patch (if the patch changed, the tree is reset and it's applied again; edits of its own are saved to vendor/ghostty-local-<time>.patch first), that the SDK copy covers every stub. Downloads Zig makes during a build are retried, and named if they keep failing. The host's terminal library is built with -Dmanifold-vt-only, which sets up nothing of Ghostty's app, so it fetches two small packages (uucode, zlib), not the GTK, Wayland and font libraries Ghostty's Linux app wants.