No format/vendor lock-in and very amenable to living in a git repo. For my note taking that's already game over right there against everything else. I don't want to worry about whatever cursed format OneNote uses is still something I can extract in 2035.

I also like that it's become a defacto standard that LLMs speak. I can tell it to look at the code in this server repo and make me a API_documentation.md and it'll grasp that I want a text based summary of how to use this endpoint

It's not necessarily that writing HTML or other markup flavors is harder (obviously it is), but the beauty of Markdown for me is that it's perfectly readable in its raw form as well as with an applied styling.

And speaking of customizing the 'look' of markdown, a shameless plug for a markdown editor I've been working on with extensive customization options: https://kraa.io/about

I respect Anil's argument that the extensibility has helped it be adapted to different contexts, and in practice the looseness of it doesn't cause a problem. I do wish CommonMark had more traction (and acceptance and use of the name Markdown). It'd be nice to have a standard, at least for the basic stuff.

It's just plain text, so no vendor lock-in and you can ripgrep/fzf/grep through it Lives happily in git repos with proper diffs LLMs speak it natively - they output Markdown, they understand Markdown input Way easier for agents to parse than PDFs (which are binary, layout-focused, tables turn to mush) Can do tables (at least in GFM), headers, code blocks, links - all structure preserved

What it can't do (as far as I understand): complex layouts, precise typography, embedded binary content, anything that needs pixel-perfect rendering. Am I missing anything? What are the other limitations I should know about?

I know that in my younger years I would get a lot of flak for converting .rst files into .md when I joined projects.

(As I got older I just stopped seeing .rst that much)

My favorite Markdown creation was "GistDeck", a bookmarklet that turned a GitHub Gist of Markdown content into a slide show.

So much easier to make and share than a PowerPoint deck.

https://github.com/nzoschke/gistdeck

I appreciate that Gruber brought this very helpful thing into the world, but OTOH he was such a prick about the whole Standard Markdown debate, for no real reason other than ego. And it resulted in Markdown remaining an ill-defined standard to this day, with occasional compatibility issues still cropping up even though most platforms support most of "Github-flavored Markdown" (itself a stupid name and indicative how badly this has gone).

Likewise, things like org mode, which also emerged around the same time, catered to a niche of emacs using people. Which almost by definition is a subset of techies. It wasn't a logical choice for a mainstream blogging tool.

Markdown was aimed at people that used blogging tools (initially), and later any other kind of tool that accepted text. It spreading to tools like Slack, Github, etc. is no accident. Github actually has supported plenty of alternatives for documents. But they picked markdown for issue tracking, pull requests, etc. Because they had to just pick something and Markdown was the most popular.

By the time AsciiDoc became more popular (2009ish), Github was already being developed. With Markdown support. AsciiDoc was a niche thing, Markdown was already somewhat widely used then. It was an obvious choice. Them picking Markdown was important because the whole OSS community started using Github and got exposed to Markdown that way.

The rest is history. Other formats existed (textile, and various other wiki formats). They have features that are important to some people. But getting people to switch who don't really care about those features is hard. It's a bit like VHS over Betamax. Was it better. Not really. But it was there and video rental shops had to pick a format. And that wasn't Betamax when the dust settled.

https://www.48hourpress.com/publish-with-markdown/

When markdown emerged, docbook was getting even more elaborate, and vendors everywhere had for decades been locking people into frameworks and languages with fantastic features that were hard to use -- and then the internet bubble had popped. Then people realized they'd thrown away years building complex system, and had little tolerance for promises.

Markdown is something you can use in its native form. It's both source and destination, with a touch of future-proofing: if the opportunity arrives, you can polish it into anything, and mostly parse it yourself.

(What's surprising to me is that pandoc barely registers when compared with markdown on google trends since 2004; pandoc is the reason I switched completely to markdown in ~2010)

I was there when those easy markup languages were invented. It started all with wiki's (after Stallman's info of course). The first one being C2, and then the discussion about better formatting syntax on the MeatBallWiki because we had many different wiki's back then (long before MediaWiki). I was with PhpWiki, which had a good start because every webserver had php support, but almost nobody perl.

Links should have no different text, as this would hide the target. A security problem. Mediawiki destroyed that because Jimbo had a different vision, and because they didn't care. Markdown followed because Gruber had no idea and followed Jimbo, not the consensus from the other wiki's. More support for the []() link syntax came then with inline images, even when that was a bigger security nightmare.

Headers switched from the simple ## prefixes to the underlines, which just looked better, and most engines supported both.

Markdown was just a compromise of all the existing wiki formatting, which was simple enough. It should stay simple and readable, because that's what made POD better than other more verbose formatting styles. Mostly info, rST, AsciiDoc, org-mode (which was the most verbose). Which replaced troff and TeX. People still wrote books in GNU info, rST, AsciiDoc, POD and org-mode. But Markdown looked better on both eyes, the pure ascii eyes and the formatted layout.

Perhaps md is an opportunity to re invent the web: a browser for just md AND a search engine with an open algorithm that indexes just what is visible.

it's like YAML: it looks so simple at first, and then the horrors start if you try to use it seriously.

in both cases the most horrors lie in the spaces/tabs/newlines.

Markdown is an 'improvement' over HTML, makes it even more flexible and tolerant and easier to write without using tags.

If you ever hear any of that, don't listen to it. Just use Markdown. If you're building a messaging system or an announcement system instead of a fully fledged CMS - YAGNI/KISS. Or pick anything other than HTML, even BBCode.

Check out my "Advent of Markdown" where I go through surprising markdown behavior: https://mastodon.social/@timokoesters/115643467322561173

...but it's delicious that this blog post also demonstrates an ambiguity in Markdown: how to handle intra-word emphasis. In the rendered output, "mark_up_" and "mark_down_" were probably intended to be "mark<em>up</em>" and "mark<em>down</em>", but the underscores were instead rendered literally.

I do appreciate that Markdown's solution to ambiguities like this is dead simple - just inline some HTML.

the individual also claimed (in so many words) that the trillion-dollar AI industry is "controlled" by Markdown. he has either a deeply wrong understanding of the technology, or a shameless ambition for making wild claims to boost traffic

strong writing skills. but weak on technology and nuance, or history of our field

I still prefer WYSIWYG.

It's a TUI md reader, fast and cheap on the memory, because of Rust. Give it a try if you find yourself wanting a quick MD reader in a terminal.

https://github.com/seymores/mdr

Example: https://daringfireball.net/linked/2026/01/09/moylan.text

... and if you look closely at some of the entries you might spot custom Markdown features that aren't part of the published spec.

Chatgpt is pushing markdown to the maximum expose, Google & Microsoft sooner or later should react.

Easier to understand Shape it creates is scannable

GitHub render it by default

IYKYK. Joyent. TextDrive. Textpattern CMS.

Imagining an alternate universe where it might have been Textile. https://textile-lang.com/

Really it comes down to historically the time and place when Markdown was needed and the power of momentum leading to its mass adoption.

Restructured Text is much more capable, and yet here we are, still using Markdown.

My markdown pages often also have HTML in them, I mainly use Markdown so if I decide some overlong thing I wrote on Reddit actually doesn't suck, I can copy-paste it into a webpage, and my web-server's .smd handler does the convertion. Lowest common denominator. :(

Gary Hart?

It's just like comedy, timing is everything.

It would be insanely faster to render

pandoc readme.md | lynx -stdin

I like the results better than glow, bat and a few other viewers.

I know what I want, ffs. And I don't want html

Markdown did not come up with the idea of lightweight markup languages (LMLs). It just happened to become the most popular one, for reasons that the article doesn’t really address. There were other LMLs before and after Markdown. (It does mention Textile later on, but doesn’t mention that there were a number of others, and that it was a field that had been steadily developing.)

> What if you could just write out the text and then the link, sort of like you might within an email? Like: [Anil Dash’s blog](https://anildash.com)!

No one would ever have spelled it like that. It would rather have been either “Anil Dash’s blog (https://anildash.com)” or “Anil Dash’s blog <https://anildash.com>”.

> If mark_up_ is complicated, then the opposite of that complexity must be… markd_own_.

I’m guessing this was intended to have actual italics. (Clearly it wasn’t checked after writing, or else the third underscore would have been shifted before the d.) This shows one of the problems of Markdown. (“_anti_commercial” later has the same problem.) Also why you should prefer * for italics rather than _ when writing Markdown, because in CommonMark it allows you to mark up partial words. Throw away Prettier’s Markdown formatting, by the way, it’s terrible and if you’re not careful may destroy your content, and it insists on underscore for italics.

> Hitting the Mark

> [Stuff about Markdown becoming supported by Google Docs, Microsoft Notepad, Slack, WhatsApp, Discord, Apple Notes.]

A lot of this is wrong:

• What most of them have added is an input mode for their WYSIWYG editor which is best expressed as inspired by Markdown. If you want to actually deal in Markdown, they are always infuriatingly incomplete and incompatible. At best (and it’s never even that good) you’re only typing Markdown, not editing Markdown.

• What most of the rest of them have is a lightweight markup language only superficially similar to Markdown. Slack’s mrkdwn and WhatsApp’s formatting are this.

> The Ten Technical Reasons Markdown Won

I’ll grant 1 as valid but non-technical. 2 as valid for Markdown and less valid for other LMLs for reasons that I’ll get into shortly. 3 as valid for Markdown but also some other LMLs that already existed. 4 as valid and somewhat technical. 5 I won’t grant as distinct from 4. 6… well, the key there is actually that correctness isn’t as important as some of us would like. The flavours part of it was more a building up of technical debt. 7, 8, 9 and 10 I will not grant as reasons that Markdown won—several other LMLs already existed with the same benefits.

But it really misses out on the big reason, though 2 and 6 nudge on it:

Markdown won because it was simple, and extended HTML. It was horribly underspecified and all early implementations were all awfully buggy, inconsistent and incompatible, but it was simple and we didn’t care so much about those problems in those days (for better or for worse). People could implement Markdown themselves in an hour or two.

Nowadays, people familiar with Markdown will look baffled at some of reStructuredText’s syntaxes, but at the time I’d say Markdown and reStructuredText were similarly weird, just in different areas. When getting away from things like BBCode which was almost just HTML with square brackets, and Textile which had more idiosyncratic spellings (I mean things like “bq. ” where email had “> ” on every line), reStructuredText and Markdown were about equal.

reStructuredText is way more technically sound. It’s more capable than Markdown, and there’s none of the wild and incompatible fragmentation. But reStructuredText is heavy to implement, and if you only care about outputting HTML and only for yourself, it’s actually harder to extend—you’ll have to define a node type and extend the writer to know what to do with it, or else use the “raw” directive or role. Whereas with Markdown, you just wrote HTML and hoped for the best. Because Markdown was such a mess. But you’d get it right faster than in reStructuredText.

It’s no coincidence that there’s only one major implementation of each of reStructuredText and AsciiDoc, and only three or four total for each. They were designed for bigger, heavier things. Markdown was designed for simplicity at the cost of correctness… just like HTML was.