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	Untitled 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, and its row in the sidebar opens a name field with Untitled already selected: type the name, press Enter, and it is named. Press Esc — or click away without typing — and it stays Untitled. It is the same field as Rename on the row's right-click menu, so naming a new note is no longer a second step you have to remember. New folders and subfolders open that field the same way.

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.

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)
• 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 ![whiteboard](memry://canvas/<id>); 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
• 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 or gallery.
• 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"
}
```

Move the cursor into the block with the arrow keys, from the line above or below, to see that text under the list and edit it by hand; the list follows as you type. Clicking the list itself never moves the cursor into it, so a click on a row or a menu cannot type into the text by accident. If the text stops being valid, the block says so and keeps the text visible until it is fixed. Obsidian, GitHub, the phone and older versions of memrynote show the fence as an ordinary code block and leave it as it is.

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.

Tables

/table inserts a table with a header row and two body rows. 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, and splitting or merging

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.

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.

Slash Commands

Type / anywhere in the editor to insert a block. Filter by typing — /h2 jumps straight to Heading 2. Press Enter to confirm.

• 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 and toggle headings), 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 /tod shows 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
Heading 1–3	The same level as a toggle heading
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

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 text

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

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.

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.

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 .html keeps them after you move or send it
• 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 .md file 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 .md file 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 one exception: 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. Tables, files, tasks and other blocks without text of their own keep their type.

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

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

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

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.

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, ![name](path), 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 ![name|300](path), 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.

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.

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; Enter walks the first 2,000. Narrow the query to reach the rest.
• Case is ignored for A–Z only. error finds ERROR, 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.

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.

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.
• 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, 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, 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.