John Gruber has a name for something I've used for years without being able to describe: prestructured WYSIWYG. Apple Notes and Messages let you apply bold, italics, headings, lists, links, and monospaced text. They do not let you pick a typeface. There is no Font menu in the toolbar, no default-font preference, no size in points. You get Apple's system font and its preset styles, and that is the deal.
He argues this is one of the better software design ideas of the last fifteen years, and I think he's right — for reasons that go further than typography.
The two problems it solves
The old model was: text is either plain or rich, and if it's rich you can choose any font and size you want. That model has two failure modes, and both are unavoidable.
The technical one: the fonts on my machine aren't the fonts on yours. Documents develop missing-font problems, substitution problems, and layout drift. Anyone who has received a design-heavy PDF or a Keynote deck knows the genre.
The aesthetic one: most people, given a font menu, make bad choices. That's not elitism, it's base rates. The people most likely to install fonts are also the people most likely to use them.
Prestructured WYSIWYG solves both by removing the choice. You keep the expressiveness that matters — emphasis, structure, hierarchy — and lose the part that causes trouble. Sizes are relative, which is good for accessibility. Styles map cleanly onto Markdown, which is good for everything else.
The real reason it works
The pattern isn't really about fonts. It's about what the document stores.
Visual formatting stores appearance: this run of text is 13-point Helvetica Bold. Semantic formatting stores intent: this is a heading, this is emphasis, this is code. Appearance has to be recreated for every renderer — screen, print, dark mode, screen reader, export, a different app in five years. Intent can be interpreted by any renderer that understands the vocabulary.
That's why prestructured WYSIWYG maps so well to Markdown, and why Markdown has outlived a dozen "better" document formats. It's also why AI systems write Markdown: it's the format where structure survives the trip.
A product that stores intent can be re-rendered by anything. A product that stores appearance is locked to whatever produced it.
The footnote is the best part
Gruber's footnote is the detail that makes the essay honest: on the Mac, and only on the Mac, Notes does let you pick arbitrary fonts. Format → Font → Show Fonts, the standard AppKit panel, and you can set a note in anything installed. Those fonts show up on iOS only if the font is installed there, which for third-party fonts is complicated.
So the constraint is not enforced by the data model. It's enforced by the UI, and by nobody knowing the shortcut exists. Apple didn't remove the capability; it removed the affordance. That's a weaker guarantee, and Gruber's advice is to pretend the feature doesn't exist.
I find that more interesting than a clean story. Most design constraints are like this: not physical limits, but decisions about what to put in front of people. The keyboard shortcut remains for the people who need it, and the default remains sane for everyone else.
Where the pattern doesn't fit
Constraints are freeing in note-taking because the content is the point. They're wrong where appearance is the content: a poster, a menu, a brand page, a typographic essay. Email is the cautionary counterexample — full WYSIWYG got entrenched there decades ago, and now we live with a format where the same message renders differently in five clients and nobody can reliably paste a table.
The test isn't "is this app for writing?" It's "does the reader need to see what the author saw, or do they need to understand what the author meant?" Notes, docs, changelogs, code comments: intent. Posters, packaging, slides you will present: appearance.
The AI version of the same bet
There's a version of this argument that's about to matter more. Agents produce structured text — Markdown, JSON, diffs — because that's what can be checked and re-rendered. Products that store semantic content can accept an agent's output directly; products that store visual spans need a human to translate.
Prestructured WYSIWYG is the UI half of that bet, made fifteen years early. The document model is semantic, the editor exposes only semantic operations, and the renderer decides what it looks like. When the renderer changes — a new device, a new theme, a model reading the page — nothing breaks.
The best formatting menu, it turns out, is the one that doesn't offer fonts. Not because fonts are bad, but because most of the time the choice isn't the point, and removing it makes everything else work better.
Source: Prestructured WYSIWYG — John Gruber, Daring Fireball.