Quikdown vs marked vs markdown-it: 17KB Markdown Parser Showdown (2026)

A new Show HN project called Quikdown hit the front page on June 21, 2026 with a striking claim: a Markdown parser that fits both directions (MD→HTML and HTML→MD) into a 17 KB single-file bundle. For a privacy-first client-side tool like md2rich, where every kilobyte adds to first-load time and every dependency adds attack surface, Quikdown is the most interesting parser release since marked v18. Here is how the three libraries stack up and when to pick which.

What Quikdown Is (and Why a Show HN)

Quikdown is a regex-based Markdown parser written by David Williams (deftio). It has zero runtime dependencies, no eval, no dynamic RegExp, escapes HTML by default, and sanitizes URLs to block javascript:, vbscript:, and data: URIs. The README states the motivation plainly: working with many different LLM frameworks and wanting to test tool calling and collaborative editing.

The headline feature is bidirectional conversion. Most parsers (marked, markdown-it) only do Markdown→HTML. Quikdown ships a separate quikdown/bd module that round-trips Quikdown's own annotated HTML back to Markdown — useful for editors where the user might edit in the rendered view and want the change reflected in the source.

The Show HN post (news.ycombinator.com/item?id=48616229) reached 7 points within three days and zero comments as of writing. Small signal, but the bundle-size claim is verifiable.

Bundle Size: Measured, Not Claimed

Marketing claims of "17 KB" are easy to inflate. To verify Quikdown's bundle, the minified ESM file was fetched from jsDelivr and measured in bytes. For comparison, marked and markdown-it were measured the same way on the same day:

The numbers tell a clear story. Quikdown core is 2.3× smaller than marked and 7.2× smaller than markdown-it. Even Quikdown's full bidirectional module (22 KB) is still 1.7× smaller than marked alone — and marked does not include HTML→MD at all. For a privacy-first client-side tool where every kilobyte is a privacy-cost (the user has to download it before rendering), Quikdown's footprint matters.

API: Same Shape, Smaller Body

All three parsers expose roughly the same calling convention. The following renders the same GFM table from each library:

marked

markdown-it

Quikdown

The drop-in nature is the headline. A client-side converter like md2rich could swap marked.parse(md) for quikdown(md) with no other code changes. The reverse direction is also available via quikdown/bd:

That round-trip is the part md2rich-style apps may want for future features like "edit rendered view, get Markdown back." It is not what md2rich needs today — but it is a free upgrade path.

Feature Parity: What You Lose by Switching

Quikdown's README is explicit: Quikdown intentionally does not try to be a full CommonMark implementation or a ProseMirror replacement. That sentence is the trade-off in one line. Here is what the three libraries actually support for the features that matter in client-side converters:

For the 90% of use cases that are headings, bold, italics, links, lists, code blocks, and tables, all three parsers produce identical output. The differences show up in edge cases — nested list indentation, raw HTML passthrough, definition lists. md2rich does not use those edge cases, so the trade-off is not felt in the product.

The Critical Distinction: Quikdown's HTML→MD Scope

This is the part that trips people up. Quikdown's toMarkdown() function is designed to round-trip Quikdown's own annotated HTML — not arbitrary text/html pasted from a browser or a Word document. The README says this in plain language: It is not intended to be a generic arbitrary-HTML-to-Markdown converter.

For md2rich, the source is always Markdown you wrote. That is exactly the case where Quikdown is a clean drop-in. But for apps that need to ingest pasted rich content from third-party sources — say, a browser's clipboard HTML from a Notion export — Quikdown's reverse direction will produce surprising output. Libraries like Turndown or marked-it are built specifically for that job.

For client-side converters where you own the source Markdown, the recommended stack is:

• Quikdown core (17 KB) for Markdown→HTML rendering
• Your own DOM-walking logic for clipboard HTML→rich-text (which is what md2rich actually does today)
• Quikdown /bd (22 KB) only if you also want rendered-view editing

Browser-Ready: No Build Step Needed

One of the underrated features of Quikdown for client-side apps is the UMD bundle. Drop it into any HTML page and it just works:

The same script tag works in Node, Deno, and via import quikdown from 'quikdown' in any modern bundler. ESM and CJS bundles ship alongside UMD in the dist/ directory.

When to Pick Which

Use this quick rule of thumb:

Production Readiness: Young But Maintained

Quikdown is a 14-star project created August 15, 2025. That is young. Two markers push it into "production usable" territory:

• Active maintenance: the latest release v1.2.21 was published on June 20, 2026 — four days before this article. 24 tags and 125 commits in 10 months indicate a real project, not a weekend hack.
• Security by default: HTML is escaped, URLs are sanitized against javascript:/vbscript:/data:, no eval, no dynamic RegExp, 99.3% test coverage. These are the design choices that matter for client-side converters handling untrusted Markdown input.

That said, the ecosystem around Quikdown is thin. marked and markdown-it have years of plugins, Stack Overflow answers, and battle-tested edge case fixes. If your project already uses one of them and you do not have a bundle-size problem, the migration cost is not worth it. If you are starting fresh and bundle size is on your requirements list, Quikdown deserves a serious look.

The md2rich Perspective

md2rich is a 100% client-side Markdown to rich-text converter. Its single biggest constraint is: everything must work in a browser tab without a build step and without uploading user content to a server. That constraint maps directly onto Quikdown's design:

• Zero dependencies — matches the privacy promise
• No eval and no dynamic RegExp — matches the "no surprises in user content" guarantee
• 17 KB core bundle — first load is essentially instant on any connection
• ESM / UMD / CJS — works in the existing single-file md2rich deployment
• HTML escaping and URL sanitization on by default — protects users from pasted Markdown that contains hostile HTML

For an app whose source code is one HTML file plus one CSS file plus one JS file, swapping a 40 KB marked for a 17 KB Quikdown is not an abstract optimization — it is a 23 KB reduction in what every visitor downloads. On a slow 3G connection, that is the difference between "instant" and "noticeable."

FAQ

Conclusion

Quikdown is not a replacement for marked and markdown-it in every situation. It is a replacement in a specific situation: a privacy-first client-side converter where bundle size, zero dependencies, and XSS safety are requirements. In that situation — which is exactly what md2rich is built for — Quikdown is the cleanest option on the market as of June 2026.

If you are building a converter, an editor, or any client-side Markdown tool and you are currently on marked, run the numbers: a 23 KB reduction in your main JS bundle, no dependencies to audit, the same call signature, and a free upgrade path to bidirectional editing when you need it. That is what a Show HN project looks like when it solves a real problem.