The Story of Markdown: From Perl script to internet infrastructure

A single Perl script, released on a blog in 2004, now shapes how billions of people format text online.

Markdown has no company behind it. No marketing budget. No official standards body. Its creator hasn’t updated the specification in twenty years. Yet the format has colonized platforms from GitHub to WhatsApp, from Reddit to ChatGPT, becoming invisible infrastructure for digital communication.

How did a side project by a blogger become foundational to the internet? The answer involves plain text email conventions, a collaboration cut short by tragedy, and a standardization battle that remains unresolved.

The invention

John Gruber ran Daring Fireball, an influential Apple-focused blog, in the early 2000s. Like every blogger of that era, he wrote in HTML. Unlike most, he found the experience increasingly intolerable.

“It just felt like I was making work for myself,” Gruber recalled. “I really thought that HTML made it hard to proofread my work.”

The solution he developed drew from existing plain text conventions. Email users had long surrounded words with asterisks for emphasis. Usenet discussions used underscores for titles. Technical documentation indented code blocks with spaces. These patterns felt natural because they’d evolved over decades of digital communication.

Aaron Swartz, a programmer who would later help create RSS 1.0 and co-found Reddit, became Gruber’s collaborator. Swartz had released his own plain text format called atx in 2002, expressing frustration with HTML’s demands: “I’m sick of bringing my writing down to the level of the computer.”

With Swartz as his “sounding board,” Gruber codified these conventions into Markdown. On March 15, 2004, he announced the release: a Perl script that converted plain text with simple formatting marks into valid HTML.

The philosophy was explicit: “A Markdown-formatted document should be publishable as-is, as plain text, without looking like it’s been marked up with tags or formatting instructions.”

The syntax

Markdown’s design prioritized readability over parsing efficiency:

Headers used hash marks, visually stacking to indicate hierarchy:

# Main Title
## Section
### Subsection

Emphasis used asterisks, matching existing email conventions:

*italic* and **bold**

Lists started with dashes or numbers:

- First point
- Second point

Links combined brackets and parentheses:

[visible text](url)

Code used backticks:

`inline code` and fenced code blocks

The syntax could be learned in minutes. More importantly, it remained legible without rendering. A Markdown file was a document, not a code file.

Gruber released version 1.0.1 in December 2004. It was also the last update he would ever make.

The spreading

Markdown’s timing proved perfect.

Blogs were exploding in popularity. Comment systems needed formatting. Technical documentation was moving online. Platforms needed something simpler than HTML but more structured than plain text.

GitHub became the crucial vector. The code hosting platform adopted Markdown for README files, making it the standard for software documentation. Every open source project, every code repository, every technical guide began using Markdown by default.

GitHub also extended the syntax. “GitHub Flavored Markdown” added tables, task lists, syntax highlighting for code blocks, and automatic linking. These extensions became expectations.

Other platforms followed. Stack Overflow used Markdown for questions and answers. Reddit adopted it for comments. Trello, Slack, Discord, and eventually WhatsApp integrated Markdown-style formatting.

Each implementation made choices about edge cases. What happens when you nest bold inside italics? How should blank lines in lists behave? Gruber’s original specification left ambiguities that different platforms resolved differently.

The fragmentation

By the early 2010s, “Markdown” had become a family of dialects rather than a single format.

GitHub Flavored Markdown dominated software development. MultiMarkdown added footnotes, tables, and math support for academic users. Pandoc’s Markdown enabled conversion to dozens of formats. CommonMark (later) attempted formal standardization. Each claimed Markdown heritage while implementing different behaviors.

The problem wasn’t just theoretical. Documents that rendered correctly on one platform broke on another. Writers couldn’t assume their Markdown would behave consistently across tools.

Gruber’s silence compounded the confusion. The original specification hadn’t been updated since 2004. He didn’t participate in extension discussions or resolve ambiguities. Markdown was simultaneously everywhere and authorless.

The standardization war

In 2012, a group of developers decided to fix the fragmentation problem permanently.

Jeff Atwood (co-founder of Stack Overflow and Discourse), John MacFarlane (creator of Pandoc), and others began drafting a formal specification. They invited Gruber to participate via email. He never responded.

After two years of work, they launched their project in September 2014 as “Standard Markdown,” complete with comprehensive test suites and unambiguous parsing rules.

Gruber was furious.

The name implied official status he hadn’t granted. The specification made decisions about edge cases he’d deliberately left undefined. The project claimed his creation while excluding him.

After a public dispute, the project renamed itself “CommonMark.” Gruber’s response, relayed through Atwood: “No form of the word ‘Markdown’ is acceptable to him in this case.”

CommonMark continues today, and many platforms have adopted its specification. But the politics remain unresolved. Gruber’s original Markdown persists unchanged. Two competing visions of what “Markdown” means coexist without reconciliation.

The AI amplification

Large language models added a new dimension to Markdown’s ubiquity.

When ChatGPT launched in November 2022, it output responses in Markdown format—headers, bullet points, code blocks, emphasis. Claude, Gemini, and other AI assistants followed the same convention. The format that Gruber designed for bloggers became the default output language for artificial intelligence.

This wasn’t arbitrary. AI systems needed a format that was:

• Readable without rendering
• Structurally expressive
• Already familiar to technical users
• Simple enough to generate reliably

Markdown checked every box. The format’s twenty-year evolution had optimized it for exactly this use case: making structured text readable to humans.

Now millions of people encounter Markdown daily through AI interfaces, whether they recognize it or not.

The state of Markdown in 2024

Twenty years after its creation, Markdown occupies a strange position.

It’s everywhere. GitHub documentation, Reddit comments, Discord messages, Slack formatting, Notion pages, Obsidian notes, static site generators, AI outputs, technical documentation across the software industry.

It’s standardized and unstandardized. CommonMark provides formal specifications. GitHub Flavored Markdown dominates software development. The original Markdown specification remains frozen. None has absolute authority.

It’s invisible. Most users don’t know they’re using Markdown when they surround text with asterisks on WhatsApp. The syntax has become intuitive enough to feel like default behavior rather than a specific format.

It’s unmaintained by its creator. Gruber continues writing Daring Fireball but hasn’t touched Markdown’s specification since 2004. The community has evolved around him, not with him.

The accidental standard

Markdown succeeded because it solved a real problem in the simplest possible way.

Writers needed to add structure to text without learning HTML. Gruber gave them hash marks for headers and asterisks for emphasis. The syntax was so obvious that it spread without evangelism, so useful that it persisted without updates, so minimal that it could be extended without breaking.

Aaron Swartz died in 2013, never seeing how thoroughly his collaboration with Gruber would reshape digital communication. The “sounding board” for Markdown left behind a legacy embedded in every README file, every formatted message, every AI response.

John Gruber’s Perl script from 2004 is still running—not the original code, but the idea. A readable format for readable writing, unchanged at its core, invisibly essential to how the internet communicates.