Help

What is Markzen?

Markzen is a desktop editor for lightweight markup languages — Markdown and six others — with a live, fully styled preview. You write plain text marked up with simple punctuation on the left, and Markzen renders it as formatted HTML on the right as you type.

What sets it apart from an ordinary Markdown editor is the round-trip. Markzen reads eight markup languages, renders 30 live extensions (diagrams, charts, mathematical formulas, music scores, chess boards, QR codes) inside the document, and exports to more than twenty formats — ebooks, Word, PowerPoint, LaTeX, Jupyter notebooks and more. Write once, hand the result off as almost anything. The converter is built in, so there are no external tools to install.

You can open an existing file or just start typing — there's no requirement to open a file first.

The editor

The left pane is a full CodeMirror code editor, not a plain text box: it has syntax highlighting for the markup you're writing, a formatting toolbar (bold, italic, headings, lists and more, plus dedicated buttons for inserting links and images — see Links & images — and for inserting a table, see Tables & spreadsheets), and a find-and-replace search. Standard editing shortcuts — copy, paste, undo, redo — work as you'd expect.

You write in one of eight lightweight markup languages. These are plain-text formats that express structure with punctuation (# for a heading, * for emphasis) instead of hidden styling, so a document stays readable as text and diff-friendly in version control. Markzen reads all eight and decides which one a file is by its extension — you never pick the format manually. Compatibility lists which extensions open which language.

Each language has its own conventions and its own existing ecosystem of documents; Markzen renders each in its own dialect rather than converting everything to Markdown first. BBCode is the one with no single standard — every forum invented its own variant — so Markzen reads it generously, accepting the common spellings side by side ([list] or [ul], [h1] or [heading=1]) and leaving any tag it doesn't recognise visible as plain text rather than swallowing it. To switch the kind of markup a document is written in, use the toolbar's Convert to menu (see Convert & export below).

Not every language can express everything. The formatting toolbar carries the same buttons in every document, but Markzen only ever writes markup the language itself defines — it never invents a private dialect to paper over a gap. A button the current language has no notation for is greyed out. Bold, italic, headings, lists, code blocks, links, images, rules and tables are available in all eight; the handful of gaps are listed in Compatibility. Markdown's is the one that surprises people: it has no standard way to centre a paragraph, so Markzen offers no alignment buttons there rather than writing something only some readers would honour.

The text size is set with the toolbar's Increase font size and Decrease font size buttons. The editor pane can also be hidden entirely — when it is, Markzen becomes a pure reader (see Live preview).

Links & images

The formatting toolbar has two dedicated buttons for putting a link or an image into the document, and each opens a small popup right where your cursor is. Link (Ctrl+K) — or press Ctrl+K — inserts a hyperlink: type the link text and its address, and Markzen writes the correct markup for it. Image inserts an image the same way, with a few extra choices covered below.

Both are written in the markup the current document uses — a link inserted into an AsciiDoc file comes out as AsciiDoc, into an Org file as Org, and so on across all eight languages.

Starting from an address you already have. Paste a web address into the document, select it, and press Ctrl+K: Markzen sees that the selection is an address rather than words, puts it in the popup's address field and leaves the cursor in the empty text field, waiting for what the link should say. Without that, a selected address would have become the link's visible text — a link that reads as a bare URL. Absolute file paths count as addresses too, on Windows and elsewhere, so the same shortcut turns a pasted path into a link to that file.

Editing a link or image you already have. Put the cursor anywhere on an existing link or image and open the popup again (the button, or Ctrl+K): Markzen recognises the construct, loads its current text and address into the popup, and replaces the whole thing when you confirm — so you edit it in place instead of accidentally nesting a new link inside the old one.

For an image, the popup also offers a Browse for an image button to pick a file from disk instead of typing a path — it opens in the folder you last took an image from, kept separately from the one your documents come from — and one important choice: whether the image is embedded or linked.

Embedded or linked images

When you insert an image, Markzen can store it in the document two ways:

Linked — the document only points at the image, by file path or web address. The document file stays small, but the image has to travel with it (or stay reachable at its URL), or it won't show up elsewhere. This is the default.
Embedded — the image's actual bytes are written into the document as text (a base64 data: block), so the file is completely self-contained: one file carries everything, with nothing to lose track of. The trade-off is size — the document grows by the weight of the image, and an embedded image can't use a relative path.

Pick Embedded when you want a single portable file to hand off; pick Linked when you keep images beside the document and want the file to stay small.

For a linked image, one more option appears: Relative path. When the image sits in the document's own folder (or a subfolder), ticking this writes the reference as a short relative path instead of a full absolute one, so the link keeps working when you move the document and its images together. It's offered only when the image is inside the document's folder — otherwise there's no relative path to write.

Embedded images stay tidy in the editor. A base64-embedded image is a long wall of text that would otherwise bury the lines around it, so Markzen folds each one into a small chip showing its type and size (for example 🖼 webp · 38 KB). The chip is display-only — the underlying text is untouched, so saving, copying or cutting always carries the full image, and the cursor skips over the chip as a single unit.

Files, tabs & saving

Markzen keeps as many documents open at once as you like, each in its own tab, so you can work across several files and switch between them freely. You don't need to open a file to begin — start typing in the blank document that's already there, or use the toolbar's file buttons:

New document — opens a short menu (Create a new) listing the eight markup languages; pick one to start a fresh, empty document written in that markup, in a new tab.
Open a Markdown file — browse for an existing file and open it. The picker accepts all eight markup formats, and Markzen chooses the right one from the file's extension. It opens in the folder you last took a document from, remembered between sessions, so you don't start from scratch each time.
Save — write the active document back to its file. A document that has never been saved falls through to Save As so you can name it first.
Save As — save the active document to a new file, leaving any original untouched.

You can also drag a file out of your file manager and drop it onto the window to open it.

Each open document is a tab across the top of the window. An unsaved tab is marked with a dot, and a tab whose markup isn't Markdown carries a small format badge (for example adoc). The × on a tab closes it — and closing a document with unsaved changes never discards them silently: an inline bar appears on the tab so you can Save or Discard first.

While a document is open, Markzen watches its file on disk. If the file changes in another program and you have no unsaved edits of your own, Markzen pulls in the new version automatically; if you do have unsaved edits, it asks first — an inline Reload bar lets you decide whether to take the version on disk or keep your own.

Live preview

The right pane is the document rendered as styled HTML, updated live as you type. Links work, tables align, code is shown in a monospace block, task lists get checkboxes, and every rendering-extension block (see below) draws its figure in place. The preview is a faithful picture of what an HTML or PDF export will look like.

If a Markdown document opens with a YAML front-matter block — the --- key: value --- section that tools like Jekyll, Hugo and Obsidian put at the very top — Markzen renders it as a tidy metadata card above the document, instead of letting the closing --- turn into a stray heading.

Layout modes

A group of three toolbar buttons sets what the window shows:

Split view — editor and preview side by side. Drag the divider to change how much space each gets.
Show editor — the editor alone, filling the window for distraction-free writing.
Show preview — the preview alone, a clean full-width reader.

The Table of Contents button opens a panel built automatically from every heading in the document (#, ##, ###, …). Click any entry to scroll the preview to that section. Any heading with sub-headings beneath it shows a chevron: click it to Collapse that section and hide its nested headings, or Expand to bring them back — so you can fold a long outline down to just the parts you're working in. The small 2 / 3 / 4 buttons in the panel header limit the outline to that heading depth — useful in a long document when you only want the top levels in view — and clicking the active one again brings every level back. The panel resizes by dragging its left edge and collapses to free up reading space. It's a navigation aid inside the app only — it never appears in an export.

Supplying your own outline. If the headings aren't the outline you want, a document can carry its own. A fenced block tagged markzen whose first line is toc replaces the generated panel with the list written under it:

```markzen
toc
- [Introduction](#intro)
  - [Background](#background)
- [Results](#results)
```

Indentation sets the level, and every entry points at an anchor that has to exist in the document itself — a heading you gave an explicit id, or a plain <a id="intro"></a>. The block itself draws nothing: it is metadata the panel reads.

Tables & spreadsheets

Tables move cleanly between Markzen and any spreadsheet. Paste tab-separated text — copied from Excel, Google Sheets, Word, or a web table — into the editor and Markzen turns it into a proper table written in the document's own markup, instead of dropping in a wall of tab characters. The paste reader is quote-aware (it correctly handles cells that themselves contain tabs, line breaks, or quotation marks) and only triggers when the clipboard holds a clean rectangular grid of at least two columns; anything else pastes as ordinary text.

You can also start a table from scratch. The toolbar's Insert table button opens a small grid — sweep across it to choose how many rows and columns you want, and Markzen writes an empty table of that size in the document's own markup, ready to type into. The first row is the header row.

The reverse works too. Hover over any rendered table in the preview and a copy button appears in its corner: it copies the table back out as tab-separated text that drops straight into a spreadsheet cell or a Word document. These copy buttons are a preview convenience only — they're stripped from every export and conversion, so a shared file contains just the clean table.

Rendering extensions

Markzen extends standard markup through fenced code blocks. The language tag right after the opening triple backticks decides how the block renders: a tag Markzen recognises as an extension draws a live figure instead of showing the code.

Each kind of figure is drawn by its own rendering engine, and Markzen fetches an engine the first time a document actually asks for it rather than loading all of them at launch — which is why the app starts almost instantly, and why the first diagram of a given kind can take a moment to appear while every later one is immediate.

For example, this source:

```mermaid
graph LR
  A --> B --> C
```

renders as a live flowchart, not a code listing — and it stays a flowchart in PDF and HTML exports too.

Diagrams, charts, mathematics, music notation, chess and Go boards, QR codes and more are built in — Compatibility lists every one of them with its tag.

Each extension has its own language tag (mermaid, chartjs, katex, abc, chess, …). You can mix as many as you like with ordinary prose in a single document — they all render together. Whether a figure is still a figure once the document leaves Markzen depends on where you send it — see Convert & export below.

Formulas inside a sentence

A mathematical formula can be a block of its own — a katex or asciimath block, standing alone and centred like an equation in a textbook. That works in all eight markup languages.

A formula can also sit inside a sentence, so that "the area is pi r squared" reads as one line of prose with real symbols in it. That depends on the markup language having a notation for it, and each one spells it differently — the notation per language is in Compatibility.

Textile and BBCode are the two exceptions, and it is a limit of those languages rather than of Markzen: neither ever defined a way to write mathematics. In a Textile or BBCode document a formula therefore has to be a block of its own. Nothing is lost — the formula renders, and it survives export — it simply cannot be woven into a line of prose.

Placing and sizing a figure

Hover a rendered figure in the preview and a small panel appears beside it: align buttons (left, centre, right) and — for the kinds of figure that can be resized — width and height boxes in pixels. remove style block clears them again.

That choice isn't kept somewhere invisible: the panel writes it into the document, as a short block tagged markzen placed immediately before the figure it applies to.

```markzen
style
align center
width 480
```

So the layout travels with the file — it is part of what you save, hand over and export, on any machine. You can equally write the block by hand: one directive per line, align (left, center or right), width and height in pixels, always applying to the block directly below it.

Styling one document with CSS

A Markdown document can also carry its own stylesheet, in a fenced block tagged style:

```style
h2 { color: #b03030; border-bottom: 2px solid #b03030; }
blockquote { font-style: italic; }
```

The rules apply to that document's preview and to its PDF and HTML exports, on top of whichever style template is active — a way to give one document a look of its own without changing your settings for everything else. Ordinary selectors only: at-rules such as @media and @keyframes are not supported, and the block works in Markdown documents only.

Convert & export

The toolbar's Convert to menu is where a finished document leaves Markzen. It does two distinct things.

Convert to another markup language. Under Lightweight markup, rewrite the open document as any of the other seven markups — AsciiDoc, BBCode, Djot, MediaWiki, Org, reStructuredText or Textile. Useful when a wiki wants MediaWiki, a forum wants BBCode, a publisher wants AsciiDoc, or you're moving notes between ecosystems. Each of the eight appears once in the menu, as a markup language: a document saved as MediaWiki from here is the same file you would get anywhere else.

Export to a finished format. Hand the document to the bundled converter, which emits more than twenty document formats, grouped by what they're for:

Category	Formats
Ebooks	EPUB 3, FictionBook2
Word Processor	Microsoft Word (`.docx`), OpenDocument (`.odt`), Rich Text Format (`.rtf`)
Presentation	Microsoft PowerPoint (`.pptx`), reveal.js (`.html`)
Typesetting	InDesign ICML, LaTeX (`.tex`), Typst (`.typ`)
XML	DocBook, JATS, OpenDocument XML, TEI Simple
Notebook	Jupyter Notebook (`.ipynb`)
Outline	OPML (`.opml`)

The converter ships inside Markzen — nothing extra to download or configure. Alongside these, three quick outputs sit on the toolbar: Save as PDF and Save as HTML export the rendered document exactly as previewed (style template, fonts and extension figures included), and Print sends it to a printer. The code font travels inside the exported file, so a code block or an ASCII diagram lands on the reader's machine looking the way you saw it, whether or not they have that font installed.

What travels, and what doesn't. A rendering-extension figure only stays a figure where the target format can hold a picture, so a document leaves Markzen by one of two routes:

As the document you see — the three toolbar outputs just described (PDF, HTML, print) and five of the formats in the table above: EPUB 3, Microsoft Word (.docx), OpenDocument (.odt), Microsoft PowerPoint (.pptx) and Rich Text Format (.rtf). Diagrams, formulas and scores are written out as images and arrive intact.
As the document's source text — every other target, and every conversion to another markup language. Prose, headings, lists, tables and links all convert; a mermaid or katex block arrives as an ordinary code block holding the source you typed, because those formats have no figure for Markzen to hand them.

So a document built around diagrams is best handed over as PDF, HTML, EPUB, Word, OpenDocument, PowerPoint or RTF. LaTeX, Typst, reveal.js and the rest still give you the whole document — with each figure's source left in place, ready for that ecosystem's own tools.

Exporting from the command line

Markzen also works without opening a window. Pass the Markzen executable a source file and -o with an output path, and it renders the document and writes the export straight to disk:

markzen.exe report.md -o report.pdf

The source can be any of the eight markup formats Markzen reads; the output is a PDF or an HTML file, chosen by the output name's extension. The export goes through the same rendering as the app itself, so diagrams, formulas and every other extension block come out as live figures. Exports use the default style template and fonts — the command line runs in its own clean profile, separate from the app, which also means it works fine while Markzen is already open.

Several documents can be exported in one call — give any number of source -o output pairs and a single launch renders them all, at a fraction of the cost of launching once per file:

markzen.exe a.md -o a.pdf b.adoc -o b.html c.rst -o c.pdf

Fonts & appearance

Markzen is built to make a document look typeset rather than generic. The controls for that sit together on the toolbar behind the Style and fonts button, so you can adjust them while you read; the theme and interface language live in Settings → Display.

Style template

Style offers five preview styles: Standard, GitHub, Book, Modern, Minimal. The template you pick is also the style applied to PDF and HTML exports, so it decides how a shared document reads — choose Book or Modern for something you'll hand off, Minimal for distraction-free reading. The template styles the preview only, never the editor.

Fonts

Three pickers in the same panel set a separate font for each kind of text — Heading, Body and Code — which is what makes a Markzen document feel typeset:

Heading — Oswald, Playfair Display, Merriweather, Raleway, Montserrat, Lora, Libre Baskerville, Bebas Neue, Abril Fatface, Cinzel.
Body — Inter, Roboto, Georgia, Lato, Source Serif 4, Nunito, PT Serif, Crimson Text, Libre Franklin, Open Sans.
Code — JetBrains Mono, Source Code Pro, Cascadia Mono, Fira Mono.

The code fonts are chosen for one property beyond looks: they all draw the box-drawing characters (│ ├ └ ─) that tree listings and ASCII diagrams are made of, so a directory tree pasted into a code block keeps its shape instead of breaking into gaps. They are also the ligature-free variants — a font with ligatures redraws != as a single ≠, which is pleasant in a code editor and wrong in a document that is meant to show what the file actually says. JetBrains Mono and Source Code Pro ship inside Markzen, so they work on a machine that has never seen them and with no connection at all.

Theme & language

In Settings → Display:

Theme — Light or Dark. Default: Light.
Language — Markzen's own interface is translated into more than fifty languages, including right-to-left scripts (Arabic, Hebrew) and CJK (Chinese, Japanese, Korean).

Compatibility

The reference tables: what each markup language supports, and every kind of live figure Markzen can draw. Everything here is about what works where — the explanations live in the sections above.

What each markup language can do

Markup language	Opens files ending in	Live figures	Contents panel	Formula in a sentence	Cannot express
Markdown	`.md`, `.markdown`	all	yes	$…$	text alignment
AsciiDoc	`.adoc`, `.asciidoc`, `.asc`	all but `style`	yes	block only	strikethrough
reStructuredText	`.rst`, `.rest`	all but `style`	yes	$…$	strikethrough
Org	`.org`	all but `style`	yes	$…$	left and right alignment
Textile	`.textile`	all but `style`	yes	block only	—
Djot	`.dj`	all but `style`	yes	$`…`	—
MediaWiki	`.wiki`, `.mediawiki`, `.wikitext`	all but `style`	yes	`<math>`	inline code, strikethrough, blockquote, text alignment
BBCode	`.bbcode`, `.bb`	all but `style`	yes	block only	—

Live figures — the style block is the single exception: it applies CSS to the document itself, which only Markdown supports. Every other kind of figure works in every language. In a BBCode document the block is written [code=mermaid]…[/code] rather than with backticks; in MediaWiki, <syntaxhighlight lang="mermaid">…</syntaxhighlight>.

Cannot express — these are limits of the markup languages themselves, not of Markzen: where a language has no notation for something, Markzen offers no button for it rather than writing a private dialect only it could read back. See Formulas inside a sentence for the mathematics row.

Every kind of figure

Write the tag after the opening triple backticks — ```mermaid — and the block becomes a figure.

Category	Figure	Block tag	Notes
Diagrams	Mermaid	`mermaid`	flowcharts, sequence, class, Gantt, ER, state
	Graphviz	`graphviz`	the DOT language
	Cytoscape	`cytoscape`	network graphs; pan and zoom in the preview
	Markmap	`markmap`	mind map from a bulleted outline; click to fold
	Timeline	`timeline`	vertical event timeline
Software diagrams	Nomnoml	`nomnoml`	UML
	PlantUML	`plantuml`	UML — the one figure that needs an internet connection
	DBML	`dbml`	database schema diagrams
Charts	Chart.js	`chartjs`	bar, line, pie, radar
	Vega-Lite	`vega-lite`	declarative charts from JSON
	ECharts	`echarts`	large interactive charts
IT development	Pseudocode	`pseudocode`	typeset algorithms
	Tabulator	`tabulator`	sortable interactive table
	Bytefield	`bytefield`	bit and byte field layouts
	QR Code	`qrcode`
	Railroad	`railroad`	syntax diagrams
	WaveDrom	`wavedrom`	digital timing diagrams
Mathematics	KaTeX	`katex`	also $…$ in a sentence — see the table above
	AsciiMath	`asciimath`	plain-text maths notation
Graphs	function-plot	`fnplot`	plot a function curve
	JSXGraph	`jsxgraph`	interactive geometry
	Plotly	`plotly`	scientific and 3-D charts
Sciences	SMILES	`smiles`	chemical structure diagrams
Music	ABC Notation	`abc`	sheet music from plain text
	VexFlow	`vexflow`	engraved staves
	VexChords	`vexchords`	guitar chord diagrams
	ChordPro	`chordpro`	chords above lyrics
	MusicXML	`musicxml`	full scores
Games	Chess	`chess`	a board from a FEN position
	Go Board	`goboard`	9×9, 13×13 and 19×19
Document	Markzen	`markzen`	invisible: places and sizes the figure below it, or overrides the contents panel
	Style	`style`	invisible: CSS for this document — Markdown only

File associations

On Windows, the installer can register Markzen as a handler for every markup file type it reads — all fifteen extensions listed in Compatibility, across all eight languages. Once registered, double-clicking one of those files in Explorer opens it straight in Markzen, and if several editors are installed you can still choose Markzen via "Open with…".

Keyboard shortcuts

Key	Action
`Ctrl+S`	Save
`Ctrl+Shift+S`	Save As
`Ctrl+ +` / `Ctrl+ -`	Increase / decrease text size

Standard editor shortcuts — find, replace, copy, paste, undo, redo — and the formatting-toolbar shortcuts (bold Ctrl+B, italic Ctrl+I, heading Ctrl+H, link Ctrl+K, and more) work in the editor pane. A formatting shortcut exists only where the current markup has the construct — Ctrl+D does nothing in an AsciiDoc document, which has no strikethrough of its own (see The editor).

Tips

Hide the editor to read. Single view with the preview showing turns Markzen into a clean reader, and the five style templates let you set how it looks.
One document, every kind of content. A Mermaid flowchart, a KaTeX equation and a music score can sit next to plain prose — they all render together and all survive PDF and HTML export.
The style template is the export look. Whatever template you pick is the style baked into PDF and HTML output, so set it before you export.
Write in the markup you like, deliver in the format they need. Draft in Markdown (or any of the eight), then use Convert to for a Word file, a slide deck, an ebook or a LaTeX source — no separate tools required.