Markdown and wikilinks

Display modes

.md notes open with editor and reading side by side (configurable). The markup is dimmed outside the cursor's paragraph so the page looks like a finished document.

Shortcuts: Ctrl+B/Ctrl+I apply bold/italic and Ctrl+E cycles the view mode (editor → split → formatted → reading).

The / menu: in the formatted editor, type / at the start of the line (indentation is fine) or after a space: the insert list opens at the cursor. Type to filter (/table, /callout, /h1), choose with ↑/↓ and insert with Enter; Esc or Space close the list and what you typed stays as text. The right-hand column shows the markup each item writes, so you can type it directly next time. The menu does not open inside a code block, a formula or a table cell.

Reading mode: the last Ctrl+E mode is the same screen as formatted editing, but read-only — which is why it can show what the file does not contain: the table of contents for the [TOC] token. The folder listing for the [files] token and the body of notes transcluded with ![[note]] also show up in formatted editing. None of it is written to the .md: the file keeps the token, and the generated text does not accept editing. In this mode a plain click follows links, wikilinks and tags (no Ctrl needed), and the editing buttons are disabled — including undo, cut and paste, which used to act on the off-screen text editor. Copy still works, and copies what you are looking at. Ctrl+F searches what is on screen; the replace row is disabled, with the reason in its tooltip, because a replacement here would never reach the file.

Calculations with units, in reading mode. A line ending in = gets the result: 3.5 km / 2 s = shows as 3.5 km / 2 s = 1.75 km/s. The file does not change — same idea as [TOC] and the formatted citation. It does dimensional analysis, and that is what earns it its keep: 1 km + 1 s = is refused naming both, because a calculator that answered 2 there would not be worse — it would be one that lies, and in a lab notebook the mistake would survive all the way to the paper. Adding the same quantity in different units works and converts (2 h + 30 min =), and the result comes out in the unit you wrote. It knows the SI prefixes, the physical constants (c, h, k_B, N_A, g…), explicit conversion (3 km in m, also to and ->) and uncertainty: (2.00 ± 0.05) m / (1.0 ± 0.1) s = propagates the error and writes only the digits the measurement allows. Code and formulas stay out — inside a ``` fence, between backticks or in a $…$, the = at the end of the line is somebody else's syntax. And a line that is not a calculation (Total =) is left alone, silently.

It ships turned off: switch it on in Settings → Features → Academic → Calculator with units.

Spaced repetition flashcards. A note tagged #flashcards becomes a deck: inside it, every Question::Answer line is a card, ::: also creates the reverse card, a lone ? between two lines makes the multi-line card, and ==like this== becomes a blank. Without the tag, no note has cards — that is what stops a std::vector in a programming note from becoming a card you never wrote. Tools → Flashcards → Review flashcards opens the session: the answer stays hidden until you ask for it (that is the whole feature — seeing both at once is rereading, and rereading does not stick), and the four grades carry written on them how much time each one buys. Scheduling is FSRS, the same algorithm Anki uses.

A card's identity is its QUESTION: fixing the answer does not touch the schedule, and rewriting the question retires that card and starts another — which is right, because the question is what you are learning. The history lives in an open file next to the note (note.md.cards.ndjson): you can version it with Git and read it in any editor, and the price is one more file in the folder. Export to Anki writes the text file it imports — the schedule does not go along, because Anki's text importer does not accept it; it stays in the .ndjson files.

Code blocks

Code blocks come out colored. A fence with a declared language (```python) gets its body highlighted token by token, using the same colors as the code editor — including the code theme chosen for this window. This applies to formatted editing, reading mode, the exported file and the answers in Ask your notes. A fence with no declared language stays monochrome, and so does a language with no highlighting available: the text never fails to show.

Folding, sticky headings and export

Folding sections and pinning the heading also work in formatted and reading modes. Ctrl+Shift+[ collapses the cursor's section and Ctrl+Shift+] expands it; clicking the little arrow left of the heading does the same, and View → Collapse all headings / Expand all headings acts on whichever surface is in front. As you scroll, headings that went off the top stay pinned in a band — click one to jump to its section. Folding is screen state: the .md does not change, and folded text stays in the file.

Export: the PDF and the HTML are generated from the same document as reading mode — the file you get is what you have just read, with the table of contents, the folder listing and transclusions included. The HTML is self-contained (local images are embedded) and the PDF has vector text, so it stays searchable. The HTML comes out with semantic markup — headings with anchors, callouts as <aside>, tables with a header, footnotes with a way back — and formulas in MathML: real text, which can be copied, read aloud and never blurs when zoomed. The theme follows each format: the HTML keeps the colours you see on screen, dark theme included (the file carries its own background); the PDF always goes on light paper, because it is meant to be printed and sent — if your content theme is dark it is printed with the default light theme, and a light theme you already use is preserved. Word, OpenDocument, LaTeX, Typst and EPUB are written by LightNote itself, with nothing to install.

The .docx and the .odt come with headings, lists, tables, footnotes, images and formulas as editable equations — Word equations in one, LibreOffice Math objects in the other; the .tex has a complete preamble and compiles with pdfLaTeX, XeLaTeX and LuaLaTeX. If the folder has a bibliography and the Academic section is on, the .tex comes out with live citations: [@key] becomes \autocite, the [bibliography] token becomes \printbibliography, and a refs.bib with the cited works is written next to it — the app tells you it did. Compile with biber.

The .typ is the same idea in Typst, which compiles in seconds with no LaTeX distribution installed: formulas travel as LaTeX through the mitex package (downloaded on the first compile) and citations come out as @key with #bibliography.

The .epub is the e-book: one chapter per level 1 heading, a navigation table of contents, images as package files and the same semantic markup as the HTML. The .ipynb is the Jupyter notebook: prose becomes a text cell and the fence in the kernel's language becomes a code cell — only that one, because a code cell is sent to the kernel, and a Mermaid diagram turned into a cell would run as Python the first time anyone executed it. The kernel comes from the kernel key in the note's properties, or from the most frequent fence.

No output is invented: the cells come out with no result, because a result comes from running — the same rule the notebook import already follows when it drops the stored outputs. And there is Markdown for…: the same note in the destination's dialect — a > [!NOTE] alert on GitHub, !!! note on MkDocs, :::note on Docusaurus, ::: {.note} on Pandoc, the Obsidian spelling or strict CommonMark.

Wikilinks become relative links (outside Obsidian) and the %%…%% comment is not published, because it is private. With Typst installed (winget install --id Typst.Typst), the export itself offers Compile the PDF right there — and without it the button becomes Install Typst..., which opens the guide. If your course or client hands out a Word template, point at its .docx in Workspace settings → Citations and references → Word template: the exported file comes out with the template's styles, paper size, margins and header. A note can use a different one by declaring reference-docx: template.docx in its properties. All three start from the reading Markdown — citations already formatted, figures numbered — and whatever does not make it across is reported when the export finishes. The compilation runs in the background, as a task in the Activities panel: the window keeps responding, and Stop interrupts it.

Mermaid diagrams and chemical structures go in as images — drawn on light paper in the .docx, the .odt and the EPUB, in the screen colors in HTML —; only through lnote, which has no window to draw them, do they come out as code blocks. And there is Markup text for…: reStructuredText, AsciiDoc, Org mode, MediaWiki and plain text, also written by LightNote itself. Each one gets its own native construct, not an imitation: the box becomes .. note:: in Sphinx, [NOTE] in AsciiDoc and #+begin_note in Org; the formula becomes .. math::, latexmath:[], plain LaTeX and <math>; the footnote becomes footnote:[] and <ref>. Plain text carries no markup at all — the table comes out aligned in columns, so it fits in an e-mail or a commit message. Whatever the destination lacks is reported at the end: MediaWiki has no box in its core (it becomes a quote with the label in bold) and reStructuredText has no strikethrough. To take a piece along without writing a file, the editor's context menu has Copy selection as (or Copy note as, with nothing selected): formatted text to paste into Word, Google Docs or an e-mail, GitHub Markdown, LaTeX and Typst. LaTeX and Typst carry the body only — no preamble, no title — because the destination is a document that already has them; a package the passage needs, or a citation that depends on the destination's bibliography, is reported in the status bar, and the %%…%% comment stays behind as well.

RTF lives under More formats (pandoc) and goes through pandoc, a separate program (winget install --id JohnMacFarlane.Pandoc): without it that destination appears disabled, with the reason, and Install pandoc... in the same submenu opens the guide and does the install. If you already have pandoc somewhere else, point at the file with I already have it: locate on disk... in the guide, or in Settings → Code tools → External programs.

Export with options... is the first item of the export menu — the tab's and the one under File → Export note are the same menu. It lists every destination, with a search that matches name, use and extension (wiki finds MediaWiki, sphinx finds reStructuredText), and shows only the options that apply to the chosen destination: Table of contents at the start, when the note has no [TOC] yet; Document language, which decides hyphenation and the labels the document generates by itself; Citations live or resolved in the text, for LaTeX and Typst; the Word template, with the box that makes it the folder's default; the Formulas of HTML and EPUB as MathML or as images, for older e-book readers or HTML pasted into an e-mail; the PDF Paper, A4 or Letter; and Compile the PDF with Typst right after. An option that applies but cannot be used is disabled with the reason — live citations with no bibliography in the folder —, and a destination that depends on a missing program offers to install it right there. The last choice is remembered per folder and the dialog reopens the way you left it; the direct menu items keep exporting with the factory values, so that a choice made weeks earlier does not change the file a shortcut writes. A [TOC] written in the note works in every destination: it becomes the table of contents in Word and LibreOffice (Word updates it on opening), \tableofcontents in LaTeX, #outline() in Typst and a list of links in HTML and Markdown. In the formatted text of Copy selection as, formulas and diagrams go as images, with the LaTeX source as alternative text: there is no telling where the text will be pasted, and only an image looks the same in Word, Google Docs and an e-mail — if you need the editable equation, export the .docx or the .odt.

The whole folder goes out too: File → Export folder... (or right-click a folder in the tree) turns its notes into an HTML site — one page per note, with an index when no note already became index.html —, a set of .docx or .odt, or a tree of Markdown in the destination's dialect. The subfolder structure is preserved, the links and wikilinks between the notes now point to the files that came out (in Word and LibreOffice too, from one document to the other) and the images and attachments that live inside the folder go along, in the same place. What is outside it is not copied: it stays as you wrote it, and the report at the end lists every case, together with the links with no target. The destination folder must be empty — or you tick Replace files with the same name — and cannot contain the exported folder. With no window: lnote folder-export --path . --format html --out site, and the folder_export tool over MCP; there transclusion, [files] and figure numbering are not resolved, because the window is what resolves them.

Formatted editing

Formatted editing (WYSIWYG): the fourth mode shows the note as it looks — a heading in heading size, a list with its bullet, a table as a grid and an image inline — instead of the markup. The file is still the same .md: LightNote writes it, not Qt, which is why bold, italic, wikilinks, transclusion and callouts survive the round trip. Entering the mode and leaving without editing does not change a byte of the file. The toolbar offers only what Markdown can represent — heading, bold, italic, strikethrough, code, lists (with task checkbox), quote, link, table and horizontal rule; alignment, indentation and font size are left out because they would be lost on save.

Inside a table, Tab moves between cells and creates the next row on the last one. Enter in the empty space beside the table — where the caret lands when you click to the right of a row — appends a row at the end, with the cursor in the first cell. Inside a cell, Enter breaks the line right there (it goes to the file as <br>, the only form a Markdown table accepts) and Ctrl+Enter creates the row below, with the cursor in the same column. Hovering the table reveals discreet handles: to the left of the row, a pair of arrows that moves it up or down — and that you can also drag to take it somewhere else; above the column, the pair that moves it sideways; and a + on the bottom edge and another on the right one, which add a row and a column. The first row is the header and does not move. All of it is in the context menu too, under Table — which also carries Remove the table, the safe way to take the whole table out.

In a box (<details> or :::), the last line closes the box and cannot be deleted: it is what keeps the content below from being swallowed by the box. To undo the box and keep the text, use Remove the box in the context menu. Enter always creates a line. In an empty list item it leaves the list without adding a line — as Word does — and in an empty paragraph it creates the blank line. One blank line in the file is the normal separation between paragraphs and does not show as an empty line; from the second one on it does, and it goes back to the file exactly as you wrote it.

Dragging an image's right edge resizes it, and the width goes to the file as ![alt|300](photo.png). The bar has twelve controls: bold, italic and heading directly, plus two menus that split the rest by what they do — Format acts on what is already written (marks, lists, quote, table alignment and the Text operations) and Insert creates something new (link, image, table, block, diagram, formula, callout). Formatting a table and the Text menu still belong to the text editor: here they appear disabled, with the reason. Fading the markup moved to the View button, next to the reading column and typewriter scrolling, which work in all four modes. And the Insert menu offers here the same as in the text editor — highlight, superscript, subscript, wikilink, footnote, callout, collapsible block, table of contents and definition list —, everything this mode already knew how to show and did not know how to create.

What reading mode shows, formatted editing shows too. The :fire: emoji appears as 🔥, ==highlight== as a yellow mark, ^2^ and ~2~ as superscript and subscript, #tag as a pill and a bare web address as a link. The file keeps the written form: opening the note rewrites nothing. Editing inside a rendered span keeps the markup — typing in the middle of a highlight stays highlighted — and what you type right after it stays outside. The %%…%% comment stays visible, dimmed: hiding it would make it invisible and uneditable.

Callouts become a box in formatted editing too. A quote starting with > [!NOTE] — or [!TIP], [!IMPORTANT], [!WARNING], [!CAUTION] — shows a coloured bar and title, just like in reading mode: the marker gives way to the type's label, or to your own title when you write > [!TIP] My title. The file keeps the marker as written, and editing the title preserves the callout's type. The callout names from Obsidian and MkDocs are understood as well: [!SUCCESS], [!ABSTRACT], [!FAILURE], [!QUESTION] and their aliases (tldr, missing, faq) fall into the closest box, so a note that came from there already shows up in colour — and, on export, each destination gets the name it knows.

This is the default mode on a new installation. If you already used LightNote, your previous mode is kept; to change it, use Settings → General → Initial Markdown view. Clicking a heading in the Outline jumps within the current mode, without pulling you out of formatted editing or reading.

Aligning a table column. With the cursor inside the table, the context menu offers Table → Align column: Left, Centered, Right or Default. Alignment belongs to the whole column — that is how Markdown represents it — and goes into the file on the separator line (:--, :-:, --:); Default goes back to ---. The check mark in the menu tells you which one is in force: on screen a --- column and a :-- one look alike.

The Outline shows what is on screen. The list of headings comes from the surface you are looking at: in formatted editing, a heading you have just typed shows up right away, without waiting for the text to reach the text editor; in reading mode it also includes the headings of notes transcluded with ![[note]], which are part of what you are reading. Clicking an item lands on the right heading in both cases. And in split mode scrolling now works both ways: scrolling the reading pane takes the text editor along, as it already did the other way round.

Markup becomes formatting as you type. Writing **test** applies bold and removes the asterisks; the same goes for *italic*, ~~strikethrough~~, `code` and the underscore forms. At the start of a line, #  through ######  become headings, -  and 1.  become lists (the number you type is where it starts), - [ ]  becomes a task with a checkbox, >  becomes a quote and --- alone becomes a horizontal rule when you press Enter. The markers that draw something take effect on the space itself; only the heading waits for the first letter, because an empty heading would show nothing.

Ctrl+Z undoes only the conversion and brings the literal markup back — the way out for someone who really wanted the asterisks. Pasting converts too: text with markup pasted in comes out formatted, without the markers. The rule here is more cautious than while typing — only unambiguous markup fires — because when pasting you do not watch the result form: that way a code snippet, full of * and _, stays code. Nothing is converted inside a code block, because there the markup is the subject. To turn it all off: Settings → General → Convert the markup as you type.

From Word, Google Docs or a web page, what arrives is the text with its structure: headings, lists (including Word's, which underneath is not a list at all), tables, links, inline code and code blocks with the language. The source's font, size and colour stay out — Markdown does not represent them, and keeping them would leave a blue Arial run that vanishes on save. A picture that comes along becomes an attachment of the note when Word or the browser left it in the temporary folder, which empties itself; one that points to the internet keeps pointing there, and its context menu offers Download the image into the workspace.

Images, links and wikilinks

Images and links. There are three ways to put an image in: Insert → Image… on the toolbar, typing ![](photo.png), or dragging the file into the note — dragging an image inserts the image, dragging a .md note inserts a [[wikilink]], and any other file becomes a clickable link labelled with the file name — and dropping several at once puts each one on its own line. The stored path is relative to the note's folder whenever possible, so the note keeps working after the vault is moved. A link's address does not appear in the text (what you see is the label), so it is shown in the status bar on hover, and Ctrl+click opens it: a web address goes to the browser, a local path opens in LightNote.

Editing an existing link: put the cursor in it and use the Link button (or Edit link… in the context menu) — the dialog opens with the text and the address filled in. The context menu over a link also offers Copy link address and Remove the link, which undoes the link and leaves the text. Over a [[wikilink]] it offers Open the note and Copy the target; over a #tag, Search the tag and Copy the tag. Over an image there is Alternative text… — invisible in the formatted mode, but it goes to the file and to the search — and, once you have dragged the handle, Original size, which gives the image its own size back. Over an image with a web address you get Download the image into the workspace: the file goes to Attachments/ next to the note and the note points at it — otherwise it would depend on that URL still being there. And there is the shortest path of all: select some text and paste a URL — it becomes [text](url) instead of replacing the selection. It works in both editing surfaces. Until it is downloaded, a web image shows up as a card with the address and the menu path — LightNote does not go to the network to render a note, and the spot used to hold the empty broken-image box, saying nothing about what to do.

And the markup can be undone. In the Format menu, the Highlight, Superscript and Subscript items appear checked when the cursor is inside one of them, and clicking there removes the markup instead of applying it again. From the keyboard there is the quick path: with the cursor at the end of a formatted run, Ctrl+Shift+Backspace gives the literal markup back minus one character — bold becomes **bold* as plain text — and completing the missing delimiter forms it again. It works for bold, italic, strikethrough, code, highlight, superscript and subscript. Backspace on its own deletes a character, there as anywhere else.

Edit the diagram without leaving the note. A Mermaid diagram or a $$…$$ formula appear drawn in the formatted editor; to reach the source, put the cursor on them and press Ctrl+Enter — or use Edit this block… in the context menu. The bottom bar shows the text, the note stays locked while it is open, and closing it (✕, Esc, Ctrl+Enter, a click on the note) applies: the way back is Ctrl+Z. In the same menu, Extract to new note… writes the selected passage to a note beside this one and leaves a [[wikilink]] in its place — the markup goes along, so heading, list and table arrive intact in the new note. The field shows only the content: the ```mermaid and ``` lines (or the $$) became the type selector in the bar’s header, which also switches between diagram, formula and code block. Enter keeps the line’s indentation, which in an indented language like Mermaid is the gesture of every line. And the block’s context menu offers Copy the Markdown code and Copy the image — the code pastes into any Markdown editor and draws again; the image pastes into an e-mail or a chat. Both also work in reading mode.

Asking the AI for the change. With the block bar open, the AI button in the header opens a line where you write what should change — “add an error path that goes back to the start”, “turn the sum into an integral” — and Enter sends it. Next to the field, a button shows which AI will answer: its menu switches assistant for this block only, without touching your default AI, and carries See what will be sent. It is worth a look, because the AI receives the block, the note's title and section and the text around it — that is what lets you ask the diagram to reflect what is written there. The answer lands in the field and the drawing is redone at once: Ctrl+Z brings back what you had written. LightNote checks the answer with its own renderer and, when it does not draw, asks for one fix, telling the model the line and the command it refused — if that fails too, it writes the answer anyway and leaves the reason on the bar, so you can fix the two lines by hand. The button only appears on diagrams, formulas and chemical structures.

Point at a section, and tag from the properties. [[Note#Section]] opens the note at that section — the anchor names the heading text — and ![[Note#Section]] transcludes only it (up to the next heading of the same level or higher, subheadings included). An anchor that matches no heading says so in the status bar, and the transclusion is left as written: bringing in the whole note there would be handing over something else in silence. And frontmatter tags: now count as the note's tags, in both spellings (tags: [a, b] and the list on its own lines) — they reach Bases, tag search and what the assistant sees, together with the #tags in the body. With no note name, the anchor points at the note itself: [[#Conclusion]] jumps to that section without opening any tab, and ![[#Conclusion]] brings the section to where you are. And anchors nest: [[Thesis#Method#Sample]] is the Sample inside Method, not the first one with that name in the note. The third form points at a block: a line ending in ^id (or an ^id alone right below the block) is the target of [[Note#^id]]. LightNote does not create those identifiers — it takes you to what you wrote. And the anchor of a target that is not a note is the address inside it: [[paper.pdf#page=3]] opens the PDF at that page.

Wikilinks: type [[ to autocomplete with the workspace notes; the link closes itself with ]]. Hold Ctrl and click a [[note]] to open the corresponding note. The Links panel shows the connections between notes. The Obsidian embedded figure shows up too: ![[photo.png]] is drawn as an image, and ![[photo.png|300]] honours the width. The file keeps what you wrote — the image path is never written in place of the token.

And an attachment that is not an image becomes a card: ![[paper.pdf#page=3]], ![[lecture.ogg]] and ![[map.canvas]] show up as a box with the file name, clickable — and the PDF opens on the page you pointed at. Obsidian’s .canvas and .base carry one extra line, saying the file stays in the folder and LightNote does not draw it. A target that does not exist stays exactly as you wrote it: a card there would promise a file that is gone. In the middle of a sentence, the picture shows the same way and the attachment becomes just the file name, which Ctrl+click opens: a card there would split the paragraph. The same note under another name: write aliases: [Sampling, Sampling method] in the note properties and [[Sampling]] opens it — the alias also joins the [[ autocomplete. A file with that name always wins over an alias. Aliases come from the folder index, which the app rebuilds in the background when the workspace opens: a freshly written aliases: resolves on the next scan, not the same second.

Tags panel

The Tags panel. The sidebar strip has a Tags section: the tree of every #tag in your notes, nested by / (#project/alpha and #project/beta become branches of project), with the number of notes beside it — counted per note, not per occurrence. Selecting a tag lists the notes that carry it below (a parent also shows the ones in its branches); double-click opens the note. The panel reads the index, so it sees both sources: the #tags in the body and the tags: in the frontmatter. Ctrl+clicking a tag inside a note opens this panel with that tag selected — before, it opened a text search for #tag, which does not find the note that declares the tag in its frontmatter. For the literal occurrence in the text, keep using global search.

Boxes, footnotes and rich markup

Rich reading: fenced code blocks appear in a box with the language label and a copy link; ~~strikethrough~~ and ==highlight== are rendered; and GitHub-style callouts (> [!NOTE], [!TIP], [!WARNING], [!IMPORTANT], [!CAUTION]) become colored boxes. #hashtag tags are highlighted and, with Ctrl+click, open a search for that tag; the YAML frontmatter block at the top (---) is highlighted. On the tab's toolbar there is a button to export the note as PDF/HTML, a centered toggleable reading column and the note's display modes. Zen mode (F11) and typewriter scrolling help you write without distractions.

Footnotes jump both ways. The [^1] reference appears as a superscript number, and Ctrl+click on it goes to the definition; in the definition, the [^1]: marker stays visible — it is the jump target, and you need to see it to know which note you are editing — and Ctrl+click on it goes back to the reference. Unlike many Markdown viewers, the editor does not renumber footnotes or move definitions to the end: the file's order is yours. The inline spelling from Obsidian and Pandoc — ^[the note text] — draws too: you write the text where the note is called, and in reading mode it shows up numbered at the end. The file keeps exactly what you wrote, and on export it becomes a real footnote in Word, LaTeX, Typst and EPUB.

The MkDocs admonition (!!! note with the body indented by 4 spaces) is kept exactly as written in formatted editing: the indentation is what makes the body belong to the admonition, so its text gets no rich formatting — in exchange, opening the note and saving does not undo the construct.

Boxes with a closing marker also show up as a box. :::tip … ::: (Docusaurus) and <details> … </details> get a coloured bar and title, in both spellings — the compact one and the one with blank lines. The opening marker gives way to the type's label, to the title you wrote, or to the <summary> text; the closing one leaves the screen and stays in the file, because markup the app itself writes should not sit literally on the page. What remains is the last line of the box: it is what delimits the box, it is where you put the cursor to keep writing inside it, and it cannot be deleted — without it, the content below would be swallowed. To undo the box and keep the text, use Remove the box in the context menu. The : of a definition list is still dimmed. The <summary> has to be on the same line as the <details> to become the title: on a line of its own it shows up as written, and the box keeps the default label.

Inline HTML and code blocks. <kbd>, <mark>, <sub> and <sup> are rendered in formatted editing too — the tags disappear and only the content stays, just like in reading mode. A fenced code block gets a box, with the language name and a copy link in the corner — the same link in formatted editing and in reading mode, where code gets copied the most. It takes only the fence's body (without the markers) and says copied for a moment; both labels only appear when they fit without writing over the code.

More in reading: the YAML frontmatter block at the top is not shown in the rendered note — you edit it in the Properties panel. #hashtag tags become clickable chips that open the search for that tag (the same as Ctrl+click in the editor). Obsidian-style comments (%%this stays hidden%%, or a block between lines containing %%) stay in the file only. Besides GitHub callouts, the boxes of the Docusaurus (:::tip Title … :::) and MkDocs (!!! note "Title" with an indented body, and ??? note) dialects are rendered as well — handy when reading documentation repositories.

New in reading: besides ~~strikethrough~~ and ==highlight==, you also get superscript ^x^, subscript ~x~, shorthand emoji (:rocket:), autolinked URLs, footnotes [^1], collapsible blocks <details>, definition lists, tasks - [ ]/- [x] (⬜/✅) and the [TOC] token (a clickable table of contents in reading); plus local images and inline HTML (<kbd>, <mark>…). The Outline panel (tab toolbar) walks the headings and follows the cursor, and the Insert button (or the context menu → Format/Insert) applies any markup.

Headings, folder notes and text tools

Sticky headers (sticky scroll): as you scroll, the headers enclosing the top line stay pinned in a strip at the top of the editor; clicking one jumps to that section (toggle it in Settings → Markdown). A folder's context menu in the tree creates/opens the Folder note (index.md with frontmatter), handy as an index.

Folder note and file list: double-clicking a folder opens its index.md, if it exists. Inside any note, the token [files] (or [arquivos]) alone on a line is replaced in formatted editing and in reading by the list of the note's folder files, as clickable links — generated on the fly, writing nothing to the file (like [TOC]).

Text and line operations. The code editor's operations work in notes too — via the Text submenu of the Format button on the tab bar, the context menu and the Lines and Cleanup submenus of the Edit menu: move the line (or the selected lines) up/down (Ctrl+Shift+↑/↓), duplicate (Ctrl+Shift+D), delete (Ctrl+Shift+L), sort (A→Z / Z→A), reverse the order, join lines, remove duplicate or empty lines, trim spaces and case (UPPERCASE/lowercase/invert). Number lines… opens a dialog with start, step, leading zeros and separator — with the default (". ") the result is a valid Markdown ordered list. With a selection the operation applies only to it (expanded to whole lines); with no selection, to the entire document — always a single undo step. The tab bar also has an AI button: Ask / Edit with AI — the same Ctrl+K / Ctrl+I as in code — and Ask your notes, the chat that answers using the notes in the workspace.

Suggest title and tags. In the same AI button of the note, Suggest title and tags… asks the default assistant for a title and tags for the open note. It reads the note (for a long note, the beginning and the end) and the list of tags you already use in the workspace, and prefers reusing them over inventing synonyms. The suggestion appears in a small, editable window: change the title, uncheck or fix the tags. Apply writes title: and tags: to the note's properties — the tags are added to the ones it already has, never replacing them — and, if the note has neither a title nor a # … heading, offers to put the title at the top as well. It is a single edit: Ctrl+Z undoes it. With no AI configured, the item offers to connect one. The note's text leaves the machine if the assistant is a cloud service; with a local model, it does not.

Foldable headings: click the little arrow to the left of a heading (or use Ctrl+Shift+[ / Ctrl+Shift+]) to collapse and expand the section; under View there is Collapse/Expand all headings. Folding is purely visual — it is never written to the file — and LightNote remembers it across sessions. Jumping from the Outline or from a search into a collapsed section expands it.

Binder: the folder as one work

What it is: a folder whose notes are chapters, in an order you declare. It works for a book, a thesis, a course, a manual, a runbook or a work journal — the mechanism is the same. In the folder's context menu, Turn into a Binder opens a screen with the notes in their current order: drag to reorder and confirm. The order is saved in the chapters: key of the folder's index.md — a text file of yours, which travels with the notes and still works on any machine. A subfolder can also be named in the order: its chapters enter at the position where it appears, and it declares its own order in its index.md — that is how a book gets parts. A subfolder's cover does not become a page of the document; it is there to declare the order of that level and to navigate.

Navigating: with a declared order, the note's toolbar shows Chapter 3 of 12, with an arrow on each side (Alt+PgUp and Alt+PgDn); the middle button lists every chapter. The Outline panel then shows two levels: the chapters of the work and, under the one that is open, its headings. At the ends of the work the arrow is greyed out. In a folder without a declared order none of this appears, and everything stays as it always was.

The note template: a Binder can declare which template the notes created inside it start from (the template: key). There are five ready-made templates — book chapter, thesis chapter, lesson, procedure step and journal entry — and picking one saves it as a file in the Templates folder, where it stays editable. A note created inside the Binder joins the order by itself; a file dropped in from outside sits under Out of order until you adopt it. Renaming a chapter fixes the key and keeps its position. To start from a ready-made work, Structure from a template… (in the folder's context menu) writes both keys at once — the order and the chapters' template — keeping whatever cover you have already written; and while a declared chapter does not exist yet, the Outline shows a button that creates them all at once, each already from the folder's template. Nothing is overwritten: a chapter that is already there stays as it is.

Compiling into one document: when exporting the folder, the Compile the chapters into one document box produces one file with the chapters in the declared order. Because the text is joined before it is rendered, footnotes, figures, tables and citations are then numbered across the whole document — and a cross-reference from one chapter to a figure in another starts working. Whatever is not in the declared order is left out, and the report says what.

Properties, theme and zoom

Note properties: the Properties side panel shows the YAML frontmatter as typed fields (text, number, date, checkbox), with the Type box at the top. Setting the type and the properties is what lets you gather notes into a Base.

Note theme: the Theme box in the Properties panel sets the look of this note — text colors and font — without touching the theme of the rest of the app. The choice goes into the frontmatter (the theme key), so it travels with the file: the note looks the same on any machine. The button next to it writes the colors into the note itself, so it looks the same even for someone who does not have that theme. Without the key, the note follows the workspace theme. If you would rather have notes from elsewhere not change your look, turn off Respect the theme declared in the note under Settings → Markdown.

A theme LightNote does not know yet: the theme list is a single file downloaded from the site, so a note citing a theme published after your last update simply will not find it. The note then opens with the workspace theme and the Properties panel says so, with a shortcut to see the available themes. LightNote looks for the updated list on its own — once per session, in the background, without holding up the note. If you would rather it never fetched anything, turn off Fetch tool catalog online under Settings → Features.

Ctrl++ and Ctrl+− (or Ctrl+mouse wheel) change the size of the note, and Ctrl+0 goes back to 100% — handy to read a long note without changing the font of every note. The editor and the reading pane scale together: in split mode both sides stay the same size. An <svg> written straight into the note is drawn in reading too: you can paste an AI-generated chart without turning it into a separate file.

How many words, and where. The status bar counts the words in the note and estimates the reading time; next to it, section N is the count of the section the cursor is in — the same one the Outline highlights, from its heading to the next one of equal or higher level. Set a daily goal in Settings → Notes & writing and today N/M shows up too: what grew in the notes you opened today. Deleting does not subtract — revising your own text must not become a punishment —, a note you did not open does not count, and at midnight the tally resets.