Pros of cmark

• More focused on the CommonMark specification, providing a reference implementation
• Potentially more stable and consistent with the core CommonMark standard
• Simpler codebase, easier to understand and maintain for core CommonMark features

Cons of cmark

• Lacks GitHub Flavored Markdown (GFM) extensions
• May have fewer features and customization options
• Potentially slower development cycle for new Markdown features

Code Comparison

cmark:

void cmark_node_free(cmark_node *node) {
  cmark_mem *mem = node->mem;
  if (node->last_child) {
    cmark_node *child = node->first_child;
    while (child) {
      cmark_node *next = child->next;
      cmark_node_free(child);
      child = next;
    }
  }
  ...
}

cmark-gfm:

void cmark_node_free(cmark_node *node) {
  cmark_mem *mem = node->mem;
  if (node->last_child) {
    cmark_node *child = node->first_child;
    while (child) {
      cmark_node *next = child->next;
      cmark_node_free(child);
      child = next;
    }
  }
  ...
}

The core node freeing function is identical in both projects, reflecting their shared codebase. The main differences lie in the additional features and extensions implemented in cmark-gfm, which are not present in the core cmark library.

Pros of commonmark-spec

• Focuses on the specification itself, providing a clear reference for CommonMark
• Includes extensive test cases for validating CommonMark implementations
• Serves as the authoritative source for the CommonMark standard

Cons of commonmark-spec

• Lacks a direct implementation of the CommonMark parser
• May require additional effort to integrate into projects compared to cmark-gfm
• Updates to the specification might lag behind practical implementations

Code Comparison

commonmark-spec (example test case):

example: 189
markdown: |
  [foo]: /url "title"

  [foo]
html: |
  <p><a href="/url" title="title">foo</a></p>

cmark-gfm (example C code snippet):

cmark_node *document = cmark_parse_document(buffer, len, CMARK_OPT_DEFAULT);
char *html = cmark_render_html(document, CMARK_OPT_DEFAULT);
printf("%s", html);
free(html);
cmark_node_free(document);

Summary

commonmark-spec is ideal for those seeking a comprehensive understanding of the CommonMark standard and for developing compliant implementations. cmark-gfm, on the other hand, provides a ready-to-use implementation with GitHub Flavored Markdown extensions, making it more suitable for direct integration into projects requiring Markdown parsing and rendering capabilities.

Pros of markdown-it

• Written in JavaScript, making it easy to integrate into web applications
• Highly extensible with a plugin system for custom syntax and features
• Faster parsing and rendering compared to cmark-gfm

Cons of markdown-it

• Less strict adherence to CommonMark specification
• May produce different output for edge cases compared to cmark-gfm
• Requires more setup and configuration for GitHub Flavored Markdown support

Code Comparison

markdown-it:

const md = require('markdown-it')();
const result = md.render('# Hello, world!');

cmark-gfm:

#include <cmark-gfm.h>
char *result = cmark_markdown_to_html("# Hello, world!", 15, CMARK_OPT_DEFAULT);

Both examples demonstrate basic usage for rendering Markdown to HTML. markdown-it uses a JavaScript API, while cmark-gfm uses a C API. The markdown-it example is more concise and easier to integrate into JavaScript projects, while cmark-gfm offers a lower-level implementation that can be compiled and used in various programming languages through bindings.

Pros of Showdown

• JavaScript-based, making it easy to integrate into web applications
• Highly extensible with a plugin system for custom syntax and features
• Supports both client-side and server-side usage

Cons of Showdown

• Generally slower performance compared to cmark-gfm
• Less strict adherence to CommonMark specification
• May produce inconsistent output across different versions or configurations

Code Comparison

Showdown (JavaScript):

var converter = new showdown.Converter();
var html = converter.makeHtml('# Hello, Markdown!');

cmark-gfm (C):

char *html = cmark_markdown_to_html("# Hello, Markdown!", 18, CMARK_OPT_DEFAULT);

Key Differences

• cmark-gfm is written in C, offering better performance but less flexibility
• Showdown provides more customization options and is easier to integrate into JavaScript projects
• cmark-gfm follows the GitHub Flavored Markdown spec more closely
• Showdown has a larger ecosystem of plugins and extensions
• cmark-gfm is maintained by GitHub and used in their products, ensuring compatibility with GitHub's Markdown rendering

Pros of marked

• Written in JavaScript, making it easy to integrate into Node.js and browser-based applications
• Highly extensible with a plugin system for custom rendering and parsing
• Faster parsing and rendering compared to cmark-gfm in most scenarios

Cons of marked

• Less strict adherence to CommonMark and GFM specifications
• May produce inconsistent output for edge cases or complex Markdown structures
• Lacks some advanced features present in cmark-gfm, such as footnotes and task lists

Code Comparison

marked:

import { marked } from 'marked';

const html = marked('# Hello, world!');
console.log(html);

cmark-gfm:

#include <stdio.h>
#include <stdlib.h>
#include "cmark-gfm.h"

int main() {
    char *html = cmark_markdown_to_html("# Hello, world!", 15, CMARK_OPT_DEFAULT);
    printf("%s\n", html);
    free(html);
    return 0;
}

The code examples demonstrate the simplicity of using marked in JavaScript environments, while cmark-gfm requires C programming and memory management. marked offers a more straightforward API for web developers, whereas cmark-gfm provides lower-level control and potentially better performance for system-level applications.

Pros of Blackfriday

• Written in Go, offering better performance for Go-based applications
• More customizable with various extension options
• Smaller codebase, potentially easier to understand and contribute to

Cons of Blackfriday

• Less strict adherence to CommonMark specification
• May have fewer security guarantees compared to cmark-gfm
• Not officially supported by GitHub, potentially less aligned with GitHub Flavored Markdown

Code Comparison

cmark-gfm (C):

cmark_node *document = cmark_parse_document(buffer, len, CMARK_OPT_DEFAULT);
char *html = cmark_render_html(document, CMARK_OPT_DEFAULT, NULL);
cmark_node_free(document);

Blackfriday (Go):

markdown := blackfriday.Run(input)
html := blackfriday.Run(input, blackfriday.WithExtensions(blackfriday.CommonExtensions))

Both libraries offer straightforward ways to convert Markdown to HTML, but Blackfriday's API is more concise in this basic usage. cmark-gfm provides more granular control over the parsing and rendering process, which can be beneficial for complex use cases.