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)
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.

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
open another note while the editor is up (Cmd+P / Ctrl+P and so on)

Action	Key
Go to the 1st–9th tab from the left	`Cmd`+`1` – `Cmd`+`9` / `Ctrl`+`1` – `Ctrl`+`9`
Go to the 10th 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 them all and go back to the list	`Esc`

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.

The tab bar only appears with two or more tabs

With a single note open, the body uses the whole screen as before.

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.

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.

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 always available too). 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.

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 not carried over — if the template tag 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).

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.

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
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 — the body uses the full area (the tab bar only appears with two or more notes open). Renaming, save state, and preview live in the Inspector.

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`+`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

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.

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

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`)	✅	❌
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. In exchange, links work between any file kinds, not just notes.