Creating & Editing Notes
memrynote's editor is built on BlockNote — a block-based rich text editor with full markdown support. Every paragraph, heading, list item, code block, and image is a block you can drag, duplicate, or delete.
Creating a Note
| How | What you get |
|---|---|
| ⌘+N | New note in the current folder |
| Sidebar + affordance | Same, scoped to the section you click |
| From a Template | New note seeded with template content |
| New note from this note | Same folder, icon, tags, properties |
[[New title]] in another note | Linked note created on first save |
The new note opens in a tab with the cursor in its empty title, which shows New note as a placeholder: type the name and press Enter (or move on to the body), and it is named. Press Esc, or click away without typing, and the note keeps the name New note, numbered (New note 1, New note 2) when that name is already taken in the folder. New folders and subfolders still open a name field on their sidebar row.
The sidebar follows along: the folder the note landed in is opened — nested folders included — and the note is scrolled into view and briefly highlighted, so you can see where it went without going looking for it. This matters most when the note did not land where you were standing: with Create in Selected Folder off and a Default Location for New Notes set, the note goes to that folder, and the sidebar takes you there. It is the same jump as Reveal in navigation in a note's ⋯ menu.
Every way of making a note does this: ⌘+N, the sidebar's New button, the New note icon on the Collections header, the tab bar's +, and New note on a folder's right-click menu — including when that folder is closed. All of them open the name field too.
New note from this note
When follow-up notes share a note's classification (a meeting note or a checklist under a project note), right-click the note in the sidebar or open its ⋯ menu and choose New note from this note. The new note lands in the same folder with the source note's icon, tags, and properties, an empty body, and the name field open. A toast confirms what came across, for example "Created with 2 tags and 3 properties from Project X".
The copy happens once. Editing either note afterwards never changes the other. If the source note belongs to a project through its project property, the new note joins that project too. If the folder has a default template, the template body fills the empty body. Where the template and the source note set the same property or icon, the source note wins, and tags from both are kept.
Several notes and folders at once
To file or clean up a batch of items in the sidebar, select them first. ⌘-click (Windows and Linux: Ctrl-click) adds or removes one note or folder, and Shift-click selects everything between the last click and this one. Then right-click any selected row:
| Action | What it does |
|---|---|
| New folder with selection (N items) | Makes a folder in the deepest folder the items share, moves them into it, and opens its name field |
| Move N items to… | Opens the folder picker and moves every item to the folder you choose |
| Bookmark N items | Adds every item to Bookmarks. Items already bookmarked stay as they are |
| Delete N items | Asks for confirmation, then deletes them |
For example, select the folder Projects and the note Loose idea at the top level, then choose New folder with selection. You get Untitled Folder/Projects and Untitled Folder/Loose idea, with the name field open on the new folder.
These moves follow the same rules as dragging. A folder never moves into itself or one of its subfolders, so the folder picker leaves those out. When you select a folder together with something inside it, the inner item moves with its folder and stays inside it. Journal entries are not bookmarked from here, the same as on a single entry's menu.
Block Types
Available from the slash menu (/) or the block-handle drag-out:
- Paragraph
- Heading 1 through 6
- Bullet list, numbered list, check list
- Quote, callout
- Equation (a LaTeX formula on its own line)
- Toggle list (collapsible section — nest text, images, even other toggles inside it)
- Two, three, four or five columns (blocks side by side)
- Code block (language picker: 50 languages, alphabetical)
- Diagram (Mermaid)
- Whiteboard (an inline canvas you draw on)
- View (a live list of notes from a folder, a tag or the whole vault)
- Divider
- Image, file
- Table
- Wiki-link block (or inline
[[...]])
Code Blocks
/code or ``` starts a code block. Point at one, or put the cursor in it, and a small toolbar appears in its top-right corner:
- the language picker, which sets the syntax highlighting — 50 languages, alphabetical, Plain Text first
- Copy code, which puts the whole block on the clipboard
PowerShell and KQL are in the picker and are saved to your file like any other language, but they currently render without colour.
A fence with no language, or tagged with one the picker does not list, shows Plain Text in the picker and keeps its original tag in the file until you pick a language yourself.
Highlighting follows your theme: the same block is light in the light theme and dark in the dark one, on the sidebar's own background rather than a black slab. Code text sits one notch below body text and scales with Appearance → Font Size.
Diagrams
/mermaid (or /diagram, /flowchart, /chart, /graph) inserts a Mermaid diagram, starting from a two-box flowchart so there is something on the page to edit. The block shows the drawing; click it to open the source and edit it, and the picture redraws as you type. Source with a mistake in it keeps showing the last diagram that worked, with the error underneath, so a half-typed line does not blank the page.
Flowcharts, sequence diagrams, Gantt charts, state diagrams, pie charts — whatever Mermaid draws.
A diagram is stored as an ordinary ```mermaid code fence, the same notation Obsidian, GitHub and GitLab use. Nothing extra is written beside it, so a diagram you make here shows up as a diagram there, a fence written there opens as a diagram here, and a fence written by a Memry version that predates this block opens as one too.
On the phone the block shows the Mermaid source, labelled, rather than the drawing — the renderer is far too heavy for the mobile editor. You can read and edit it there and the change syncs; the picture is drawn on the desktop.
Whiteboards
/whiteboard (or /canvas, /excalidraw, /draw, /sketch, /board) creates a new canvas, titled after the note ("Meeting notes whiteboard"), and shows it right in the note. The drawing is read-only until you press Edit, which turns on the full drawing tools; changes save into the canvas as you draw, and Done saves at once. While you are not editing, scrolling passes through to the note, pinch or Ctrl+scroll zooms the drawing, and changes made elsewhere — in the canvas's own tab, or on another device — show up in the block. Open in tab opens the canvas full size.
A canvas made this way belongs to its note, so it stays out of the sidebar's canvas list, but it is an ordinary canvas otherwise: [[ finds it, it opens in a tab of its own, and other notes can show it too.
To put an existing canvas in a note, type @ and pick it. Mention inserts a link to it, the same [[Canvas Title]] link [[ gives you; Embed shows the canvas inline, like /whiteboard does. One canvas can be embedded in any number of notes; they all show the same drawing, because there is only one. If the canvas is deleted or cannot be read, the block says so instead of drawing it.
The note stores only a pointer to the drawing, one line of the form ; the drawing itself stays in the canvas's own .excalidraw file under canvases/. The pointer uses the canvas's id rather than its title, so renaming a canvas never breaks a note that shows it. Other markdown apps see that line as an image they cannot load.
A note shown as a card on a canvas shows its whiteboards as their title and Open in tab rather than as live drawings.
On the phone the block shows a Whiteboard card rather than the drawing; the note keeps it, and the board is drawn on the desktop.
Views
/view (or /query, /base, /database) puts a live list of notes in the note. It starts as the ten notes you changed most recently, with its source menu open so you can point it somewhere else:
- All notes: every note outside the journal
- Journal: your journal entries, one per day. A view over the journal is always a chart.
- Folder: the notes in a folder and its subfolders
- Tag: the notes, tasks and inbox items carrying a tag
The header next to the source holds the rest:
- Saved view, when the folder or tag has more than one saved view. Picking one uses its layout, filters and sort.
- Filter, the same filter builder a folder page has. Filters set here apply on top of the saved view's.
- Layout: list, table, gallery or chart.
- New note creates a note where the view lists it and opens it, as the folder page's New note does: in the folder (with the folder's template), in the vault's default folder for All notes, or carrying the tag. It is not there for a journal chart. A note that the view's own filters exclude is still created, but the list does not show it.
- Open as tab opens the folder or tag page itself, on the same saved view.
The list stays current. Create, edit, tag or delete a note anywhere and the view updates. Clicking a row opens it, and a middle-click opens it in a background tab. The list scrolls inside the block once it is taller than a few rows.
A view is stored in the note as a code fence tagged memry-view, holding what the view shows as a few lines of JSON:
```memry-view
{
"source": { "kind": "tag", "tag": "inbox-thought" },
"layout": "list"
}
```The app never shows that text; the header's controls rewrite it. Arrow keys from the line above or below select the whole view, so typing then starts a new line under it and Backspace removes it. If the text in the file stops being valid, the block says so and offers the source menu to start over. Obsidian, GitHub, the phone and older versions of memrynote show the fence as an ordinary code block and leave it as it is.
A new view with its own folder
/new view (or /new database, /inline database, /collection) starts a view for notes that do not exist yet. It creates a folder named Untitled View next to the note, numbered Untitled View 2 and so on when that name is taken, and puts a view over that folder in the note. Notes made with the block's New note go into that folder, so the list fills itself. Renaming the folder later does not update the view: it then says the folder is gone, and you pick the renamed folder from its source menu. If the folder cannot be created, nothing is inserted and an error says why.
Views in templates
A view in a template is copied into every note made from it, so a default journal template can give each day the same list. Template variables inside the view's text are filled in when the entry is created. To list only the notes created since that day, open the block's text and add a filter:
"filters": "created after \"{{date:YYYY-MM-DD}}\""Use {{date:YYYY-MM-DD}} rather than {{date}}: the plain form is a long, localized date that a filter cannot compare against.
Charts
/chart (or /graph, /plot, /heatmap, /tracker) plots one property over time. It starts on the journal with its settings open, so the first step is to pick the property. Any view can also switch to the chart layout, which plots its folder's or tag's notes instead.
The property's type picks the chart, marked Suggested in the settings:
| Property | Suggested chart | Also |
|---|---|---|
| Number, rating | Line, with the average, the change against the period before and the lowest day | Bar, heatmap |
| Checkbox | Heatmap of done days, with the current and longest streak | Bar |
| Select, status | Heatmap coloured by each option's own colour, with the most common value | Bar of how often each value was picked |
| Multi-select | Bar of how often each value was picked | Heatmap |
| Anything else | Heatmap of the days it was filled in | Bar |
The settings also hold:
- Range: the last 7, 30 or 90 days, half a year or a year, ending today. Lines default to 30 days and heatmaps to half a year.
- Same-day entries, for numbers: when more than one note falls on a day, their average, sum, lowest, highest or count.
- Missing days, for lines and bars of numbers: leave a gap, or count as zero.
- Date from, for a folder or a tag: the day a note falls on, from when it was created, last modified, or a date property. The journal always uses the entry's own day.
Hover a day to see its value. Click it to open that day's journal entry, or the note that falls on it.
A chart is the same memry-view fence as a view, with a chart layout:
```memry-view
{
"source": { "kind": "journal" },
"layout": "chart",
"chart": { "property": "sleep", "rangeDays": 90 }
}
```Older versions of memrynote show a chart over a folder or a tag as a list, and a chart over the journal as a view they cannot read. Both leave the text as it is.
Tables
/table opens a size grid before it inserts anything. Hover the grid and click, or size it with the arrow keys and press Enter; Escape closes it with nothing inserted. The grid opens on 3 rows by 3 columns and goes up to 10 by 10. The first row is the header row, and it counts toward the rows you pick. The header row is part of the table, not a style: notes are stored as markdown, and a markdown table always writes its first row as the header.
Use the row and column handles on the edge of a table to toggle a header row or a header column on and off. The same table controls are available in task descriptions and in inbox items.
A column width you drag is kept when you leave the note and when you restart the app. Like cell colours, it is stored as a comment line above the table that other markdown editors ignore. Row heights are not stored, because the editor has no row height to store.
The handles on the border lines
Put the pointer in a cell and three small grey marks appear, on the table's own border lines rather than floating beside it:
| mark | where | opens |
|---|---|---|
| on the table's left edge, beside the cell's row | outer border | the row menu — delete the row, insert one above or below |
| on the table's top edge, above the cell's column | outer border | the column menu — delete the column, insert one left or right |
| on the cell's own right border | inner border | the cell menu — Colors, splitting or merging, and the row and column actions |
Hover a mark and it grows into a small six-dot button; click it for the menu. A mark's clickable area reaches a few pixels either side of the line it is drawn on, so you do not have to land on the line itself — it is easier to hit than it looks.
Row and column live on the table's outer edges on purpose. An inner vertical line belongs to two cells at once — the line to a cell's left is the line to its neighbour's right — so a mark there would be ambiguous about which one it meant. The one inner line that is used, a cell's right border, belongs to the cell menu, which is the only one that acts on a single cell.
While the cursor is in a cell, that cell is outlined in your accent colour, and that one column edge cannot be dragged to resize — the mark sits on the same line, and resizing would take the pointer before you could click it. Every other edge resizes as usual; click into another cell to resize that one. The marks stay up while you move along that edge, so the cell you are typing in is the easiest one to open a menu for, not the hardest.
Selecting cells
Drag across cells to select them. The selection is a range of cells, and Backspace clears what is inside them and leaves the table standing. To select the table itself as a block — to move it or delete it whole — start the drag in the margin beside it rather than inside a cell.
With several rows or columns selected, the row and column actions in the cell menu and in the keyboard menu (Mod+Shift+Enter) act on all of them at once: Delete 3 rows removes the three, Add 3 rows below adds three new ones under them. One undo takes the whole change back. Deleting every row or every column is not offered; delete the table as a block instead.
Row and column actions from the keyboard
The marks are raised by hover, which a keyboard and a touch screen do not have. With the cursor in a cell, press Ctrl/Cmd + Shift + Enter — or Shift + F10, or the Context Menu key — to open one menu holding both sets of actions:
- Delete row, Add row above, Add row below
- Delete column, Add column left, Add column right
The menu is titled with the cell it will act on (Row 2 · Column 2, counting from one and counting the header row), and a screen reader announces the same row and column as the menu's name. Move through it with the arrow keys, run an item with Enter, and press Escape to close it — the cursor returns to the cell it was opened from.
Cell colours and splitting or merging stay on the cell mark for now.
Cell colour and formatting
Open a cell's right-hand mark and choose Colors to set that cell's text or background colour. Bold, italic, underline, links and mentions all work inside a cell exactly as they do in a paragraph — select the text and use the toolbar or the usual shortcuts.
A markdown table has no column for a cell colour, so Memry writes it on a comment line just above the table, the same way a coloured paragraph is stored:
<!-- table-colors:{"1:0":{"backgroundColor":"red"}} -->
| Task | State |
| --- | --- |
| Shipping | Open |The key is the cell's position — row:column, counting from zero and counting the header row. Other markdown editors ignore the comment and show the table normally. Text styles need no such line: markdown carries them itself.
To align cells, select them (or the text inside one), open ⋯ in the formatting toolbar and choose left, center or right. Cell alignment is saved the same way, on a <!-- table-align:{"1:0":"center"} --> line above the table.
Slash Commands
Type / anywhere in the editor to insert a block. Filter by typing — /h2 jumps straight to Heading 2. Press Enter or Tab to confirm the highlighted command.
- Recent — the last three commands you used sit at the top of the menu, above every other command. They are remembered on this device only.
- Groups — the rest of the menu is always the same order: Blocks, More headings (Heading 4–6), Insert, Media and AI. Every command is listed; none of them is hidden behind search.
- Best match — while you type, the command Enter will pick is lifted to the top. A command found through another name says so, for example
/todshows Task with matches todo. - Shortcut hints — the right edge of a row shows the markdown that makes the same block without the menu (
##,-,[],>,[[,@…). - Action bar — the bottom of the menu describes the selected command. Some commands have a second action on ⌘+Enter (Ctrl+Enter on Windows and Linux):
| Command | ⌘+Enter inserts |
|---|---|
| Check list | A linked task |
| Date | A reminder |
When nothing matches, the menu offers to Link to a note with what you typed — it opens the [[ search with your text already in it — or, with AI on, to Ask AI. Keep typing and the menu closes on its own, as before.
Inserting a Template
/ and Insert template content…, or the ⋯ menu's Insert template content…, drops a template's body in at the cursor. Choosing the row opens the picker. Type a query instead and matching templates appear as their own rows under Templates, so /meeting then Enter inserts Meeting Notes straight away.
The block handle offers the same thing: hover a block, click its ⋮⋮ handle, and Insert template… puts the template directly below that block.
Nothing already in the note is touched: the text before and after the insertion point stays as it was. See Inserting a Template at the Cursor for how it differs from Apply Template.
Markdown Shortcuts
Common markdown shortcuts work inline:
| Type | Becomes |
|---|---|
# | Heading 1 |
## | Heading 2 |
###### | Heading 6 |
- | Bullet list |
1. | Numbered list |
[ ] | Task |
> | Quote |
**bold** | bold |
*italic* | italic |
`code` | code |
``` | Code block |
Brackets close themselves
Typing ( writes () and typing [[ writes [[]], with the caret inside. [[ also opens the note search, and choosing a note replaces the whole [[]] with the link. Typing the closing ) or ]] yourself steps over the one already there, and Backspace between an empty pair removes both halves.
A bracket typed right before a word, and any bracket in a code block or inline code, is left alone.
Callouts
/callout inserts an info callout. Click its icon to change the type. Each type has its own colour and icon: info, warning, error, success, note, summary, to-do, tip, important, question, example, quote and bug.
A callout is saved as a > [!type] marker on its own line with one > line per body line. The types use the common Markdown callout names (summary is saved as abstract), so a > [!note] or > [!tip] callout written in another app opens as a callout here. A callout with a title after the marker, a type Memry does not have (such as [!danger]), or an uppercase marker such as GitHub's > [!NOTE] opens as a quote and keeps its bytes.
Click the arrow at a callout's right edge to fold it. A folded callout shows only its type name, and its body is hidden. The fold is saved in the note with Obsidian's marker: > [!tip]- starts closed and > [!tip]+ starts open. A callout without a marker is never rewritten, and it gets one the first time you fold it. An older Memry version drops the marker when it saves the note.
Your own callout types
Add types in Settings > Editor > Callout types: a name (the text in > [!name]), a display name, a colour and an icon. They appear in the callout's icon menu and in the / menu, and they sync to your other devices. Delete one and its callouts show as info callouts until you pick another type.
A note keeps the plain > [!name] marker, so nothing about the type is stored in the note. Where the name is not defined (another app, an older Memry version, or a device that has not synced yet) the callout opens as a normal quote and keeps its bytes. Names use lowercase letters, digits, - and _, and cannot reuse a built-in name.
On the iPhone app, types that share a colour are told apart by their icon. An older Memry version shows the newer types as info callouts and keeps their type.
Quotes
A quote can hold more than one paragraph. A blank quote line separates them, and a quote indented inside another one stays nested:
> [!note] Outer callout
> Outer body text
>
> > [!warning] Inner callout
> > Inner body textBoth survive a save, byte for byte. A note written in Obsidian with multi-paragraph or nested quotes opens here and is written back exactly as its author wrote it, so the two apps can edit the same vault without either one reflowing the other's quotes.
The blank lines around a quote or a callout are kept the same way: an extra blank line above or below one is still there the next time the note is opened.
A nested quote written without the blank line between the levels (> Outer directly above > > Inner) keeps its nesting too, but not its exact bytes: the blank quote line is added on the first save, and the file stops changing after that. Markdown reads both spellings as the same nested quote, and a note can only be saved in one of them.
A list inside a quote or a callout keeps its bullets and numbers when the quote is edited. Some spellings are saved in a standard form on the first save: a line that continues an item without its > gets one, and a callout or a paragraph followed directly by a list gets a blank quote line before the list. After that the file stops changing. A code block in a quoted list stays a code block, and a code block written without a language is saved without one.
A callout can hold other blocks: lists, headings, more paragraphs, quotes. Press Tab on the block under a callout to move it inside. A checkbox list inside a quote or a callout keeps its checkboxes and is never turned into tasks, so opening the note never adds task ids to the file.
Toggle lists
A toggle is written to disk as a <details> section, so GitHub and Obsidian render it as a real collapsible block. The blank lines around it belong to whoever wrote the file: an extra blank line above a toggle, below it, or between two of them is still there the next time the note is opened.
Two shapes are deliberately left alone rather than adopted:
- A
<details>written by hand, without Memry's own marker attribute, does not become a toggle. It stays exactly as its author wrote it, tags and all, so a vault shared with Obsidian keeps its hand-written collapsible sections. - A toggle whose closing
</details>is missing — half-typed, or cut short in transit — is not closed for you. Its<details>and<summary>lines stay in the note as literal text, so nothing is lost; close the block by hand and it becomes a real toggle on the next open.
Columns
/2 columns through /5 columns puts blocks side by side. You can also drag a block by its handle onto the left or right edge of another block: the two become columns. Drag the line between two columns to resize them. Removing the last block from a column removes that column; when only one column is left, its blocks go back to being ordinary page blocks.
On disk a column layout uses the syntax of Obsidian's Multi-Column Markdown plugin, so a vault shared with Obsidian shows the same columns there:
--- start-multi-column: a1b2c3
```column-settings
Number of Columns: 2
Column Size: [30%, 70%]
```
Left column
---
```
end-column ---
```
Right column
--- end-multi-columnEvery spelling the plugin accepts opens as columns, including its older === markers and Pandoc's ::: columns fenced divs. Settings Memry does not draw, such as Border or Alignment, are kept as written; only the column count and sizes are rewritten after you add, remove or resize a column. A region that is never closed, or has only one column, stays plain text. On iPhone columns are shown one under another.
Equations
/math — or /equation, /latex, /formula — inserts an equation block. Click it to open the source box, type LaTeX, and press Esc when you are done; the block shows the typeset formula the moment you close the box. LaTeX that does not parse shows the error instead of a formula, with your source still in the box.
The file keeps the source, not the rendering:
$$
E = mc^2
$$That is the same block form Obsidian, GitHub and Pandoc read, so an equation written here is an equation there, and one written there opens here as a block.
Two shapes are deliberately left alone:
$$E = mc^2$$written on a single line stays the text its author wrote. Adopting it would rewrite the line into the three-line form the next time the note was saved.- A
$$that starts or ends in the middle of a paragraph, or that is never closed, stays text for the same reason.
On iPhone and iPad an equation shows its LaTeX source rather than the typeset formula. The formula is unchanged in the file, and the same note shows it typeset on the desktop.
Folding a bullet list
Any bullet with something nested under it can be folded. Hover the line and a small chevron appears in the margin beside its bullet; click it to hide everything indented below, click it again to bring it back. A folded bullet keeps its chevron on screen, so you can always see that something is tucked away.
This is a view, not an edit. Nothing about the fold is written to the note: the file on disk is unchanged, other devices are unaffected, and reopening the note shows every line expanded again. For a collapsible section that is saved with the note — and that GitHub and Obsidian also render collapsed — use a toggle list instead.
Folding a heading
Headings fold the same way. Hover a heading that has content under it and click the chevron in the margin to hide its section: every block after it, up to the next heading of the same or a higher level. Folding a Heading 1 hides the Heading 2s inside it too; folding a Heading 2 stops at the next Heading 2 or Heading 1.
Like bullet folding, this is a view only. The note is unchanged and reopens fully expanded.
Title
The title is editable inline at the top of the editor. Renames are live — the title updates in tabs, the sidebar, search, and any inbound wiki links.
If you leave the title empty, memrynote generates a fallback ("Untitled" or the first heading).
Titles become filenames in your vault, so characters that are invalid in filenames or break Obsidian wiki links (< > : " / \ | ? * [ ] # ^) are stripped on save — a note titled Draft [v2] #1 is saved as Draft v2 1.md. Existing files are never renamed retroactively.
Note Menu
The ⋯ button in the top-right of a note (the More actions menu) collects note-wide and file actions, so you can act on the note you are viewing without going back to the list.
View & tools
- Local graph — show or hide the note's local link graph
- Find… — open in-note search (also ⌘+F)
- Version history — browse and restore past versions
- Export — export the note to PDF or HTML. Both formats embed the note's images in the exported file itself, so the PDF prints them and an exported
.htmlkeeps them after you move or send it. A task prints as its checkbox and title, without the{task:<id>}that ties the line to the task in the note file - Insert template… — insert a template's body at the cursor, leaving the rest of the note untouched
- Save as template — create a new custom template from this note's body, tags, and properties (see Templates)
- New note from this note — create a note in the same folder with this note's icon, tags, and properties (see New note from this note)
- Full width — toggle the wide editor layout
File actions
- Rename… — moves focus to the title so you can rename in place
- Move to folder… — move the note into another folder
- Copy path — copy the note's vault-relative path
- Reveal in Finder — show the
.mdfile in your operating system's file manager. The item is named for the one you have: Reveal in Finder on macOS, Show in Explorer on Windows, Show in file manager on Linux - Reveal in navigation — highlight the note in the sidebar
- Open in default app — open the
.mdfile in your system's default editor
A folder's right-click menu carries the same Reveal in Finder item. It selects the folder itself inside its parent directory — it never opens into the folder's contents.
Local only keeps the note on this device (never synced). Both halves stay put — the note's details and its text — and editing is unaffected. Turning it back off uploads the note again, including everything you wrote while it was local only.
Delete note moves the note to the trash after a confirmation, then closes its tab. This does the same thing as deleting from the note list — you no longer need to close the note first.
Drag-and-Drop Blocks
Hover the gutter on the left to reveal the block handle. Drag a block to:
- Reorder within the note
- Move out into a different note (drop on a sidebar item or another open tab)
Block Menu
Click the block handle in the left gutter to open the block menu. Everything in it applies to that one block, with two exceptions: if you drag-selected several blocks from the margin and open the menu from one of them, Turn into converts every selected text block at once, and Copy copies every selected block in document order. Tables, files, tasks and other blocks without text of their own keep their type under Turn into.
| Action | What it does |
|---|---|
| Turn into | Converts the block to another text type — text, heading 1–3, bulleted or numbered list, checkbox, task, toggle list, quote, code, callout. Indented children come along. |
| Turn into checkbox | On a task: puts its line back as a plain checkbox, then asks whether the task stays in Tasks. Not offered on a task with subtasks. |
| Colors | Sets the block's text and background colour. |
| Copy | Copies the block and its indented children. Pasting into a note brings back the same blocks, colours and tasks included; other apps get the Markdown the note file holds without task ids, or rich text. |
Duplicate (⌘D / Ctrl+D) | Copies the block and its indented children directly below. |
| Move to… | Search for another note and move the block to the end of it. |
| Delete | Removes the block. |
| Comment | Opens a comment on the block, in the same review sidebar as a comment on selected text. |
Pointing at Turn into or Colors opens a submenu beside the block menu. The submenu stays open while you move the pointer across to it, even if you pause on the way, so you can head straight for the item you want.
Some entries are hidden when they do not apply. Turn into and Comment do not appear on blocks with no text of their own — files, images, embeds, bookmarks, tasks, equations, whiteboards and tables. Move to… is hidden on blocks that hold an attachment, because the file stays with the note that owns it and the embed would break on your other devices.
Move to… writes to the target note first and only removes the block here once that succeeds, so a failed move leaves the block where it was. Undo restores the block in this note; it does not remove the copy in the target note.
Selecting Text and Blocks
Dragging that starts inside a line always selects text, however far it travels and in whatever direction. Dragging straight down across several paragraphs selects the text between the two points, exactly as dragging diagonally does.
To select whole blocks instead, start the drag outside the text column:
- the gray margin to the left or right of the column
- the bullet or number in front of a list item
- the strip to the left of an indented block
- a block with no editable text of its own — a task, a file or a video
- the empty area below the last block
A selection box follows the pointer and every block it touches is highlighted, the same way selecting files works in a file manager. The box only appears once you have moved a few pixels, so a plain click in the margin still just puts the cursor at the end of the note. Only a click in the empty area below the last block starts a fresh line there; a click or a drag in the margin beside the text leaves the note as it is.
A bookmark card is the one exception: its whole surface is a link, so clicking it opens the link and a drag has to begin in the margin beside it instead.
Inside a table, dragging selects cells, not blocks — a drag from one cell to another selects the range between them, and Backspace then clears those cells and leaves the table standing. To select the table itself as a block, begin the drag in the margin beside it, the same as for any other block.
With blocks selected, typing a character replaces them with a new line that starts with it, Backspace deletes them, Tab and Shift+Tab indent and outdent them, and Esc clears the selection.
Text selected across several blocks works the same way: Tab and Shift+Tab indent and outdent every block the selection touches, and a single undo reverts the whole step. A block that is already as far left as it can go is left where it is; the rest still move.
One consequence worth knowing: the empty space to the right of a short line still counts as that line's text, so the right-hand margin outside the column is the place to begin a right-side block selection.
Saving
Saves are automatic and debounced (default ~1 second). Changes also flush on:
- Tab close
- Switching the tab to another note or journal day
- App quit
- Sync push
The flush on close or switch includes whatever you typed just before it, and it is saved to the note or journal day you typed it in, never to the one you opened next.
You can flush manually with ⌘+S. Auto-save delay is configurable in Settings → Editor.
Memry reads only files inside the vault. A note or journal file replaced by a symlink to a file outside the vault does not open. The error names the file. Memry does not save over it, search does not index it, and sync sends none of its text. Moving blocks into it or restoring one of its versions fails with the same error. Renaming another note does not rewrite the links in it, a tag rename, merge or delete skips it, its backlink excerpts stay empty, and attachments it might reference are kept. Deleting a task that came from it leaves the file alone, quitting keeps no version of it, and a lock on it keeps no copy of its text and does not change the file's permissions. Deleting it, or the folder it is in, does not offer to delete tasks listed in the outside file. Semantic search and its outgoing links do not read it either. The permission change a lock makes, the delete dialog's task check, search and semantic indexing, sync pushes, versions, block moves, link rewrites on rename, external-edit handling, opening a note or journal day, backlink excerpts, the copy a lock keeps and the restore of a locked file at open, the sync editor's first load of a note, attachment counting and the check for other notes that use an attachment, opening a canvas, and reading text from an attached HTML file, reading text from an image, showing an image to an agent, uploading a file for sync, the canvas index that is rebuilt when a vault opens, and the canvas shapes library also hold when the file is swapped for such a link while Memry is checking it: they act on the file they opened and checked, not whatever the path points to a moment later. An embedded image, PDF, audio, video or HTML file that is such a link does not display, also when it is swapped for one while Memry is checking it. The link stays as you made it. A symlink to another file inside the vault works as usual.
Word Count
If enabled in Settings → Editor, word count appears in the editor footer.
Spell Check
Off by default. Turn on Check Spelling in Settings → Editor to underline misspelled words as you write.
Open the context menu on an underlined word to correct it. Suggestions sit at the top of the menu; picking one replaces the word. Add to Dictionary teaches the spellchecker the word so it stops being flagged, on this and future runs. Words with no suggestion show a disabled No Suggestions entry.
Memry does not pick a spellchecking language of its own. macOS detects the language you are writing in; Windows and Linux use the dictionary for the system locale.
Toolbar
The formatting toolbar can be sticky at the top or float above selections — choose in Settings → Editor, or with Pin toolbar to top in the toolbar's More (⋯) menu. With the toolbar pinned, the block type and list buttons also apply to blocks you drag-selected from the margin.
Both modes show the same single row, in the same order: block type (paragraph, heading, list), then bold, italic, underline, strikethrough, inline code (`code`) and colour, then the list toggles, then link and link to note, then Comment. The block type control is hidden for blocks that have no alternative type, such as tasks, callouts, and files.
Alignment and indent/outdent sit in the More (⋯) menu at the end of the row. Hovering a button shows its name and keyboard shortcut.
Opening the context menu stands the floating toolbar down, so you get one menu rather than two. It returns on your next click or keystroke.
Turning existing lines into a list
Select the lines — a whole pasted block of them if you like — and press Bulleted list, Numbered list, or Check list on the toolbar. Every selected line is converted, not just the one holding the cursor, and pressing the same button again turns them back into paragraphs. Blocks that cannot become list items, such as tasks and files, are left as they are.
Text Formatting
Bold, italic and strikethrough are written to the vault as plain Markdown (**bold**, *italic*, ~~strike~~). Formatting inside formatting, such as italic words in a bold sentence, is written as one span inside another (**a bold *and italic* sentence**), and a link whose text mixes formatting stays one link (**[a *b*](https://example.com) c**), so the note reads the same in Memry and in other Markdown apps.
Markdown has no syntax for underline, text color or highlight, so those are written as inline HTML, which Obsidian renders:
<span style="text-decoration:underline">underlined</span>
<span style="color:red">red</span>
<span style="background-color:yellow">highlighted</span>Color and underline are kept on separate nested spans, so an older version of MemryNote opening the same vault still reads the color.
Note snippets (search results, note lists) and journal previews show the colored or underlined text without the span tags.
Formatting applied in MemryNote round-trips. Underline written any other way — Obsidian's <u> tags, for example — is not read back, and is dropped the next time MemryNote saves the note.
Text alignment
Centring a paragraph, or aligning it right or justified, is kept when you leave the note and when you restart MemryNote. Markdown has no syntax for alignment, so it is stored as a comment line above the paragraph (<!-- align:center -->) that other markdown editors ignore. Left alignment is the default and writes nothing.
Text colours
The nine text colours are tuned so each one is legible and tellable apart from the others in every theme. Each clears the WCAG AA contrast floor for small text against the page, carries enough colour to be nameable rather than reading as grey, and stays clear of the default body text. Grey is the deliberate exception: it stays neutral, and reads as a muted colour rather than a hue.
Two consequences worth knowing:
- Yellow is a gold rather than a lemon. A yellow light enough to look like lemon cannot meet the contrast floor against a white page.
- Brown, orange and yellow share a warm range, so they are separated by how dark they are. Brown is the darkest of the three.
Colours are stored by name, not as a fixed shade, so notes you coloured in an earlier version pick up the current tuning when you open them. Highlight (background) colours are unchanged — a filled background does not need the same treatment to stay readable.
Pasting a Link
Pasting a URL offers four ways to keep it: plain URL, an inline Mention pill, an Embed (for a video the app recognises), or a Bookmark card.
URL keeps the line you are on exactly as it was. Paste into a bulleted item and it stays a bulleted item, bullet and all; the same goes for a numbered item, an item nested under another, and a table cell. Whatever you had typed before and after the cursor is still there, with the link sitting between them.
The link it leaves behind is ordinary text. You can put the cursor on either side of it, select part or all of it, copy it, retype it, delete it, or drag it to another line — the same as any other words in the note. It is saved as plain Markdown, so it reads the same way after a sync or in another editor.
This works inside a table cell too. Mention replaces the pasted URL in that one cell and leaves the rest of the table alone. Embed and Bookmark are blocks in their own right and a cell holds text only, so they take the URL out of the cell and place the card after the whole table.
Pasting into a Table Cell
Pasted text is normally read as Markdown, so a pasted # Heading becomes a heading and a pasted | a | b | becomes a table. Inside a table cell that reading is switched off: a cell holds text, and text is what you get. Paste a row of pipes into a cell and you get a row of pipes, not a second table spliced over the one you are editing.
Two things follow from a cell holding a single line of inline content:
- Pasted line breaks stay inside the one cell. A Markdown table row is a single line, so they are saved as spaces — the words all survive, the line breaks do not.
- Copying cells rather than text still pastes as cells. A cell or a range of cells copied from a table in memrynote keeps its shape and fills the grid from wherever the cursor is, the way a spreadsheet does.
Images in a Table Cell
A table cell can hold a picture as well as text. With the cursor in the cell, type /image and pick a file, paste an image, or drag an image file onto the cell — it lands inside that cell rather than after the table, and text can sit on either side of it.
Pasting works for a picture you copied as well as one you have as a file — from another note, from a web page, from a document. A cell holds text and pictures, not blocks, so a copied picture is placed inside the cell rather than dropped on the floor, which is what used to happen. Two things are deliberately left alone: a paste that mixes a picture in with text is handed to the ordinary paste, and a picture stored inside another note is not taken, because its path is written relative to that note and would arrive here already broken.
The image is written into your note as ordinary markdown, , so the row stays a normal table row that Obsidian and any other markdown editor can read. A table you wrote by hand with images already in it now opens with those images showing, instead of an empty cell.
A cell image with no size of its own is capped at the height of a few lines, so one large screenshot cannot stretch a row out of shape. To give one a size of its own, hover it and drag the handle on its trailing edge — the picture keeps its proportions and the row grows with it.
That width is saved into the note as , the same | convention Obsidian uses, so the size survives a sync and other markdown editors still read the row as an ordinary table row. Obsidian's two-number form (name|300x200) is left exactly as written rather than rewritten to a single width.
Outside a table, an image on its own line is still a full image block with a caption and its own resize handle — that has not changed.
Checkboxes in a Table Cell
A cell can hold a tickable checkbox. Type [ ] at the start of a cell and it becomes one, or pick Check List from the / menu with the cursor in a cell. Click the box to tick it.
The checkbox is stored as the plain text a markdown table can carry — a row reads | [x] Buy milk | on disk — so the table stays a table that Obsidian and every other markdown editor can read, and a table you wrote by hand with [ ] already in its cells opens with real checkboxes in it.
Outside a table, [ ] still makes a full check-list item on its own line, and that is the one that counts as a task. A checkbox inside a cell is a checkbox and nothing more: it does not appear in the task list, take a due date, or sync as a task.
A cell whose text genuinely begins [ ] becomes a checkbox too. The characters on disk are the same either way, so nothing is lost — the cell just shows a box you did not ask for.
Link Previews
Links in a note are enriched with the page title, site name and favicon, both for inline link mentions and for bookmark blocks. The lookup runs once per URL and the result is kept in memory, so reopening a note with the same links does not refetch them.
Only the URL is written to the note file, so a mention that has been through a restart or a vault switch comes back showing its site's domain. Its title and favicon return the next time that note's links are looked up.
A mention is saved as a ((mention:…)) token. A token written inside inline code, bold, italic, underline, strikethrough or a colour stays plain text, so editing that paragraph keeps the backticks or formatting marks around it. An unformatted token anywhere else in the note still opens as a pill.
That in-memory cache holds the 200 most recently used links and evicts the least recently used entry beyond that, which keeps a long session with many link-heavy notes from growing without a limit. Evicted links are simply fetched again the next time they are shown.
Readwise Sections
A note that holds Readwise highlights wraps them in a section. The editor draws the start of the section as a filled band labeled Readwise · syncs automatically, with the line Edit inside this section and Readwise stops updating it. under it. A matching band, End of Readwise section, closes it. On a journal day the bands read Readwise · today's highlights and End of Readwise. On iPhone the same markers show as a thin line with a book icon and the same labels, and they cannot be edited there.
The bands only change how the section looks. The file keeps the two marker comments exactly as written, and your own text above, below or inside the section is saved as you typed it. Deleting a band removes its marker. Any other HTML comment keeps its small <!----> chip. The labels follow the app language and mirror in right-to-left layouts.
Comments
Select text to open the floating toolbar. Comment creates an anchored review card in the right rail; selecting the text itself does not open the rail. The right rail aligns each card beside the marked text. Comment cards can be resolved or deleted.
Comments can carry file attachments. Image attachments show an inline thumbnail; clicking an image or PDF opens it in the in-app viewer (close with Esc, a click outside, or the ✕). Other file types open in your operating system's default app.
Formatting a Comment
Comment text supports bold, italic, underline, strikethrough and inline code. Select text inside the comment box and a small toolbar appears above the selection, or use the usual shortcuts:
| Shortcut | Mark |
|---|---|
| ⌘+B | Bold |
| ⌘+I | Italic |
| ⌘+U | Underline |
| ⌘+Shift+S | Strikethrough |
| ⌘+E | Inline code |
Markdown shortcuts work too — typing **bold** or `code` formats as you type. The toolbar stays hidden while the @ mention picker is open.
The comment text itself is stored in your note file as plain text, with the formatting recorded separately alongside the comment's other metadata. Comments written before this feature keep rendering exactly as they did, and a comment you format still reads cleanly if you open the note in another markdown editor. Editing a comment's text outside memrynote drops its formatting rather than applying it to the wrong words.
What Notes Are Made Of
Under the hood, every note is a Yjs CRDT (Y.Doc). Markdown is a derived export, not the canonical form — this is what lets edits from two devices merge cleanly. See CRDT & Notes Sync for details.
Very Large Files
A markdown file can be too big to edit. memrynote decides this when the file arrives in the vault, and it uses two limits, not one:
| Limit | Value |
|---|---|
| File size | 1 MB |
| Largest run of lines with no blank line between them | 128 KB |
A file has to clear both to open as an editable note. 1 MB is around 150,000 words — several novels — so ordinary notes, however long, are nowhere near it.
The second limit is the one that catches log dumps, exported transcripts and pasted data. What makes markdown slow to open is how dense one unbroken run of lines is, not how many bytes the file has: 128 KB of paragraphs opens in about 50 ms, while 128 KB of table rows or minified JSON takes a full second. A file with no blank lines in it is one block, however long it is.
A file that misses either limit still appears in the sidebar. Opening it shows the file in a read-only viewer instead of the editor, under a bar naming its size, the limit it passed, and read-only · not synced:
- It does not open in the editor, so it cannot be edited in memrynote.
- It is not synced to your other devices.
- The file on disk is not touched. Nothing is truncated, rewritten or deleted, and you can still open it in any other editor.
The limits apply to notes arriving over sync too. A device still running an older version can send you a note that is over them; memrynote keeps every byte of it and writes the file to your vault, but opens it read-only rather than in the editor, exactly as if you had dropped it in yourself.
Reading a large file
The viewer scrolls the file without loading it. On first open it makes one pass over the file to find where each line starts, showing a progress bar while it does; after that, scrolling anywhere in the file is instant, and only the lines on screen are read. Switching tabs and coming back does not repeat the pass.
The file is set the way a note is — same type, same width, no line numbers and no gutter.
Three things to expect:
- No editing. There is no cursor and no way to type. Use Reveal in Finder or your own editor to change the file.
- Long lines wrap. A line wider than the pane continues on the next line, as a note's text does. There is nothing to scroll sideways to, and nothing sitting past the edge.
- Very long lines open shortened. A line over about 2,000 characters — one minified JSON record, for example — is drawn up to that point, followed by Show the rest of this line. A single line that long wraps into a couple of hundred rows, and a screenful of those is what makes the app slow to answer while you scroll it. Nothing is lost: the control shows the whole line, and the file on disk is untouched either way.
- Very long single lines are cut. A line longer than 64 KB — a whole file on one line — is read only up to that point. Show the rest of the line and the end of it is marked
long line cut here. The rest is still on disk, untouched.
Because lines wrap, a row is as tall as the pane's width makes it, and that is only known for the part of the file you have looked at. In a file of very long lines the scrollbar is an estimate: it settles as you read, so it can shift while you scroll through a stretch for the first time. Which line you are on is never affected — only how far along the bar says you are.
The viewer opens files up to 2 GB. Above that, the file still appears in the sidebar, and opening it explains that it is past the limit and offers to open it in your default app or show it in your file manager.
Finding text in a large file
Search does not index these files, so the global search box will not find anything inside one. The viewer has its own find instead, on the same shortcut as everywhere else — Cmd/Ctrl+F — or from Find in the note menu.
Type and it searches the whole file, not the part on screen. Enter moves to the next match, Shift+Enter to the previous one, and Esc closes the bar. Matches are highlighted on the lines you can see, and moving between them scrolls the file to each one.
Three things worth knowing:
- The count grows while it searches. A pass over 2 GB takes a few seconds, so the bar shows
12 so far…until it has crossed the whole file, then settles on the final count. - Only the first 2,000 matches are navigable. A query matching a million lines still reports the real count, shown as
1/2000 of 1000000;Enterwalks the first 2,000. Narrow the query to reach the rest. - Case is ignored for A–Z only.
errorfindsERROR, butédoes not findÉ.
Notes you already have keep working exactly as before — nothing is re-scanned or re-indexed, and existing notes under these limits are unaffected.
When a New File Appears in the Sidebar
Dropping a file into your vault folder from Finder or Explorer shows it in the sidebar straight away, whatever its size. To draw that row memrynote reads only the filename and the file's timestamps — not the file itself. A quarter-gigabyte paste costs the same as a one-line note.
Everything that needs the file's contents happens a moment later, in the background, smallest file first:
- word count
- the preview snippet under the note title
- search
So a brand-new row can briefly show no word count and no snippet. That is the measurement not having arrived yet, not an empty note — it fills itself in within a second or two for ordinary notes, and a little later for very large ones. Nothing is lost if you quit before it finishes; the file is measured again next time it changes.
Very large files are measured in pieces rather than loaded all at once, so even a file too big to fit in memory gets a word count and becomes searchable. For those, search covers the beginning of the file rather than all of it.
When a Note Changes Outside memrynote
Editing a note's file in another app — Obsidian, a script, a text editor — is picked up while memrynote is running, and the note carries the change the next time you look at it. This does not depend on the note being the one on screen: a note you had switched away from, or never opened this session, is updated the same way.
A note you are looking at while its file changes merges the change in place, so an edit you are making at the same time is not thrown away.
memrynote will not write over bytes it has not read. If a note's file has changed since memrynote last looked at it, the app leaves the file alone until it has taken that change in, rather than saving an older version of the note over it.
memrynote will not write over a file it has never read at all. Pointing memrynote at an existing vault lists every note straight away, from the filename and timestamps alone. Until a note is opened, its file is left exactly as its author wrote it — a background sync round that touches that note skips the save rather than replacing bytes nobody here has looked at.
A note whose file is still there but cannot be read, for example after chmod 000 or while antivirus holds it, is not treated as deleted. The note stays in the list and on your other devices, a save names the note in a notice, and your edit stays open. Once the file can be read again, memrynote picks it up and your next edit saves as usual.
Deleting a note's file outside memrynote deletes the note, and the delete syncs to your other devices. That holds for a file deleted while memrynote is closed too: the delete happens the next time it opens the vault. A file iCloud offloaded to save space (on macOS 12 and 13 it leaves a hidden .icloud file in its place) is not deleted, nor is an attachment this device has not downloaded yet; once the offloaded file is deleted as well, so is the note. A note file put back from the trash or a backup comes back as a new note.
A note renamed or moved while memrynote is closed, alone or with its whole folder, keeps its history, tasks and links. When more than 20 files, and more than a quarter of the vault, are missing at once (a vault still being copied or restored, say), memrynote deletes none of them and checks again the next time it opens the vault. Twenty or fewer missing files are always deleted, so in a small vault even all of its notes going missing at once syncs their deletes.
Opening a Note Written Somewhere Else
Opening a note that another app wrote reads its markdown into memrynote's editor, and saving it afterwards writes the file back. Whatever you did not change comes back exactly as its author wrote it: * bullets stay *, _emphasis_ stays underscored, an underlined Title heading stays underlined, a --- rule stays dashes, a list glued to the line above stays glued, and a nested list keeps its indent. Only the parts you edited are written in memrynote's own style, and only when the result still says exactly what the editor shows. Opening a note and closing it again writes nothing at all. Very large notes, roughly half a megabyte of markdown and up, are written in memrynote's own style throughout so that they keep syncing between your devices.
memrynote keeps a copy of the author's spelling beside the note for this. When that copy no longer matches the note, for example after another device changed it, the note's file stands in for it. A save that changes nothing leaves the file exactly as it is, and an edit is written into the file's own spelling. A note saved with Windows line endings (CRLF) keeps them, and is treated the same way, and so is a save that catches a paragraph ending in a space or a tab while you type. A file that cannot be read at that moment is left unchanged, and a notice names the note: your edit stays open in memrynote while the app is running, and the file gets it with your next edit that saves. Only when the file was read and neither copy can be kept is the whole note written in memrynote's own style.
Inside an edited region the two are not always byte-for-byte the same. What is guaranteed there is that nothing is lost on the way through:
- A hard line break stays a hard line break. A line ending in two spaces keeps them, so the break stays a break rather than becoming a paragraph gap, in a quote or list item too. A line ending in a backslash is saved the same way. A
<br>inside a paragraph is saved as a line ending in two spaces, so it stays a line break in other Markdown apps too. A heading is one line, so the line under it is its own paragraph. A line break inside link text, hard or soft, ends the link there and starts it again on the next line, both halves pointing at the same address. Bold, italic and strikethrough in that text are kept, written around the link, and saving again does not change the line. In a list item, a soft line break inside link text stays inside one link, so the item keeps its link and gains no blank line. - Code inside link text keeps the link.
[`a`](https://…)stays a link. The editor cannot style text as both code and a link, so it shows the backticks inside the link, and the file keeps the code span. - Parentheses in a link address stay as written.
[a](https://e.com/x_(y))is saved as it is, with no backslashes added before the parentheses on each save. - Backslash escapes in a link address stay as written.
[a](u\(y\))and[a](u\_y)are saved as they are, with no backslashes added on each save. - Link titles and spaced link addresses stay as written.
[a](u "t")keeps its title, and[a](<u (y)>)and[a](u\ y)are saved as they are. Clicking such a link, its toolbar's open button, or tapping it on iOS opens the address. The toolbar's address field shows only the address, and editing it keeps the title. - A reference-style link keeps both halves.
[the docs][d]and its[d]: https://…definition both survive, including a definition several links share. The link stays a working, clickable link while the note is open. Definitions are gathered at the end of the file. - A code fence with no language keeps no language. A bare
``` fence is not given one, wherever it sits, inside a quote or not, which is what an Obsidian Kanban board's settings block needs to keep working. - An indented code block stays a code block. A run of lines indented four spaces or one tab stays code, written back as a fence with no language, and a line break inside a table cell keeps its row intact rather than cutting the table off there.
Within an edited region some cosmetic details are normalized to one house style: * and + bullets become -, _em_ becomes *em*, an underlined Title heading becomes # Title, a ~~~ fence becomes a ``` one, and an indented code block is rewritten as a fenced one. A line break pasted into a table cell becomes a space, because a table row is one line. These change how that region is spelled, never what it says. A note carrying review comments or tracked changes is written in house style throughout.