In Defense of Plain Text (and Why It Beats Every Note-Taking App)

There is a quote, attributed to many people, that goes "the best file format is the one that will still be readable in 50 years." In 1974, the best answer was plain text. In 2024, it is still plain text. In 2074, it will probably still be plain text. No other format in the history of computing has that kind of longevity, and no other format is as well-suited to the kinds of writing humans do most — notes, lists, drafts, references, journals, code, configurations.

This is the case for plain text over every note-taking app, word processor, and proprietary format. It is not the case for plain text over all the other tools — spreadsheets are still better for tabular data, slides are still better for presentations, video is still better for video. But for written information, plain text wins on every dimension that matters, and it has been winning since before most of the current note-taking apps existed.

Plain text is the most durable format in computing

The ASCII text format is 60+ years old. The Unicode text format is 30+ years old. UTF-8 (the encoding that powers the web) is 30+ years old. In computing terms, these are stone tablets. They were designed when "file format" meant "a sequence of bytes on tape," and they have outlasted every other format designed since.

Compare with the proprietary formats that have come and gone:

• WordStar files (1980s) — unreadable in 2024 unless you have a WordStar emulator.
• Word .doc files (1990s) — barely readable in 2024, requires a Microsoft Office license or a converter.
• Word .docx files (2000s) — readable but the format is owned by Microsoft and changes with each version.
• Google Docs native format — only readable by Google Docs, no offline export that preserves full fidelity.
• Notion blocks — only readable by Notion, export options are lossy or incomplete.
• Evernote .enex files — readable but the format is half-documented, the export loses attachments, and the company has changed hands multiple times.
• Bear notes — only readable by Bear, export to plain text or markdown is lossy.
• Apple Notes — only readable by Apple Notes, export to PDF is the official option.

Compare with plain text: any text editor in 2024 can read a plain text file written in 1964. The format has not changed. The encoding is documented. The bytes are human-readable. The same is true of files written in 2024 — they will be readable in 2084 by any text editor that exists then, because the format has not changed in 60 years and is not going to change in the next 60.

When you write a note in plain text, you are writing to a format that will outlive you. When you write a note in a proprietary app, you are writing to a format that will outlive the company that makes the app.

Plain text is the only format that is truly portable

Plain text files work on every operating system, in every text editor, on every device. You can open a .txt file on a 1970s mainframe, a 1990s Mac, a 2024 Windows PC, a 2024 Linux server, an iPhone, an Android phone, a Kindle, a web browser, a smart fridge. The same file, byte-for-byte, opens the same way.

Compare with proprietary formats:

• Word .docx — opens on Windows and Mac with Microsoft Office, but mobile support is partial, and the format is occasionally incompatible between versions.
• Google Docs — opens in a browser, but offline support is limited, and the format is not standardized.
• Notion blocks — only opens in Notion. Period.
• Apple Notes — only opens in Apple Notes on Apple devices.

The portability of plain text means your notes are not locked to a device, an OS, or a company. You can move from a Mac to a Windows PC, from an iPhone to an Android phone, from Evernote to Notion to Obsidian, and your notes come with you because they were never in a proprietary format to begin with.

Plain text is the only format that is truly searchable

Try this: open your favorite note-taking app and search for a phrase you wrote 5 years ago. Then try the same search on a folder of plain text files using grep. The grep search will be faster, more accurate, and more reliable — it will find the exact match, not a fuzzy approximation, and it will not require the app to be open or the database to be indexed.

The Unix tool grep has been searching plain text files since 1974. It is fast (gigabytes per second on modern hardware), it is reliable (it does not miss matches), and it is universal (every Unix system has it, every Linux distro has it, macOS has it, Windows has it via WSL or Git Bash). The combination of plain text and grep is a search engine for your own notes, and it works better than the search inside most note-taking apps.

For more advanced search, ripgrep (rg) is the modern replacement for grep, and it is faster on every metric. The Character Counter on this site is the kind of tool that is built around plain text for exactly this reason — the text you paste is processed in the browser, never uploaded, and the count is instant.

Plain text is the only format that is truly scriptable

If you have a folder of plain text files, you can do anything with them. Count words across all files. Find every file that mentions a person. Convert markdown to HTML. Extract a TODO list. Generate a word cloud. Run a spell check. Translate to another language. Send to an LLM for summarization. All of these are one-line shell commands, and all of them work on the same .txt files.

Compare with a note-taking app's "API": you can usually read your notes, but you cannot easily transform them. The note-taking app is a black box; the plain text folder is a programmable surface. The plain text folder is yours in a way the app is not.

Common scripts people run on their plain text notes:

# Count words across all notes
find . -name '*.md' | xargs wc -w

# Find every note that mentions a person
grep -r "Alice" .

# Extract all TODO items from notes
grep -r '^- [ ]' .

# Count notes per year
ls *.md | awk -F'-' '{print $1}' | sort | uniq -c

# Convert markdown to HTML
for f in *.md; do markdown "$f" > "${f%.md}.html"; done

None of these are exotic. They are standard Unix tools applied to standard plain text files. The same scripts work on your laptop, on a server, in a CI pipeline, on a friend's computer. Portability, durability, scriptability — they are the same property applied to different tasks.

Plain text is the only format that is truly diffable

Version control (Git) is built on plain text diffs. When you commit a change to a plain text file, Git can show you exactly what changed, line by line, character by character. When you commit a change to a Word .docx file, Git can only show you that the file changed — the actual changes are buried in a binary blob that no human can read.

Diffability matters more than most people realize. It is the difference between:

• "I changed something in this note" (binary, opaque) — and — "I added a sentence about the budget meeting and corrected a typo in the third paragraph" (plain text, transparent).

For a single user, the difference is small. For a team, the difference is everything. Code review (which is just text diffing) is the foundation of modern software development, and the reason code is reviewable is that it is plain text.

The same applies to writing. If you are collaborating on a document, plain text or markdown lets you see exactly what your collaborator changed. Word or Google Docs has a "track changes" feature, but the underlying file is still a binary blob, and the version history is locked to the app.

Plain text is the only format that is truly future-proof

This is the most important property, and it deserves its own section. The argument is simple: any future text editor will be able to read any past plain text file, because plain text is the lowest common denominator of human-readable bytes. ASCII was designed to be readable by a human with a piece of paper and a pencil. UTF-8 was designed to be readable by a human with a piece of paper and a pencil, in any language. The format has not changed in 60 years because the format does not need to change.

Compare with proprietary formats. The .doc format was replaced by .docx in 2007. Google Docs native format changes frequently. Notion's block format is undocumented and changes without notice. Every proprietary format is, by definition, owned by a company that can deprecate it on their schedule, not yours.

When you write in plain text, you are not betting on a company's roadmap. You are betting on the stability of the most successful file format in the history of computing. That is a much safer bet.

The honest counterarguments (and why they don't matter)

"But I need formatting (bold, italic, headings)"

Markdown (and its variants like AsciiDoc, reStructuredText, org-mode) is plain text WITH formatting. You can have headings, bold, italic, links, lists, code blocks, images — all in plain text files that are still searchable, scriptable, and diffable. The Markdown to HTML tool on this site converts markdown to HTML for publishing, but the source remains plain text.

Markdown is the modern default for note-taking in plain text. It is the format this blog is written in. It is the format most technical documentation is written in. It is the format GitHub uses for READMEs. It is the format the majority of writing-focused plain text tools use. The case for plain text is the case for markdown, because markdown is plain text with formatting.

"But I need images, attachments, files"

You can store images and attachments alongside plain text notes. The convention is to put the files in a subfolder (like attachments/ or media/) and reference them by relative path in the text. The text remains plain; the attachments are files in a folder. The whole thing is portable, scriptable, and durable.

Alternatively, Obsidian (and similar tools) supports the ![[filename]] syntax for embedding images and PDFs in markdown notes, with the files in a subfolder. The text stays plain; the rendering is rich.

"But I need rich linking between notes"

Markdown supports [[wiki-style]] links (via Obsidian, Roam, and most modern tools). These are plain text strings that tools can resolve to other notes by filename. The links are readable in the text (you can see them, search them, count them) without needing a special app to interpret them.

"But I need collaboration"

Git + plain text files is the original collaboration tool. Every line of every open-source project in the world is a plain text file in a Git repository, with hundreds of contributors collaborating asynchronously across years. If it works for Linux (15+ million lines of code, 20,000+ contributors), it works for your notes.

For real-time collaboration on a single document, Google Docs is better. For asynchronous collaboration across many documents, Git is better. The use case determines the tool, but plain text + Git is a perfectly viable collaboration workflow for many teams.

"But the UX of plain text editors is bad"

The modern plain text editor (Obsidian, Logseq, VS Code, Sublime Text, Neovim, Emacs) has more features than most word processors. Live preview, syntax highlighting, autocompletion, vim/emacs keybindings, multi-cursor editing, find-in-project, git integration, plugin ecosystem. The UX of a good text editor in 2024 is better than the UX of Word in 2004.

If the "UX of plain text editors is bad" was true in 2010, it is definitely not true in 2024. The category has matured.

How to start with plain text

Three low-friction ways to start:

1. A folder of .txt files: pick a folder (e.g., ~/notes/), create a .txt file for each topic, and write. No tool, no setup, no app. The folder is your app.
2. A folder of .md files in Obsidian or Logseq: pick a folder, open it in Obsidian, and write in markdown. Obsidian is a free app for personal use; it is a polished front-end for a folder of plain text markdown files. You can leave Obsidian at any time and your notes are still there, in plain text, in a folder.
3. A Git repository of .md files: pick a folder, run git init, and start writing. Commit when you want a snapshot. Push to GitHub for backup and sync. This is the most durable workflow, and it is the one used by most technical writers and developers.

All three are free. All three work today. All three will work in 2074. Pick one and start writing.

The honest summary

Plain text is the most durable, portable, searchable, scriptable, diffable, and future-proof format for human-written information in the history of computing. It is 60+ years old, will be readable in 100+ years, and is the only format that can be searched with grep, transformed with shell scripts, version-controlled with Git, edited with any tool, and read on any device. Every note-taking app eventually becomes a plain-text export or a dead format. Plain text files in a folder, indexed by grep, are a tool that will outlive every app you use today. The case is not that plain text is the only tool you should use — spreadsheets and slides and video are better for their respective jobs. The case is that for written information, plain text is the right default, and the cost of using anything else is lock-in, format rot, and an app that decides when your notes become unreadable. The Word Counter, Markdown Editor, and Markdown to HTML tools on this site are built around plain text for exactly this reason. The format has not changed in 60 years and is not going to change in the next 60.