About

Jira Wiki Markup and Markdown are structurally similar but syntactically incompatible. A heading in Jira is h1. Title while Markdown requires # Title. Bold text uses single asterisks in Jira (*text*) but double asterisks in Markdown (**text**). Tables, code blocks, links, and images all follow different escaping rules. Manual conversion introduces errors: broken links from swapped bracket order, malformed tables from missing pipe alignment, lost formatting in nested lists. This tool parses over 40 distinct syntactic patterns in strict precedence order, handling multiline constructs (code blocks, panels, {noformat} regions) before inline transforms to prevent false matches inside preformatted content.

The converter operates bidirectionally. Paste Jira markup to get Markdown, or paste Markdown to get Jira syntax. Nested lists preserve depth. Tables retain header rows. Color macros and panel blocks degrade gracefully into Markdown blockquotes since Markdown has no native color support. Note: Jira macros with no Markdown equivalent (e.g., {anchor}) are passed through as-is. Pro tip: always verify table output - Jira's ||header|| syntax maps to Markdown's pipe-and-dash format, but column alignment may need manual adjustment for wide content.

Formulas

This converter is not mathematical - it is a deterministic text transformation engine. The core logic follows a rule-based rewriting system with strict precedence ordering.

convert(input) → output = R_n ∘ R_n−1 ∘ … ∘ R₁(input)

Where each R_i is a rewrite rule consisting of a regex pattern and a replacement template. The composition order is critical:

Phase 1 (Protect): Extract multiline blocks ({code}, {noformat}) → replace with placeholders
Phase 2 (Block): Transform block-level syntax (headings, lists, tables, panels, quotes, rules)
Phase 3 (Inline): Transform inline syntax (bold, italic, strikethrough, monospace, links, images, color, super/subscript)
Phase 4 (Restore): Reinsert protected blocks with converted delimiters

Where R = rewrite rule, n = total number of rules (over 40), and the composition operator ensures earlier rules' outputs do not get re-matched by later rules. The protection phase prevents code block contents from being transformed - a critical correctness guarantee.

Reference Data

Element	Jira Wiki Markup	Markdown Equivalent	Notes
Heading 1	`h1. Text`	`# Text`	Levels 1-6 supported
Heading 2	`h2. Text`	`## Text`
Heading 3	`h3. Text`	`### Text`
Bold	`bold`	`bold`	Jira uses single asterisk
Italic	`_italic_`	`italic`	Underscore vs single asterisk
Strikethrough	`-text-`	`~~text~~`	Dash vs double tilde
Monospace	`{{text}}`	`text`	Double curly vs backtick
Code Block	`{code:lang}...{code}`	```lang...```	Language param preserved
Noformat Block	`{noformat}...{noformat}`	```...```	No language tag in output
Quote Block	`{quote}...{quote}`	`> ...`	Each line prefixed
Block Quote	`bq. text`	`> text`	Single-line only
Link	`[label\|url]`	`[label](url)`	Pipe vs parenthesis
URL-only Link	`[url]`	`[url](url)`	Auto-expanded in MD
Image	`!image.png!`	`![image](image.png)`	Exclamation placement differs
Unordered List	`* item` / `** nested`	`- item` / `- nested`	Depth via repeated chars vs indent
Ordered List	`# item` / `## nested`	`1. item` / `1. nested`	Hash count vs numbering
Table Header	`\|\|H1\|\|H2\|\|`	`\|H1\|H2\|` + separator row	Double-pipe for headers
Table Row	`\|C1\|C2\|`	`\|C1\|C2\|`	Identical syntax
Horizontal Rule	`----`	`---`	Four vs three dashes
Panel	`{panel:title=T}...{panel}`	`> T` + content	Degraded to blockquote
Color Text	`{color:red}text{color}`	`text`	No MD equivalent; color stripped
Superscript	`^text^`	`<sup>text</sup>`	HTML fallback in MD
Subscript	`~text~`	`<sub>text</sub>`	HTML fallback in MD
Inserted Text	`+text+`	`<ins>text</ins>`	HTML underline in MD
Citation	`??text??`	`<cite>text</cite>`	HTML fallback in MD
Emoji	`:)` `:(` `:P`	`😀` `😞` `😛`	Common emoticons mapped

Frequently Asked Questions

Jira's {code:java}...{code} syntax maps directly to Markdown's fenced code blocks with language hints: ```java...```. The language parameter is extracted via regex capture group and placed after the opening triple backticks. If no language is specified ({code}...{code}), the output uses plain ``` fences. Content inside code blocks is never transformed - it is protected during Phase 1 and restored verbatim in Phase 4.

Jira {color:red}text{color} macros have no native Markdown representation. The converter strips the color wrapper and preserves the inner text. Panels ({panel:title=Warning}content{panel}) are degraded to Markdown blockquotes with the title rendered as bold text on the first line: > **Warning** followed by > content. This is the closest semantic equivalent available in standard Markdown.

Yes. Jira represents nesting by repeating the list character (** for level 2 unordered, ## for level 2 ordered). Markdown uses indentation (2 or 4 spaces per level). The converter counts consecutive list characters in Jira and converts them to the appropriate indent depth. In reverse (MD to Jira), leading whitespace is measured and divided by the indent unit to determine the nesting level. Mixed ordered/unordered nesting (e.g., *# in Jira) is supported and maps to indented markdown with alternating - and 1. markers.

Jira uses double pipes (||) for header cells and single pipes (|) for data cells. The converter detects header rows by the || pattern, strips them to single pipes, then inserts the required Markdown separator row (|---|---|) immediately after the header. Column count is dynamically determined from the first row. In reverse, the converter identifies the separator row (matching |-+|) and converts the row above it to use || delimiters.

Yes. The converter processes only recognized patterns and passes unrecognized text through unchanged. If your input contains a mix of Jira markup, plain text, and even some Markdown, only the Jira-syntax elements will be transformed. However, ambiguous patterns (e.g., a standalone dash - at start of line) may be interpreted as strikethrough in Jira mode. For best results, ensure your input is consistently formatted in one syntax.

The converter processes text synchronously in the browser. Inputs under 500 KB (approximately 500,000 characters or 10,000+ lines of formatted content) convert in under 50 ms on modern hardware. Inputs exceeding this threshold will still process but may cause a brief UI pause. There is no hard limit - the practical ceiling is your browser's memory allocation for string operations, typically several megabytes.

The converter supports standard GFM extensions including fenced code blocks (```), strikethrough (~~text~~), task lists (- [ ] and - [x] mapped to Jira's (x) and (/) macros), and pipe tables. Footnotes, definition lists, and other extended Markdown flavors are not covered and will pass through unchanged.