A lightweight, zero-boilerplate Java library that converts Markdown to styled HTML for any CSS framework — Tailwind, Bootstrap, Bulma, or your own custom classes — using a clean fluent API built on top of commonmark-java.

String html = Markdown.from(text).withTailwind().toHtml();

Install form maven

<dependency>
    <groupId>io.github.gaurav101</groupId>
    <artifactId>fluentmarkdown</artifactId>
    <version>1.0.4</version>
</dependency>

• Requirements
• Installation
• Quick Start
• Step-by-Step Guide
  • Step 1 — Parse plain Markdown
  • Step 2 — Apply a built-in preset
  • Step 3 — Use a custom style config
  • Step 4 — Extend or override a preset
  • Step 5 — Enable safe (XSS-sanitised) output
• Built-in Presets
  • Tailwind CSS
  • Bootstrap 5
  • Bulma
• StyleConfig Reference
• API Reference
• Project Structure
• Building from Source
• Running the Tests
• FAQ

If you haven't published the library to a remote repository, first install it into your local Maven cache:

cd <project-name>
mvn install

Then add this dependency to your project's pom.xml:

<dependency>
  <groupId>io.github.gaurav101</groupId>
  <artifactId>fluentmarkdown</artifactId>
  <version>1.0.4</version>
</dependency>

The library is only four files. You can copy the io/io.github.gaurav101/fluentmarkdown package directly into your src/main/java directory and add commonmark to your own pom.xml:

<dependency>
    <groupId>org.commonmark</groupId>
    <artifactId>commonmark</artifactId>
    <version>0.22.0</version>
</dependency>

import io.github.gaurav101.fluentmarkdown.Markdown;

public class Example {
  public static void main(String[] args) {
    String markdown = """
            # Hello, FluentMarkdown!
            
            This is a **bold** statement with a [link](https://example.com).
            
            > A styled blockquote.
            
            - Item one
            - Item two
            """;

    // Tailwind CSS output
    String tailwindHtml = Markdown.from(markdown).withTailwind().toHtml();

    // Bootstrap 5 output
    String bootstrapHtml = Markdown.from(markdown).withBootstrap().toHtml();

    // Plain HTML (no CSS classes)
    String plainHtml = Markdown.from(markdown).toHtml();

    System.out.println(tailwindHtml);
  }
}

The simplest use-case: convert Markdown to HTML with no CSS classes attached.

String html = Markdown.from("# Hello\n\nSome paragraph.").toHtml();

Output:

<h1>Hello</h1>
<p>Some paragraph.</p>

Call one of the three preset methods before .toHtml() to inject CSS framework classes automatically.

// Tailwind CSS
String html = Markdown.from(markdown).withTailwind().toHtml();

// Bootstrap 5
String html = Markdown.from(markdown).withBootstrap().toHtml();

// Bulma
String html = Markdown.from(markdown).withBulma().toHtml();

Example — Tailwind output for # Hello:

<h1 class="text-4xl font-extrabold tracking-tight mb-4 mt-6">Hello</h1>

Example — Bootstrap output for > A quote:

<blockquote class="blockquote border-start border-4 ps-3 text-muted my-3">
  <p class="mb-3">A quote</p>
</blockquote>

Create a StyleConfig with StyleConfig.builder() and map any HTML tag name to a string of CSS classes.

import io.github.gaurav101.fluentmarkdown.Markdown;
import io.github.gaurav101.fluentmarkdown.StyleConfig;

StyleConfig myConfig = StyleConfig.builder()
        .tag("h1", "page-title")
        .tag("h2", "section-title")
        .tag("p", "body-text")
        .tag("a", "link link--primary")
        .tag("code", "inline-code")
        .build();

String html = Markdown.from(markdown).withStyle(myConfig).toHtml();

Tags that are not listed in your config are rendered without a class attribute — there are no silent defaults.

Use mergeFrom() to start from a preset and then change specific tags:

import io.github.gaurav101.fluentmarkdown.Markdown;
import io.github.gaurav101.fluentmarkdown.Presets;
import io.github.gaurav101.fluentmarkdown.StyleConfig;

StyleConfig custom = StyleConfig.builder()
        .mergeFrom(Presets.tailwind())          // start from the Tailwind preset
        .tag("p", "mb-6 text-gray-700 text-lg leading-loose")  // override paragraph
        .tag("a", "text-indigo-600 underline") // override link
        .tag("table", "w-full text-sm")         // override table
        .build();

String html = Markdown.from(markdown).withStyle(custom).toHtml();

mergeFrom() copies all tag mappings from the preset into the builder first; subsequent .tag() calls overwrite only the tags you name, leaving the rest intact.

When the Markdown source comes from untrusted user input, chain .safe() before .toHtml(). This strips raw HTML blocks and inline HTML from the source before rendering.

String userInput = "<script>alert('xss')</script>\n\n# Safe content";

String safeHtml = Markdown.from(userInput)
        .withTailwind()
        .safe()          // strips raw HTML
        .toHtml();

// The <script> tag is gone; normal Markdown is still rendered.

Recommendation: Always call .safe() for user-generated content, form submissions, or any text that didn't originate from your own application.

Applied by .withTailwind(). Targets Tailwind v3+. Each tag and its default classes:

Applied by .withBootstrap().

Applied by .withBulma().

StyleConfig is an immutable value object. Build one with StyleConfig.builder():

StyleConfig config = StyleConfig.builder()
    .tag("tagName", "class-a class-b")   // add or overwrite a mapping
    .mergeFrom(anotherConfig)            // bulk-import mappings from another config
    .build();                            // returns the immutable instance

You don't normally use this class directly, but it's available if you need to integrate with a manually constructed HtmlRenderer:

HtmlRenderer renderer = HtmlRenderer.builder()
        .attributeProviderFactory(StyleAttributeProvider.factory(myConfig))
        .build();

fluentmarkdown/
├── pom.xml
└── src/
    ├── main/java/io/fluentmarkdown/
    │   ├── Markdown.java               ← fluent builder & entry point
    │   ├── StyleConfig.java            ← immutable tag → class map + builder
    │   ├── StyleAttributeProvider.java ← commonmark AttributeProvider impl
    │   └── Presets.java                ← Tailwind / Bootstrap / Bulma factories
    └── test/java/io/fluentmarkdown/
        └── MarkdownTest.java           ← unit tests

# Clone or download the project, then:
cd fluentmarkdown

# Compile, run tests, and package the JAR
mvn install

# Skip tests if you just want the JAR quickly
mvn install -DskipTests

# Clean before building (recommended after pulling changes)
mvn clean install

The JAR is produced at target/fluentmarkdown-1.0.0.jar and installed to your local ~/.m2 repository.

mvn test

The test suite covers:

• Plain (unstyled) rendering
• All three built-in presets (Tailwind, Bootstrap, Bulma)
• Custom StyleConfig injection
• Preset extension via mergeFrom()
• Safe mode (XSS stripping)
• Edge cases: null input, empty string, repeated toHtml() calls

Can I use this with Gradle?

Yes. Install the JAR locally with mvn install, then add the dependency:

// build.gradle
dependencies {
  implementation("io.github.gaurav101:fluentmarkdown:1.0.4")
}

Can I apply two presets at the same time?

Not directly — .withStyle() replaces the previous config. To combine them, merge manually:

StyleConfig combined = StyleConfig.builder()
        .mergeFrom(Presets.tailwind())
        .mergeFrom(Presets.bootstrap())   // bootstrap entries overwrite tailwind ones
        .build();

Does this support Markdown extensions (tables, strikethrough, etc.)?

Tables are supported natively by commonmark-java and styled by the presets. For other extensions (e.g., commonmark-ext-gfm-strikethrough), add the extension jar to your pom and wire it through the commonmark Parser inside Markdown.toHtml().

Is the Markdown builder thread-safe?

Each Markdown.from(...) call creates a fresh, independent builder. Do not share a builder across threads. The StyleConfig instances (including presets) are fully thread-safe — share those freely.

Will the library modify classes added by other AttributeProviders?

No. StyleAttributeProvider uses Map.merge() which appends to any existing class attribute rather than overwriting it, so it is safe to stack multiple providers.