This web page created from the user-guide.md file with MarkSchrift v.0.9.7 (800)
MarkSchrift is the plain-text workspace for iPhone, iPad, and Mac. Write your meeting notes, your class handout, your next chapter, and watch the Markdown style itself in place as you type: no separate preview pane, no proprietary file format, no lock-in. Plan your week and track your projects in the same plain text. Every document you create is an ordinary .md file you own outright and can open anywhere, forever.
This guide is for the people who actually use MarkSchrift day to day: writers, students, note-takers, planners, and anyone who wants the polish of a rich editor with the durability and openness of plain text. It explains not just how to use each feature, but why you’d reach for it: when it earns its place in your workflow and what everyday problem it solves.
Untitled note opens: there’s no mode to enter and no Save step; it autosaves as you go.# Shopping list and watch the # disappear into a real heading the moment your cursor leaves the line.**bold**, start a line with - for a bullet, or type - [ ] for a checkbox. Or select text and press ⌘B, ⌘I, or tap the Aa bar on iPhone/iPad.That’s the whole loop: launch, type, and your formatted note is already saved as portable plain text.
MarkSchrift styles and renders your Markdown live, in place, as you type, so what you edit IS the finished-looking document, and the file on disk stays plain, portable .md text.
Why use it. Most Markdown apps split your screen: you type symbols on the left, and a separate preview pane shows the result on the right. You’re always glancing back and forth, and the “real” document is something you only see in the preview. MarkSchrift removes that split entirely. You write in one place and the styling happens right under your cursor: # Heading becomes a heading, **bold** turns bold, a - becomes a real bullet, Note Name becomes a link, all without a second pane.
The trick that makes this work without ever hiding your text: the line your cursor is on shows its raw Markdown (so you can edit the actual symbols), while every other line renders clean. Move off a line and it “sets”; click back onto it and the markup reappears for editing. You’re never editing a hidden format: you’re always editing the true source, just beautifully presented.
This matters because of what it protects:
.md files. Open them in any text editor, on any platform, forever. There is no proprietary file format hiding underneath: the styling is something MarkSchrift paints on; it isn’t baked into the file.Who benefits: anyone who wants the polish of a rich editor but the durability and openness of a plain text file: writers, students, note-takers, anyone who has been burned by a document trapped in a format they can no longer open.
How
# on a heading, the ** around bold, the -/*/+ of a bullet, the == of a highlight). Move the caret away (by clicking elsewhere or arrowing to another line) and that line re-renders. This is automatic; nothing to toggle.\ shows a faint ↵ marker, except inside a fenced code block, where a trailing \ is left literal.)--- … ---, the “document properties”) is collapsed by default into a single orange ▸ chevron at the top. Click it to expand the raw block (it becomes editable, dimmed ---…--- text with a ▾ chevron to re-collapse). The block stays in the file on disk for portability; it’s just tucked away on screen.Example
Type this literally into a new document:
# Grocery List
Milk and eggs
Bread
- [ ] Call the plumber
- [x] Water the plants
A note with **bold** and ==g:green highlight==.
What you see: “Grocery List” is a large heading (its # hidden). “Milk and eggs” and “Bread” sit on two separate lines even though there’s no blank line between them. The two - [ ] lines show real, tappable checkboxes (the second one ticked). In the last line, the word bold is bold with its ** hidden, and “green highlight” is highlighted in green with the ==g: and == hidden.
Now click into the heading line: it shows the literal # Grocery List again so you can edit the text and the #. Click into the last line and you’ll see the raw **bold** and ==g:green highlight==. Click away and both snap back to styled. Save and open the file in any other editor and you’ll find exactly the plain Markdown you typed: nothing hidden, nothing proprietary. Export to PDF and each of those lines is its own line on the page, just as on screen.
MarkSchrift renders Markdown live as you type, so emphasis, headings, links, and more take shape right in the editor without a separate preview pane.
Why use it. Good formatting is what turns a wall of text into something scannable: a heading you can jump to, a bolded warning you can’t miss, a quote set apart from your own words. Because MarkSchrift writes plain Markdown, you get all of that with a couple of keystrokes and never have to lift your hands off the keyboard or hunt through a ribbon of buttons. That speed matters when you’re drafting notes in a meeting, marking up a passage, or shaping a long document on the go. And because it’s just Markdown underneath, your formatting stays portable: it reads the same in any other Markdown app and exports cleanly. If you prefer tapping over typing, every format is also one tap away in the Aa bar (great on iPhone/iPad) or the Format menu (on Mac).
How. You can apply any format three ways: type the Markdown directly, use a keyboard shortcut, or pick it from a menu/bar. With no text selected, a shortcut wraps the whole word your cursor is inside (or, at a word’s edge, drops empty markers for you to type into). Applying the same format again toggles it off.
Inline emphasis (shortcut · syntax):
**bold***italic*++underline++~~strike~~`code```` and an optional language (```js, ```python, …). The code is syntax-highlighted by that language (keywords, strings, numbers, comments) in the editor, and the same colors carry into your PDF, HTML, and Word exports. Dark mode uses a brighter palette so code stays readable.x^2^H~2~O==text==[label](url)Colored highlights: add a one-letter color prefix right after the opening ==: ==g:green==, ==b:blue==, ==m:magenta==. Plain ==text== is yellow. If you re-highlight an already-highlighted span in a different color, MarkSchrift swaps the color instead of piling on more markers; the same color removes it.
Links: ⌘K is smart about what you’ve got: select some text and it becomes [text](url) with the url placeholder selected so you can paste or type the address; select a bare URL and it becomes [](url) with the cursor in the empty label; with a URL on your clipboard it fills both in for you.
Images: type  and the image renders inline; the alt text shows as a placeholder while it loads (or if it can’t be loaded).
Headings: ⌘1 through ⌘6 set Heading 1–6 (# to ######); ⌘0 clears a heading back to body text. Changing levels replaces the marker (it never stacks hashes), and re-applying the same level toggles it off. (Note: #tag with no space is left alone; only # with a space is a heading.)
Blocks:
> quoted- item1. item- [ ] to-do*** on a new line (this form always renders as a divider, even without a blank line above)Footnotes: type a reference like text[^1] and define it on its own line as [^1]: your note. The reference renders as a footnote marker, and on export the notes collect at the bottom.
Where to find these without the keyboard:
Example. Type this:
# Trip notes
We left **early** and the road was *gorgeous*.
> "Not all those who wander are lost." [^1]
- [ ] Book the ferry
- [x] Pack the ==g:reusable== bags
Water is H~2~O; the area is 12 km^2^.
[^1]: J.R.R. Tolkien.
***
What you see: a big “Trip notes” heading; “early” in bold and “gorgeous” in italic; an indented italic quote with a small footnote marker after it; a checklist with one item ticked off and “reusable” highlighted in green; “2” sitting low in H₂O and “2” raised in km²; and a horizontal divider line at the end. The footnote text gathers at the bottom when you export.
Build structured outlines from ordinary Markdown lists, and render them as plain numbers, a legal outline (I / A / 1 / a / i), a decimal outline (1, 1.1, 1.1.1), or an alphanumeric outline (1 / A / (1) / a / i / (a)), without ever locking your file to one app.
Why use it. When you’re drafting a plan, a spec, a contract, a set of bylaws, or a meeting agenda, the structure IS the document: who reports to what, which clause sits under which section, what happens in what order. MarkSchrift lets you write the outline once as a normal nested list and then choose how it looks: switch the whole document to legal numbering for a board resolution, decimal for a requirements spec, or leave it as plain 1‑2‑3 for a quick checklist, all from one setting, with no re-typing. The numbers stay correct on their own: insert, delete, or reorder items and the ordinals re-flow instantly, so you never hand-renumber a fifteen-item list again. Move a whole branch (a heading and everything beneath it) up or down with two keys. And because the file on disk is always standard CommonMark (nested 1. lists), your outline opens correctly in GitHub, Obsidian, or any plain-text editor, and carries its legal/decimal look into PDF, Word, and HTML exports with proper hanging indents. It’s the structure of a word processor’s outline mode with the portability of plain text.
How
Make a list (or toggle it off by repeating):
⌘⇧7, or Format ▸ Numbered List, or the format-bar list.number button.
⌘⇧8, or Format ▸ Bullet List, or the list.bullet button.
⌘⇧T, or Format ▸ Task List, or the checklist button.
You can also just type - or 1. and keep going; Return continues the list, and Return on an empty item ends it.
Nest and re-shape (works on the item the caret is in):
Tab / ⇧Tab: indent/outdent just the current line.⌥Tab / ⌥⇧Tab (or ⌘] / ⌘[): indent/outdent the item and all its children together.⌥⌘↑ / ⌥⌘↓: move the item with its children up/down among its siblings.⌘Return: add a new sibling below the whole subtree, at the current level. (Plain Return at the end of an item that has children continues the list one level deeper, inside the children; ⌘Return is the direct “next item at THIS level” key.)On iPhone and iPad these all live on the format bar: the indent/outdent arrows and the up/down “move item” arrows act on the whole subtree when the caret is on a list item, so you don’t need a hardware keyboard. On Mac the same actions are in the Format menu (Indent, Outdent, Move Item Up, Move Item Down, New Sibling Below). These menu items carry no key equivalent, because the editor owns those keystrokes directly. The keyboard shortcuts above work on Mac and on iPad with a hardware keyboard.
Choose the numbering look (whole document): Settings ▸ Display ▸ Numbered list style →
1. → A. → (1) → a. → i. → (a) by depth, cycling deeper. Like Legal, but it leads with a number and uses parentheses for the repeated number/letter levels.This is a display + export style only: your .md stays standard nested 1. lists. Want one document to differ from your global default? Add a manifest (File ▸ Add Manifest) and set outline: legal, outline: decimal, or outline: alphanumeric in its front matter.
Numbers that stay right: the first number of a top-level list is authoritative: type 1. to start fresh, or 6. to continue an outline across an intervening paragraph. Everything after follows automatically, and reordering, deleting, or moving items renumbers in the same step (one ⌘Z undoes the edit and its renumbering together). Nested levels always count from 1, so reordering children self-heals. A heading starts a fresh outline beneath it, and that new list begins at whatever number you write as its first item: type 1. to restart at 1 (legal I), or any other number to pick the count up there (so an outline can even carry across a heading on purpose). The first number is always yours; the rest follow from it, in the editor and in your PDF/Word/HTML exports. A blank line on its own does not begin a fresh outline (the list keeps counting across it); a heading or a line of text is what starts a new one.
Headings can join the outline: number a heading by hand (## 1. Work) and it renders in your chosen style at heading size (legal shows A. Work; decimal shows the 1.1. path), while the Markdown stays plain ## 1. Work. Lists beneath a numbered heading continue at the next-deeper level, so # 1. → ## 1. → a 1. list reads I. → A. → 1. as one hierarchy, in the editor and in print. A heading you don’t number is a plain grouping, left out of the numbering; that’s how you keep some headings off the outline. And like lists, you don’t count the headings either: type 1. on each one you want numbered and MarkSchrift fills in the running number (two # 1. sections read I. then II.), restarting the deeper levels under each new section, so inserting, deleting, or moving a section renumbers the rest on its own.
Paste a structured outline from anywhere: copy it (tabs or any indent width, even Word’s • bullets and 1) ordinals), then Insert / Paste ▸ Paste as Outline (⌃⇧⌘V). With the caret on a list item the pasted items land after that item’s subtree, re-leveled to continue at its level; numbering merges automatically.
Example
Type this with the style set to Legal outline:
## 1. Project Plan
1. Discovery
1. Stakeholder interviews
2. Audit current system
2. Build
1. Backend
2. Frontend
3. Launch
(Notice every item is typed 1.; you don’t count.) With Legal numbering it renders:
A. Project Plan ← the numbered ## heading joins the outline
1. Discovery
a. Stakeholder interviews
b. Audit current system
2. Build
a. Backend
b. Frontend
3. Launch
Now switch Settings ▸ Display ▸ Numbered list style to Decimal and the same untouched file reads 1.1. Discovery → 1.1.1. / 1.1.2., 1.2. Build, 1.3. Launch. Put the caret on the Build item and press ⌥⌘↑ to move Build (with both its children) above Discovery; the numbers re-flow on their own. The file you saved is still plain 1. Markdown the whole time.
Once a note grows past a screen, “where was that section about X?” becomes the slow part. MarkSchrift builds three ways to move around (and to show a reader the shape of the whole) straight from the headings you already wrote.
Why use it. Scrolling a long document to find a section is tedious, and a finished file handed to someone else has no map. An outline that’s always a tap away, and a table of contents the document carries with it, turn a wall of text into something you navigate.
How
⌥⌘O. It lists every heading, indented by level, and updates live as you write. Tap a heading to jump straight to it; the panel highlights the section you’re in as you scroll, folds subtrees away with the chevrons, and has a filter box to find a heading by keyword. On iPhone it slides up as a sheet; on iPad and Mac it sits beside your text.[toc] on its own line and MarkSchrift turns it into a live, clickable contents list right in the document: tap an entry to jump there. It rebuilds itself whenever your headings change, so it never goes stale, and it exports as a real linked table of contents in PDF, HTML, and Word.⌥⌘↑ / ⌥⌘↓ moves that heading and everything beneath it as a unit (you can also drag a heading in the Outline panel to reorder). Numbered headings re-flow in the same step.hfont: to its manifest to set each level’s size: hfont: H1=2, H2=1, H3..H6=0 makes H1 a little larger, H2 slightly larger, and H3–H6 the same size as body text. Each number is “steps over body size” (0 = body), so headings can sit naturally in the prose while still driving the outline, and the sizes carry into PDF/Word/HTML export.Example
Drop this near the top of a long note:
[toc]
MarkSchrift renders a boxed, clickable contents list of every heading below it, kept up to date as you edit. Export the document to PDF and that same structure becomes a navigable bookmark sidebar: open it in any PDF reader and click through the document by section instead of scrolling.
A table is a grid you build and edit right inside your note: fill in cells as if it were a tiny spreadsheet, and it stays plain Markdown underneath.
Why use it. Reach for a table whenever your information has columns and rows: a packing list with quantities, a sermon-prep grid (passage / theme / application), a comparison of options, a schedule, a simple budget. You get structured, aligned data inline with your writing: no switching to Numbers or Excel, no screenshots pasted in. Because it’s just Markdown pipes under the hood, it travels with your note everywhere, exports cleanly, and stays editable forever. The payoff over typing pipes by hand: you never count | characters or line up dashes; you click a cell and type, and MarkSchrift keeps the source perfectly formatted for you. Anyone who jots structured notes (planners, students, anyone tracking a few facts side by side) benefits.
How
Insert a table
;;tbl. It fires the instant you finish typing it.::TABLE::.::TABLE:CxR:: where C is columns and R is total rows (the first row is the header). For example ::TABLE:4x4:: makes 4 columns and 4 rows; ::TABLE:5x2:: makes 5 columns and 2 rows. Type the closing ::; that’s what locks in the size before the table drops in. All triggers are case-insensitive (::table:4x4:: works too). Sizes are clamped to sane limits (up to 12 columns, up to 50 rows).The table always starts on its own line, so a line break is added before it automatically if your cursor’s line already had text.
Edit cells in place
Format inside a cell
Type normal inline Markdown and it renders when you leave the cell: **bold**, *italic*, ~~strikethrough~~, `code`, ++underline++, ^super^, ~sub~, links [text](url), wiki-links Note or label, and highlights ==text== (with color prefixes ==g:green==, ==b:blue==, ==m:magenta==).
Reshape and align
Below the table is a control bar:
Saving. Edits commit automatically when you leave a cell (click away, press Enter, Tab, or arrow out) and are written straight into the note, so they’re saved with the document: nothing is lost on close and reopen.
Example
Type this trigger and you get a 3-column, 3-row table (one header row plus two body rows):
::TABLE:3x3::
Click cells and fill it in; the source MarkSchrift maintains looks like this:
| Passage | Theme | Application |
| ----------- | ------------ | --------------- |
| **John 1** | The Word | Behold him |
| ==g:Ps 23== | The Shepherd | Rest in him |
(MarkSchrift normalizes the spacing for you: every column is padded to the width of its widest cell, so you never line anything up by hand.)
On screen you see a clean grid: a shaded header row, John 1 in bold, The Word and The Shepherd as plain text, “Ps 23” highlighted green, and “Rest” styled as a wiki-link. Tap ↔ while a Theme cell is focused to center that whole column.
Write mathematical notation in plain LaTeX between dollar signs and watch it render as a real equation, right in the editor: $E = mc^2$ inline, or a centered display block for the bigger expressions.
Why use it. If your writing touches numbers (a physics problem set, an economics note, a statistics write-up, lecture notes, a recipe with a ratio), a typed-out “x squared over 2” never reads as cleanly as the actual symbol. MarkSchrift renders LaTeX math the way the rest of the app renders Markdown: live, in place, with no preview pane. The equations show typeset on screen as you write, and the file on disk stays plain $…$ text you can open anywhere. It’s done with KaTeX and the math fonts are bundled, so it works fully offline: no network, no account. And because the same renderer drives your shared reader links and your PDF and HTML exports, an equation looks identical wherever the document goes.
How
Inline math: wrap a short expression in single dollar signs: $E = mc^2$ sits right in the run of your sentence, sized to the text around it.
Display (block) math: wrap a larger expression in double dollar signs for a centered block on its own line. You can put the $$ on their own lines around the content, or write a one-liner $$ x $$:
$$
\int_0^1 x^2 \, dx = \frac{1}{3}
$$
The cursor reveals the source, just like everywhere else. Off the cursor’s line, math shows as the rendered equation; put the caret on the line and the raw LaTeX $…$ reappears so you can edit it. To edit a display block, tap it (or arrow into it) and its source opens for editing; move away and it re-renders.
Dollar signs in prose still just mean money. MarkSchrift follows the same delimiter rules as Pandoc: a lone $ isn’t math, so $5 and $10 stay literal text; you rarely need to escape a dollar sign. (A $$ block renders even when there’s no blank line above it.)
A broken equation won’t break the page. If an expression has a LaTeX error, MarkSchrift shows its source in red where the equation would be, and keeps going; it never crashes or hides your work.
Where it renders. The same everywhere: in the editor, in a shared read-only / web reader link, and in your PDF and HTML exports. Word (.docx) export is the one exception: it keeps the raw $…$ source in place (a deliberate degrade). If you need native Word equations, run the exported .md through Pandoc, which converts $…$ into Word’s own equation format.
Example
Type this:
The energy–mass relation is $E = mc^2$.
$$
\int_0^1 x^2 \, dx = \frac{1}{3}
$$
Lunch was only $8, so $5 in change.
What you see: “the energy–mass relation is” with a typeset E = mc² sitting inline, then a centered integral on its own line, then a normal sentence where $8 and $5 stay plain text (a lone $ is money, not math). Click into the display block and its raw \int_0^1 … LaTeX appears for editing; click away and it re-renders. Export to PDF or HTML and both equations come through typeset.
Drop a picture into your note (paste it, drag it in, or pick it from a file) and MarkSchrift keeps it with the note and shows it inline.
Why use it. A photo of a whiteboard, a screenshot, a diagram, a chart from another app: sometimes a picture says it faster than a paragraph. MarkSchrift copies each image into an attachments folder right beside your note, so the note and its pictures stay together: move the note (with its folder) and the images come along; export it and they’re baked in. It’s still plain Markdown underneath (), so the note opens correctly in any other Markdown app too.
How
Add a picture
While an image is being copied in you’ll briefly see a Saving… placeholder; it becomes the picture the moment the copy finishes. If you keep typing or move the cursor meanwhile, the picture still lands where you put it.
Size a picture
Add a hint to the caption (the text inside the ![ ]):
: 400 pixels wide.: half the width of the text column.(A too-small pixel size is ignored, so a stray |5 can’t shrink a picture to nothing.)
Where the files live. Images are stored in an attachments folder next to the note’s .md file. A pasted image gets a timestamped name; a dragged or picked image keeps its own name (a second copy of the same name gets " 2", " 3", …).
Export. Pictures are embedded directly into your PDF and Word exports, so each file stands alone: no broken image links. An HTML export with pictures instead saves as a folder named for the document: the .html plus the images beside it (renamed Document-1.jpg, Document-2.png, …), which keeps the page small, editable, and web-ready. (An HTML export with no pictures is a single self-contained .html file.) iPhone HEIC photos and TIFF images are converted to a standard format for the export so they appear in Word and in every browser; the original file on disk is left as it is.
Point a note at a file that lives outside your notes (a PDF in iCloud Drive, a document in another folder) without copying it in.
Why use it. You may keep documents in their own filing system (an iCloud Drive folder, a Johnny-Decimal layout) that you don’t want to pull into your notes. A file link lets a note reach that material without importing or duplicating it: the note stays tidy, the file stays where it belongs, and one tap brings it up.
How
Good to know
Center a title, right-align a date or signature, or center a whole passage, without leaving plain Markdown.
Why use it. Standard Markdown has no way to center or right-align text, but real documents often want it: a centered title or epigraph, a right-aligned date or sign-off, a centered pull quote. MarkSchrift adds it as a simple block you drive from a menu (no HTML to hand-write), and it renders centered both in the editor and in your PDF/Word/HTML exports.
How
What it writes. The block is wrapped in a fence:
::: center
A Centered Title
:::
In the editor the fence lines show as a faint centered / right-aligned tag marking the block; put the cursor on one to reveal and edit the raw ::: line. Everything inside stays normal Markdown (headings, bold, links) so it all still renders, just centered.
Export. The alignment carries into PDF, Word, and HTML.
Portability note. ::: fenced alignment is a MarkSchrift (and Pandoc) convention, not part of standard Markdown. Open the file in another Markdown app and the text simply shows left-aligned with the ::: lines visible; nothing is lost, it just isn’t centered there.
A live scoring grid you drop right into a note to keep score for any game: players are columns, rounds are rows, and totals tally themselves with a crown on whoever’s ahead.
Why use it. It’s game night and someone’s hunting for a scrap of paper. Instead, open a note in MarkSchrift and type a few characters: you get a real scoreboard that adds itself up, crowns the leader, and never loses your running total. Reach for it any time you need to track points over rounds: board games, card games, darts, trivia, a backyard tournament, even tracking reps or chore points. It solves three everyday annoyances: arithmetic mistakes (totals recompute the instant you enter a score), the “who’s winning?” question (a crown ♔ sits on the leader automatically), and losing the sheet (the scorepad is just text saved inside your Markdown note, so it’s there next time and exports cleanly). And because it lives in the document, it shines in a shared collab session: everyone keeps score together: each player can update their own column, or one person can run the whole pad.
How
Insert one. On its own blank line, type ::SCOREPAD:: or the shorthand ;;pad (both are case-insensitive). It instantly expands into a starter grid: two players, one round. This works the same on iPhone, iPad, and Mac.
Or start from a game. Type a game trigger and you get a pad already set up for that game plus a foldable How to play rules card beneath it. The built-in set: ;;crib (Cribbage), ;;gin (Gin Rummy), ;;rum500 (Rummy 500), ;;yahtzee, ;;ttr (Ticket to Ride), ;;catan, ;;starrealms (Star Realms), ;;handfoot (Hand and Foot), ;;spades, ;;hearts, and ;;bridge. Each also has an UPPERCASE ::NAME:: form. The rules card is an ordinary collapsible section: keep it for the table, or delete it once everyone knows the game.
Enter a score. Tap (or click) a cell and type. Four things you can enter:
12 sets the cell to 12.3+4 is worked out to 7 (it also handles -, *, /, and parentheses, e.g. (2+3)*4).+ adds to what’s there: +5 bumps the cell up by 5.- sets a negative value: -30 makes the cell −30 (for games where you can drop below zero). On a phone keypad with no minus key, type the number and tap the ± button to flip its sign.An empty cell counts as 0; an entry that doesn’t make sense leaves the cell unchanged. Results are rounded to whole numbers.
The buttons under the grid. Two stepper pills, − Players + and − Rounds +, grow or trim the grid (a pad always keeps at least one of each). The blue −1 / −5 / +1 / +5 keys nudge whichever cell you last tapped, so you can score without opening the keyboard. ⇄ Flip swaps the layout between players-across-the-top and players-down-the-side. 🎯 sets or clears a win target (type the number; clear it to remove). ⧉ Duplicate drops a fresh, zeroed copy of the pad (same players, same setup) above the current one, so the next game is one tap away with no retyping. The copy’s title is stamped with the current date and time (e.g. Catan, Friday 20260622 1905) so you can tell successive games apart; duplicating again replaces that stamp rather than stacking another on.
Name players and rounds. Tap a player’s name in the header and type to rename. Tap a round’s label (R1, R2…) to name that round or category, handy for Yahtzee (“Ones, Twos, Full House…”), Ticket to Ride’s end-game lines, or anything where the rows mean something. (Colons and line breaks aren’t allowed in names; they’re turned into spaces.)
Who’s winning. A crown ♔ rides on whoever’s ahead, updated live. Set a 🎯 target and, the moment someone reaches it (or you fill in the last round), the winner’s column lights up bright green with a 🏁 above their name. Low-scoring games like Hearts work the other way: the lowest total wins, so the crown and flag follow the lowest score (the game templates set this up for you).
Move around with the keyboard (great on iPad/Mac): Tab moves to the next player across a round (and wraps to the next round); Shift-Tab goes back; Return or ↓ drops to the same player’s next round; ↑ goes up a round; → / ← hop between players when the cursor is at the end/start of a cell.
Lots of players? Columns scroll sideways when there are more than fit your screen; the round-label column stays pinned on the left so you keep your place.
Title the game (optional). The pad is plain text (see the example) so you can add a # Title line as the first line inside the block to name the game; it shows above the grid and in exports.
Snippets work here too. Your QuickKeys and the ;;dd / ;;dt date stamps expand inside the title, player names, and round labels, useful when you’d rather fill a pad in by hand.
Exports. When you export or print the note, the pad renders as a clean table in the same layout you see on screen: a column per player (the leader crowned and bolded), a row per round, and a Total row at the bottom. Opened in another Markdown app, it simply shows as a fenced code block; your scores stay readable and nothing breaks.
Example
Type this on a blank line:
;;pad
It expands to a two-player, one-round grid. Add a couple of players and a round, rename everyone, and your note now contains literal text like:
Hand & Foot, Friday
| Us | ♔ Them | |
|---|---|---|
| R1 | 805 | 910 |
| R2 | -310 | 2490 |
| R3 | 3450 | -280 |
| R4 | 1200 | 3250 |
| Total | 5145 | 6370 |
In the editor you see a grid: Us, and Them as the columns, R1, R2, R3 and R4 as the rows of Rounds, and a Total row reading 5145 and 6370, with the crown ♔ on Them (the leader at 6370). Tap Us’s R2 cell and type +1300: the R2 becomes 990, his total jumps to 6445 live, and the crown hops to Us. Export the note and the same grid prints as a tidy table with Us’s column bolded and crowned.
A lightweight, plain-text to-do and planning system that lives right inside your notes: TaskPaper-style checkboxes, a small vocabulary of @ planning tags, and an Agenda panel that pulls everything due across the document into one place.
Why use it. You already keep your thinking in MarkSchrift notes; this lets your action items live there too, instead of in a separate app you have to keep in sync. Jot - [ ] call the printer @due(Fri) in the middle of a meeting note and it’s a real, checkable task with a deadline: no context-switch, no copying. Because it’s all plain Markdown, your tasks travel with the document, render cleanly anywhere, and never lock you into a proprietary format. The payoff shows up when a note grows long: instead of scrolling to find what’s actually on fire, you open the Agenda and see Refine, Past Due, Due Today, Check-ins, Discussion, and Up Next, each task labeled with the heading it lives under, one tap away. It’s for anyone who plans inside prose: sermon prep, project notes, research logs, weekly reviews, wherever the to-dos and the thinking belong together.
How
Make a task. Type - [ ] and your text. As a shortcut, type - [] (no inner space) and the moment you close the bracket (with the cursor right after it at the end of the line) MarkSchrift auto-expands it to - [ ] so you can keep typing. The marker renders as a single styled, tappable [ ] checkbox (the leading - bullet is absorbed into it, so you see one box, not a dash plus brackets). You can also turn the current line into a task with Format ▸ Task List (⌘⇧T).
Check it off. Click or tap the checkbox. The marker flips to [x] and MarkSchrift stamps the completion date inline as @done(date) at the end of the line, using your date format, at that moment (not whenever you later tidy up). Unchecking removes the stamp.
Plan it with tags. Add any of these to an open task line:
@due(date): a deadline. The tag turns red once the date is near or past (see the setting below).@til(date): defer it. The line dims and stays out of the Agenda’s Up Next until the date arrives.@chk(date): a follow-up reminder; surfaces under Check-ins once its date arrives.@to(name): present to / discuss with a person: your action toward them (shown with a →). Goes in the Agenda’s Discussion group.@del(name): delegated / waiting on a person: their action, you’re waiting (shown with a ←). Also in Discussion.@sch: committed to do (no day yet). Surfaces at the top of the Agenda in Refine, where you decide when to do it.@p1 @p2 @p3: priority, 1 highest; shows a colored badge and sorts the Agenda.The two person tags capture direction of information: in a meeting you can see which tasks you owe someone (@to, →) versus which you’re waiting on (@del, ←). A task with no @to/@del is solo work; a task with none of @sch/@to/@del/dates just sits in Up Next.
A task’s notes travel with it. Lines indented under a task belong to that task: meeting details, links, whatever context you keep beneath the checkbox. Tags on those note lines bind to the task above: put +project or @due(Fri) on an indented note and the task itself picks it up (the task’s own line wins if both name the same tag). A nested - [ ] task is its own task: it keeps its own tags and claims the notes indented under it. In the Agenda, a task carrying notes shows a small ≡ mark after its text. Indentation can be spaces or tabs; a tab counts as one level.
Relative dates. Inside @due(…), @til(…), or @chk(…) you can type a relative token and MarkSchrift pins it to a concrete date the instant you close the paren: Mon (the coming Monday, strictly after today), 2Mon (the second Monday out), 2MonDec (the second Monday in December; rolls to next year once it’s passed), Today, Tomorrow, NW (next week, +7 days), NM (next month, same day clamped to month end), +3d, +2w. Pinning matters: a relative token left in the file would re-resolve every day, so a due date written that way would never actually arrive. (Relative tokens are pinned only inside @due/@til/@chk, not the person tags.) The ;;dd date-insert trigger also works inside the parentheses.
Open the Agenda. Press ⌥⌘A (Option-Command-A) on Mac or iPad, or use the ••• menu ▸ Agenda… (also on the toolbar). It opens grouped Refine · Past Due · Due Today · Check-ins · Discussion · Up Next · Completed, each task shown under its source note and heading. (Refine = your @sch commitments; Discussion = your @to/@del people tasks, waiting-on first.) A This Note / Folder / Binder switch at the top sets the scope: just the open note, one folder, or every open task across your whole vault (Binder is the default, so the Agenda is one place to see everything you’re carrying). Tap any row to jump to that task (across the whole Binder it opens the note the task lives in). The Agenda never edits your text, and it stays current on its own: leave it open while you work and it re-gathers a moment after each edit settles, so a task you just tagged shows up (and a box you just checked moves to Completed) without closing or reopening anything.
Scope to a folder. Tap Folder and a picker pops up: “Whole Binder” plus every folder, indented by depth. Pick one (say, Work or Home) and the Agenda narrows to that folder’s whole subtree (its files and any nested subfolders), so you can plan within a project area and ignore the rest. A small 📁 chip under the switch shows which folder you’re in: tap it to switch folders, or the ✕ to widen back to the whole Binder.
Narrow it down three ways: the search box filters by any text in the task, its note, or its project origin; the chip bar adds priority (P1/P2/P3), person (@name), and #tag chips (additive within a facet: P1+P2 = either; AND across facets: P1 + a person = that person’s P1s); Scheduled / Unscheduled splits tasks by whether they’ve been pulled into a week (see The task flow below; Unscheduled is your triage inbox); and Hide later check-ins drops check-ins whose date falls beyond this week. Search and chips reset each time you reopen the panel.
On Mac and iPad the Agenda opens as a dedicated tab, pinned at the far left of the tab strip, so it gets the full width of your window (the sidebar and Outline work beside it like any tab). ⌥⌘A opens or jumps to it; pressed again on the Agenda tab it hops back to the tab you came from; ⌘W closes it. Want the Agenda beside a note, or on another monitor? Right-click the Agenda tab and choose Open in New Window. Press ⌘P on the Agenda tab to print the view exactly as filtered. On iPhone it’s a sheet you can drag up to full height.
Three housekeeping sweeps (Mac shortcuts; also under the Tasks menu and the ••• menu):
## Completed section (created at the end if missing), newest on top, the checkbox dropped, and each labeled with its owner breadcrumb (headings first, then parent items) like ▸ Sermon prep ▸ Liturgy. A swept item that had no @done gets one stamped.## Completed section to the top of ## Archive (created at the end if missing), leaving the Completed heading in place but empty, so Completed always reads as “done since the last archive.”@chk points to (the earlier of @chk and @due), undated tasks into a ## Unscheduled block at the top, and anything dated beyond the week into a ## Later block at the bottom; completed tasks stay on their day, children travel with their parent, and each group is ordered by priority then nearest date. On a note without day sections it falls back to reordering each level in place (@due then @p) with relative dates pinned to concrete ones.Each sweep is one transaction, so a single Undo (⌘Z) reverses the whole thing. Tasks inside ## Completed / ## Archive are ignored by the Agenda and by further sweeps.
The due-soon setting. Settings ▸ Tasks ▸ “Due dates turn red” controls how far ahead an open @due(date) shows as urgent: On the day, 3, 7 (default), 10, or 14 days ahead. Past-due dates are always red regardless.
Platform notes. The keyboard shortcuts above are the macOS menu shortcuts. On iPhone and iPad, reach the same actions through the ••• menu and the Agenda toolbar button; tapping checkboxes, typing tags, and relative-date pinning all work the same. List/format keyboard shortcuts (like ⌘⇧T) work with a hardware keyboard on iPad and Mac while the editor has focus.
Example
Start a fresh task by typing - [] and closing the bracket (it expands to a real checkbox), then type the rest of each line:
# Sermon prep
- [ ] Read commentary on Romans 8 @due(Mon) @p1
- [ ] Email worship team the song list @to(Dana) @chk(Tomorrow)
- [ ] Order new bulletins @til(NW)
- [x] Pick the closing hymn
What you get: @due(Mon) becomes the coming Monday’s date and the tag glows red as it nears (Monday is always inside the default 7-day window), @chk(Tomorrow) and @til(NW) pin to concrete dates (the “Order bulletins” line dims until next week), and the checked hymn line gains @done(…) with today’s date. Press ⌥⌘A and the Agenda shows “Read commentary…” under Up Next with a red P1 badge, and the worship-team task under Discussion (→ Dana; you’re presenting the list to them); its @chk is tomorrow, so it stays out of Check-ins until that date arrives. Both tasks are labeled “Sermon prep.” Run ⌃⇧D and the finished hymn task moves under a new ## Completed heading.
Once you keep tasks in more than one note, the question becomes “where does this live, and what’s happened to it?” MarkSchrift answers that by giving every task one home and a clear path through your week. Three places, one job each:
Why use it. Plans drift the moment your tasks are scattered across a dozen project notes: you forget what you pulled into this week, you finish something in your journal but the project still says it’s open, or you copy a task forward and now there are two. This flow keeps one source of truth (the project) while still letting you plan a focused week (the journal), and it leaves a visible trail at every step so you always know what’s checked out and what’s done.
Scheduling checks a task out. In the Agenda, right-click (Mac) or long-press (iPad) a task and choose Schedule to…, then pick a day from the next two weeks. MarkSchrift then does two things:
@moved(w27), so the project still shows the task exists, just checked out to week 27.So a scheduled task lives in two places with a clear relationship: the project holds the checked-out marker, the week holds the working copy. In the Agenda a scheduled row shows ↩ <project>, so you can see at a glance where it came from, and the Scheduled / Unscheduled chips split “already planned into a week” from “still needs a home.”
You can also schedule from the project side. Type an inline marker right on a task line: --w27th (week 27, Thursday) or --w27 (week 27, its first day), then run Tasks ▸ Schedule Marked Tasks. MarkSchrift checks out every marked task across your notes the same way and removes the markers. The weekday codes are su mo tu we th fr sa. This is handy when you’re planning straight from a project note instead of the Agenda.
Finishing flows home. Work the copy in your week note and check it off. Run Sweep Completed (⌃⇧D) and MarkSchrift not only files the week copy under ## Completed; it also finds the project breadcrumb and resolves it to @done, so the project note shows the work as finished, not as a dangling “moved” line. The record closes where the task was born.
Changed your mind? Right-click a scheduled task and choose Return to Project: MarkSchrift removes the week copy and reopens the project task, unscheduled, as if you’d never pulled it.
Commit and Defer from the same menu. The task menu also lets you triage without leaving the Agenda:
@sch on the line.)@til(date) so the task drops out of the active view until then: pick Next week, In 2 weeks, or Next month. Deferring a task that’s already scheduled to a week first returns it to its project, then defers it there, so it comes back as a plain project task with the @til date on it.Completed shows recent wins. When you check off a task ([x]) it moves to a Completed group at the bottom of the Agenda (most recently finished first), so you can see what you’ve closed today before you sweep it away. (A checked task carries its @done date if it has one.) Running Sweep Completed (⌃⇧D) files these under the note’s ## Completed heading and they leave the Agenda.
Recurring tasks. Add a repeat rule to any task; when you file it away with Sweep Completed, or when the Weekly Review processes it as completed, the next occurrence is created automatically in the right week (and only once, even if both run):
--r7d: every 7 days.--r1wth: weekly, on Thursday.--r1m2tu: monthly, on the second Tuesday.The rule sets the next @chk/@due the same way you would by hand, so a recurring check-in keeps coming back on schedule.
Open this week’s note any time with This Week (the calendar button, ⌥⌘J, or the menu); MarkSchrift creates the week note on demand if it doesn’t exist yet. And when a week gets messy, Reflow Week (⌥⌘W) re-files every task under the right day (the earlier of @chk and @due), pushing undated tasks to ## Unscheduled at the top and beyond-this-week tasks to ## Later at the bottom; completed items stay on their day, and children travel with their parent.
The shape of it, end to end:
Project note Agenda (Vault) Week note (journal)
- [ ] Draft budget → Schedule to Thu → ## Thu, Jul 2
@moved(w27) ↩ Project Plan - [ ] Draft budget
↑ ↓ (check off + ⌃⇧D)
resolved to @done ←———————————————————————— done flows home
A project ties together the tasks that belong to one body of work, wherever they’re written: a task in Tuesday’s journal and a task in a design note can both surface under markschrift in the Agenda. Projects are orthogonal to folders (a project can span folders), and a task can belong to more than one.
Two ways to assign one:
The whole note. Give the note a leading manifest and every task in it belongs to the project, zero per-task typing:
---
project: markschrift
---
Several at once: project: [markschrift, web].
One task. Tag the line inline with +markschrift; it renders as a green pill. An inline tag overrides the note’s manifest for that task, so a journal task can point at whatever project it really belongs to. Nest with / (+markschrift/ios), and use letters/digits plus -, _, . in names.
In the Agenda. Tasks with a project show it at the front of their breadcrumb (markschrift ▸ Design notes ▸ Sync). The lens picker under the search box (Status · Project · Person · Week) includes a Project lens: it groups the list one section per project; the usual status order (past due first, completed last) applies inside each section, a task in two projects appears under both, and tasks with no project gather at the bottom. (With no projects anywhere, the Project lens simply shows the Status view.) Green +project chips in the filter bar narrow any view to one project or several.
The other two lenses: Person groups the list by who each task involves: the people you’re waiting on (@del, ←) first, then those you’ll present to (@to, →), with unassigned work last; a task naming two people appears under both. Week lays the list out on the calendar instead: Past Due · This Week · Next Week · Later · No Date (a task places by its @due, or its @chk if that’s all it has). And once you’ve dialed in a view you like (chips, lens, schedule split), save it from the bookmark menu in the toolbar as a named filter set; recalling it later is one tap. Filter sets are saved per-vault.
One more trick: the sun button switches the Agenda to Today: a narrow, chrome-free mode showing only Past Due, Due Today, and arrived Check-ins. On Mac and iPad, put the Agenda tab in its own window (right-click it ▸ Open in New Window), size the window narrow, and Today becomes a live dashboard beside your work; on iPhone the same button strips the sheet down to the day’s triage. The mode is remembered between launches. Your filters keep applying while compact: an orange Filtered pill appears above the list whenever something is narrowing it (a chip, a search, a saved set), so a filtered view never reads as a light day; tap the pill to bring the chips back and adjust. Within the sections, Due Today ranks by priority (everything there is equally due), and Past Due keeps the full Agenda’s oldest-first order.
The project’s home page. Mark one note as the project’s home by adding projectHome: yes beneath its project: line, or simply name a note exactly like the project (markschrift.md); the explicit flag wins if both exist. Open the home note and the Binder sidebar grows a Project section listing every member note and every open +tagged task across your vault: tap a note to open it, tap a task to jump straight to its line. Nested projects roll up: the markschrift home also gathers markschrift/ios. (Since a file name can’t contain /, a nested project’s home needs the explicit flag.) The list follows your typing: add a project: line or a +tagged task and the panel updates a moment after you pause. Changes synced in from another device appear after Binder ⌄ ▸ Refresh. Beneath the open tasks, a collapsed Completed fold holds the project’s finished work: checked tasks (including ones swept under ## Completed), newest first, so the panel stays about open work until you ask for history. Above the lists, a People row shows everyone the project’s tasks name via @to/@del, busiest first: tap a person to narrow the panel to their work, tap again to widen.
The tags and manifest keys are plain text in your Markdown; they travel with your files and are ignored by other editors.
Where this is heading. Project management in MarkSchrift is still in development: what you see here is the foundation, not the finished shape. The direction is a simple, plain-text way of working we call 3R (Record, Review, Refine): record everything where it belongs (projects hold the work, your journal holds the week), review it from one place (the Agenda), and refine as you go (sweeps, scheduling, and the week note as your working surface). More of it will arrive in coming releases; everything will stay ordinary Markdown you could read in any editor.
A wiki link is a quick, name-based connection from one note to another: type Note name and MarkSchrift turns it into a tappable link to that file.
Why use it. Wiki links are how you grow a pile of separate notes into a connected personal wiki, the way you would in Obsidian or a Zettelkasten. You don’t have to remember where a note lives or type a file path: just reference it by name and MarkSchrift finds it for you, anywhere in your MarkSchrift folder. Reach for them when you want a meeting note to point at the project it belongs to, a daily journal entry to link to the people you mentioned, or a hub/index note that gathers all your reading notes in one place. Because the link is just the note’s name, you can write it before the note even exists and create it later, and you can move files around your folder without breaking the link (MarkSchrift re-finds it by name). The payoff is a web of notes you can hop through with a single click, instead of a flat folder you have to dig through.
How
Type a name between double square brackets:
Project Atlas: links to the note named “Project Atlas”.the Atlas project: links to the same note but shows the friendlier text “the Atlas project”. Everything before the | is the target (the file to find); everything after it is just what you read on screen.What you’ll see and how to follow a link:
... text so you can edit it. Move your cursor off the line (or turn on view-only reading mode) and the link renders as a styled link.Where MarkSchrift looks for the note:
Atlas is matched by name across your whole folder, including subfolders. Matching ignores capitalization, so atlas and ATLAS both find “Atlas.md”.Projects/Atlas, and you can name an explicit file type, e.g. notes.txt. MarkSchrift links .md, .markdown, .mdown, .mkd, .markdn, and .txt files. Links can never reach outside your MarkSchrift folder.Name.md in the current note’s folder) and opens it. It asks first (“Create “…” in this note’s folder?”), so a mistyped link can’t quietly leave a stray file. (A link that would point outside the folder, like ../Other, just shows a not-found notice instead.)When you export or print, wiki links can’t be clicked in a PDF or Word file, so MarkSchrift flattens them to plain text automatically: the Atlas project prints as “the Atlas project”, and Project Atlas prints as “Project Atlas”. Your typed ... syntax stays untouched in the saved Markdown file; only the exported copy is flattened.
Example
# Weekly review
Caught up with Maria Chen about the launch.
Next steps live in the Atlas plan.
On screen, once your cursor leaves those lines, “Maria Chen” and “the Atlas plan” appear as styled links. Click “Maria Chen” and (on Mac) her note opens in a new window or tab; on iPhone it slides up rendered and read-only. Click “the Atlas plan” and MarkSchrift opens Atlas.md from your Projects subfolder. Export this note to PDF and the same lines read: “Caught up with Maria Chen about the launch. Next steps live in the Atlas plan.” Clean text, no brackets.
A few conveniences for writing about the Bible: bringing Logos passages and citations in as clean, linked text, and typing accented Greek and Hebrew.
Why use it. If you write sermons, studies, or commentary you quote Scripture constantly, and you want it to read well and link back to your library. These tools drop a passage in already formatted, turn a plain citation into a tap‑through Logos link, and let you build a Greek or Hebrew word with its breathing marks and accents without hunting through the system character viewer.
How
— Romans 8:1–4 ESV) and it becomes a link that opens Logos right to that passage. Good for references you write by hand.Example
Type a reference by hand at the end of a quote:
"There is therefore now no condemnation…" — Romans 8:1 ESV
Once you finish the line, Romans 8:1 ESV turns into a link that opens Logos to the passage. Paste a longer passage straight from Logos and it arrives as a tidy paragraph with superscript verse numbers and its own citation link.
The Binder is MarkSchrift’s home: your whole writing vault in one window: every note and folder on the left, your tags and saved searches beside them, and as many open documents as you like across tabs on the right.
Why use it. Most editors make you open one file at a time and hunt through a system file browser to find anything else. The Binder turns MarkSchrift into a project workspace instead. When you’re writing a book with a folder per chapter, keeping a research vault of linked notes, or just juggling a few drafts at once, the Binder lets you browse the whole project, jump between notes, and keep several open in tabs, all without ever leaving the app. Your tags become a second way to navigate (every note marked #research is one click away), saved Views give you instant smart-folders built from the filter bar, and Backlinks show you which notes point at the one you’re reading. It’s the single place you start your day and the thing you come back to between every note.
Your vault lives in your iCloud MarkSchrift folder (it falls back to the app’s local Documents when iCloud is signed out), so the same notes, folders, and tags appear on every device. The Binder only ever reads your files to build the list; it never moves or rewrites anything behind your back.
How
The window has two parts:
Tap the Binder ⌄ menu at the top of the sidebar for the vault-level actions:
Untitled note at the top of your MarkSchrift folder and opens it. (On iPad with a hardware keyboard, and on Mac, the keyboard shortcut is ⌘N.) Naming itself: an Untitled note renames itself to its first # Heading on the first save: type # Q3 Planning and it becomes Q3 Planning.md (once; only while still “Untitled”; a note you’ve named yourself is never touched).Opening files and tabs:
Per-note actions. Long-press a note in the sidebar (or right-click on Mac) for Rename…, Move…, and Delete…. The same actions live in the open note’s ••• ▸ File menu, plus Duplicate…. On iPad with a hardware keyboard: ⇧⌘R Rename, ⇧⌘M Move, ⇧⌘S Duplicate. Move… opens a folder picker listing MarkSchrift (top level) and every subfolder; Delete… moves the note to the Trash after a confirmation. Duplicating a note makes a <name> copy beside it and opens it in a new tab.
Tags & Filters. Any note that carries a tag shows up under Tags. A tag is either inline in the body (#research) or in a YAML frontmatter block (tags: research, ideas). A #tag inside a fenced code block is ignored. If a note’s inline tags matter only inside that note (a reference doc with dozens of them), add tagsLocal: yes to its front matter and its body #tags stay with the document instead of crowding the global Tags list (its declared tags: line still shows there). Nested tags like #project/web form a tree you can drill into; the number on each tag row is how many notes carry it (counting everything at or under that tag). When the list gets long, the control row at the top of Tags sorts it A–Z or Most used and (via its menu) can collapse rarely-used tags: any tag used in a small number of notes (default ≤ 4, adjustable) tucks under a “Show N more” row so the tags you actually use stay on top. Views are saved filters: fill the filter bar with the tokens you want (see Filtering the whole Binder below), then tap the star next to the chips and name it. Tapping a saved view loads its query back into the bar. Views saved from the old Filters feature carry over automatically, including any “at least N of these tags” threshold (shown as a small ≥N on the row).
Backlinks. When a note is open, the Backlinks section lists every note that links to it with a wiki link, plus an Unlinked mentions group for notes that name it in prose without linking.
iPhone vs iPad/Mac:
Example
Say you’re researching for an article. Create a note from Binder ⌄ ▸ New Note, rename it Climate sources, and type:
---
tags: research, climate
---
# Climate sources
Key background lives in IPCC summary.
Still need numbers on #renewables and #policy.
A moment after you pause typing, the Binder’s Tags section lists research, climate, renewables, and policy; tap #renewables to see every note carrying it. Open your IPCC summary note and its Backlinks section shows Climate sources pointing at it (no Refresh needed; the sidebar follows your edits). Type #research #climate in the filter bar and star it as an “Active research” view; loading that view narrows the whole sidebar to those notes in one tap. Open all three notes at once as tabs and flip between them with ⇧⌘] while you write.
Search the text of every note in your vault from one box at the top of the Binder sidebar.
Why use it. Files and Tags get you to a note you can name or have tagged. Global search is for the rest: a phrase you wrote months ago, the note that mentions someone, every place you used a term, without remembering which file it’s in. It reads the words inside your notes, not just their names.
How
cafe finds Café.gospel grace."means of grace".gospel #sermons.gospel -draft, notes -#archive.The same box is a binder-wide filter, and you never have to type a token: the ＋ button beside the box lists every dimension as a menu of your vault’s real values (your tags, your projects, the people on your tasks, due windows, folders, and excludes); picking one files the chip for you. Or type the tokens you already write in notes, and the sidebar narrows in place instead of switching to search results. #tag matches notes carrying the tag (nested tags include their children), +project matches a project’s notes, @name matches notes with tasks involving that person, @due(today) / @due(this-week) / @due(overdue) match notes with open tasks due in that window (@sch, @open, and @done(...) work the same way), in:Folder limits to a folder (quote names with spaces: in:"Sunday School"), and plain words still match text. Space between tokens means AND; write OR between two tokens for either; a leading - excludes (-#draft, -in:Archive).
While a filter is active, each token shows as a chip under the box (tap its ✕ to remove it, next to the live match count), the Files tree prunes to matching notes with a count on each folder, and Tags narrows to the tags present in the results. Tapping any tag name files its #tag chip into the bar instead of navigating, so the sidebar itself builds the filter. The results stay live as you type in your notes. Tap the star to save the bar as a named View; saving under an existing view’s name updates it, and a view’s row menu offers Rename and Delete.
Search covers your whole vault and stays current as you edit the open note. After you add or change notes on another device, Binder ⌄ ▸ Refresh re-scans so they’re included.
Example
Looking for where you wrote about a passage: type means of grace and you get every note mentioning both words, each with the line it’s on. Narrow to your sermons with means of grace #sermons. Tap one and the note opens with the phrase selected, ready to keep writing.
A compact, MarkSchrift-built keyboard that docks at the bottom of the editor: far shorter than the system keyboard, with the formatting controls built right into the keys and a symbol on every key, reached by a quick slide.
Why use it. On an iPhone or an iPad in landscape with no hardware keyboard attached, iOS’s own keyboard swallows roughly half the screen, leaving you a thin sliver to actually write in. MarkSchrift’s keyboard is purpose-built to be short, so you get far more of the page for your words. It puts a symbol on every key (press and slide up-and-left or up-and-right to reach it), so the brackets, quotes, dashes, and the rest of the punctuation sit right under your fingers instead of behind a symbol layer. The whole formatting toolbar (bold, headings, lists, highlights, table, math, and more) runs across the top, worked with the same tap-or-slide. And it adds the things the stock keyboard makes awkward: double-tap a letter to capitalize it, hold the space bar to drag the cursor, plus Esc, a true forward-delete, Cut/Copy/Paste, and ⌃ ⌥ ⌘ for shortcuts. If you write long-form on an iPhone or an iPad you carry without a keyboard case, this is the way to do it comfortably.
How. This runs on both iPhone and iPad.
It offers itself the first time you need it. On a device with no hardware keyboard, the first time you tap into the editor a small dialog asks whether you’d rather use the System keyboard or the MarkSchrift keyboard. Your answer is saved for that device and is never asked again, and you can change it anytime in Settings ▸ On-Screen Keyboard (the choices are Ask on first use, System, or MarkSchrift). When a hardware keyboard is attached, the in-app keyboard never auto-shows; you just type on the real keys.
You can also show or hide it by hand at any time:
To open Settings on iPhone or iPad, tap ••• ▸ Settings….
Once the keyboard is up:
1 and !, w gives 2 and @, on through o (9 () and p (0 )). The home and bottom rows carry the brackets, slashes, quotes, dashes, and the rest of the punctuation in those same corners, so almost every symbol is one slide away without leaving the letters.$…$ on its up-left slide / Insert Table on its up-right slide), ― divider (paragraph / quote), ☑ lists (numbered / bullet), ⇥ indent (inline code / outdent), and a delete key: tap ⌫ to delete back, slide up-right for forward-delete ⌦ (it’s in a darker gray, set apart from the format keys). Highlight and headings press-and-hold to open a little vertical menu of their full choices (the four highlight colors; H1 / H2 / H3 / body).$, with ¢ on its up-right slide), the less-common symbols (°, ±, ×, ÷, the footnote marks § † ‡ ¶, em and en dashes), plus ÷ + − = where the cursor pad used to be; the cursor keys now live on the main keyboard’s bottom row. Tap ABC to return.The keyboard also tidies the screen while it’s up: the bottom-corner version badge steps aside, and it works inside table cells and the Scorepad too (the format buttons wrap a cell’s text for inline styles and leave block commands alone, so they won’t corrupt a table).
Dismissing it leaves a clean page. Tap the top-left Hide key and the keyboard goes away with no caret and no keyboard left behind; the page reads as a clean document. Tap back into the text to bring the MarkSchrift keyboard up again; it no longer pops the system keyboard at you. (If you attach a hardware keyboard, the in-app one stays out of the way; just type on the real keys.)
Example. You’re drafting on an iPad in landscape, no keyboard attached. Tap ••• ▸ On-Screen Keyboard. Then type, using the palette for structure:
# Trip notes
## Day 1
- Ferry at ==g:8:00 a.m.==
- **Reservation** confirmed
- [ ] Buy sunscreen
You’d get an H1 title, an H2 subhead, a bullet list, a green highlight on the time, a bold word, and an unchecked task, all built by typing text and tapping H1, H2, • , the green H swatch, B, and ☑ on the palette, with the keys staying short the whole time so the page stays readable above them.
The MarkSchrift M at the top of the window is a quick-action button, not just a badge.
Why use it. A handful of editor controls don’t need a permanent home in the toolbar. Folding them into the logo keeps the top of the window calm (one mark instead of a row of icons) while putting the one you reach for most a single tap away and the rest one press behind it.
How
The tap-action choices are the same list (the On-Screen Keyboard option is iPhone & iPad). Everything here is also reachable from the ••• menu, so the logo is a shortcut, never the only way in.
The Outline toggle lives at the right end of the tab row, beside the Aa format pill, mirroring the Binder toggle on the left edge.
Example. You proofread more than you edit, so you set the logo’s tap action to Reading Mode: one tap on the M drops the document into a clean reading view, another taps you back into editing. When you need an accented Greek letter, you press and hold the M (or right-click it on a Mac) and pick Special Characters instead.
Host a whole project on the web from its home note, and work in it — notes, wiki links, and tasks — from any browser, even a computer where nothing can be installed.
Why use it. Your projects live in plain files on your own devices. Sometimes you need one of them from a machine that isn’t yours: a locked-down work computer, a borrowed laptop, a browser-only setup. Hosted Project takes the project you already have — the home note and every member note the Project panel knows about — and serves it through MarkSchrift’s relay, end-to-end encrypted, at a single link. The server only ever stores scrambled bytes; the keys travel in the link and never touch the wire.
How. Open the project’s home note and choose ••• ▸ Collaborate ▸ Host Project on the Web… — a hosting panel opens showing whether the project is on the web right now. Press Start Hosting to put it there (nothing is shared until you do); the pill turns green connected, and the panel shows your codes and links: the editor code/link lets its holder edit everything in the project; the viewer code/link is read-only. Every code and link has both a Copy and a system Share button (Messages, Mail, AirDrop — a shared code arrives with its instructions), and Show QR Code puts either link on screen for nearby people to scan, just like a per-note session. Stop Hosting in the same panel takes it all down again. In the browser you get the member list, the full MarkSchrift editor on whichever note you pick — with a Format menu in the banner for the everyday moves (bold, headings, lists, indent and outdent, moving an item with its children), a presence strip that shows who’s in the note, and your note’s manifest honored (font, heading sizes, legal outline numbering) — an Agenda button that gathers the project’s tasks from every note — check one off in the browser and the .md file on your Mac updates moments later — and a PDF button that opens the note as a paginated document ready for the browser’s print dialog. Wiki links between member notes navigate; links to notes outside the project politely refuse — sharing a project shares its members and nothing else. Notes that join or leave the project (a project: line, a +tag) appear and disappear from the share on their own.
Who did what. Anyone holding the editor code is someone you chose to trust — and the document itself keeps the receipts. A task added, edited, or checked off from a browser gains a small @from(Name-20260707 1016) pill naming who did it and when (one per task; a later touch updates it), so you always know where something came from that wasn’t you. The name is the browser user’s display name — clicking your own pill in the presence strip changes it — and the first time someone edits a note, their name is filed on a collaborators: line in that note’s manifest (created if the note has none). It’s all plain text in your file: edit or remove any of it like anything else. Edits made on your own Mac never carry a stamp — you know what you did.
The honest fine print. Your Mac is the host: while MarkSchrift is open there, files and the web stay in step both ways; when it’s closed, the web keeps working against the relay and your files catch up next time the app runs. To spare your battery, a session eases off the network after sleep or a connection drop, and participants who go idle in a hidden tab fade from the roster after about half a minute — everything catches up the moment you touch the document (or within a minute on its own). The project stays alive as long as someone touches it (each edit buys two more weeks; an abandoned share expires on its own). Stop Hosting in the share sheet is the real off switch: it deletes the project from the web on the spot — every code and link stops working immediately, and hosting the project again later mints fresh rooms and codes. The browser keeps a local copy for instant loads and offline reading of notes you’ve opened — treat it as a convenience, not a backup; your files at home remain the real thing. And the link carries the keys: share either link only with people you’d hand the project to, and know that anything you open on an employer’s machine is visible to that machine. It is an early alpha, built first for working from a browser you can’t install anything on.
Co-edit one document live with other people in real time, end-to-end encrypted, so you all see each other’s changes as they happen.
Why use it. Reach for this when a document needs more than one set of hands at the same time: drafting meeting notes while the meeting is still happening, working through an outline with a co-author, getting live edits from an editor, or walking a small group through a shared agenda where everyone can type. It solves the “email the file back and forth” problem: no versions to reconcile, no “did you get my latest?” Because it is end-to-end encrypted (the relay only ever sees scrambled bytes, never your text), it is private enough for sensitive drafts. And the link is the invite: anyone you hand it to can join from iPhone, iPad, Mac, or even a browser, with no accounts to set up. It is an early-stage alpha, so treat it as a fast way to work together in the moment rather than a place to permanently store a document.
How
.mscollab file that opens the app and joins on the other device..mscollab file: it launches the app and joins automatically.#, which browsers and servers never transmit, so the relay routes opaque, encrypted bytes and never sees your text. Anyone with the link can read and edit, so share it over a channel you trust.Example
You’re the owner. Enable collaboration in Settings, open a note, and start a session. You type:
# Sprint planning: Thursday
## Agenda
1. Demo recap
2. Carryover from last sprint
3. New stories
## Notes
-
You tap Show QR Code; a teammate scans it with their Camera and joins. Their editor switches to your document, and as they type under Notes you watch the line fill in live:
## Notes
- Ship the export fix this sprint (owner: Dana)
- Spike the import path, needs a day
Their name shows in the capsule at the top with a colored dot; you tap it to jump to their cursor. When you’re done, you open ••• ▸ Collaborate ▸ Stop Sharing & Delete: the room is purged and the link goes dead. The finished note stays in your Binder; your teammate, who joined without “save a copy” enabled, keeps nothing locally.
Turn the document you’ve been editing into a polished, page-accurate PDF you can preview, share, and print, or hand it off as an HTML or Word file.
Why use it. Markdown is great for writing, but most people you send things to want a finished document, not raw .md. When a sermon outline, meeting agenda, or task list is ready, you want to see exactly how it’ll look on paper, fix the page breaks, and then send a clean PDF, without leaving the app or fiddling with a separate converter. That’s what this is for:
Weekly Agenda.pdf), so whatever you share carries the right name.The big payoff: what you export is what you saw on screen. Single line breaks stay line breaks (no surprise paragraph-merging), task items become real checkboxes, your outline numbering style (legal I/A/1 or decimal 1.1.1) carries through, headings print at the size you see (including any hfont: sizing), and the first line sits flush at the top margin. You write once and hand off either the .md or the finished document.
How
On iPhone and iPad, open the ••• (more) menu:
On Mac, use the File menu:
These all act on the document that’s open in front; with no document open they’re dimmed. The export uses your current font and outline-numbering preferences, and if the document has a manifest (front matter) that sets a font or outline, that wins, so the export matches the display. (The front matter itself is never printed.)
Force a page break anywhere by putting one of these on a line by itself:
\newpage and <!-- pagebreak --> work identically. (Page breaks apply to PDF and Print; they’re simply dropped in HTML and Word output, which don’t have fixed pages.)
A few niceties carry over automatically: colored highlights like ==g:approved== keep their color, wiki links print as plain text (a PDF can’t navigate them), a ```scorepad block prints as a clean totals table, and, unless you turn off the page-numbers preference, every PDF page gets a small “Page X of Y” footer. A PDF also carries a navigable bookmark sidebar of your headings, and a [toc] (plus [text](#heading) links) becomes clickable, so a reader can jump around the document rather than just scroll it.
Example
Type this in the editor:
# Elders Meeting
Agenda for Tuesday.
Please review before we start.
- [x] Approve last month's minutes
- [ ] Building fund update
- [ ] ==g:New== member welcome
# Notes
Discussion captured here.
Choose View as PDF (••• ▸ View as PDF, or ⌥⌘P on Mac). You’ll see a two-page PDF named Elders Meeting.pdf:
[x] on the approved item, blue [ ] on the rest), and “New” is highlighted green.\pagebreak pushes “Notes” onto page 2.From the preview, tap Share to send that exact PDF, or Print to send it to a printer.
A small block of “document properties” at the very top of one note that overrides your global look (font, heading sizes, numbering) for that document only. It’s ordinary YAML front matter, so it travels with the file and stays out of the way.
Why use it. Your Settings set how every document looks, but the occasional document wants to be different. A working memo reads better with small headings that sit in the prose; a handout you’ll print wants a serif body; a dense reference note has dozens of #tags you’d rather not dump into the Binder’s global tag list. A manifest lets you dial in one document without disturbing your defaults, and because it’s saved in the file itself, the document keeps its look wherever it goes, and the same look carries into its PDF, HTML, and Word exports. Reach for it when a particular document has particular needs.
How
Add the block with File ▸ Add Manifest (Mac) or ••• ▸ Add Manifest (iPhone/iPad); it drops a --- … --- block at the top, which folds away behind the orange ▸ chevron once you’re done. Set any of these keys:
font: sets the body font for this document. The easiest way: every font in Settings ▸ Editor Font shows a number, and font: 4 picks font #4 — Serif (New York). Names work too, in any capitalization, including exactly what the Settings menu shows: font: Serif (New York), font: serif, font: georgia, font: source serif, font: caveat, font: mono, and so on. Add a signed number to nudge the body size a step at a time: font: serif +1 (or font: 4 +1) is a serif body one step larger, font: -1 a step smaller, font: +.75 a partial step. A size on its own (font: +1) keeps your font and just changes the size.hfont: sets each heading level’s size, measured in steps over body text. hfont: H1=2, H2=1, H3..H6=0 makes H1 two steps up, H2 one step up, and H3–H6 the same size as body, so headings can sit naturally in the text while still driving the outline. (Ranges like H3..H6 and single levels both work.)outline: sets the ordered-list / numbered-heading style for this document: outline: legal (I, A, 1, a, i), outline: decimal (1, 1.1, 1.1.1), or outline: alphanumeric (1, A, (1), a, i, (a)). Overrides your global Numbered List Style.tagsLocal: yes keeps this note’s body #tags out of the Binder’s global Tags list (handy for a reference doc full of inline tags). Its declared tags: line still appears in the Binder.collaborators: lists who has edited this note from a browser (collaborators: [Ann, Bob]). Maintained automatically the first time each browser user edits the note — see Hosting a Project on the Web — and yours to edit or clear like any manifest line.Whatever the manifest sets for font, heading sizes, and outline carries through to the document’s exports, so what you hand off matches what you see. It also wins during live collaboration and in hosted projects — the manifest travels inside the shared text, so everyone in the session sees the document the same way.
Example
A printed handout: a serif body a touch larger, restrained headings, decimal numbering.
---
font: source serif +1
hfont: H1=2, H2=1, H3..H6=0
outline: decimal
---
# Quarterly Review
## 1. Highlights
The document now renders in Source Serif, one size up, with H1 a little larger and the rest at body size, and “## 1.” shows as a decimal outline (1.1), in the editor and in any PDF/Word/HTML you export. Your other documents are untouched.
A single Settings panel that tunes your writing environment (font, width, line numbers, folding, date format, and more) and quietly mirrors most of those choices to your other Apple devices over iCloud.
Why use it
You don’t write the same way on every device. On the Mac you might want a wide page and line numbers; on iPhone you want a clean, narrow column. But the things that make MarkSchrift yours (your serif body font, your 24‑hour clock, whether spell‑check nags you in Greek, how far ahead a due date turns red) shouldn’t have to be set up again on every machine. MarkSchrift keeps those preferences in sync through iCloud, so set them once and they follow you. Reach for Settings when you want to:
;;dd shortcuts come out the way you expect.How
Where Settings lives
iCloud syncing (automatic)
Nothing to switch on: it just works as long as you’re signed into iCloud with the same Apple ID on each device. Change a setting on the Mac and it shows up on iPad and iPhone, and vice‑versa. On a brand‑new device, whatever is already in iCloud wins so the new device matches the others. The synced settings include editor font, page width, toolbar position, Binder accent, PDF page numbers, date order, clock format, spell‑check, line numbers, auto‑link URLs/emails, highlight‑matching‑words, collapsible headings, numbered‑list style, appearance (light/dark), your QuickKeys snippets, due‑soon window, Vim, the Collaboration master switch, and the hosted‑session lifetime. One setting is deliberately device‑local: your collaboration Display name, so an iPad’s name doesn’t show up as your name on the Mac.
The controls themselves
font: manifest; see Document manifest.700 px or 80 %). Full Width fills the window, nice for real page‑width editing on a wide iPad or Mac.[text](url) link is blue and tappable, in the editor and in exports. Turn it on to have a valid URL/email become a blue, tappable link automatically (and export that way). When on, a field appears for the domain endings that count: comma‑separated, com, edu, org, gov, net to start; a bare markschrift.com or you@host.com links only if it ends in one of these, so add uk, de, jp, … as you need. (This keeps things like v1.0 or notes.md from becoming “links.”) Either way, anything you write with an explicit https:// or mailto: (including [Email me](mailto:you@example.com)) always links, regardless of the list.;;dd (date), ;;tt (time), ;;dt (date + time), or ;;td (time + date), or use ••• ▸ Insert / Paste (Date / Time / Date & Time / Time & Date).;;yourkey anywhere swaps in that text as you finish it. They expand in the editor and inside scorepad fields, and can’t override the built‑in triggers (;;dd, ;;tbl, the scorepad games). See Quick inserts & keyboard shortcuts.@due(date) shows as urgent: On the day, 3, 7 (default), 10, or 14 days ahead. Past‑due dates are always red.: commands, registers). Offered on Mac and iPad only, never iPhone. On iPad it engages only while a hardware keyboard is attached. Toggle it anytime with ⌃⇧V; turning it on pops a cheat sheet.Reading mode. Not a Settings toggle but a per‑document view: ⌥⌘R on Mac (View menu ▸ Reading Mode), or the brand logo (set its tap action to Reading Mode, or pick it from the logo’s long‑press menu) / ••• ▸ Reading Mode on iPhone/iPad. It makes the document view‑only; choose Resume Editing to go back.
Document stats & version badge. The editor’s bottom‑leading corner carries two stacked readouts: the stats pill on top and the version badge below it. The stats pill shows a word count; tap it to cycle words → characters → reading time (≈200 words/min, rounded up; “< 1 min read” for a near‑empty note). The version badge (e.g. v0.9.2 (642)) tells you which build you’re on. Tap the version badge to tuck it into a small orange diamond: this hides the stats pill at the same time, so the whole corner readout collapses together; tap the diamond to bring both back. The choice persists. (On iPad both hide while the on‑screen keyboard is up, and also while you’re in Vim mode, so they don’t sit on top of the keyboard or the Vim status line.)
Example
Say you write sermon notes in a serif font, mark deadlines, and want consistency between your Mac and iPad.
680 px; Date ▸ YYYYMMDD; Time ▸ 24‑hour; Tasks ▸ due dates turn red 7 days ahead.- [ ] Finish outline @due(Fri)
Drafted ;;dt
When the closing paren of @due(Fri) lands, it pins to a concrete date (e.g. @due(20260626)), and as Friday gets within 7 days the task turns red. ;;dt expands inline to, for example:
- [ ] Finish outline @due(20260626)
Drafted 20260620 1430
;;dt produces the same YYYYMMDD HHMM form, no re‑setup.Type a tiny trigger to drop in a dated stamp, a table, or a scorepad, and use one-handed key combos to format text without ever touching a menu.
Why use it. These are the shortcuts that keep your hands on the keyboard. When you’re taking meeting notes and want to stamp the time, you type four characters instead of reaching for a date picker. When you need a table, you type ;;tbl and start filling cells: no dialog, no dragging. And when you’re drafting prose, ⌘B / ⌘I / ⌘K bold, italicize, and link exactly the way they do in every other app, so formatting never breaks your flow. The triggers expand as you type (the moment you finish typing the trigger), and the key combos work the same on a Mac and on an iPad with a hardware keyboard, so the muscle memory carries across devices. If you live in this editor for journaling, task lists, or game night, this is the fastest path from thought to formatted text.
How
Quick-insert triggers (type them inline; they expand the instant the trigger is complete):
Dates & times: type ;; followed by two letters. These are case-sensitive lowercase:
;;dd → the date;;tt → the time;;dt → date then time;;td → time then dateThe format follows your Settings. With the default order (year-month-day) and 24-hour time, ;;dd gives 20260620 and ;;tt gives 1905. Switch to month-day-year and you get 06202026; switch off 24-hour time and ;;tt gives 0705PM (no separators in any of these; they’re compact tag-style stamps). You can also insert these from a menu (see below) if you’d rather not type the trigger.
Table: type ;;tbl (case-insensitive) for a quick 3-column × 2-row empty table, or use the ::TABLE:: family:
::TABLE:: → the same 3×2 starter::TABLE:CxR:: → a custom size, e.g. ::TABLE:4x4:: or ::TABLE:5x2:: (up to 12 columns × 50 rows; the first row is the header)The table starts on its own line automatically. Then click or tap any cell to fill it in.
Scorepad: type ;;pad or ::SCOREPAD:: (both case-insensitive) for a starter interactive scorekeeper (two players at 0), perfect for game night. Or drop a ready-made pad for a specific game (;;crib, ;;gin, ;;rum500, ;;yahtzee, ;;ttr, ;;catan, ;;starrealms, ;;handfoot, ;;spades, ;;hearts, ;;bridge), each set up with the right players, rounds, and win target, plus a foldable “How to play” card. (See the Scorepad section.)
Your own snippets (QuickKeys): beyond the built-ins above, you can define your own. In Settings ▸ QuickKeys, add a key and the text it expands to; then typing ;;yourkey anywhere swaps in that text the instant you finish typing it, perfect for a signature, an address, a heading you reuse, or boilerplate. QuickKeys expand in the editor and inside scorepad fields, and they sync across your devices. They can’t shadow the built-in triggers above (;;dd, ;;tbl, the scorepad games), so your own keys never collide with them.
Relative due-dates (bonus, in task tags): inside @due(...), @til(...), or @chk(...), you can type a relative word and it pins to a real date the moment you close the parenthesis: e.g. @due(Mon) becomes next Monday’s date, @due(Tomorrow), @due(NW) (next week), @due(NM) (next month), @due(+3d), @due(2MonDec) (2nd Monday in December).
The Command Palette (⇧⌘P). One shortcut that reaches every MarkSchrift command: press ⇧⌘P (or ••• ▸ Command Palette…) for a searchable list: type a few letters and press Return to run the top match, or tap a row. Frequent commands show a single-letter key on their row: with the palette open, Shift + that letter runs the command at once. Shift is already down from ⇧⌘P, so “⇧⌘P, A” opens the Agenda in one motion; plain lowercase typing filters the list instead.
The ⌥⌘ family. The everyday views fire directly on ⌥⌘ with the same letters the palette shows: ⌥⌘A Agenda · ⌥⌘O Outline · ⌥⌘R Reading Mode · ⌥⌘J This Week · ⌥⌘W Reflow Week. (These moved from the old ⌃⇧ chords; ⌃⇧A, ⌃⇧R, ⌃⇧W, and ⇧⌘J still work this release so your hands can catch up, but the ⌥⌘ family is the one to learn.)
Keyboard shortcuts. On Mac, Mod = ⌘. On iPad with a hardware keyboard, the formatting combos below also use ⌘ and work while you’re editing. (On a touchscreen with no hardware keyboard, reach for the format bar and menus instead.) Throughout, ⌘ = Command, ⌥ = Option, ⌃ = Control, ⇧ = Shift.
Inline text formatting (selection, or the word the cursor sits inside):
Headings & blocks (apply to the selected lines; press the same heading combo again to toggle back to body text):
*** thematic break)Editing, find & history:
macOS menu bar (the Binder’s native menus; these carry their own key equivalents):
Edit: ⇧⌘P Command Palette… · ⌘⇧F Search Binder…
File: ⌘N New Note · ⌘T New Tab · ⌘⇧0 Welcome · ⌘⇧N New Window · ⌥⌘J This Week · ⌥⌘⇧[ / ⌥⌘⇧] Previous / Next Week · ⌘O Open… · ⌘W Close Tab · ⌘⇧R Rename… · ⌘⇧M Move… · ⌘⇧S Duplicate…
File ▸ Print/Export: ⌥⌘P View as PDF · ⌘P Print… · ⌘⇧E Export as PDF…
Tasks: ⌥⌘W Reflow Week · ⌃⇧D Sweep Completed · ⌃⇧E Archive Completed
View: ⌥⌘O Outline · ⌥⌘A Agenda · ⌥⌘R Reading Mode · ⌃⇧F Format Bar · ⌃⇧G Special Characters
Window: ⌘⇧] Next Tab · ⌘⇧[ Previous Tab · ⌥⌘] Move Tab Right · ⌥⌘[ Move Tab Left
Edit ▸ Insert / Paste: ⌃⇧⌘B Paste as Scripture · ⌃⇧⌘V Paste as Outline (plus Date / Time / Date & Time / Time & Date items with no shortcut)
Help: ⌃⇧/ Keyboard Help · ⌘/ MarkSchrift Help · ⌃⇧V Toggle Vim Keybindings
Collaborate (only when you’ve turned collaboration on): ⌃⇧C Start · ⌃⇧J Join · ⌃⇧L Copy Editing Link · ⌃⇧S Save Checkpoint
Highlight colors beyond yellow live in the Format ▸ Highlight menu: Yellow, Green (==g:), Blue (==b:), Magenta (==m:).
Example
You’re starting meeting notes. Type:
## Standup ;;dt
;;tbl
The moment you finish ;;dt it becomes the date and time (e.g. ## Standup 20260620 1905), and ;;tbl jumps onto its own line and becomes an empty 3×2 table:
## Standup 20260620 1905
| | | |
| --- | --- | --- |
| | | |
Click the first cell, type a header, Tab to the next. Then select a phrase and press ⌘B to bold it, or put your cursor on a line and press ⌘⇧T to turn it into a checkable task, all without leaving the keyboard.
Every MarkSchrift document is a plain .md text file you own outright: kept in your iCloud Drive MarkSchrift folder (or any folder you choose), and openable here or in any other editor on earth.
Why use it. This is the quiet promise underneath everything else in the app: your writing is never trapped. Because each note is just UTF-8 Markdown on disk, you get real benefits day to day:
cat in Terminal; it’s all there as readable text..md in the Files app, double-click one in Finder, or AirDrop one to your iPad, and MarkSchrift opens it in place, editing the real file where it lives, not a buried copy. Great when a colleague sends you a Markdown file or you keep a project’s notes alongside its code.Reach for this whenever you care about longevity and control: long-lived notes, anything you also touch from another app, or files you want plainly backed up.
How
Where your files live. The first time you run MarkSchrift signed into iCloud, it creates a MarkSchrift folder in iCloud Drive (you’ll find a starter note, “Welcome to MarkSchrift.md”, inside). Files kept there are owned by the app, so renaming, moving, and autosave all work without permission prompts, and they sync across your devices. If you’re signed out of iCloud (or iCloud Drive is off), MarkSchrift uses the app’s local Documents folder instead.
Make a new note. Press ⌘N (New Note). MarkSchrift creates an empty Untitled.md in your MarkSchrift folder (Untitled 2.md, Untitled 3.md, and so on if the name’s taken) and opens it. Rename it whenever you like.
Open a file already on disk. Press ⌘O, or use the Open… button on the welcome screen / in the ••• overflow menu. Pick any .md (or plain-text) file; MarkSchrift opens it in place and edits the original where it sits; it is not imported or copied. If that file is already open in a window or tab, MarkSchrift just brings the existing one to the front instead of opening a second copy.
Open a .md the system hands you:
.md to the device. It opens as a document in MarkSchrift. (Note: tapping a .md inside the Files app on stock iOS may Quick-Look it; use Share → Open in MarkSchrift, or open from within the app, to edit.).md in Finder (or drag it onto the Dock icon, or right-click → Open With → MarkSchrift). To make double-click always use MarkSchrift, select any .md in Finder, press ⌘I (Get Info), choose MarkSchrift under “Open with:”, and click Change All….MarkSchrift recognizes the standard Markdown extensions (.md, .markdown, .mdown, .mkd, .markdn) plus plain .txt, since it’s all just text.
Keeping a copy / portability. Since the file is plain text, “backing up” is just copying the file: drag it out of the MarkSchrift folder in Finder, duplicate it, drop it in a git repo, or open it in any other editor. Nothing is locked to the app.
Example
Make a note and watch it appear as a real file:
Untitled.md opens.# Trip planning
- [ ] Book flights
- [ ] Reserve hotel
Notes live in plain text, so I can open this anywhere.
Untitled.md sitting there. Double-click it from Finder and it reopens in MarkSchrift; open it in TextEdit and you’ll see the exact # and - [ ] characters above. Rename the file to Trip planning.md in Finder and it still opens, and on your iPad, the same note shows up in MarkSchrift’s MarkSchrift folder a moment later via iCloud.