# Heading 1

Top-level heading. ATX style with `#`.

## Heading 2

Section heading.

### Heading 3

Sub-section heading. Up to 6 levels (`######`).

Big title
=========

Smaller title
-------------

Alternate heading: `===` underlines H1, `---` underlines H2.

Note: Only H1 and H2 supported in Setext form.

A paragraph is just text
with a soft wrap.

Blank line starts new paragraph.

Plain text separated by blank lines becomes paragraphs.

**bold text** or __bold text__

Wrap text with two `*` or two `_`.

*italic* or _italic_

Single `*` or `_`. Avoid mid-word `_` to prevent surprises.

***bold italic*** or **_mixed_**

Three `*` or combine `**` with `_`.

---

or

***

or

___

Three or more `-`, `*`, or `_` on their own line.

line one  
line two

Two trailing spaces force a hard break inside a paragraph.

Note: Or use a `\` backslash at end of line.

\*literal asterisks\* and \_underscores\_

Backslash before a special character to render it literally.

## Setup {#install}

Some renderers (GitLab, kramdown, Pandoc) accept `{#id}` to override the auto slug.

Note: Not GFM. GitHub ignores the braces and renders them as text.

line one
line two becomes one line

blank line splits paragraphs

A single newline is a soft wrap: it joins into one line. A blank line splits paragraphs.

un**believ**able

`**` works mid-word, but `__` does not — intra-word `_` is left literal in CommonMark.

A literal backtick: \`

Backslash escapes a backtick outside code spans.

- - -

or

* * *

The three rule characters may have spaces between them.

line one\
line two

A trailing backslash forces a hard break — more visible than two spaces.

Note: CommonMark and GFM support it; some older parsers do not.

- apple
- banana
- cherry

Use `-`, `*`, or `+` followed by a space.

1. first
2. second
3. third

Numbers followed by `.`. Numbers can be all `1.` — renderer renumbers.

- top
  - nested
    - deeper
- back to top

Indent nested items by 2 spaces (CommonMark) or 4 (some flavors).

1. ordered
   - bullet
   - bullet
2. ordered

Mix `1.` with `-` at different indent levels.

5. five
6. six
7. seven

The first number sets the start; the rest are renumbered from it.

1) first
2) second

CommonMark also accepts `)` as the ordered-list delimiter, not only `.`.

- item one

- item two

- item three

Blank lines between items make a loose list — each item wraps in `<p>`.

1. First paragraph.

   Second paragraph, indented 3 spaces.
2. Next item.

Indent continuation text to align under the item content to keep it inside.

- step:

  ```sh
  npm run build
  ```

Indent a fenced block under the item (blank line + alignment) to nest it.

Term
: Definition of the term
: Second definition

Pandoc/kramdown/PHP Markdown Extra: term then `:` lines. Not in CommonMark/GFM.

Note: GitHub renders this as plain text.

[Toolora](https://toolora.com)

Most common form. Text in `[]`, URL in `()`.

[Toolora](https://toolora.com "Tooltip")

Quoted string after URL becomes the hover tooltip.

Visit [Toolora][site] today.

[site]: https://toolora.com "Tooltip"

Define the URL elsewhere — handy for repeated links and long URLs.

<https://toolora.com> or <hi@toolora.com>

Bare URL or email wrapped in `<>` becomes clickable.

![alt text](https://toolora.com/logo.png)

Like a link but prefixed with `!`. Alt text shown if image fails.

![alt](https://toolora.com/logo.png "Logo")

Title in quotes appears on hover.

![logo][img]

[img]: https://toolora.com/logo.png

Reference-style for images — same shape as reference links.

Read the [docs][].

[docs]: https://toolora.com/docs

Empty `[]` reuses the link text as the reference label.

See [the readme](./README.md) and [a section](../docs/setup.md#install).

Relative paths resolve against the current file location on most hosts.

[![alt](icon.png)](https://toolora.com)

Nest an image inside a link to make the image clickable.

[Email us](mailto:hi@toolora.com)

Use a `mailto:` URL in a normal inline link to open the mail client.

![build](https://img.shields.io/badge/build-passing-brightgreen)

Badges are just images pointing at a badge service like shields.io.

Run `npm install` then go.

Wrap in single backticks.

Use `` `code` `` if your code contains a backtick.

Double backtick lets you embed a single backtick.

```
const x = 1;
console.log(x);
```

Three backticks on their own lines wrap a multi-line code block.

```js
const x = 1;
console.log(x);
```

Add a language identifier after the opening fence for syntax highlighting.

~~~python
print("hi")
~~~

Tilde `~~~` is an alternate fence — useful when code contains triple backticks.

Normal paragraph.

    indented 4 spaces
    is a code block

Indent 4 spaces (or 1 tab). Older syntax — prefer fenced.

````
```
nested fence shown literally
```
````

A longer fence wraps content that itself contains a triple-backtick fence.

`` `a` ``

One leading and trailing space is stripped, letting the code start/end with a backtick.

```diff
- old line
+ new line
```

The `diff` language colors `+`/`-` lines green and red on GitHub.

```mermaid
graph TD
  A --> B
  B --> C
```

GitHub and GitLab render a ` ```mermaid ` block as a diagram.

Note: Plain CommonMark shows it as a code block.

```json
{
  "name": "toolora",
  "private": true
}
```

Tag the fence `json` for keys-and-values highlighting.

| Name | Age |
| ---- | --- |
| Alice | 30 |
| Bob | 25 |

Pipe-delimited cells. Separator row required.

Note: GFM extension. CommonMark does not include tables.

| Left | Center | Right |
| :--- | :----: | ----: |
| a    | b      | c     |

Use `:` in the separator row: `:---` left, `:---:` center, `---:` right.

| Name | Link |
| ---- | ---- |
| **bold** | [site](https://x.com) |

Cells accept inline formatting: bold, italic, links, inline code.

Note: Block content (lists, fenced code) is NOT allowed in pipe-table cells.

| Name | Code |
| ---- | ---- |
| or   | a \| b |

Use `\|` to put a literal `|` inside a cell.

| A | B | C |
| - | - | - |
| 1 | 2 |
| 1 | 2 | 3 | 4 |

Short rows pad with empty cells; extra cells are dropped.

| A | B |
| - | - |
| 1 | 2 |

A single `-` per column is enough in the separator row.

A | B
--- | ---
1 | 2

Leading and trailing `|` are optional in GFM tables.

| Item | Notes |
| ---- | ----- |
| A | line1<br>line2 |

Use `<br>` for a line break inside a cell — newlines are not allowed.

> This is a quote.
> Wrapped onto a second line.

Prefix each line with `>`.

> Outer quote
> > Inner quote
> back to outer

Use `> >` for nesting.

> ## Quoted heading
>
> Paragraph with **bold**.
>
> - list item

Blockquotes can contain any other Markdown block.

> First line
still the same quote

A line right after a `>` line joins the quote even without its own `>`.

> Run this:
>
> ```sh
> npm ci
> ```

Prefix each fenced-code line with `>` to keep it inside the quote.

> [!NOTE]
> Useful information.

> [!WARNING]
> Be careful here.

GitHub renders `[!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, `[!CAUTION]` as colored callouts.

Note: GitHub-specific. Other renderers show a plain blockquote.

Press <kbd>Ctrl</kbd>+<kbd>C</kbd> to copy.

Inline HTML tags pass through as-is.

<details>
<summary>Click to expand</summary>

Hidden content.

</details>

Block-level HTML passes through. Common for `<details>`, `<table>`.

Note: Many renderers sanitize away <script>, <style>, <iframe>, on* handlers.

<!-- This is a comment, not rendered. -->

HTML comments are stripped from output. Useful as TODO notes.

H<sub>2</sub>O and E = mc<sup>2</sup>

No native syntax — use `<sub>` and `<sup>` HTML tags.

<details open>
<summary>Shown expanded</summary>

Content.

</details>

Add the `open` attribute to render `<details>` already expanded.

<div>

**This is bold** inside a div.

</div>

A blank line after the opening tag lets Markdown render inside the block.

Note: Without the blank line, the inner text is treated as raw HTML.

~~struck through~~

Two `~` on each side. GFM extension.

Note: Not in CommonMark spec — GFM/GitLab/Bitbucket all support.

- [ ] todo
- [x] done
- [ ] another

`- [ ]` for unchecked, `- [x]` for checked. GFM extension.

Note: GitHub/GitLab/Bitbucket render checkboxes; CommonMark renders as text.

Just paste https://toolora.com — GFM auto-links.

GFM extension: bare URLs become links without `<>`.

Note: CommonMark requires `<>`. GitHub/GitLab/Bitbucket auto-link without.

Here is a claim.[^1]

[^1]: Citation goes here.

Inline reference + footnote definition. GFM/GitLab support.

Note: CommonMark does not include footnotes. Bitbucket does not support.

cc @octocat please review

`@user` becomes a link to that user. GitHub-only.

Fixes #42 and closes owner/repo#7

`#123` and `owner/repo#123` auto-link to issues. GitHub/GitLab.

I :heart: Markdown :sparkles:

`:name:` renders as emoji. GitHub-specific extension.

Note: Renders literally on non-GitHub viewers.

- [x] parent done
  - [ ] child todo
  - [x] child done

Indent child checkboxes under a parent item to nest tasks.

Claim one.[^a] Claim two.[^b]

[^a]: First note.
[^b]: Second note.

Labels can be any identifier, not just numbers; output is renumbered in order.

Visit www.toolora.com for tools.

GFM auto-links bare `www.` hosts, adding `http://` for you.

Note: CommonMark does not auto-link www-only hosts.

Fixed in a1b2c3d and owner/repo@f4e5d6c

GitHub auto-links 7+ char commit hashes, optionally `owner/repo@sha`.

Ship it 🚀 — works everywhere.

A pasted Unicode emoji renders on every viewer, unlike `:shortcode:`.

# Heading

Paragraph with [link](url) and `code`.

The strict baseline spec. No tables, no task lists, no strikethrough, no footnotes.

CommonMark + tables + task lists + ~~strike~~ + autolinks + emoji + @mentions + #refs

Superset of CommonMark. Adds tables, task lists, strikethrough, autolinks, emoji, @mentions, #issue refs.

GFM + math via $...$ + diagrams + video/audio embeds

GFM superset. Adds math `$...$`, mermaid diagrams, video/audio embeds, MR refs.

CommonMark base + anchor prefix: #markdown-header-my-heading

Closer to CommonMark. Anchors use `markdown-header-` prefix — GFM-style intra-doc links break.

See [Setup](#setup) below.

## Setup

Headings get auto-generated `id` slugs. Link via `#slug`. Slug rules differ per host.

![Demo](demo.mp4)

GitLab renders video formats as a `<video>` player. GitHub/Bitbucket render as a broken image.

Inline: $E = mc^2$

Block:
```math
\sum_{i=1}^n i = \frac{n(n+1)}{2}
```

GitLab supports `$...$` inline and ` ```math ` block. GitHub uses `$...$` since 2022.

---
title: My Post
date: 2026-05-30
---

Body starts here.

Jekyll, Hugo, Astro and 11ty read a `---` fenced YAML block for metadata.

Note: Plain CommonMark renders the first `---` as a horizontal rule.

[[_TOC_]]

GitLab inserts an auto table of contents at `[[_TOC_]]` (or `[TOC]` on some hosts).

Note: GitHub renders its own TOC from the file outline, no marker needed.

This is ==highlighted== text.

`==text==` becomes `<mark>` in Obsidian, Pandoc and some others. Not in GFM.

[[Page Name]] and [[Page Name|display text]]

Obsidian, GitHub wikis and DokuWiki link by page title with `[[...]]`.

Note: Not part of CommonMark or GFM document Markdown.

> [!info] Title
> Body of the callout.

Obsidian extends blockquotes with `[!type]` callouts (info, tip, warning, …).

[//]: # (This is an invisible comment.)

A link-reference definition with no use renders nothing — a portable comment.