Markdown Paragraphs Explained: Blank Lines, Line Breaks, and Cross-Platform Compatibility

What Is a Markdown Paragraph? Simpler Than You Think

Paragraphs in Markdown might be the most "non-syntax" part of the whole language — you don't need any special markup. Just write text. Paragraphs are separated by blank lines. That means if you leave a completely empty line between two blocks of text, they'll render as two separate paragraphs.

Simply put, a Markdown paragraph is one or more consecutive lines of text, separated from other paragraphs by one or more blank lines. This rule has been the same since John Gruber designed Markdown in 2004.

When rendered, each paragraph gets wrapped in a <p> tag. So when you write:

This is the first paragraph. You can write
multiple lines and it still works.

This is the second paragraph. There's a blank line above.

The rendered HTML is:

<p>This is the first paragraph. You can write
multiple lines and it still works.</p>
<p>This is the second paragraph. There's a blank line above.</p>

Here's something beginners often miss: consecutive lines within a paragraph are merged into a single line. Without any special treatment, the line breaks you type in your editor won't show up in the rendered output — multiple lines become one.

Creating Paragraphs: Blank Lines Do All the Work

There's only one way to create paragraphs: leave a blank line between two blocks of text.

Content of the first paragraph.

Content of the second paragraph.

That's it. No tags, no markers, no indentation. A blank line is the paragraph separator.

A few details worth knowing:

• What counts as a blank line: A completely empty line, or a line containing only spaces and tabs, both count as blank lines. So even if you accidentally type a space on an otherwise blank line, it still separates paragraphs correctly
• Multiple blank lines = one blank line: Whether you leave 1 or 5 blank lines, the rendering result is the same — standard spacing between two paragraphs. Markdown won't triple the spacing just because you left three blank lines
• Don't indent paragraphs: This differs from traditional writing habits. Markdown paragraphs should not be indented at the beginning — adding spaces or a Tab in front may cause the content to be parsed as a code block (4 spaces = code block) or produce unexpected indentation

When I first started using Markdown, I made this exact mistake — habitually adding two spaces at the start of each paragraph, only to find weird indentation on GitHub. It took me a while to understand that Markdown's design philosophy is to use blank lines for paragraph separation, not indentation.

Line Breaks Within a Paragraph: Three Methods

Blank lines separate paragraphs. But what if you want a line break within the same paragraph? Like formatting a poem or a mailing address. There are three common methods:

Method 1: Trailing Double Spaces (The Classic)

At the position where you want a line break, type two spaces, then press Enter.

First line··
Second line

(The ·· above represents two spaces — in practice, they're just regular spaces)

These trailing spaces get rendered as a <br> tag, creating a line break within the paragraph. This method comes from Markdown's original design and is supported by all mainstream parsers.

But here's the catch: Trailing spaces are invisible in most editors, and some editors will automatically strip them for you. VS Code does this by default. If you find that trailing double spaces aren't working, check your editor settings for a "trim trailing whitespace" option.

Method 2: Trailing Backslash (More Visible)

Add a backslash \ at the end of the line, then press Enter:

First line\
Second line

The advantage of this method is that the backslash is visible — no need to worry about your editor secretly deleting it. It's a standard syntax supported by the CommonMark spec, and works on GitHub, GitLab, and Obsidian.

However, not all parsers recognize it. Some older Markdown parsers may not support trailing backslash line breaks. If you need compatibility with less common platforms, test first.

Method 3: HTML <br> Tag (Most Universal)

Just use the HTML line break tag directly:

First line<br>
Second line

As long as your Markdown parser allows inline HTML (and almost all do), this method works. The benefit is clear semantics and no compatibility issues. The downside? It's not really Markdown syntax — you're mixing in HTML.

In practice, my personal habit is: use backslashes on GitHub and most platforms (visible, reliable), and <br> when I need maximum compatibility. Trailing double spaces, while classic, are just too error-prone because they're invisible.

Paragraph Behavior Differences Across Platforms

This is probably the most confusing part — different platforms handle paragraphs and line breaks differently. Here's a comparison table:

Let me highlight the GitHub Issues/PRs vs. .md files difference. In GitHub's Issues, Pull Requests, and Discussions comment areas, pressing Enter directly creates a line break — this differs from standard Markdown behavior. But in .md files in repositories, you must use trailing spaces or backslashes to create line breaks. This difference can be confusing at first.

Typora has a similar situation. In WYSIWYG mode, pressing Enter directly creates a line break because the editor handles the logic for you. But when you open the same file on GitHub or other platforms, those plain Enter keystrokes may not produce line breaks.

How Paragraphs Interact With Other Elements

Markdown paragraphs don't exist in isolation. They interact with many other elements, and understanding these interactions helps you avoid some head-scratching moments.

Paragraphs and Lists

List items can contain paragraphs, but the second and subsequent paragraphs need to be indented by 4 spaces or 1 tab:

- First list item

    Second paragraph within the list item. Note the 4-space indent.

- Second list item

Without the indent, that "second paragraph" would be treated as a regular paragraph outside the list.

Paragraphs and Blockquotes

Paragraphs inside blockquotes work the same way — separated by blank lines:

> First paragraph in the blockquote.
>
> Second paragraph in the blockquote. Note the `>` on the blank line.

Note the > on the blank line — without it, the blockquote would be split into two separate blockquotes.

Paragraphs and Code Blocks

If you indent paragraph text with 4 spaces or 1 tab, it's no longer a paragraph — it gets parsed as a code block. This is a trap beginners fall into all the time:

This is a regular paragraph.

    This becomes a code block because of the 4-space indent.

Paragraphs and Headings

It's good practice to leave a blank line before and after headings. While some parsers don't require it, building this habit avoids many compatibility issues:

## This is a Heading

Paragraph content below the heading.

Common Issues and Troubleshooting

Why aren't my paragraphs separating?

The two most common causes:

1. No blank line — there must be a completely empty line between paragraphs
2. Invisible characters on the blank line — could be spaces or tabs. While these count as blank lines per the spec, some parsers may handle them inconsistently

Why did multiple lines render as one line?

This is standard Markdown behavior — consecutive lines within a paragraph are merged into a single line. If you want line breaks within a paragraph, use one of the three methods described earlier.

I once wrote several lines in Obsidian and they all merged into one — I thought it was a bug. Later I realized this is just Markdown's design: line breaks within a paragraph are ignored unless you explicitly mark them with trailing spaces or backslashes.

Why did my paragraph turn into a code block?

There are 4 or more spaces, or 1 or more tabs, in front of the paragraph. Check if you accidentally typed extra spaces at the beginning.

Why don't multiple blank lines create more spacing?

In the Markdown spec, multiple consecutive blank lines are equivalent to a single blank line. If you genuinely need larger spacing, you'll need to use HTML (like multiple <br> tags or CSS). You can't achieve it by stacking blank lines.

Trailing double spaces not working?

First check if your editor is automatically stripping trailing whitespace. VS Code, Sublime Text, and other editors do this by default. You can disable this feature in your editor settings, or switch to using backslashes and <br> instead.

Markdown Paragraph Quick Reference

References

• CommonMark Spec — Paragraphs
• Daring Fireball — Markdown Syntax: Paragraphs
• GitHub Docs — Basic Writing and Formatting Syntax
• Markdown Guide — Basic Syntax
• 菜鸟教程 — Markdown 段落