Markio

macOS 14+ · one-time $1.99 · source on GitHub · no account

Markdown, at the speed
of Preview.

Click a .md file and it's simply there — diagrams, formulas, terminal colour, already drawn. Open a dozen documents and every window stays live, reloading the moment a file changes, still at the line you were reading. A 32 MB report opens as fast as a two-line note.

Download Markio on the Mac App Store See it working

One payment, not a subscription · Never writes the file it opens · Nothing leaves your Mac, and the code that proves it is public

refactor-report.md
A refactor report open in Markio, its heading tree in the sidebar and the flowchart drawn on the page

The moment this is for

Reading one file should not turn into a project.

📄

A 4 000-line report lands

Six diagrams, three tables, a wall of detail. Finder's preview hands you the raw ## and ```mermaid fences and wishes you luck.

⏳

So you open an editor

A workspace loads, an extension host spins up, a browser engine boots — all to display a document you only wanted to read once.

🌐

Or you paste it into a site

The flowchart finally renders. Your internal spec is now on somebody else's server, and you have to remember that tomorrow.

Markio is the missing third option: a reader. It opens the file, draws it properly, and gets out of the way.

Pressing Space today

---
task: extract the ledger from the monolith
run: 2026-08-13 09:14 → 09:51
files read: 214
files changed: 18
status: needs your review
---

# Refactor report — extracting the ledger

I read 214 files and changed 18 of them. The ledger now
runs as its own service with its own storage, and the
monolith calls it instead of writing the tables directly.

## What I found

Every write went through one service, and the queue
behind it is what wakes people up at night. Four call
sites wrote to the ledger tables directly, going around
the service entirely.

```mermaid
flowchart LR
    A[Checkout] --> B[Monolith]
    B --> C[(Ledger tables)]
    B --> D[Payout worker]
```

Pressing Space with Markio installed

The same report drawn properly: the front matter as a metadata block, a real heading, and the flowchart as a diagram

The same file, the same keystroke. Only the right-hand one is something you can read.

In Finder

Space bar, and you've read it.

Markio installs a Quick Look extension, so the preview you already reach for shows the real document — diagrams and formulas included. No window to open, no app to switch to, nothing to close afterwards.

  • The same rendering as the app, inside the Finder preview
  • Light and dark follow the system
  • Drop a file on the window when you want the full reader
A real Finder Quick Look window showing the same refactor report drawn by Markio, front matter as a metadata block and the flowchart drawn as a diagram, with the Copy PNG control showing under the pointer

An actual Quick Look window — the Space bar, and nothing else was opened. The diagram is drawn right there in the preview, Copy PNG included; the "Open with Markio" button is macOS's own.

refactor-report.md
The sequence diagram from the report, drawn by the app itself

Diagrams & formulas

Drawn on your Mac. Never uploaded.

Over twenty Mermaid types — flowcharts, sequence, state, ER, C4, Gantt, mindmaps, Sankey — drawn with real paths and glyphs. Formulas between dollars get real glyphs too: Greek, stacked fractions, matrices, aligned blocks.

  • No Mermaid.js, no KaTeX, no diagram service — none of it is in the bundle
  • Hover a diagram for Copy PNG; click it to see it large
  • Works on a plane, in a locked-down office, on a machine with no network

Always live

The view keeps up with the file.

Leave the file open while another app rewrites it, and the view reloads exactly where you were reading. Paste a terminal log and it keeps its colours instead of turning into grey noise. A diff block reads as green and red bands.

  • ANSI colour: the sixteen basics, the 256 cube, true colour
  • Live reload that keeps your scroll position
  • Syntax highlighting for Swift, Python, Go, Rust, shell, SQL, JSON, YAML, C family
refactor-report.md
The error-budget formula, the test log keeping its PASS and FAIL colours, and the fix as a green and red diff
refactor-report.md — Compare
The report beside an earlier version of itself, gained text on green, lost text on red

Long documents

Find your way, and see what changed.

The table of contents is the heading tree — click to jump. Find puts every match on a strip down the right edge. And File ▸ Compare shows the document against an older version of itself: gained on a green band, lost on a red one, or side by side, scrolling together.

  • ⌥⌘S for the heading tree, ⌘F to find, ⌘+ / ⌘− for column width
  • Compare in the same window or side by side
  • Footnotes, <details> sections, YAML front matter as a metadata block

Why it feels different

No web engine. That is the whole trick.

The parser reads your file as bytes and CoreText typesets only the lines on screen. Nothing is converted to HTML on the way, so there is no browser to start and no second copy of your document living inside a renderer.

32 MB opens like a two-line note

The biggest document the benchmark throws at it — 341 868 blocks — parses in 69 ms, and the first screenful is drawn in well under a millisecond. Length stops being something you think about before double-clicking.

20 to 40 times less work

Opening an 8 MB report costs Markio 2.8 ms of processor time. Three other native Markdown viewers for the Mac, given the same file on the same machine by the same harness, spent 64, 122 and 123 ms on it, and every one of them held more memory doing it — from half as much again to thirteen times as much. Each of them hands the document to a browser engine first.

0 bytes leave your Mac

No account, no telemetry, no font fetched at runtime, no diagram sent away to be drawn. Nothing about your reading is recorded anywhere, because there is nowhere for it to go.

Release build, Apple silicon, generated documents of realistic shape — and both harnesses ship with the source. deno task bench gives you the parser numbers on your own machine; deno task viewbench is the comparison, which drives finished applications from the outside and measures each one's whole process tree, so a number about this app and a number about another came from the same procedure. Runs taken while the machine had no spare core, or with the window out of sight, are refused rather than averaged in. Point it at whatever viewer you already have.

Instead of what

You already have two ways to read a .md file.

Here is honestly where each one leaves you.

Markio Finder preview Editor preview Other MD viewers
Read without opening an app Space, fully rendered Space, plain text No — launch the editor Some, with their extension
Mermaid diagrams Built in, over twenty types No With the right extension Usually, via a JS library
Maths Built in, real glyphs No With the right extension Usually, via a JS library
Coloured terminal output ANSI, including true colour No Rarely No
Compare two versions, rendered Green and red bands, side by side No Source diff at best Line diff at best
A 32 MB document Opens like a short note Truncated text Slow, sometimes refuses A browser engine's pace
What draws the page Native — bytes to glyphs System text view Browser engine Browser engine
Source you can read All of it No Depends on the editor Rarely

Source available

Every claim on this page is one you can check yourself.

All of Markio's source is public on GitHub. That is not a footnote at the bottom of the page — it is the reason you can believe the rest of it. Every other reader asks you to take its word. This one hands you the evidence and invites you to go looking.

The privacy claim, checkable

"Nothing leaves your Mac" is a sentence any app can print on a website. Here you can read the code behind it — and the build gate fails outright if a reference to WebKit or JavaScriptCore ever reaches the sources.

The speed numbers, repeatable

The harness that produced 0.3 ms and 69 ms ships with the source. Clone the repository, run deno task bench, and get the numbers on your own Mac instead of mine.

Look before you pay

A Swift toolchain and one command give you a working app for nothing. If Markio does not do what this page promises, you can find that out without spending anything.

It can't be taken away

The licence lets you build Markio for your own use, today and later. An app you can rebuild yourself doesn't vanish when a store delists it or a developer loses interest.

Then the obvious question

Free to build. So what does $1.99 buy?

The part that building it yourself does not give you — the app already assembled, trusted by the system and keeping itself up to date.

  • Signed, notarised, sandboxed — it just opens, no right-click ritual
  • The Quick Look extension registered with the system on install
  • Updates arriving with the rest of your apps, not with a git pull
  • A small vote that this should keep being maintained

$1.99. Once.

No subscription, no account, no upsell inside the app. macOS 14 or later.

Download Markio on the Mac App Store Or build it yourself

Before you buy

Does it edit my files?

No. Markio opens documents to read them and never writes a file it opens. Keep editing in whatever you like — the view reloads where you left off.

Does it need the internet?

No. There is no account, no telemetry and no fetched font. Links open in your browser only when you click one.

Do the diagrams really render offline?

Yes. There is no Mermaid.js and no diagram service anywhere in the bundle — the app draws each diagram itself with paths and glyphs.

What happens to Markdown it doesn't support?

It keeps its source instead of being guessed at. A formula outside the supported subset, or a diagram type not yet drawn, stays visible as the text you wrote.

Will it cope with a giant file?

A 32 MB document parses in 69 ms and shows its first screen in 0.3 ms. Only the lines on screen are ever typeset, so length costs you nothing.

What if it doesn't work for me?

Open an issue on GitHub and you will get an answer from the person who wrote the app. Apple refunds App Store purchases on request, through Report a Problem — and I would rather fix the reason than keep the money.

If the code is free, what am I paying for?

Convenience, and only that. Building it yourself gives you the same app; $1.99 gives you a signed and notarised copy that opens without a right-click, a Quick Look extension the system registers on install, and updates that arrive with the rest of your apps.

Which macOS?

macOS 14 Sonoma or later.