mermaid-ascii.art

Mermaid ASCII is a tool that converts Mermaid diagram code into ASCII text diagrams. You paste or type Mermaid syntax into the "Mermaid Code" area, and it renders the result as plain-text ASCII in the "ASCII Output" area. The current version shown on the site is v1.6.1. It is useful when you need a diagram that survives in environments where images or rendered SVG won't display — plain text files, terminal output, code comments, or chat messages.

How it works

The tool takes standard Mermaid graph definitions and lays them out using ASCII characters. You control the spacing with two settings visible on the page:

• xPadding (shown as 5) — horizontal spacing between elements
• yPadding (shown as 3) — vertical spacing between elements
• Use extended characters — a toggle for richer box-drawing characters instead of basic ASCII

The page includes several worked examples you can inspect directly:

• Nested subgraphs
• Labelled arrows
• Styled text
• Sequence diagrams

Each example pairs the Mermaid source with its ASCII output, so you can see exactly how a given construct translates before writing your own.

Using the web interface

1. Enter Mermaid code in the Mermaid Code field. For example: graph LR\nABC --> DEF
2. Adjust xPadding and yPadding if the default spacing doesn't suit your target width.
3. Toggle Use extended characters if you want box-drawing glyphs rather than plain ASCII.
4. Read the result in ASCII Output and use the Copy button to take it elsewhere.

The expected result is a text rendering of your graph that preserves direction and labels, sized according to your padding settings.

Alternative usage methods

The site notes that the same Git repository (AlexanderGrooff/mermaid-ascii) supports other ways to generate output.

cURL request — send Mermaid code to the service and get ASCII back:

curl https://mermaid-ascii.art -d mermaid="graph LR\nABC --> DEF"

Run the Golang tool locally — clone the repo and run it against a file:

git clone https://github.com/AlexanderGrooff/mermaid-ascii
cd mermaid-ascii
go run main.go -f test.mermaid

The local route needs a Go toolchain installed and a .mermaid file containing your diagram. The cURL route needs no local setup but depends on the hosted service being reachable.

When to choose it

Use Mermaid ASCII when the destination can only hold plain text — README files rendered without image support, terminal logs, commit messages, or documentation that must stay diff-friendly. If your target renders Mermaid natively or accepts images, a normal Mermaid renderer will give you cleaner output with less manual spacing tuning. The padding controls and extended-character toggle exist precisely because ASCII layout is width-sensitive, so expect to adjust them for narrow terminals or fixed-width documents.

Mermaid ASCII (v1.6.1) converts Mermaid diagram code into ASCII art. Based on the examples shown on the site, it supports flowcharts with nested subgraphs, labelled arrows, and styled text, as well as sequence diagrams. If your diagram relies on features beyond these, the tool may not render them correctly.

Diagram Types and Features with Confirmed Support

The site provides four worked examples, each demonstrating a specific capability:

The cURL example on the page also uses a basic flowchart (graph LR\nABC --> DEF), confirming left-to-right graph direction is supported.

Flowcharts and graphs

Flowchart syntax (graph LR, graph TD, etc.) is the primary use case. The examples cover:

• Nested subgraphs — subgraphs within subgraphs render as nested ASCII boxes.
• Labelled arrows — edge labels appear alongside the connecting lines.
• Styled text — styled node text is preserved in the ASCII output.

Sequence diagrams

Example 4 confirms sequence diagrams are supported, so the tool is not limited to node-and-edge graphs.

Rendering Options That Affect Output

The interface exposes a few settings that change how the ASCII output looks:

• xPadding (shown as 5) — horizontal spacing.
• yPadding (shown as 3) — vertical spacing.
• Use extended characters — a toggle for using extended ASCII/Unicode box-drawing characters instead of plain characters.

These affect layout and appearance, not which diagram types are accepted.

Alternative Ways to Generate the Same Output

The page lists two additional methods beyond the web interface, both using the same GitHub repository (AlexanderGrooff/mermaid-ascii):

cURL request:

curl https://mermaid-ascii.art -d mermaid="graph LR\nABC --> DEF"

Run locally with Go:

git clone https://github.com/AlexanderGrooff/mermaid-ascii
cd mermaid-ascii
go run main.go -f test.mermaid

The Go CLI method reads from a file (test.mermaid), which is useful for batch conversion or offline use.

What to Check Before Relying on It

The page only demonstrates the four features above. If your diagram uses other Mermaid constructs — such as class diagrams, state diagrams, Gantt charts, or pie charts — there is no evidence on the site that these are supported. For those cases, test your specific diagram code in the tool first, or use the Go CLI locally to check the output before committing to it in a document or README.

Paste your Mermaid diagram code into the Mermaid Code box on mermaid-ascii.art, and the ASCII Output panel updates with the text version of your diagram. You can then use the Copy button to grab the result. The site runs Mermaid ASCII v1.6.1 and works for anyone who needs a plain-text diagram for a terminal, README, code comment, or chat message where rendered graphics won't show.

Steps to convert a diagram

1. Open mermaid-ascii.art in your browser.
2. In the Mermaid Code area, type or paste valid Mermaid syntax. For example:

   graph LR
   ABC --> DEF
   

3. Watch the ASCII Output area. It regenerates as you edit, showing the diagram drawn with text characters.
4. Adjust the layout controls if the default spacing looks cramped or too loose:
   • xPadding — horizontal spacing (shown as 5 by default in the interface).
   • yPadding — vertical spacing (shown as 3 by default).
   • Use extended characters — toggle for richer box-drawing glyphs instead of basic ASCII.
5. Click Copy to put the ASCII output on your clipboard.

The expected result is a block of monospaced text that mirrors your graph's structure and labels, ready to paste anywhere plain text is accepted.

What kinds of diagrams you can try

The site ships with several examples you can load or imitate:

• Example 1: Nested Subgraphs — diagrams with grouped nodes.
• Example 2: Labelled Arrow — edges that carry text labels.
• Example 3: Styled Text — nodes using styling syntax.
• Example 4: Sequence Diagram — message-passing diagrams, not just flowcharts.

If your diagram doesn't render as expected, the most common cause is invalid Mermaid syntax rather than a problem with the converter. Check that arrows, node brackets, and subgraph blocks are closed correctly.

Alternative ways to generate the same output

The same Git repository (AlexanderGrooff/mermaid-ascii) offers two non-browser methods.

cURL request — send Mermaid code to the endpoint and get ASCII back:

curl https://mermaid-ascii.art -d mermaid="graph LR\nABC --> DEF"

Run the Go program locally — clone the repo and run it against a file:

git clone https://github.com/AlexanderGrooff/mermaid-ascii
cd mermaid-ascii
go run main.go -f test.mermaid

Use the web interface when you want a quick visual check and manual copy. Use cURL or the CLI when you need to script the conversion or run it inside a build pipeline.

Choosing between the options

If you only need to convert a diagram occasionally, the web page is the fastest path. If the conversion is part of a repeatable process, the cURL or CLI route avoids manual copying.

Mermaid ASCII (v1.6.1) offers two alternative ways to generate ASCII graphs besides its web interface: a cURL request to https://mermaid-ascii.art and running the Go program from the AlexanderGrooff/mermaid-ascii repository in your CLI. Both are listed on the site under "Alternative Usage Methods" and are useful when you want to generate diagrams from a script, terminal, or automated workflow instead of pasting code into the browser.

Option 1: cURL request

Send your Mermaid code directly to the site as a POST parameter.

curl https://mermaid-ascii.art -d mermaid="graph LR\nABC --> DEF"

• Input: the mermaid parameter containing your Mermaid definition (here a simple left-to-right graph with two nodes).
• Action: cURL posts the data to the Mermaid ASCII endpoint.
• Expected result: the ASCII rendering of the graph is returned as the response, which you can print in a terminal or pipe into a file.

This is the quickest option if you only need the output and don't want to install anything. It fits shell scripts, CI steps, or one-off conversions.

Option 2: Run the Go program in your CLI

Clone the repository and run the Go program locally.

git clone https://github.com/AlexanderGrooff/mermaid-ascii
cd mermaid-ascii
go run main.go -f test.mermaid

• Input: a .mermaid file (the example uses test.mermaid) passed with the -f flag.
• Action: go run main.go executes the program, reading the diagram definition from the file.
• Expected result: the ASCII graph is printed to your terminal.

This option requires a Go toolchain and a local clone, but it keeps everything offline and lets you version your diagram files alongside your code.

Which one to choose

If you just need a one-off conversion or want to call it from a script, use the cURL request. If you prefer working with diagram files locally and having the tool available offline, clone the repository and run the Go program.

The web interface itself also exposes settings such as xPadding, yPadding, and an option to use extended characters, and it includes examples like nested subgraphs, labelled arrows, styled text, and sequence diagrams — so you can preview a diagram there first, then switch to either alternative method once the output looks right.