Mark is a WYSIWYG Markdown editor for reading and editing the files your AI agents write, while they write them.
Mac App Store
Get Mark on the Mac App Store. Installs and updates through the App Store.
Homebrew (macOS, Apple silicon)
brew tap xronocode/mark && brew install --cask markDeveloper ID signed and notarized by Apple. Updates through the in-app updater or brew upgrade --cask mark.
Windows (x64)
Download Mark_<version>_x64-setup.exe from the latest release. The installer is not code-signed yet, so SmartScreen shows "Windows protected your PC": choose More info, then Run anyway.
The App Store build and the Homebrew/download build are the same editor with a few differences. See Two editions, same editor.
- A calmer, native look. Theme families Paper, Ink, Docs and macOS; a slim title bar with the document info card; an outline beside the page; a status bar; the system font, accent colour and icons throughout (Mica on Windows); Settings in five tabs, in the theme colour.
- A home screen. Recent files and folders, the Guide, and one click to connect your agent. What's New opens after an update, and the interface language can follow the system.
- Diagrams and math in the theme. All 22 Mermaid diagram types, Vega charts and KaTeX formulas take the theme's colours; any diagram or wide table opens full screen; wide tables scroll inside the column and columns resize.
- Folders with just your notes. The tree shows Markdown files only — no empty folders — with Recent and Pinned on top. Open a folder from the clipboard with ⌥⌘V, or by dropping it on the window.
- Closer to your agent. ⌘D shows what your agent changed, against snapshots Mark takes itself before every reload (a
.beforefile or the last git commit still works as the baseline), and the agent prompt now lists everything Mark renders. - And the rest. One zoom for the whole app, code line numbers are back, and Share ships in the App Store build.
The 2.3.0 highlights — Split View, callouts, Copy as Structured Text, the 10× faster opening of large documents — are in CHANGELOG.md.
Agents write plans, specs and reports as Markdown. In a terminal the tables collapse and the diagrams are code. Mark shows the finished page and lets you edit it in place.
Watch your agent write. Keep the file open while an agent works on it. Every save on disk reloads the tab in place and keeps your scroll position, so you can follow a long pass and step in when it finishes. ⌘D shows exactly what the agent changed, against a snapshot Mark takes before every reload.
Start on your notes. The home screen lists recent files and folders, keeps the Guide at hand, and connects your agent with one click.
Write in the finished page. Headings, tables, task lists, footnotes, callouts and front matter look done while you type. When you need the raw Markdown, Split View puts it beside the page.
Diagrams and math inline. Mermaid diagrams, charts, KaTeX formulas and highlighted code render in the document — not in a preview pane — in the colours of the theme.
Open anything full screen. Any diagram or wide table opens in a clean viewer with zoom, pan and a sticky header for tables.
Copy it clean. Copy as Markdown, as HTML for email, as plain text, or as structured text that keeps paragraphs, bullets, links and tables readable wherever you paste.
Light and dark, one app. Themes come in families — Paper, Ink, Docs, macOS and more — each with a light and a dark member, one title-bar button apart.
Also: a folder sidebar that shows Markdown files only, find in file and in folder, print and PDF export, and no account, analytics or telemetry.
Measured on 2026-10-15 on one Apple silicon Mac, Mark 2.3.0. Your numbers will differ.
| Mark | |
|---|---|
| First window | ≈ 0.4 s |
| On disk | ≈ 30 MB |
| Memory, plain document | ≈ 150 MB (Mark process 33 MB plus its WebKit page renderer) |
| Memory, rich document (Mermaid, KaTeX, a table) | ≈ 310 MB |
| Same rich document in an Electron notes app | ≈ 400 MB |
| Same rich document in an Electron code editor | ≈ 1 GB |
| Opening a 4,100-line file | ≈ 3 s |
Mark uses the system WebView (WebKit on macOS, WebView2 on Windows) instead of shipping its own browser engine.
Mark ships in two editions built from the same code. The editor, rendering, theme families, live reload, Split View, copy formats, print and PDF export, Share, and the ⌘D diff against Mark's own snapshots are the same in both.
| Homebrew / direct download | Mac App Store | |
|---|---|---|
| The editor and everything not listed below | Yes | Yes |
| Share button (macOS share sheet) | Yes | Yes |
Diff view (⌘D) against Mark's snapshots or a .before file |
Yes | Yes |
| Pandoc export (DOCX, ODT, EPUB… when pandoc is installed) | Yes | No |
| Insert screenshot | Yes (macOS) | No |
| Set Mark as the default Markdown app | Yes (macOS) | No |
| Diff against the last git commit | Yes | No |
| Local live server for agents (localhost HTTP endpoint) | Yes | No |
| In-app updater | Yes | No, updates come from the App Store |
| Reviewed by Apple and sandboxed | No (notarized on macOS) | Yes |
| Windows builds | Yes | No |
Why the difference? The App Store sandbox does not let an app run other programs (git, pandoc, screencapture) or open a local server, so those features are left out of the App Store build.
Add this to your agent's instructions (CLAUDE.md, AGENTS.md, a system prompt, or whatever your agent reads):
When you produce a plan, spec, report, or any document longer than ~50 lines,
write it to a .md file and open it for the user:
open -a Mark <file>.md # macOS
The user reads and edits it in Mark, which reloads the file whenever it changes
on disk. When the file changes after you wrote it, read it again: the user left
corrections or comments inline. Treat those edits as your next instruction.Your agent writes, Mark renders, you edit, the agent reads your changes.
Example: review a plan before the agent runs it
You: "Write an implementation plan for the new auth module."
The agent writes plan.md and runs `open -a Mark plan.md`.
You read it with the tables and Mermaid diagrams rendered.
You delete step 3, rewrite step 5 and add a note: "use JWT, not sessions".
Save.
The agent reads the file again:
"Step 3 removed, step 5 now uses JWT. Proceeding with the revised plan."
Example: a knowledge base two authors keep
Add to your agent's instructions:
Maintain a knowledge base in docs/kb.md.
After each significant decision, append a dated entry.
The user may reorganise or annotate entries in Mark;
treat their edits as authoritative.
Open docs/kb.md in Mark once and leave it open.
Every time the agent appends, the tab reloads.
Command-line flags
The Mark binary accepts these flags. On macOS, open -a Mark --args --watch notes.md passes them when Mark starts.
| Flag | Effect |
|---|---|
--preview |
Open the file read-only; click to start editing |
--watch |
Reload the file whenever it changes on disk, even if live reload is off in Settings |
--diff |
Open the file in diff view |
-d, --dir <DIR> |
Open a folder as the sidebar root |
Diff view (⌘D) compares the file with Mark's own snapshot from the last reload — no set-up needed. Without a snapshot it falls back to a notes.md.before file next to the document, or to the last git commit in the Homebrew build. Want an explicit baseline? Have your agent copy the file to .before before it edits, and you see exactly what changed.
Requirements: Node.js 22, stable Rust, and on macOS the Xcode command line tools.
git clone https://github.com/xronocode/mark.git && cd mark
npm ci
npm run tauri dev # development build with hot reload
npm run tauri build # release bundle in target/release/bundleSee CONTRIBUTING.md for tests and pull requests.
Mark began as a port of MarkText and would not exist without it:
- @Jocs created MarkText: the muya WYSIWYG engine, the theme system, and the inline editing model Mark still builds on.
- @Tkaixiang maintained the community fork that kept MarkText alive with security fixes (CVE-2023-2318), crash fixes and the Mermaid v11 upgrade. Mark's early Electron phase was based on that fork.
- The MarkText community: years of issues and pull requests about what a good Markdown editor should do.
- The Tauri team, for a framework that runs on the system WebView.
Bug reports, ideas and pull requests are welcome. Start with CONTRIBUTING.md. To report a security problem, see SECURITY.md.
Documentation: mark.xronocode.com. If Mark is useful to you, you can support it on Ko-fi.
MIT. Maintained by @xronocode.