Markup language

Inline formatting

Within any line, you can add bold, italic, and inline code formatting. This works inside any text-bearing prefix type.

Inline code uses single backticks and renders in a monospace font with a subtle tinted background. Code spans never process formatting inside, so `*literal*` stays literal. Escape a delimiter with a backslash: \*, \`, or \\.

Formatting markers are stripped in the rendered view and in fuzzy matching, so **bold** matches bold when checking off tasks or searching.

Lists and indentation

Bullet lists use *, numbered lists use %. To nest a list, indent two spaces per level. Up to five levels of nesting are supported.

Escaping and comments

Two prefixes keep Mudlark from interpreting a line. \ makes the rest of the line plain text, so \ + Not a task renders as the literal text “+ Not a task”. / marks a comment, a private note that stays in the left pane and never appears in the rendered note.

Smart matching

When you check off a task with - or move something with >, you don’t need to type the full name. Each word you type just needs to match the beginning of a word in the original, in order.

This also works with filenames and paths. A file like images/daisy-pants-stereo.jpg is broken up at slashes, dots, and dashes, so _ @ pants is enough to match it.

The editor colors the line live as you type: green when it finds exactly one match, yellow when more than one item matches (ambiguous, so nothing happens), and red when nothing matches.

Checking off tasks

- looks for a matching task and marks it done. Content after the space is the task name to match.

Removing items and sections

To remove any other kind of item, use _ followed by the type’s prefix. Works with Heading, Task, Highlight, Question, Quote, Bullet, Media, Numbered, Code, Math, Timer, Loop, Table, Footnote.

Use _ # name to remove an entire section and everything in it.

Moving things around

The > character moves content between sections.

Move an item here

Add a type prefix and a fuzzy match. The matched item moves into the current section.

Send an item to a heading

Add a pipe and a destination heading.

Relocate a whole section

Use the heading prefix # inside the move to target a heading by name. Without a pipe, the matched heading and its contents re-parent into the current section. With a pipe, they re-parent under the destination heading instead.

A fourth form moves a whole named block. See Acting on a whole block.

Writing to another section

The . character creates a new item under another heading without moving your cursor. Write the type prefix, the content, then a pipe and the destination heading.

> moves an existing item. . creates a new one. The pipe destination is required.

Finding and replacing

The , character searches everything above it. Add a pipe to replace matches, a type prefix to target a specific type, or @ heading to scope the search to a specific section.

Rules as barriers

The ~ character draws a horizontal rule. Add a label to center text on the rule: ~ Chapter 2. A rule is also a barrier. Completions and moves cannot cross it: a - task below a rule cannot check off a task above it. Use one to fence off finished work.

Opening and closing a block

Double a block-capable prefix to open a block. Use the same doubled prefix again to close it. Single-prefix lines stay as typed-line shortcuts.

Block-capable types: ++ !! ?? "" ** %% `` == :: ;; && // ^^.

Named blocks

Give a block a title by writing the doubled prefix followed by a name. Named blocks show up as groups on the right side, and you can check off, remove, or move the whole group at once.

-- Shopping marks all items done. > ++ Shopping moves the entire block.

Acting on a whole block

A single type prefix targets one item. Doubling the inner prefix targets a whole named block.

The same doubling works inside action lines. _ + milk removes one item and _ ++ Shopping removes the block. > + milk moves one item and > ++ Shopping | Home moves the block under “Home”.

These commands look upward from where you type and stop at the nearest ~ rule. If two blocks with the same name are both in reach, Mudlark does nothing rather than guess.

Composite blocks like code, tables, and math can only be targeted this way: by name, with the doubled form.

Container and composite blocks

Blocks come in two kinds. Inside a container block (++, **, %%), every line is still its own item. You can check off one task inside a ++ block with a plain - milk.

A composite block (!!, ??, "", code, math, tables, media) is one unit. Its inner lines cannot be targeted on their own. To complete, move, or remove it, use its name with the doubled form.

Code blocks

A code block can carry both a language hint and a title. Write the language right after the doubled backtick (no space), then a space, then the title.

The language drives syntax highlighting. The title renders as a header on the rendered block. A bare ``swift opens an unnamed block. A bare `` opens an unnamed, untyped block.

Block hints

A few block prefixes accept a hint glued to the opener, with no space between them. Code takes a language: ``swift Login flow. Math takes an aggregator: ==sum totals. Tables take a format: &&csv. Other prefixes accept the bare doubled form with an optional name only.

Note links

Write [[Title]] anywhere inside a line to link to another note in the same vault. Typing [[ opens an autocomplete of vault titles. Pick one and the closing ]] is inserted for you.

In the editor, the link shows as a compact chip. Move your caret into it and it turns back into the raw [[Title]] text for editing. In the right pane the chip is clickable and jumps to the linked note.

Renaming or moving a note auto-rewrites every [[ ]] reference across the vault, so links stay valid without manual cleanup. On export, each link resolves to the destination’s native note-link form (a Markdown link by default, a wiki-style link for Obsidian, an internal link for Notion, and so on). See the export guide for the per-destination behavior.

Inline embeds

The {{ … }} notation embeds something live inside a sentence: an image, a calculation, a code snippet, or a timer. The first character inside the braces is the same prefix you would use to open that item on its own line. Five types embed:

Inline math

The same engine that drives full-line = expressions runs inside {{= }}: unit-aware arithmetic across lengths, weights, times, and temperatures, plus any variables you defined earlier in the document. The right pane shows the formatted result, the source survives in the editor.

Inline code

{{`code}} renders monospaced code inline. Glue a language hint to the backtick for syntax highlighting: {{`python def f()}} highlights as Python. Inline code is for short snippets that want richer treatment than the backtick-wrapped `text` inline-formatting shortcut.

Inline media

{{@ filename}} drops a piece of media into the sentence. Typing {{@ opens an autocomplete of vault media. Local images render in place, sized to the column, with rounded corners, an accessibility label from the filename, and a click action (tap to copy, Cmd-click to open). Remote URLs load asynchronously. Videos show a poster and open in the default app on click.

For a gallery, open a media block with @@ and put one media reference per line. The right pane lays the items out in a mosaic of justified rows sized from each image’s aspect ratio, with runs of tall images stacked so they sit beside shorter neighbors. Nothing is cropped or squeezed to a uniform tile.

Inline timers and loops

{{: 25:00 Focus}} for a countdown, {{; 5:00 Break}} for a loop. The rendered pane shows an icon and a formatted duration, ticking down in real time. Bare numbers can carry a phase name, so {{: 25 Focus}} reads as 25 minutes. Inline timers are for when a timer wants to live inside a sentence. Full-line timers are covered in Timers and loops.

Where embeds work

Embeds and [[note links]] work inside prose: headings, tasks, highlights, questions, quotes, bullets, numbered items, footnote definitions, and custom callouts. Inside code blocks, full-line math, tables, media lines, and comments, the braces stay literal text. Put the embed on a prose line if you want it to render. Escape a literal brace pair with \{{.

Footnotes

Put a ^ at the end of a word, with no space, to mark a footnote. Then define the note on its own line with ^ text.

The first marker pairs with the first definition, the second with the second, and so on. In the rendered pane this becomes “The cat sat on the mat.¹” with a numbered footer below the section. Unpaired markers render as ˣ.

For longer notes, open a footnote block with ^^.

A footnote block renders as a callout in the right pane. The footnote number sits in the block’s header, so the body reads on its own. Escape a marker with \^ to render a literal caret. In Settings → Markup, you choose where footnote definitions appear: in the body, next to the reference, or in a footer at the end of the section.