How to convert github-flavored markdown to commonmark
- Step 1Paste or drop your GFM Markdown — Paste the text into the editor above or drop a
.md,.mdx, or.markdownfile. The tool accepts a single Markdown file at a time (acceptsMultipleis false). Free tier caps each file at 1 MB / 500,000 characters. - Step 2Note that there are no options to set — This tool has
needsOptions: false— there are no checkboxes, dropdowns, or presets. The three transforms always run together. If you only want one of them, the Convert Task Lists and Remove Strikethrough guides describe the same engine applied to the same input. - Step 3Run the conversion — Click Run. In one pass the engine rewrites task-list bullets, strikethrough, and bare URLs. The transforms are line- and pattern-based regex replacements — there is no full Markdown parse, so unrelated syntax is preserved exactly as written.
- Step 4Review the diff for the three changed constructs — Compare input and output. Expect
- [ ]/- [x]to lose their checkboxes,~~...~~to become<del>...</del>, and bare links likehttps://example.comto gain angle brackets. Nothing else should differ. - Step 5Handle the constructs this tool does not touch — GFM tables, footnotes (
[^1]), emoji shortcodes (:smile:), and alert blockquotes (> [!NOTE]) pass through unchanged. Strip emoji shortcodes with the Emoji Remover; tables are left as pipe tables (most CommonMark renderers tolerate them as plain text or with a table extension). - Step 6Download the CommonMark-compatible output — Save the result as
.mdand test it in your target renderer. To verify true spec compliance, pass it throughcmark(the CommonMark reference implementation) or your CMS preview. Output type ismarkdown.
What the converter actually transforms
The complete, exhaustive list of changes this tool makes. There are exactly three regex passes — no parser, no options, no other rewrites.
| GFM construct | Input pattern | Output | Done by this tool? |
|---|---|---|---|
| Task list (bullet) | - [ ] todo / - [x] done / * [ ] / + [ ] | - todo / - done (checkbox removed, bullet kept) | Yes |
| Strikethrough | ~~text~~ | <del>text</del> | Yes |
| Bare autolink | https://example.com (not already in <>, [], or ()) | <https://example.com> | Yes |
| GFM pipe table | | a | b | + |---|---| | Unchanged (left as pipe table) | No |
| Footnote | [^1] + [^1]: ... | Unchanged | No |
| Emoji shortcode | :smile: | Unchanged | No (use Emoji Remover) |
| Alert blockquote | > [!NOTE] | Unchanged | No |
Tier limits for the converter
Markdown-family limits from the codebase. The character limit (charLimit) is enforced independently of the file-size limit.
| Tier | Max file size | Max characters | Files per run |
|---|---|---|---|
| Free | 1 MB | 500,000 | 1 |
| Pro | 10 MB | 5,000,000 | 10 |
| Pro-media | 50 MB | 20,000,000 | 50 |
| Developer | 500 MB | Unlimited | Unlimited |
Cookbook
Before/after for a typical GitHub README run through the converter. The output column is the exact engine output, not an idealised rewrite.
A README with all three convertible constructs
A real README mixes a task list, struck text, and a bare support URL. One pass rewrites all three; the heading and code fence are untouched.
Input: # Roadmap - [x] Ship v1 - [ ] ~~Old plan~~ rewrite docs Support: https://example.com/help Output: # Roadmap - Ship v1 - <del>Old plan</del> rewrite docs Support: <https://example.com/help>
Strikethrough survives as visible struck text
CommonMark has no native strikethrough, so the tool emits raw HTML. Any renderer that allows HTML (most do) shows the text struck through.
Input: Price: ~~$99~~ $79 this week. Output: Price: <del>$99</del> $79 this week.
Bare URL gets an angle-bracket autolink
Strict CommonMark only autolinks URLs wrapped in <>. The tool adds them so the link stays clickable after conversion.
Input: Docs live at https://docs.example.com and the API at https://api.example.com. Output: Docs live at <https://docs.example.com> and the API at <https://api.example.com>.
Existing markdown links are left alone
A URL already inside a [text](url) link is preceded by (, which the autolink regex excludes — so inline links are never double-wrapped.
Input: Read the [guide](https://example.com/guide) first. Output: Read the [guide](https://example.com/guide) first. (unchanged)
Tables pass through untouched
This tool does not convert pipe tables. They remain GFM pipe tables in the output; if your renderer needs a table extension, enable it there or keep the table as-is.
Input: | Feature | Status | |---------|--------| | Tables | kept | Output (identical): | Feature | Status | |---------|--------| | Tables | kept |
Edge cases and what actually happens
GFM tables are not converted to HTML
By designDespite a common assumption, this tool does NOT convert pipe tables to <table> HTML. The engine has exactly three regex passes (task lists, strikethrough, autolinks) and tables are not one of them. Pipe tables pass through verbatim. Most CommonMark renderers accept pipe tables via a table extension, or render them as plain text; if you need real HTML tables, render the Markdown with the Markdown to HTML tool instead.
Uppercase `[X]` checkbox is not stripped
Not matchedThe task-list regex matches only [ ] and lowercase [x] (the character class is [ x]). An uppercase - [X] done is left exactly as written. GitHub itself accepts uppercase X, so source files sometimes contain it. Lowercase your [X] checkboxes before converting if you want them stripped.
Ordered-list task items are not touched
Not matchedThe pattern only matches bullet markers (-, *, +). An ordered task item like 1. [ ] step keeps its [ ] because GFM task lists are defined on bullet lists only. If you have ordered checkboxes, convert the marker to a bullet first or remove the [ ] manually.
Strikethrough containing a tilde is skipped
Not matchedThe strikethrough regex is ~~([^~]+)~~ — it matches only runs with no internal ~. So ~~strike with ~ tilde~~ is left unconverted because the inner ~ breaks the [^~]+ group. Remove or escape stray tildes inside struck spans if you need them converted.
A bare URL inside inline code gets corrupted
CautionThe autolink pass does not skip inline code spans. A backtick span like ` curl https://api.example.com becomes curl <https://api.example.com> — the inserted > lands after the closing backtick and breaks the code span. Wrap example URLs in <>` yourself, or keep them in fenced blocks (the autolink regex still matches inside fences too, so prefer pre-wrapping).
Trailing punctuation is captured into the autolink
CautionThe URL pattern is greedy up to whitespace or ), >, ]. A sentence-final URL like See https://example.com. becomes <https://example.com.> — the period is inside the brackets. Some renderers then 404 on the trailing dot. Put a space or wrap the URL manually if the trailing character matters.
URLs with a closing parenthesis are truncated
CautionBecause the regex stops at ), a Wikipedia-style URL like https://en.wikipedia.org/wiki/Markdown_(disambiguation) is wrapped as <https://en.wikipedia.org/wiki/Markdown_(disambiguation>) — the trailing ) falls outside the brackets, breaking the link. Pre-wrap such URLs in <> before running the tool.
Emoji shortcodes and GitHub alerts are preserved
Preserved:smile: shortcodes and alert blockquotes (> [!NOTE], > [!WARNING]) are GFM-specific but are NOT part of this transform — they pass through unchanged. To remove emoji shortcodes use the Emoji Remover. Alerts will render as ordinary blockquotes in a strict renderer because the [!NOTE] marker is just text to it.
Free-tier character limit
413 size capFree tier rejects files over 1 MB or 500,000 characters — and the character limit is checked separately from byte size, so a dense ASCII file can hit 500,000 chars well under 1 MB. Upgrade to Pro (10 MB / 5,000,000 chars) for large documentation sets, or split first with a splitter tool.
Reversing the conversion is manual
By designThere is no reverse mode. To go from CommonMark back to GFM you would re-add ~~ around <del> spans, restore [ ] checkboxes, and remove autolink brackets by hand or with a find-replace tool. The converter is one-directional.
Frequently asked questions
Exactly what does this tool convert?
Three things, in one pass: (1) bullet task-list checkboxes - [ ] / - [x] lose their checkbox and become plain bullets - ; (2) ~~strikethrough~~ becomes <del>strikethrough</del>; (3) bare http(s):// URLs are wrapped in <> angle brackets. Nothing else is changed.
Does it convert GFM tables to HTML?
No. The engine does not touch pipe tables at all — they pass through verbatim. (An older help note claimed tables become HTML; that is not what the code does.) If you need real HTML tables, render with the Markdown to HTML tool instead.
Are footnotes converted?
No. GFM footnotes ([^1] and the [^1]: definition) are left exactly as written. CommonMark has no footnote syntax, so strict renderers will show them as literal text. There is no footnote conversion in this tool.
Will my strikethrough still look struck after conversion?
Yes, in any renderer that allows raw HTML — which is most of them. The tool emits <del>text</del>, and CommonMark passes raw HTML through unchanged. Renderers that strip HTML for security will show the text without the strike; in that case replace <del> with another convention manually.
What happens to checkbox state?
It is lost. Both [ ] (unchecked) and [x] (checked) collapse to a plain bullet with no state marker. CommonMark plain lists cannot represent checkbox state. If state matters, keep the source as GFM and render it with a task-list-aware renderer.
Does it handle nested task lists?
Yes. The task-list regex allows leading whitespace (\s*), so indented - [ ] sub-item becomes - sub-item with the indentation preserved. Nesting structure is kept; only the checkboxes are removed.
Why did one of my bare URLs come out broken?
Two known cases: a URL containing a ) (like a Wikipedia disambiguation link) gets truncated because the regex stops at ), and a sentence-final URL captures the trailing period into the brackets. Wrap such URLs in <> yourself before running the tool to avoid both.
Are there any options or settings?
No. This tool has needsOptions set to false — there are no checkboxes, dropdowns, or presets. The three transforms always run together. There is no way to run just one of them through the UI.
Does it modify code blocks?
Code fences are not given special treatment by the parser, so the task-list and strikethrough patterns rarely fire inside them — but the autolink pass can match a bare URL inside a code span or fence and insert an angle bracket. Pre-wrap example URLs in <> inside code if you want them left alone.
Is my Markdown uploaded anywhere?
No. The conversion runs in your browser using the same engine the API exposes. Your draft text is not sent to a server during conversion. Only an anonymous processed-file counter is recorded for signed-in dashboard stats.
How big a file can I convert?
Free tier: 1 MB or 500,000 characters per file, whichever is hit first, one file at a time. Pro: 10 MB / 5,000,000 chars / 10 files. Pro-media: 50 MB / 20,000,000 / 50. Developer: 500 MB and no character or file-count limit.
How do I verify the output is real CommonMark?
Run it through cmark, the CommonMark reference implementation, or your target renderer's preview. The tool produces CommonMark-compatible output for the three constructs it handles, but constructs it doesn't touch (tables, footnotes, alerts) may still render differently in a strict parser — verify in the actual destination.
Privacy first
All Markdown processing runs locally in your browser using JavaScript. No file is ever uploaded to JAD Apps servers — only metadata counters are saved for signed-in dashboard stats.