Writing Notes¶

Melanite's Markdown editor puts one thing first: you can write the moment it opens.

Opening / creating notes¶

Task	How
Create a new note	`Cmd`+`N` / `Ctrl`+`N` → type a name → type immediately in the editor
Create from a template	`Cmd`+`Shift`+`N` / `Ctrl`+`Shift`+`N` → pick a template → type a name (any file type)
Open today's note	`Cmd`+`Shift`+`D` / `Ctrl`+`Shift`+`D`
Open an existing note	Select it and press `Enter` / double-click
Open several notes	Select several and press `Enter` (they open as tabs — see below)
Open in a new tab	`Cmd`+`T` / `Ctrl`+`T` → pick the note to open (you can also create one here — see below)
Reopen a closed tab	`Cmd`+`Shift`+`T` / `Ctrl`+`Shift`+`T`
Back to the list	`Esc`

New notes ask for a name before they are created. The file is created under the name you type, and a template's {{title}} is replaced with it too.

If a note (or file) with the same name already exists, Melanite asks before creating one. Choose "Open existing" (Enter) or "Create new" (make another one with the same name). When creating from a template the extension counts too, so a note and a Word file with the same name are different things.

A note created while you are filtering by tags gets those tags, the same way a dropped file does (→ Importing & exporting).

Opening a note replaces the entire Main area with the editor (it is not a modal). Focus is in the body the instant it opens. There are no modes to switch.

Pressing Esc to go back scrolls the file list to the note you were editing and leaves focus on the list, so the arrow keys take you straight to the next file.

Tabs (several notes at once)¶

You can keep up to 10 notes open and switch between them.

Tabs are added when you:

select several notes and press Enter, or right-click → "Open"
follow a link or backlink (the note you came from stays open)
move to the previous / next daily note, or jump to any date
create a new note while the editor is up (Cmd+N / Ctrl+N and so on)
pick a note in New Tab (Cmd+T / Ctrl+T)

Action	Key
Go to the 1st–9th note tab from the left	`Cmd`+`1` – `Cmd`+`9` / `Ctrl`+`1` – `Ctrl`+`9`
Go to the 10th note tab	`Cmd`+`0` / `Ctrl`+`0`
Next / previous tab	`Ctrl`+`Tab` / `Ctrl`+`Shift`+`Tab` (wraps around at the ends)
Close one tab	`Cmd`+`W` / `Ctrl`+`W` (or the × on the tab, or middle-click)
Close all note tabs, leaving only the list	`Esc`
New tab	`Cmd`+`T` / `Ctrl`+`T` (or the "+" at the right end of the tab bar)
Reopen a closed tab	`Cmd`+`Shift`+`T` / `Ctrl`+`Shift`+`T`

The number keys count note tabs only, from the left (list tabs are skipped). The faint number on each tab is the key that jumps to it. The limit is 10 tabs, so every tab always has a number key of its own.

Notes always open in tabs

Even with a single note the tab bar appears, with the list tabs in the order you opened them. Click a list tab to go back to the list while the note stays open. New tabs always go at the right end.

The number keys mean different things in different places

Cmd+1 – Cmd+4 switch views in the file list (grid / list / calendar / map) and select tabs while a note is open. Cmd+5 and up only do anything while a note is open — nothing happens in the file list.

What closes all note tabs

Sidebar actions and switching views from the View menu or the command palette take you back to the list, so using them with the editor up closes all note tabs. Quick Open (Cmd+P / Ctrl+P) shows its result in a new list tab, so your note tabs stay open. Cmd+Shift+T / Ctrl+Shift+T brings the closed tabs back together.

Switching tabs always saves first. Only the tab you are looking at can have unsaved changes, so nothing can be lost in a tab you cannot see.

Opening one more note when 10 are already open closes the left-most (oldest) tab. When you open several at once and they do not all fit, Melanite tells you how many were left out.

New tab (`Cmd`+`T` / `Ctrl`+`T`)¶

You pick where the tab goes before it opens. Search by name, and the note you pick opens in a new tab at the right end while the note you were writing stays open. It works from the file list too (the editor opens in that case).

The list shows files whose extension is set to open in the internal editor (.md / .markdown by default). Assign .txt or .html to the internal editor in Settings → "Opening Files" and they appear here as well.

The first three rows of the list are:

Open a list — opens a grid showing everything (no filters) in a new list tab
New note — if you have typed a name in the search field, the note is created under that name right away. Leave the field empty and Melanite asks for a name as usual
New from template — pick a template first, then type a name

Press Esc without picking anything and no tab is added (Melanite never creates an empty tab).

Reopen a closed tab (`Cmd`+`Shift`+`T` / `Ctrl`+`Shift`+`T`)¶

The tab you closed last comes back. You can go back through the last 10 closes.

Tabs closed together with Esc come back together as one step, with the tab you were looking at selected again. This is how you undo an accidental Esc.

What does not come back

Notes you deleted (moved to the trash) while the tab was closed do not come back. The cursor and scroll position are not restored either — a reopened note starts at the top. If you renamed it, it opens under the new name.

There is no side-by-side view

To compare two notes, use the preview overlay (Space).

Templates¶

Tagging a file is all it takes to make it a template. The tag name is set in Settings → "Notes" tab (default: template).

Cmd+Shift+N / Ctrl+Shift+N lists the templates. Pick one, then type a name, and the new file is created from it ("Empty note" is there too while the search box is empty). Dismiss the name prompt and nothing is created.

Recently used templates appear at the top, and the first one is focused as soon as the list opens, so pressing Enter right away picks it. Use Up / Down to move through the list.

Type in the search box at the top to narrow the list. It matches a template's name, file name or any part of its content, and space-separated words must all match (AND — e.g. meeting weekly). The box has focus as soon as the list opens, so type and press Enter. Content search covers note and text-file templates; Word files and the like match by name only. The same search box appears in "Insert template" (Cmd+Alt+T).

Tags carried over from a template¶

Tags you put on a template are applied to whatever you create from it. Tag your daily note template "DailyNote" and every day's note carries that tag from the moment it is created.

The template tag itself (default "template") is never carried over — otherwise the notes you create would show up in the template list next time
If you are filtering by tags, those tags are applied as well (→ Importing & exporting)
Opening a daily note that already exists changes nothing; tags are applied only when the note is created
Inserting a template's body at the cursor (Cmd+Alt+T) leaves the open note's tags alone. Tags are only applied when something new is created

Creating Word, Excel and PowerPoint files¶

Templates are not limited to notes. Any file you have imported — a Word document, a spreadsheet, a deck, anything — can serve as a template. Non-note templates carry an extension badge (DOCX, XLSX, …) in the list.

Import the file you want as a blank (an empty Word document, your company letterhead…)
Give it the template tag
From then on: Cmd+Shift+N / Ctrl+Shift+N → pick that template → type a name

Melanite copies the file into the library under the new name and opens it in Word (or whichever app handles that extension). Edit it, save over it, and when you come back to the Melanite window the size and modified date update themselves. No round trip through your Downloads folder.

The extension comes from the template (a .docx template makes a .docx file)
Tags are carried over (see "Tags carried over from a template" above), except for the template tag itself — if it came along, every file you created would show up in the template list next time
Right after creation the copy is byte-for-byte identical to the template, so the integrity check lists the two under "Identical items". Changing the contents and saving clears it
Which app opens it follows your per-extension setting (see Importing and exporting)

Cleaning up duplicates before you edit it moves the new file to the Trash

"Identical items" keeps the earliest import of each group and trashes the rest. The template entered the library first, so the template is what stays and the file you just created is what goes to the Trash — and any tags you put on it are carried over to the template.

Restoring it from the Trash brings its tags back with it, but the tags copied onto the template stay there — remove them by hand if you don't want them. The reliable habits are to edit and save the new file right away, or to not run the duplicate cleanup before saving. Once saved, its contents differ and it no longer shows up as a duplicate.

Keep one blank Word document around

Create a new document in Word, save it without typing anything, import it into Melanite and tag it as a template. From then on you can spin up a blank document without leaving the app.

Tokens in the body are replaced when the note is created.

Token	Replaced with
`{{title}}`	The note's name
`{{date}}`	Creation date (`2026-07-25`)
`{{time}}`	Creation time (`14:05`)
`{{datetime}}`	Date + time
`{{clipboard}}`	The text on the clipboard (empty if there is none)
`{{cursor}}`	Not replaced with text — moves the cursor here. If there are several, only the first is used

{{cursor}} works in all three cases: creating from a template, creating today's note, and inserting at the cursor.

No folders needed

Templates are ordinary items — only a tag sets them apart, so adding more doesn't clutter the list (excluding the template tag hides them → Tags).

Today's note (daily note)¶

Cmd+Shift+D / Ctrl+Shift+D opens the note named after today's date, creating it if it doesn't exist (after that, the same note opens again).

If you have set a template, the tags on that template come along too (→ Tags carried over from a template). Tag the template "DailyNote" and every day's note has it without you doing anything.

While editing, Cmd+Alt+Left / Cmd+Alt+Right jump to the previous / next day's note (→ Editor shortcuts).

For a day further away, press Cmd+Shift+J / Ctrl+Shift+J (→ Jumping to a date). It works with no note open too — from the list, the calendar, or the map. It is also in the command palette as "Go to a daily note by date".

You can also right-click the date in the calendar view (it is created with that day's name if it doesn't exist yet). Days that already have one are marked with a note icon in the corner of the cell, so you can see which days you wrote on at a glance. → Browsing your items

Jumping to a date¶

Cmd+Shift+J / Ctrl+Shift+J opens a date field with a small calendar below it (you don't need a note open to press it). Typing and picking land on the same single date, and Enter opens that day's note (creating it if needed). Days that already have a note carry a dot, so you can see where you wrote while you choose.

Because it isn't limited to editing, this key is fixed and cannot be reassigned in Settings — the same as Cmd+Shift+D.

The bottom line names the destination: "Open daily note “2026-08-20”" for a day that already exists, "Create daily note “2026-08-20”" for one that doesn't — so nothing is created without you seeing it first.

Writing the date (any separator works — -, /, ., or a space):

You type	Where it goes
`2026-08-20`	That day
`8/20`	August 20 of the year on screen
`20`	The 20th of the month on screen
`20260820` / `260820` / `0820`	Read the same way, without separators

There is no relative input such as "tomorrow" or "+3": neighbouring days are quicker to reach with the calendar or with Cmd+Alt+Left / Cmd+Alt+Right.

It works entirely from the keyboard. The arrow keys move the calendar even while you are typing.

Key	Moves
`Left` / `Right`	One day
`Up` / `Down`	One week
`Page Up` / `Page Down`	Previous / next month (same day of the month)
`Home` / `End`	First / last day of the month
`Enter`	Open that day's note
`Esc`	Close

The note opens in a new tab, so the note you were writing stays open (→ Tabs).

Settings → "Notes" tab controls:

Setting	What it does
Name format	Default `YYYY-MM-DD`. Accepts `YYYY` `YY` `MMM` `MM` `DD` `ddd` `HH` `mm`
Template to use	The template copied in when the note is created (optional)

Note

A note counts as "today's" only if the display name matches exactly. Notes in the Trash are ignored.

In Melanite Viewer (iOS / iPadOS)

The Viewer's calendar also marks days that have a daily note with a note icon in the top right. Touch and hold a day and choose “Open daily note” to open it right away. Tapping a day also puts its daily note at the top of that day's list. The Viewer is read-only, so it cannot create a note for a day that has none.

The name format is set under “Calendar” → “Daily note format” in the Viewer's Settings tab (the desktop settings are not carried over). If you changed it from the default YYYY-MM-DD on your computer, enter the same format there.

Saving¶

Saving is automatic. You don't need to think about it.

Auto-saves 1 second after you stop typing
Also saves when the window loses focus and when you return to the list
Cmd+S / Ctrl+S saves immediately

Checking the save state¶

While editing, the save state appears under the file name in the Inspector.

Shown	Meaning
Saved	The write has completed
Unsaved	Waiting for auto-save (saves after 1 second)
Saving…	Writing
Save failed	Error; the cause is shown alongside

Normally it just alternates between "Saved" and "Unsaved" — ignore it. Pay attention only when "Save failed" appears (usually disk space or permissions).

When the file was changed outside Melanite¶

While you are editing, the same file may be rewritten outside Melanite:

Your library lives in a cloud-sync folder and a change arrived from another machine
An external editor you launched via Open in an external app saved the file

When this happens Melanite stops auto-saving and asks. It never overwrites silently.

Choice	What happens
Load the external changes (discard your edits)	Re-reads the file's current contents. What you typed in Melanite is lost
Overwrite with your edits	Writes your version over the file. The external changes are lost

Warning

Whichever you pick, the other version cannot be recovered. If you're unsure, select and copy your edits first. Auto-saving is paused while the prompt is up, so there's no rush.

Editor features¶

A lightweight editor based on CodeMirror 6.

Markdown syntax highlighting
Line wrapping (no horizontal scrolling; vertical only)
Auto-continued lists and quotes — a newline carries - or > to the next line. Press Enter again on the empty line and the marker is removed, leaving the list or quote
Leading indentation carries to the next line — press Return on a line indented with a full-width space (U+3000) and the next line starts with a full-width space too, not a half-width one. Lines indented with spaces or tabs continue with spaces or tabs
Tab for indentation
Built so typing stays responsive even in notes of tens of thousands of characters (notes over 1 MB open without warnings)

There is no header above the editor — only the tab bar sits above it. Renaming, save state, and preview live in the Inspector.

Pasting formatted text¶

When you paste formatted text copied from Word, Excel, a web page, and so on with Cmd+V / Ctrl+V, it is converted to Markdown at the cursor. Headings become #, bulleted lists -, bold **, links [text](URL), and Excel cell ranges become Markdown tables (the conversion is the same as in Pasting text makes a note).

To paste without formatting, press Cmd+Shift+V / Ctrl+Shift+V. The text goes in exactly as copied
Inside a code block (```) or inline code (`), the text is pasted as is
Copies without formatting (text from an editor or a plain-text app) paste as before
Only Markdown notes (.md) are converted. Text files such as .txt paste as is

Editor shortcuts¶

These work only while a note is open. You can reassign them in Settings → "Shortcuts" tab; the defaults are below.

Key (default)	Action
`Cmd`+`Alt`+`T`	Insert a template at the cursor
`Cmd`+`Enter`	Toggle checklist
`Cmd`+`Alt`+`Left` / `Cmd`+`Alt`+`Right`	Go to the previous / next day's note
`Cmd`+`B`	Bold the selection (wrap it in `**`)
`Cmd`+`I`	Italicize the selection (wrap it in `*`)
`Cmd`+`K`	Insert link markup
`Cmd`+`Alt`+`O`	Open the outline (→ Outline)
`Cmd`+`E`	Open the full preview (→ Preview)
`Cmd`+`Alt`+`P`	Show as slides (→ Slides)
`Cmd`+`D`	Select the next occurrence (→ Multiple cursors)
`Cmd`+`Shift`+`L`	Select every occurrence
`Cmd`+`Alt`+`Up` / `Cmd`+`Alt`+`Down`	Add a cursor above / below

Toggling the checklist cycles the line the cursor is on (or every line in the selection):

Buy milk      →  - [ ] Buy milk  →  - [x] Buy milk  →  - [ ] Buy milk

Lines that are already list items keep their marker and just gain a checkbox (- Buy milk → - [ ] Buy milk, 1. Buy milk → 1. [ ] Buy milk).

Bold / italic simply wrap the selection in markers, and unwrap it when you press the key again. With nothing selected you get just the markers with the cursor between them, ready to type.

Inserting a link puts things in a different place depending on what you selected, and leaves the cursor where you need to type next — so either order works.

Selection	What you get	Cursor
Text	`[text]()`	Inside the parens (type or paste the URL)
A URL	`[](url)`	Inside the brackets (type the label)
Nothing	`[]()`	Inside the brackets

Previous / next day's note reads the name of the note you have open as a name format and opens the note one day before / after it (creating it if needed). While editing anything that isn't a daily note, today is used as the reference. Jumping to a date (Cmd+Shift+J) starts from the same day when it opens.

There is no underline

Markdown has no underline syntax, so there is no underline shortcut (_…_ is the same emphasis as bold / italic, and the preview renders it in italics).

Inserting a template is for building a note up

Where Cmd+Shift+N creates a new note from a template, Cmd+Alt+T adds one to the note you are writing. Handy for appending a "meeting notes" block to today's note again and again. Tokens like {{title}} are expanded on insertion ({{title}} becomes the name of the note you are inserting into).

Multiple cursors¶

Make the same edit in several places at once. Add cursors, then type — every cursor gets the same characters.

Key (default)	Action
`Cmd`+`D`	Select the word at the cursor. Press again to add the next occurrence
`Cmd`+`Shift`+`L`	Put a cursor on every occurrence of the selected word
`Cmd`+`Alt`+`Up` / `Cmd`+`Alt`+`Down`	Add a cursor on the line above the topmost / below the bottommost cursor
`Alt` + click	Add a cursor where you click

To turn three TODOs into DONE, put the cursor on the first TODO, press Cmd+Shift+L, and type DONE.

Esc collapses back to a single cursor; the next Esc returns to the list.

These keys can be reassigned in Settings → "Shortcuts" tab — useful if Cmd+D clashes with "duplicate" in the other apps you use, or if Cmd+Alt+Up / Cmd+Alt+Down are taken by your input method or the OS.

CodeMirror's default keymap¶

The editor is built on CodeMirror 6, so its standard key bindings work as well. These cannot be reassigned in Settings — only the bindings Melanite itself adds appear there.

Key	Action
`Alt`+`Up` / `Alt`+`Down`	Move the line up / down
`Shift`+`Alt`+`Up` / `Shift`+`Alt`+`Down`	Duplicate the line up / down
`Cmd`+`Shift`+`K`	Delete the line
`Cmd`+`[` / `Cmd`+`]`	Outdent / indent (same as `Tab` / `Shift`+`Tab`)
`Cmd`+`G`	Find next (without opening the panel)
`Cmd`+`Alt`+`G`	Jump to a line number
`Cmd`+`/`	Wrap / unwrap the selection in an HTML comment (`<!-- -->`)
`Cmd`+`Shift`+`\`	Jump to the matching bracket

The full list is in CodeMirror's official reference → defaultKeymap (search panel keys: searchKeymap)

Bindings Melanite overrides

Cmd+I (normally "select parent syntax") and Cmd+Enter (normally "insert blank line") are reassigned to italic and the checklist toggle, which matter more when writing Markdown. Clear those two in Settings to get the original behavior back.

Find & replace inside the editor¶

Cmd+F / Ctrl+F opens a find & replace panel above the body.

Esc closes just the panel (when the panel is closed, Esc returns to the list).

Preview¶

To see formatted output, open the read-only preview.

Cmd+E (macOS) / Ctrl+E (Windows), or the "Preview" button in the Inspector (the key can be reassigned in Settings → "Shortcuts" tab)
The same front overlay as Quick Preview (Space)
Renders the Markdown (sanitized)
Clicking a link opens it in your default browser, not inside the app
Select the text and copy it with Cmd+C / Ctrl+C — straight from the formatted view, so you don't have to go back to the editor just to copy something
Code blocks can be copied whole. Hover a fenced (triple-backtick) block and a "Copy" button appears in its top-right corner (it says "Copied" once you press it)
The text size has four steps (small / medium / large / extra large) — the same setting applies to text-file previews (Settings → "Appearance" tab)
Code blocks are colored when you write a language name after the triple backticks (→ Code highlighting)
Mermaid diagrams are drawn. A block fenced with ```mermaid is shown as a diagram instead of code (→ Mermaid diagrams)
==text== highlights and > [!NOTE] callouts are shown (→ Highlights and callouts)

External images are not loaded by default

Images referenced by URL — ![](https://…) — are replaced by a placeholder by default, because loading them contacts the remote server every time you open the note and reveals your IP address and the time you opened it. You can allow them in Settings > Privacy.

There is no split preview

Side-by-side split view and WYSIWYG editing are deliberately not built. Editing is always plain text; display is a read-only overlay.

Ctrl+E on macOS

On macOS, Ctrl+E is left to "move to end of line". Use Cmd+E for the preview. To use a different key, reassign "Open the full preview" in Settings → "Shortcuts" tab.

Code highlighting¶

Write a language name after the opening backticks and the block is colored, both in the editor and in the preview.

```html
<p class="note">Hello</p>
```

Language	Name to write
HTML	`html` `htm`
CSS	`css`
JavaScript	`js` `javascript` `mjs` `cjs` `jsx`
TypeScript	`ts` `typescript` `tsx`
JSON	`json` `jsonc` `json5`
Python	`python` `py`
Ruby	`ruby` `rb`
PHP	`php`
C	`c` `h`
C++	`cpp` `c++` `cc` `cxx` `hpp`
C#	`csharp` `cs` `c#`
Java	`java`
Kotlin	`kotlin` `kt`
Scala	`scala`
Dart	`dart`
Objective-C	`objc` `objective-c`
Swift	`swift`
Go	`go` `golang`
Rust	`rust` `rs`
Shell	`sh` `shell` `bash` `zsh`
PowerShell	`powershell` `ps1` `pwsh`
SQL	`sql`
YAML	`yaml` `yml`
TOML	`toml`
XML	`xml` `svg`
INI	`ini` `properties`
Lua	`lua`
Perl	`perl`
R	`r`
Dockerfile	`dockerfile` `docker`
diff	`diff` `patch`

Languages not in this table are shown without color. Language names are not case-sensitive. In JSON, keys get the same color as string values. PHP is colored correctly when the block contains only PHP (HTML written outside <?php is not colored).

Adding a file name¶

Put : and a file name after the language name, and the preview shows the file name above the code block.

```js:sample.js
console.log("hello");
```

You can leave out the language and write just ```:memo.txt
Melanite Viewer (iOS / iPadOS) also shows the file name above the code block

Mermaid diagrams¶

A block written in Mermaid syntax becomes a diagram in the preview. Gantt charts, flowcharts, sequence diagrams — any diagram Mermaid can draw works.

```mermaid
gantt
    title Writing schedule
    axisFormat %m/%d
    section Writing
        Chapter 1: done, 2026-08-01, 10d
        Chapter 2: 2026-08-10, 10d
    section Publication
        Release: milestone, 2026-09-01, 0d
```

In the editor you keep editing plain text. Only the preview draws the diagram
If there is a mistake, the reason (which line, and where) and the code are shown instead
The diagram's colors follow the app theme (light / dark)
The "Copy" button in the top-right corner copies the original code, not the picture
Drawing a diagram never contacts anything outside your computer

Melanite Viewer (iOS / iPadOS) does not draw diagrams

The Viewer shows Mermaid blocks as code, without colors, because it is built without any third-party libraries.

Properties (front matter)¶

Write YAML enclosed in --- (front matter) at the very beginning of a note, and the preview shows it as a table of keys and values above the text. Notes brought over from Obsidian and similar apps no longer show stray --- lines and YAML.

---
title: Kyoto trip
date: 2026-09-26
tags: [travel, kyoto]
aliases:
  - Autumn trip
url: https://example.com/plan
---
# Day 1

Supported forms are key: value, key: [a, b], and a list of - value lines under key:. List values are shown as small chips
A value that starts with http:// / https:// opens in your browser when clicked. Even an image URL is never loaded as an image
If any part cannot be shown as a table — nesting (key: value under another key:), multi-line strings starting with | / >, and so on — the YAML is shown as-is as code
It counts as front matter only when the first line is just ---, a closing --- (or ...) follows, and the first line in between has the key: value form. A note that simply starts with a --- horizontal rule looks the same as before
In the editor you keep editing plain text. Only the preview shows the table
# … lines inside front matter do not appear as headings in the outline

Not linked to tags

Values under tags: are only displayed; they do not become Melanite tags. Likewise, tagging a note in Melanite does not change its front matter. Keep adding tags in the Inspector.

Melanite Viewer (iOS / iPadOS)

The Viewer shows the same table on a note's detail screen, with the same rules.

Highlights and callouts¶

Using the same syntax as Obsidian and GitHub, you can mark text with a highlighter or put a note in a colored box.

A highlight is wrapped in ==. The preview draws a yellow band behind it, and the editor colors it as you type.

Please ==make sure to read== this part.

The characters right inside the == must not be spaces (== text == is not highlighted)
Inside code (`==x==` or a code block) it is shown as written

A callout is a quote (>) whose first line is [!type]. The lines after it are the body, which can contain lists and code blocks.

> [!WARNING]
> Deleting this cannot be undone.

> [!tip] A title of your own
> Text after the type becomes the title.

The type is not case-sensitive ([!NOTE] and [!note] are the same)
Without a title, the type name (Note, Warning, ...) is used as the title

Types and colors:

Color	Types
Blue	`note` `info` `todo`
Cyan	`abstract` `summary` `tldr`
Green	`tip` `hint` `success` `check` `done`
Purple	`important` `example`
Yellow	`warning` `attention` `question` `help` `faq`
Red	`caution` `danger` `error` `failure` `fail` `missing` `bug`
Gray	`quote` `cite`

Any other name looks the same as note - Write > > [!type] inside a quote to nest callouts - Obsidian's fold markers ([!NOTE]- / [!NOTE]+) are accepted, but Melanite always shows the callout expanded - In the editor you keep editing the plain text with > and [!type], as before

Melanite Viewer (iOS / iPadOS)

The Viewer shows them the same way on a note's detail screen and in slides, with the same rules.

Slides¶

Split a note with lines containing only ---, and you can show it one slide at a time, full screen. It works like Marp, but with ordinary Markdown.

# A proposal for the new project
October 2026 planning meeting

---

## Background
- Inquiries doubled from last year
- Half of them are the same questions

---

## Proposal
Publish a page that answers the common questions

The example above becomes three slides.

Open: the "Slides" button in the Inspector, or Cmd+Alt+P (macOS) / Ctrl+Alt+P (Windows). The key works not only while editing a note but also when a note is selected in the list (reassign it in Settings → "Shortcuts" tab). "Show as Slides" in the command palette works too
Move between slides: Right / Space for the next, Left / Shift+Space for the previous, Home / End for the first / last. Esc closes
Move the mouse to show previous / next and close buttons at the bottom of the screen
The window goes full screen while the slides are open, and returns when you close them

Rules for writing

A slide break is a line with only ---. It works even without blank lines around it (in Markdown, a --- right under a paragraph turns it into a heading, but slides treat it as a break)
--- inside a code block (```) is not a break
A --- at the very start or end, or several in a row, never create empty slides
Slides have a fixed 16:9 size and are scaled as a whole to fit the screen. Anything that does not fit on one slide is cut off — split long content with ---
Headings, lists, tables, images, code coloring and Mermaid diagrams look the same as in the preview
Front matter at the start is not shown on the slides (it never becomes the first slide), and its contents are not read as settings
Marp-specific directives such as  are not supported (files written for Marp still show their breaks and text as-is)

The look (header, footer, background color, text color, page numbers) is set in Settings → "Notes" tab. It applies to every slide.

Slides are for viewing only

You cannot edit text while showing slides; keep writing in the editor as usual. There is no PDF export. The Melanite Viewer (iOS / iPadOS) can show the same slides from “Show as Slides” in a note's menu. Its look is set under “Slides” in the Viewer's Settings tab (the desktop settings are not carried over). The Viewer does not color code or draw Mermaid diagrams.

Outline (heading list)¶

Move around a long note by its headings — and reorder whole sections.

Cmd+Alt+O (macOS) / Ctrl+Alt+O (Windows) opens it (the key can be reassigned in Settings → "Shortcuts" tab)
It is also in the command palette (Cmd+Shift+P) as "Outline"
A front overlay lists every # heading, indented by depth
The heading your cursor is in is selected when it opens
Type in the search box at the top to filter headings (space-separated words must all match). The first match is selected as you type, so just press Enter to jump there. Reordering is off while the list is filtered — you can only jump

Jump to a heading¶

Click a heading — or select it with ↑↓ and press Enter — to move the cursor to that line and close the outline. You can keep typing right away.

Reorder whole sections¶

Drag a heading and drop it where the line appears, and that section moves.

The heading and everything under it moves: dragging ## Background takes its body and any ### … sub-headings with it (a section runs until the next heading of the same or shallower depth)
While dragging, the rows that travel together are dimmed
A section cannot be dropped inside itself (no line appears)
Alt+Up / Alt+Down reorders without dragging. Each press advances one step, and where it lands depends on the depth of the neighbouring heading (below)
The move is an edit to the note, so Cmd+Z undoes it in one step

Change a heading's depth¶

Alt+Left / Alt+Right shifts the selected heading one level (one #).

## Background   →  ### Background   (++alt+right++)
### Details        #### Details

Sub-headings shift with it, so the structure inside the section is preserved
Nothing goes shallower than # (H1) or deeper than ###### (H6). If any heading in the section would fall outside that range, nothing happens at all — no partial clamping
Reordering never changes depth. Dropping # Implementation below another section leaves it as # Implementation. Depth only moves with these keys, so repositioning a section can never change its level by accident
Cmd+Z undoes a depth change too

Not the same as Cmd+Alt+Left in the editor

These keys apply while the outline is open. They do not clash with Cmd+Alt+Left / Cmd+Alt+Right (go to the previous / next day's note), which include Cmd.

Only whole lines are moved around; no blank lines are added or removed. A blank line that followed a section travels with it.

Where `Alt`+`Up` / `Alt`+`Down` lands¶

In the note below, Alt+Down on ## ccc puts it at the start of the # ddd section — before ## eee. It never skips over the section and lands at its end.

# aaa            # aaa
## bbb           ## bbb
## ccc     →     # ddd
# ddd            ## ccc     ← here
## eee           ## eee
## fff           ## fff

Neighbouring heading	Destination
Same depth (sibling)	Swaps with that whole section (never splits its sub-headings)
Below is shallower (a bigger heading)	The start of that section
Above is shallower	Before that heading — the end of the previous section

Press again and it continues downwards, swapping with each sibling in turn. Alt+Up is the exact inverse, so one press always brings it back.

Press Esc to close. Pressing Esc during a drag cancels only that drag and leaves the outline open.

What counts as a heading

Only ATX headings — # to ###### at the start of a line. Underlined (setext) headings, where === or --- sits on the next line, are ignored, because --- is indistinguishable from a horizontal rule and misreading it could damage the note when reordering. A # inside a fenced code block is not a heading either. Lines that are not picked up simply travel with the section above them.

Editing text files¶

Text files such as .txt can also be opened and edited in the built-in editor.

They are treated differently from notes (.md), though.

	Note (.md)	Text (.txt etc.)
Edit in built-in editor	✅	✅
Opening lines on the card	✅	✅
Markdown highlighting	✅	❌ (plain)
Preview (`Cmd`+`E`)	✅	❌
Slides (`Cmd`+`Alt`+`P`)	✅	❌
Full-text search of the body	✅	❌ (name only)

Editing in an external editor¶

"Open in External App" in the Inspector opens the note in the OS default app.

Per-extension defaults (built-in editor / OS default / a specific app) are set in Settings → "Opening Files" tab.

Notes, tags, and links¶

A note is an item like any other. Everything that works on files works on notes.

Add tags (Organizing with Tags)
Link to other items (Linking Items)
Attach a location (Location & Map)

There is no [[wikilink]] syntax

Melanite's links are references between item IDs managed in the database, not markup inside note text. Create them from the Inspector's link field, or from the suggestions that appear when you type [[ in a note (if nothing matches, you can create a note with that name and link to it; only the name is left in the text). In exchange, links work between any file kinds, not just notes. → Linking Items