The editor for text
you didn't write.

Open a messy CSV. It lines up.

Switch on Structured View and CSV/TSV columns align, minified JSON pretty-prints — millions of rows, instantly. And you can still grep it: filter down to the matching rows with the columns still lined up, at any size. The formatting is view-only, so the file on disk never changes: save and you get your original back, byte for byte. Then ⌥⌘J runs a jmespath-style query in place; the result is never written. Fixed-width records line up too: drop the field boundaries on the column ruler (⌥⌘K) — or type them, 1-8,9-14,15-40 — and read them as columns.

27 seconds. No cuts.

One take, real speed: a 10 GB log opens, and we scroll and search it while the line index is still being built in the background. When the index lands, the status bar stops guessing — 86,420,337 lines, exactly — and ⌘L jumps to the last one.

The index — counting all 86 million lines — takes about 10 seconds on this file. Watch the status bar: it shows an estimate (about 89,292,800) and settles on the exact count when the scan finishes. The view never blocks while that runs. Reading, scrolling and searching stay live throughout; the search in this clip finds 137,111 matches while the index is at 95%.

The first line appears after reading a few dozen kilobytes.

Out of 10 GB. The rest is streamed in the background to build a line index, and none of it is kept in memory. Loading the whole document first — the usual approach — falls over at this size. So MrEditor does not do that.

tail -f a 10 GB log — and edit it.

Follow mode (⌥⌘F) tracks a growing file the way tail -f does — but it never reloads. The mmap index extends by the new bytes only, so it scales to a log that's still being written at 10 GB. Editors that tail (BBEdit, Sakura) reload the whole file; log viewers that scale to 10 GB (klogg, lnav) are read-only. Following a multi-GB log incrementally, while staying editable — we couldn't find that combination anywhere else.

The log you need is on a server. Open it without downloading it.

ssh host:/var/log/app.log (⌃⌘O) opens at the tail with real line numbers, fetching only the part you look at. Filtering runs on the far side: grep -n hands back the matching lines and their numbers without transferring a byte of the file — faster than scanning locally, because nothing is sent. Follow streams tail -f and stops it over there when you stop, so nothing is left running on your server. ⌘C gives you the text, so what you found goes straight into Compare with Clipboard. Authentication is left to /usr/bin/ssh — if your terminal can reach it, so can this.

Read it. Then change it.

• Remote logs — ssh host:/path, opened at the tail without downloading. Filtering runs on the far side
• Compare / diff — two files, two open tabs, the clipboard, or a URL. Side by side, down to the character that changed
• Merge — click → and the left side lands in the right. Save the result; the originals are never touched
• Edit & save, any size — small files in memory, huge files via a piece table
• Structured view — CSV/TSV columns, NDJSON fields & JSON pretty-print, millions of rows instantly
• Column ruler & fixed-width fields — a ruler above the text (⌥⌘K); click or drag to place field boundaries, or type them (1-8,9-14,15-40). Remembered per file, and readable as columns
• Line text up by column — draw a guide and the text becomes columns (still editable). Tab pads to the next field, ⌥Tab applies the layout to every line — with no guides yet it derives one from the content
• JSON query — a jmespath-style expression (⌥⌘J) filters & projects in place; the result is never saved
• AI error diagnosis (BYOK) — select a stack trace, press ⌥⌘E, and the answer streams in as it is written. Your own key (Anthropic / OpenAI / Gemini), stored in the Keychain; pick a model — or type one that is not listed and let the connection test add it — in Settings
• Atomic save — write to a temp file, then swap; the original is never left half-written
• Reload on external change — fix a file elsewhere and it loads back in place, keeping your caret and scroll position. Unsaved work is never overwritten: a banner asks first. A log that only grew extends its index instead of being reopened
• Save encoding — convert between UTF-8 / Shift-JIS / EUC-JP on save
• Search — streams over mmap for huge files, and ⌘F works while you edit too (replace, case-preserving). Multi-term AND, regex & case toggle
• Filtered view / live grep — show only matching lines
• Multiple documents — open many files, switch from a sidebar
• Session restore — reopens your sidebar on launch, unsaved drafts included
• Recent files — File ▸ Open Recent
• Go to line & font zoom — ⌘L, ⌘+ / ⌘- / ⌘0
• Follow mode — tail -f (⌥⌘F); tracks a growing file incrementally, no reload, even at 10 GB
• Copy & navigate — ⌘C, find next / previous
• Encoding auto-detect — UTF-8 / Shift-JIS / EUC-JP
• Color themes — System / Solarized / Monokai / custom; editor + UI
• Fonts & display — family/size, tab width, line spacing, caret shape
• Status bar — encoding, lines, size, index progress
• Localized UI — English & Japanese

Free reads one file. Pro answers the question.

Everything above stays free, and stays MIT. What is being prepared as MrkEditor (Pro) is the other half: counting, summarising, seeing time, and searching across folders — the things you currently leave the editor to do. Numbers below are measured on the shipping code (M4 Max, August 2026), not estimates.

• Count by value — what sort | uniq -c | sort -rn does, on a column or a key=value field. 3.40 s over a 10 GB, 86,420,337-line log. Double-click a row and the document filters down to that value
• Column stats — every column of a CSV in one pass: type, blanks, distinct, min/max, sum & average. 4.78 s for all 30 columns of a 1.18 GiB CSV (5,816,534 data rows). A column is only called numeric when every row reads as a number
• Time histogram — when did it spike? 3.18 s over a 10 GB, 67,156,671-line log. Filter to errors first, then look at time. Lines without a timestamp are counted separately, never dropped. Drag across the bars and the document narrows to that window
• Search across folders — 3.14 s for one literal across a single 10 GB log, on par with ripgrep. What ripgrep does not do: click a hit and the file opens at that line, and Shift-JIS / EUC-JP files are detected per file and read correctly

Not on sale yet — there is no price and no checkout on this page on purpose. When it opens, the free app will tell you from the Analyze menu.