Library / SDK
showdownjs/showdown avatar
showdownjs/showdown

showdown's manifest is a 3.0 release candidate, its newest release is from 2022, and its ESM build sits behind the browser condition

A bidirectional Markdown to HTML to Markdown converter written in Javascript

14,881 stars1,559 forksJavaScriptMIT

At a glance

What is it?
Showdown converts Markdown to HTML and back, in a browser or on a server. It is MIT licensed, its default branch was pushed to on 2026-10-29, and its front page still documents installation through Bower and a package manager for .NET. The package manifest tells a different story: it requires a modern Node, ships an exports map, and points its browser condition at the module build while pointing both its import and require conditions at the CommonJS one.
Who is it for?
This is still the right library if you need the reverse direction, since converting HTML back to Markdown is the half that most converters do not do and the reason this one exists. It runs in the browser and in Node, and part of its test suite is extracted from the CommonMark specification.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 11 days ago.
What is it written in?
Mainly JavaScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • showdownjs/showdown14,881 ★ · +9
Star history
Repository2026-09-222026-11-15
showdownjs/showdown14.9k14.9k

9 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The manifest is a 3.0 release candidate and the newest release is from 2022

The version in the package manifest and the version in the release list are four years and a major version apart.

The manifest declares a 3.0 release candidate. The three most recent published releases are 2.1.0 and two releases before it, from March and April 2022, two of them on the same day about ten minutes apart.

So the working tree is on the next major version and the registry's latest is still the last release of the previous one. Everything committed to the default branch since that April is not in a published version.

The default branch was pushed to on 2026-10-29, so the work is very much alive. This is a project that is developed continuously and released rarely, which is a defensible choice for a library with this many dependents, because a major version bump on a Markdown converter breaks everyone's output.

The licensing note is worth pairing with it. The front page says that from the second major version onwards the library is under the MIT licence, and that previous versions were under a different one. The manifest agrees for the current candidate. So if you read old documentation that quotes the earlier terms, they describe code you are no longer running.

The consequence is that pinning by recency and pinning by version number are different decisions, and here they are a major version apart. If you need the current code, take the repository or a pre-release; if you need a stable artefact, you are four years behind.

The module build is reachable only through the browser condition

The exports map in the package manifest is unusual, and if you are bundling this it is the part most likely to surprise you.

There is one main entry. It resolves four ways. A browser condition, which points at the module build. An import condition, which points at the main file. A require condition, which also points at that same main file. And a default condition, pointing at it again.

So the import and require conditions resolve to the identical file, and that file is the CommonJS one, because the manifest declares the package type as CommonJS.

Which means a Node consumer importing the package name gets the CommonJS build; the module build is reachable through the browser condition, the legacy module field, or a deep import under ./dist/*.

That is arguably deliberate: a bundler targeting the browser gets the ESM file, and Node gets an interop-wrapped CommonJS file, which is the safe default. But it is the reverse of the usual arrangement, where the import condition is the one that points at the module build.

There are two other subpath exports, and they are worth noticing. One exposes everything under the build directory as a wildcard subpath. The other exposes the package manifest. So a consumer can deep-import a build artefact by path rather than through the documented entry point.

The main entry resolves four ways, and two of them point at the same file:

code
".": {
  "browser": "./dist/showdown.esm.js",
  "import": "./dist/showdown.js",
  "require": "./dist/showdown.js",
  "default": "./dist/showdown.js"
}

The consequence is that if you are writing server-side code, do not assume a module-only toolchain gets you an ES module here. Check what your resolver hands you before you write import statements, because the answer is the CommonJS build.

The front page documents Bower, a .NET package, and browsers from 2004

The installation and compatibility sections of the front page describe a library from a different decade, and they sit on the same page as a manifest requiring a current Node.

The installation section offers four routes. A tarball from the releases page. A package manager for web components that has been effectively dead for years. The npm registry for server-side use. And a package for the .NET ecosystem.

So a .NET developer is told how to install this, and the package metadata at the top of the repository contains no .NET packaging information at all. There is a Bower metadata file still checked in at the top level.

The browser compatibility section is the sharper version of the same problem. It lists seven browsers with version numbers: Firefox 1.5 and 2.0, Chrome 12.0, Internet Explorer 6 and 7, Safari 2.0.4, Opera 8.54 and 9.10, Netscape 8.1.2, and Konqueror 3.5.4.

The stated theoretical floor is the third edition of the language specification, described in the same line as JavaScript 1.5. And the line after it says the converter itself might work in things that are not web browsers, like a document reader, with no promises.

Meanwhile the manifest requires a modern Node, has an engines field, and uses a conditional exports map, which is a feature of module resolution that none of those browsers has.

The consequence is that the compatibility section cannot be used to decide anything in 2026. The manifest is the authoritative statement of what the package needs, and it says the opposite of what the front page says.

The test suite is extracted from published Markdown specifications

The scripts in this repository tell you how correctness is established, and the approach is better than hand-written tests.

There are two extraction scripts. One pulls test cases out of the CommonMark specification. Another pulls spec tests from a second source. There is a directory of specs at the top level alongside them.

So at least part of the test suite is extracted from the CommonMark specification rather than written by hand, which means conformance is measured against an external definition.

That is the right design for a converter whose entire job is matching someone else's rules. It also means the tests can be regenerated when a specification changes, rather than hand-edited.

There are three test configurations. One for the default suite, one for browser-based tests using a browser environment inside the test runner, and one Playwright configuration pointing at a hosted browser service, with a matching configuration file for that service at the top level.

So a change is checked in a simulated browser and in a real one on somebody else's infrastructure.

The consequence is that you can trust the converter's Markdown conformance more than you could for a library with hand-written fixtures, because the fixtures are not the maintainer's. The gap to check is the extensions, which the specifications do not cover.

Performance results are committed to the repository and a task list is checked in beside them

Two files at the top level are unusual enough to be worth naming, and both tell you something about how the project is run.

One is a machine-readable performance file. The other is a markdown log of performance results. Both are committed, so you can read the numbers and the history of the numbers without running anything.

Committing benchmarks is a mixed practice. It means a regression is visible in review rather than discovered in production, which is the good case. It also means the numbers go stale the moment the machine or the workload changes, and a committed benchmark is very often benchmark theatre.

So the question is whether anyone updates them. The repository has an active default branch, so if they are being regenerated you will see the diff.

The other file is a task list, checked in with a name that says it is a task list. Most projects keep that in an issue tracker. Having it in the repository means it is versioned alongside the code, which means you can see the plan at the commit that changed the code, and it also means it goes stale when nobody edits it.

Alongside both is a donations file and a funding declaration in the manifest pointing at a personal payment address, plus a note in the front page explaining that maintaining the library costs time and money.

The consequence is that this is a single-maintainer project with a stated funding ask, and the repository carries the artefacts of that: the numbers, the plan, and the request.

The list of known users is partly stale and one of its links points at a defunct service

The front page lists who uses this library, and the list has aged in a way that is worth noticing before you use it as evidence.

The entries include Antmarky, a large cloud provider's open source organisation, a web application framework, a question and answer site, a documentation generator, a page builder, and an object framework.

The question and answer site entry is qualified: it forked the library under a different name. So that entry is not a user of this project, it is a user of a fork of it. That is worth knowing, because a fork diverges.

And the link for that entry points at a code-hosting service that no longer exists as a general code host. So the citation cannot be followed.

The remaining link is to a page listing packages that depend on this one, which is the only entry here that would be current if you checked it.

None of this makes the list wrong. Every one of those names was plausibly using it when the list was written. It just means the list is a snapshot and not evidence of current adoption, and one of its items is a fork rather than a user.

The consequence is that if you are evaluating this on the basis of adoption, count the dependents page rather than this list, and check whether the ones you care about are on the 3.0 candidate or still on 2.x.

The author credits the original Markdown author as a contributor, which raises a licensing question it never answers

There is a licensing detail in this project that the front page states twice and does not resolve.

The front page says the library is based on the original works by a named person, who wrote the original Markdown. The package manifest lists that same person first in a contributors array of fifteen names, alongside the current author and a list of others going back many years.

The licensing statement is that the library has been under the MIT licence since the second major version, and under BSD before that.

So the situation is: an MIT licence on a project based on someone else's original work, with the original author listed as a contributor.

Listing someone as a contributor is a statement that they contributed, and it is a courtesy and a claim at the same time. It is not a licence grant, and it is not a relicense of the upstream work.

The front page does not address this. There is no note about upstream terms or about whether the relicensing was agreed.

For most users this is academic, because the MIT terms are permissive. It stops being academic if you are distributing something that incorporates it, or if you are auditing licence provenance, which is a thing organisations do.

So the consequence is that if licence provenance matters to you, ask. It is not something you can resolve from the repository.

Editorial conclusion

This is still the right library if you need the reverse direction, since converting HTML back to Markdown is the half that most converters do not do and the reason this one exists. It runs in the browser and in Node, and part of its test suite is extracted from the CommonMark specification. Two things to check before you adopt it. That your bundler resolves the exports map the way you expect, because the main entry hands the module build only to the browser condition, so a server-side import gets the CommonJS file. And which version you are pinning, because the published line and the working line differ by a major version and four years of commits.

Frequently asked questions

What is Showdown?

A bidirectional converter between Markdown and HTML written in JavaScript, based on the original works of the Markdown author. It runs in a browser or on a server through Node. Unlike converters that only go one way, it can take HTML and produce Markdown from it as well as the reverse.

how to use showdown

Create a converter and call one method with your Markdown to get HTML. Options can be set globally for every instance, or locally through the constructor or a setter on one converter object, and there are matching getters for reading back what was set, plus a way to read the library's defaults. In Node you require the package; in a browser you load the build from a content delivery network or bundle it yourself.

Is Showdown still maintained?

The default branch was pushed to on 2026-10-29, so development is active. Releases are not. The three most recent published releases are from March and April 2022, while the package manifest in the repository declares a 3.0 release candidate. So there is current code that has never been published, and the last published artefact is four years old.

How do I install Showdown?

The front page lists four routes: a tarball from the releases page, a package manager for web components that has been effectively dead for years, the npm registry for server-side use, and a package for the .NET ecosystem. Content delivery network builds are also given, with the version tag to substitute. Note that the manifest requires a current Node and the metadata at the top of the repository contains no .NET packaging information.

What licence is Showdown under?

The MIT licence from the second major version onwards, with previous versions under BSD, and the current release candidate is MIT. The front page also states the library is based on the original works of the Markdown author and the package manifest lists that author among its contributors. Nothing in the repository addresses how the relicensing was agreed.

Official sources

  1. Issues
  2. License: MIT
  3. README
  4. Releases
  5. showdownjs/showdown on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/showdownjs-showdown.svg)](https://hysenlabs.com/projects/showdownjs-showdown)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/showdownjs-showdown.svg)](https://hysenlabs.com/projects/showdownjs-showdown)

Was this useful?