markdown-it vs turndown vs showdown
Markdown Libraries Comparison
Search packages..
1 Year
markdown-itturndownshowdownSimilar Packages:
What's Markdown Libraries?

Markdown libraries are essential tools for web developers who need to parse, convert, or manipulate Markdown content. These libraries facilitate the transformation of Markdown text into HTML, enabling seamless integration of user-generated content, documentation, or any text formatted in Markdown. They provide various features such as extensibility, customization options, and support for different Markdown flavors, which can significantly enhance the development process and improve user experience.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
markdown-it7,498,80819,039767 kB48a year agoMIT
turndown1,038,4409,337192 kB1349 months agoMIT
showdown748,98714,487801 kB222-MIT
Feature Comparison: markdown-it vs turndown vs showdown

Extensibility

  • markdown-it:

    markdown-it is designed with extensibility in mind, allowing developers to create custom plugins that can modify the parsing process or add new features. This makes it suitable for applications that require specific Markdown syntax or additional functionality beyond the standard Markdown capabilities.

  • turndown:

    turndown is also extensible, allowing developers to customize the conversion process from HTML to Markdown. You can define custom rules for how specific HTML elements should be converted, making it adaptable for various HTML structures.

  • showdown:

    showdown offers limited extensibility options compared to markdown-it. While it provides some configuration options, it does not support a plugin architecture, making it less flexible for advanced use cases that require custom behavior or additional features.

Performance

  • markdown-it:

    markdown-it is known for its high performance, capable of parsing large Markdown documents quickly. Its architecture is optimized for speed, making it suitable for applications that need to handle a significant amount of Markdown content efficiently.

  • turndown:

    turndown performs well for converting HTML to Markdown, but its performance can vary depending on the complexity of the HTML being processed. For straightforward HTML structures, it is efficient, but intricate layouts may introduce some overhead.

  • showdown:

    showdown is lightweight and performs well for basic Markdown conversion tasks. However, it may not be as fast as markdown-it when dealing with larger documents or more complex Markdown features.

Learning Curve

  • markdown-it:

    markdown-it has a moderate learning curve due to its extensive features and plugin system. Developers familiar with Markdown will find it relatively easy to get started, but mastering its full capabilities may take some time.

  • turndown:

    turndown has a gentle learning curve, especially for developers who are already familiar with Markdown and HTML. Its API is simple and intuitive, allowing for quick adoption.

  • showdown:

    showdown is straightforward and easy to learn, making it an excellent choice for beginners or those looking for quick Markdown conversion without the need for complex configurations.

Use Cases

  • markdown-it:

    markdown-it is ideal for applications that require advanced Markdown features, such as custom syntax, syntax highlighting, or integration with other libraries. It's perfect for content management systems, documentation sites, and any application that needs robust Markdown support.

  • turndown:

    turndown is specifically designed for converting HTML back to Markdown, making it perfect for applications that need to extract Markdown from existing content, such as editors or converters.

  • showdown:

    showdown is best suited for projects that need basic Markdown to HTML conversion, such as blogs or simple text editors. Its simplicity makes it a good choice for lightweight applications.

Community and Support

  • markdown-it:

    markdown-it has a strong community and is actively maintained, with a variety of plugins available. This support network can be beneficial for developers seeking help or looking to extend the library's functionality.

  • turndown:

    turndown has a growing community and is actively maintained. It has good documentation and examples, which can help developers implement it effectively in their projects.

  • showdown:

    showdown has a smaller community compared to markdown-it, but it is still actively maintained. Documentation is straightforward, making it easy for developers to find the information they need.

How to Choose: markdown-it vs turndown vs showdown
  • markdown-it:

    Choose markdown-it if you need a highly extensible Markdown parser that supports plugins and offers a fast and efficient way to convert Markdown to HTML. It is particularly useful for applications that require customization and flexibility in rendering Markdown content.

  • turndown:

    Opt for turndown if your goal is to convert HTML back to Markdown. This library excels in transforming HTML content into Markdown format, making it ideal for applications that need to extract Markdown from existing HTML documents.

  • showdown:

    Select showdown if you are looking for a straightforward and easy-to-use library for converting Markdown to HTML. It is lightweight and offers a simple API, making it suitable for projects that require basic Markdown functionality without the need for extensive customization.

Similar Npm Packages to markdown-it

markdown-it is a powerful Markdown parser and compiler for JavaScript. It allows developers to convert Markdown text into HTML, making it a popular choice for applications that require rich text formatting. With its extensible architecture, markdown-it supports a variety of plugins that can enhance its functionality, such as adding support for tables, footnotes, and custom syntax. Its performance and flexibility make it suitable for both small projects and large applications that need to render Markdown content efficiently.

While markdown-it is a robust option, there are other libraries available that also provide Markdown parsing capabilities. Here are a few alternatives:

  • remark is a Markdown processor powered by plugins. It is part of the unified ecosystem, which allows for a wide range of transformations on Markdown content. remark focuses on the syntax tree, enabling developers to manipulate Markdown in a more programmatic way. This makes it an excellent choice for projects that require extensive customization and processing of Markdown content, such as static site generators or documentation tools. With its plugin architecture, remark can be tailored to fit specific needs, making it highly versatile.

  • showdown is another popular Markdown to HTML converter. It is lightweight and easy to use, making it a great choice for simple applications that need to convert Markdown to HTML without the overhead of additional features. showdown is particularly useful for projects where performance is a priority, as it has a minimal footprint and straightforward API. If you need a quick and efficient way to render Markdown in your application without the need for extensive customization, showdown is an excellent option.

To compare these packages, check out the following link: Comparing markdown-it vs remark vs showdown.

Similar Npm Packages to turndown

turndown is a JavaScript library that converts HTML into Markdown. It is designed to be simple and flexible, allowing developers to easily transform HTML content into a Markdown format that can be used in various applications, such as blogs, documentation, and note-taking tools. While turndown provides a robust solution for converting HTML to Markdown, there are other libraries available that also serve similar purposes. Here are a few alternatives:

  • markdown-it is a powerful Markdown parser that can convert Markdown text into HTML. It is highly customizable and supports a variety of plugins to extend its functionality. While markdown-it is primarily focused on parsing Markdown, it can be used in conjunction with other libraries to handle HTML conversion. If you need a comprehensive solution for both parsing Markdown and rendering it as HTML, markdown-it is an excellent choice.
  • showdown is another library that converts Markdown into HTML. It is lightweight and easy to use, making it a popular choice for developers who need a straightforward solution for rendering Markdown content. Showdown supports various Markdown features and can be extended with custom options. If your primary goal is to convert Markdown to HTML rather than the other way around, showdown is a solid option.

To explore how turndown compares with markdown-it and showdown, check out the comparison: Comparing turndown vs markdown-it vs showdown.

Similar Npm Packages to showdown

showdown is a popular JavaScript library that converts Markdown into HTML. It is lightweight and easy to use, making it a great choice for developers looking to integrate Markdown support into their web applications. Showdown provides a simple API for converting Markdown text to HTML, and it supports a variety of Markdown features, including tables, lists, and code blocks. Its flexibility and ease of integration make it a preferred option for many developers working with Markdown content.

However, there are several alternatives to Showdown that also provide Markdown parsing and rendering capabilities. Here are a few noteworthy options:

  • markdown-it is a powerful Markdown parser that is highly extensible and customizable. It supports a wide range of Markdown features and allows developers to create plugins to extend its functionality. Markdown-it is known for its performance and flexibility, making it suitable for applications that require advanced Markdown processing. If you need a robust solution with a rich plugin ecosystem, markdown-it is an excellent choice.

  • marked is another fast and lightweight Markdown parser that is designed for speed and efficiency. It is simple to use and provides a straightforward API for converting Markdown to HTML. Marked is particularly known for its performance, making it ideal for applications that need to render large amounts of Markdown content quickly. If you prioritize speed and simplicity, marked is a solid option.

  • remarkable is a Markdown parser that focuses on extensibility and customization. It offers a variety of features, including support for custom syntax and plugins. Remarkable is designed to be fast and efficient while providing a high level of customization for developers who need specific Markdown features. If you are looking for a parser that allows for deep customization, remarkable is worth considering.

To compare these packages and see how they stack up against each other, check out the following link: Comparing markdown-it vs marked vs remarkable vs showdown.

README for markdown-it

markdown-it

CI NPM version Coverage Status Gitter

Markdown parser done right. Fast and easy to extend.

Live demo

  • Follows the CommonMark spec + adds syntax extensions & sugar (URL autolinking, typographer).
  • Configurable syntax! You can add new rules and even replace existing ones.
  • High speed.
  • Safe by default.
  • Community-written plugins and other packages on npm.

Table of content

Install

node.js:

npm install markdown-it

browser (CDN):

Usage examples

See also:

Simple

// node.js
// can use `require('markdown-it')` for CJS
import markdownit from 'markdown-it'
const md = markdownit()
const result = md.render('# markdown-it rulezz!');

// browser with UMD build, added to "window" on script load
// Note, there is no dash in "markdownit".
const md = window.markdownit();
const result = md.render('# markdown-it rulezz!');

Single line rendering, without paragraph wrap:

import markdownit from 'markdown-it'
const md = markdownit()
const result = md.renderInline('__markdown-it__ rulezz!');

Init with presets and options

(*) presets define combinations of active rules and options. Can be "commonmark", "zero" or "default" (if skipped). See API docs for more details.

import markdownit from 'markdown-it'

// commonmark mode
const md = markdownit('commonmark')

// default mode
const md = markdownit()

// enable everything
const md = markdownit({
  html: true,
  linkify: true,
  typographer: true
})

// full options list (defaults)
const md = markdownit({
  // Enable HTML tags in source
  html:         false,

  // Use '/' to close single tags (<br />).
  // This is only for full CommonMark compatibility.
  xhtmlOut:     false,

  // Convert '\n' in paragraphs into <br>
  breaks:       false,

  // CSS language prefix for fenced blocks. Can be
  // useful for external highlighters.
  langPrefix:   'language-',

  // Autoconvert URL-like text to links
  linkify:      false,

  // Enable some language-neutral replacement + quotes beautification
  // For the full list of replacements, see https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs
  typographer:  false,

  // Double + single quotes replacement pairs, when typographer enabled,
  // and smartquotes on. Could be either a String or an Array.
  //
  // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
  // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
  quotes: '“”‘’',

  // Highlighter function. Should return escaped HTML,
  // or '' if the source string is not changed and should be escaped externally.
  // If result starts with <pre... internal wrapper is skipped.
  highlight: function (/*str, lang*/) { return ''; }
});

Plugins load

import markdownit from 'markdown-it'

const md = markdownit
  .use(plugin1)
  .use(plugin2, opts, ...)
  .use(plugin3);

Syntax highlighting

Apply syntax highlighting to fenced code blocks with the highlight option:

import markdownit from 'markdown-it'
import hljs from 'highlight.js' // https://highlightjs.org

// Actual default values
const md = markdownit({
  highlight: function (str, lang) {
    if (lang && hljs.getLanguage(lang)) {
      try {
        return hljs.highlight(str, { language: lang }).value;
      } catch (__) {}
    }

    return ''; // use external default escaping
  }
});

Or with full wrapper override (if you need assign class to <pre> or <code>):

import markdownit from 'markdown-it'
import hljs from 'highlight.js' // https://highlightjs.org

// Actual default values
const md = markdownit({
  highlight: function (str, lang) {
    if (lang && hljs.getLanguage(lang)) {
      try {
        return '<pre><code class="hljs">' +
               hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +
               '</code></pre>';
      } catch (__) {}
    }

    return '<pre><code class="hljs">' + md.utils.escapeHtml(str) + '</code></pre>';
  }
});

Linkify

linkify: true uses linkify-it. To configure linkify-it, access the linkify instance through md.linkify:

md.linkify.set({ fuzzyEmail: false });  // disables converting email to link

API

API documentation

If you are going to write plugins, please take a look at Development info.

Syntax extensions

Embedded (enabled by default):

Via plugins:

Manage rules

By default all rules are enabled, but can be restricted by options. On plugin load all its rules are enabled automatically.

import markdownit from 'markdown-it'

// Activate/deactivate rules, with currying
const md = markdownit()
  .disable(['link', 'image'])
  .enable(['link'])
  .enable('image');

// Enable everything
const md = markdownit({
  html: true,
  linkify: true,
  typographer: true,
});

You can find all rules in sources:

Benchmark

Here is the result of readme parse at MB Pro Retina 2013 (2.4 GHz):

npm run benchmark-deps
benchmark/benchmark.mjs readme

Selected samples: (1 of 28)
 > README

Sample: README.md (7774 bytes)
 > commonmark-reference x 1,222 ops/sec ±0.96% (97 runs sampled)
 > current x 743 ops/sec ±0.84% (97 runs sampled)
 > current-commonmark x 1,568 ops/sec ±0.84% (98 runs sampled)
 > marked x 1,587 ops/sec ±4.31% (93 runs sampled)

Note. CommonMark version runs with simplified link normalizers for more "honest" compare. Difference is ≈1.5×.

As you can see, markdown-it doesn't pay with speed for its flexibility. Slowdown of "full" version caused by additional features not available in other implementations.

markdown-it for enterprise

Available as part of the Tidelift Subscription.

The maintainers of markdown-it and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. Learn more.

Authors

markdown-it is the result of the decision of the authors who contributed to 99% of the Remarkable code to move to a project with the same authorship but new leadership (Vitaly and Alex). It's not a fork.

References / Thanks

Big thanks to John MacFarlane for his work on the CommonMark spec and reference implementations. His work saved us a lot of time during this project's development.

Related Links:

  • https://github.com/jgm/CommonMark - reference CommonMark implementations in C & JS, also contains latest spec & online demo.
  • http://talk.commonmark.org - CommonMark forum, good place to collaborate developers' efforts.

Ports

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.