Brookmd vs md2rich: Rust Streaming Markdown 2026

A new Show HN project called Brookmd landed in late July 2026 with an unusual claim: a Markdown renderer built entirely in Rust that streams the rendered output token by token as the parser reads the input. No waiting for the full AST to assemble. No blocking render pass at the end. Just a continuous pipeline from Markdown text to rich-text output, with the first visible characters appearing microseconds after the first keystroke.

The tool, by GitHub user siinghd, opens a third axis in the Markdown rendering conversation. Most tools compete on feature completeness (does it support tables, footnotes, GFM, math?). A smaller set competes on bundle size (marked at 17 KB, markdown-it at 20 KB, Quikdown at 17 KB). Brookmd competes on latency to first rendered pixel, and it does it by rewriting the rendering pipeline entirely in Rust with a WASM compile target.

This article compares Brookmd to md2rich, explains the streaming approach, and helps you decide which tool fits your Markdown workflow in 2026.

What Brookmd Does

Brookmd is not a Markdown-to-clipboard converter. It is a streaming rich-text renderer that takes Markdown input and produces styled rich-text output incrementally. The core architecture has three layers:

• A Rust parser that tokenizes Markdown into an event stream. Each event (heading open, paragraph, bold, link, code fence open, code fence close) fires a callback that the rendering layer immediately processes.
• A streaming rendering backend that maps events to styled output on the target platform. The Web backend writes to a DOM fragment. The React Native backend writes to a native text component. The Sift backend writes to a Rust-native canvas.
• Platform adapters that abstract the output target. The same Rust parser feeds into Web WASM, React Native, or Sift without changing a line of the parsing code.

The streaming model means a 10 KB Markdown document starts rendering before the parser has read the entire file. For a 10 KB file, the end-to-end latency to first rendered pixel is quoted at under 2 ms. For comparison, a typical JavaScript parser (marked, markdown-it) parses the whole AST before beginning the render pass, which adds 6-10 ms of latency for the same input. The difference is negligible for a human typing into an editor, but meaningful for programmatic rendering pipelines or collaborative editor streams.

Brookmd vs md2rich: Side-by-Side

When to Use Each Tool

The comparison above makes one thing clear: Brookmd and md2rich are not competitors. They operate on different parts of the Markdown workflow.

Use Brookmd when:

• You are building a Markdown editor or note-taking app and need a fast embedded preview pane.
• You need Markdown rendering in a React Native app where JavaScript Markdown parsers have limited native support.
• You are working with very large Markdown documents (50+ KB) where streaming makes the difference between a visible preview in 2 ms versus 20 ms.
• You control the app delivery pipeline and can include a ~2-5 MB WASM binary without user friction.

Use md2rich when:

• You need to convert a finished Markdown document into formatted rich text that you can paste into X Articles, LinkedIn, Medium, Substack, or Notion.
• You want a privacy-first tool that runs entirely in the browser with zero server uploads.
• You need a lightweight solution that loads instantly (150 KB, no WASM download).
• You are a writer, not an app developer, and you want the publishing workflow to be as simple as paste-and-copy.

There is also a natural composition: use Brookmd as the live preview engine inside a custom Markdown editor, write your drafts there, and when the draft is finished, convert it through md2rich for platform publishing. The streaming renderer handles the editing phase; the batch converter handles the publishing phase.

Markdown Example: md2rich in Action

Here is a quick Markdown example. Write this in your editor:

# My Post Title

**Key insight:** Streaming Markdown rendering is fast, but
batch conversion is what your publishing workflow needs.

- Write in Markdown in any editor
- Convert with md2rich (client-side, no upload)
- Paste into X Articles, LinkedIn, or Medium
- Publish with full formatting intact

Open md2rich.com, paste the Markdown into the left panel, click Copy as Rich Text, then paste into your target platform. The formatting survives: headings render as headings, bold as bold, lists as lists. No server round-trip, no account, no upload.

This is the core difference from the Brookmd approach. Brookmd renders the Markdown for you to look at. md2rich renders the Markdown for you to paste somewhere. Both are valid; they serve different moments in the same writing lifecycle.

The Rust-in-the-Browser Trend

Brookmd is part of a larger 2026 trend: Rust in the browser. Satteri (the Astro team's Rust Markdown pipeline, covered in a previous article) took a similar approach for the build-time rendering side. Brookmd takes it to the client side.

The common thread is that Rust+WASM lets developers push performance boundaries that JavaScript alone struggles with: streaming, parallel parsing, sub-millisecond first paint, and shared code across Web, mobile, and desktop via the same Rust core. The tradeoff is WASM binary size, which remains 10-50 times larger than equivalent JavaScript libraries, and the cold-start download cost for users who visit a page that uses a Rust renderer for the first time.

For md2rich, the batch-conversion model converges on a different tradeoff: zero download (the app is already loaded when you visit the page), zero streaming complexity, and a 150 KB footprint that loads in milliseconds even on a slow connection. Batch conversion is the right model for publishing because the output needs to be deterministic and complete before the paste action. Streaming is the right model for live editing because the user needs to see feedback while typing. Both models have their place.

FAQ

What is Brookmd?

Brookmd is a streaming Markdown renderer written in Rust. It renders Markdown as a stream of rich-text tokens rather than a completed HTML document, which means the first rendered content appears before the entire Markdown input has been parsed. It targets Web (via WASM), React Native, and Sift (a Rust-native UI framework). It was shared as a Show HN project in July 2026 by GitHub user siinghd.

How does Brookmd differ from md2rich?

Brookmd and md2rich serve different parts of the Markdown pipeline. Brookmd renders Markdown into a streaming rich-text display (think: a live preview pane that populates as-you-type, but powered by Rust/WASM). md2rich converts Markdown into the platform clipboard format that X Articles, LinkedIn, Medium, Substack, and Notion accept. Brookmd is a renderer you embed in your own app; md2rich is a client-side converter you use in your browser to publish long-form content.

Is Brookmd faster than JavaScript-based Markdown renderers?

Benchmarks from the Brookmd Show HN post suggest Rust streaming can parse and begin rendering a 10 KB Markdown document in under 2 ms, which is roughly 3 to 5 times faster than a modern JavaScript parser for the same input. For most real-world use (editing a blog post or a README), the difference is imperceptible to a human. The advantage becomes meaningful when rendering very large Markdown documents, streaming incremental updates from a collaborative editor, or embedding the renderer in a resource-constrained environment like React Native.

Does Brookmd work inside a browser?

Yes. Brookmd compiles to WASM and ships a Web target. You can embed the streaming renderer in a browser-based Markdown editor or preview pane. The Rust core compiles to a WASM binary that the browser loads once, and subsequent renders reuse the compiled binary. The streaming output can be piped into a virtual DOM or a canvas renderer. The tradeoff is the initial WASM binary size (a few MB gzipped for the full pipeline) versus a JavaScript library like marked or markdown-it that ships in 10-20 KB.

When should I use Brookmd instead of md2rich?

Use Brookmd when you are building an application that needs a streaming Markdown preview pane and you can afford the WASM binary size. Use md2rich when you need to convert Markdown into paste-ready rich text for social and publishing platforms. They are complementary: you could author Markdown in an editor that uses Brookmd for live preview, then copy the Markdown source and push it through md2rich when you are ready to publish to X, LinkedIn, Medium, or Substack.

Is md2rich a streaming renderer?

No. md2rich is a client-side batch converter. You paste the full Markdown document, click Copy as Rich Text, and the entire conversion happens synchronously in JavaScript. There is no streaming pipeline. The design tradeoff is deliberate: for publishing workflows, you want the complete output before you paste it into a platform editor, not an incremental stream. Streaming is better for live previews where the user is actively editing; batch conversion is better for publishing where the source document is already finished.