Markio

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

The Markdown you didn't write,
readable in one keystroke.

Press Space in Finder and the file is simply there — headings, tables, Mermaid diagrams, formulas, coloured terminal output. A 32 MB document opens as fast as a two-line note, because there is no browser engine inside Markio waiting to start up.

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
An agent's 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.

📄

The agent wrote 4 000 lines

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

Built for tool output

It speaks agent.

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

  • 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 the agent's earlier run of the same task, 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 documents, 300 MB

Keep twenty reports open at once and Markio holds about 300 MB — roughly 14 MB a window. No renderer process sits behind a window keeping a second copy of your file, so windows cost what windows cost and nothing more.

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 the harness ships with the source, so deno task bench gives you the speed numbers on your own machine. The memory figure is twenty documents open together in windows of the default size, read from Activity Monitor.

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
Read without opening an app Space, fully rendered Space, plain text No — launch the editor
Mermaid diagrams Built in, over twenty types No With the right extension
Maths Built in, real glyphs No With the right extension
Coloured terminal output ANSI, including true colour No Rarely
A 32 MB document Opens like a short note Truncated text Slow, sometimes refuses
Source you can read All of it, MIT No Depends on the editor

Open source

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

All of Markio is on GitHub under MIT. That is not a licensing 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

MIT means fork it and keep it. An app you can rebuild yourself doesn't vanish when its developer loses interest or an acquirer switches it off.

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

Who is behind it

One person, working in the open.

Markio is written by Stanislav Korchagin — korchasa on GitHub. It is a new app, and there is no point dressing that up: what stands in for a wall of reviews is that the whole history is public — every commit since July 2026, with 305 tests and the full check suite run on each one. If Markio doesn't do what this page says, open an issue and the answer comes from the person who wrote it. Apple refunds App Store purchases on request, and I would rather fix the reason than keep your two dollars.

MIT licence · 305 tests · checks on every commit · no accounts and no analytics in the app

$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 the giant file my agent just wrote?

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.