Home › Help

LightNote help & features

Full documentation of everything LightNote does — the same help that opens inside the app with the F1 key. Use the index below to jump to any feature.

✍️ Code editor 🧠 Notes & second brain 🤖 Vibe coding (AI + MCP)

LightNote Help

Lightweight code and notes editor for Windows. The sidebar lists the sections and follows what you are reading; the Home and Back buttons at the top of the window return to the start, and the Search box finds text within this help (Enter moves forward; F3 / Shift+F3 navigate). Press F1 at any time to open this help right at the section for the current screen.

Index

Editing

Tools

Automation (AI / scripts)

Reference

Overview

LightNote opens a folder as a Workspace and shows the file tree on the left, the editing tabs on the right and the status bar at the bottom. The small strip at the top of the sidebar switches between the Explorer (tree), Search, Versioning (Git), file History and Pending items (TODO/FIXME and note tasks) sections.

Beyond code and notes, it opens and edits many formats in the right place: tables (Parquet/CSV/JSON via DuckDB and Excel .xlsx), PDF, images (including animated GIF), .zip as a folder, Blocks notebooks (.lnb), Tasks boards (.lnt), custom tables (.lnd), database connections (.lnc) and SSH connections (.lns). There is an integrated terminal, global search (ripgrep), simplified Git versioning, integration with AI CLIs, an MCP server and a command line (lnote) for automation.

New here? The introductory material (the welcome workspace) stays available at any time under Help → Reopen welcome tour.

Workspace and windows

The opened root folder is your Workspace. Just opening it creates nothing; when you close it, LightNote only writes a small session file (open tabs and position). The workspace only becomes a "project" — with its own persisted configuration — when you enable Versioning (Git) or the MCP in Tools → Workspace Settings.

The General Settings apply to the whole application; the Workspace Settings apply only to the opened folder. Configuration and state live in a central database, not scattered across the folder.

LightNote runs as a single instance: opening a second folder reuses the process (multi-window, less memory). There is a tray icon and a launcher with a search box listing the Workspaces (pin your favorites to the top via the context menu) — see Daily notes and tray. Each tab can get a color label through the tab bar's context menu. For repetitive notes, create a Modelos (or Templates) folder with .md files and use File → New note from template…

Creating a file and choosing its type. The New menu (☰ File, the New button on the activity bar, or Create new in a folder's context menu) offers New note (.md), New text file (.txt) and the New code file submenu with the most used languages. In all of them the file is created on disk right away with a default name, and the tree opens the name editor — only the base name is preselected, so typing a title does not erase the extension. To accept the suggested name, just click in the editor and start writing. For an extension outside the submenu, create a file and rename it (F2): changing the extension changes the view — renaming .txt to .md reopens the same tab as a note, with preview and outline, and the other way round brings back the code editor. LightNote's own extensions (.lnc, .lne, .lnq, .lnh, .lns and the bundles) are the exception: there the extension declares the format of the content, so renaming asks for confirmation and is refused while the tab is open.

Where the new file is created. New always creates in the marked folder in the Explorer, and exactly one is always marked. At the top of the tree sits the root folder row, named after the workspace: it is an item like any other — click it to send the destination back to the root. Selecting a folder moves the mark to it; selecting a file marks the folder that contains it. In List mode, which shows no folders, the mark stays on the root row and that row displays the effective destination. The root row's context menu offers Create new and Create folder.

To open a loose file without turning it into a workspace, use Open loose file… (tray menu): the standalone window shows the file tree, but without Git, MCP or theme override. If enabled in Settings → General → Features, LightNote integrates with the Windows Explorer menu (per user, no administrator required): besides the "Open with" list, the context menu gains "Open with LightNote" on any file and "Open as LightNote workspace" on folders (on Windows 11, under Show more options). Files open in that standalone window; folders open as a workspace.

If you select several files at once in Windows Explorer — even from different folders — they all open in the same standalone window, tab next to tab (instead of scattering one window per file). That window's tabs are remembered: close it and open it again, and the same files come back. Since the focus here is on the tabs, the file tree starts collapsed — press Ctrl+B (or the button at the top of the activity bar) to show it.

Getting back to a session. The standalone files window is called Standalone files everywhere — including in the title bar, where other windows show the workspace name, so you can tell them apart in Alt+Tab. In the tray menu, under Open, the item gains a (N tabs) suffix when there are saved tabs — clicking it brings them all back. It is also the first row of the launcher, next to your workspaces. And when you reopen LightNote, it comes back with everything that was open when you quit: each window in its folder, plus the standalone window. To open only the last folder used instead, change Settings → General → Interface → On startup, open. A window you closed before quitting is left out — closing is how you say "I'm done with this space".

Favorites: the sidebar has a Favorites section with whatever you pinned (context menu of the tree or of a tab → Add to favorites) plus the recently opened files. Pinned items are per folder and are stored as relative paths, so they survive moving the workspace.

Open a tab in its own window: in the tab's context menu, Open in new window reopens that file in a standalone window (handy to keep a note beside your code). File types that depend on the workspace (.lnc, .lne, .lns and the bundles) cannot be detached.

Multiple selection. The tree accepts Ctrl+click (individual) and Shift+click (range) in all three view modes. With several items selected, the context menu acts on the whole selection: Cut and Copy (interoperating with Windows Explorer), Delete (a single confirmation for all), Duplicate, Copy hash, Compress to .zip (one archive, each item under its own name at the top), Apply color, Favorites, Git (add/restore) and Copy paths (one line per item). Actions that only make sense for a single item — inline rename, Properties, Open as, Convert — are disabled, with the reason in the tooltip. Right-clicking inside the selection keeps it; clicking outside selects just the clicked item. Selecting a folder and something inside it does not run the operation twice: the inner item is dropped.

Peek without opening. A single click on a file already opens a preview tab (recycled, shown in italics on the tab bar). While walking the tree with the arrow keys, Space does the same and returns focus to the tree, so you can keep moving down the list.

File tools. The Explorer context menu has a File tools submenu: Batch rename (filter by extension/wildcard/regex + a rule pipeline with live preview and collision detection), Split file (by lines, size or regex separator), Merge files (optionally keeping only the 1st CSV header), Duplicate, Copy hash (MD5/SHA-256) and Compress to .zip / Extract here. With several items selected, Batch rename and Join files receive exactly the chosen items (instead of scanning the folder) — and Join honors the selection order.

Navigating the standalone window. Above the tree there are back (Alt+←), forward (Alt+→) and up buttons, plus a clickable folder trail — each segment jumps to that level. The mouse side buttons also go back and forward. To type a path, click the empty area of the strip or press Ctrl+L; Esc cancels and restores the trail. Switching tabs also moves the shown folder: since the standalone window gathers tabs from different folders, clicking a tab navigates to that tab's folder.

Menus. The ☰ button (top of the activity bar) holds the File, Edit, View, Window, Tools, AI and Help menus. AI actions have their own menu (also on the wand button in the activity bar). Under Tools, the groups live in submenus: Run (F5/F6/F8, lint, send to terminal, macros), Capture (today's note, quick capture, quick task, record audio, sticky notes) and Workspace (settings, snapshot, export copy, move folder) — the latter also in the gear menu. The New menu is the same in the three places it appears: ☰ File, the New button and Create new in a folder's context menu.

Code editor

Text/code files open in the editor (Scintilla) with syntax highlighting. There is comment/uncomment (Ctrl+/), move and duplicate line, bookmarks (Ctrl+F2), a symbol/function list, word-based autocompletion, indentation guides, word wrap, zoom and detection of file changes on disk. With versioning enabled, the margin marks the lines added/changed since the last version.

There are also macros (record/replay a sequence of edits with Ctrl+Shift+R / F4, in Tools → Macros), format/beautify (Shift+Alt+F), an ASCII table on the tab's toolbar (to insert characters/box-drawing) and a spell checker (Hunspell). pt-BR and en-US ship built in; other languages you download on demand from the table in Settings → Notes & writing → Spelling (one row per language, with a Download/Remove button). To follow a log file being written, use the Monitor (tail -f) button on the tab's own toolbar. Very large files (above ~1 MB) open in a virtualized lightweight editor that loads only the visible chunks; you can force it through File → Open in Lightweight Editor…

Format and lint: Shift+Alt+F formats the document with the language's external formatter (black, prettier, clang-format, gofmt, rustfmt…) when installed, falling back to the internal formatter (JSON/XML) offline; F7 runs the language's linter (ruff, eslint, shellcheck, luacheck…) and marks the problems with an underline in the editor and in the Problems panel (bottom pane, navigable). Both have a catalog with Add in Settings → Formatting and → Linters, plus format on save / lint on save options. Run the file in the output panel with F6 (captures exit code and duration, with stop/restart) or just a snippet with F8.

More editing features: per-occurrence multi-cursor (Ctrl+D, all with Alt+F3), duplicate line (Ctrl+Shift+D), join lines (Ctrl+Shift+J), expand/shrink selection by scope (Ctrl+Shift+Space / Ctrl+Alt+Space), rectangular selection (Alt+drag), fold/unfold all, snippets (Ctrl+J, editable in Settings → Editor), Go to symbol in file (# in the palette) and in the project (Ctrl+T or ##), navigation history (Alt+←/→), a breadcrumb trail at the top of the editor, column rulers, bracket-pair colorization, auto-close/wrap pairs and cleanup on save (trim spaces, final newline) — all in Settings → Editor.

Local history and clipboard: on every save, LightNote keeps a version of the file (File → Local history…, restorable), independent of Git. Ctrl+Alt+V opens the clipboard history to paste a previously copied item. Ctrl+Shift+T reopens the last closed tab; tabs can be pinned (context menu), which protects them from being released when idle.

Go to definition: F12 or Ctrl+click on an identifier jumps to where it is defined in the project; Shift+F12 finds its uses.

Minimap. A thumbnail of the whole document sits on the right edge of the editor: it shows the “shape” of the code (the syntax highlight colours, scaled down) and marks the visible region. Click or drag it to jump anywhere in the file. Toggle it in View → Minimap or in Settings → Editor. The Minimap button on the code tab's own toolbar (next to ASCII) toggles it without leaving the editor. A mark strip runs along the thumbnail's left edge: blue for bookmarked lines (the same dot as in the margin) and amber for quick-search matches — so you can see at a glance how they are spread across the whole file, including the parts that are off screen.

Text operations. The Edit menu — and the editor's context menu — hold the Lines (move, duplicate, delete, sort, join, reverse, number) and Cleanup (trim whitespace, remove empty/duplicate lines, tabs ↔ spaces) submenus. With text selected, the context menu also offers Save selection as a new file…: it writes the snippet to a file next to the current one and opens it in a tab (the original is left untouched).

Markdown and wikilinks

.md notes open with editor and preview 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 → reading).

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.

Rich preview: 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 editor/both/preview modes. Zen mode (F11) and typewriter scrolling help you write without distractions.

New in the preview: 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 the preview); 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.

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

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.

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.

Connections graph

Tools › Connections graph (Ctrl+Alt+G) shows every note in the workspace as an interactive graph: each node is a .md note, each line a wikilink. Nodes settle into place on their own (animated physics) and can be dragged; hovering highlights the neighbors and fades the rest; click opens the note. Scroll to zoom (names appear as you get closer) and drag the background to pan.

On the tab's toolbar: filter by name (fades non-matching notes), a toggle for orphan notes (no links at all — shown in gray), force sliders (repulsion, distance and gravity), fit the graph to the window and rescan the notes. The more connections a note has, the bigger its node; each top-level folder gets its own color.

Tables (Parquet, CSV, JSON, Excel)

.parquet files open as a table; .csv, .tsv and .json open as text, and the tree's context menu offers Open as table. Reading is paginated (on demand) via DuckDB, with sorting (click the header) and filtering pushed down to the engine. The Structure button shows columns, types, row count and, for Parquet, row-groups and compression. The view is read-only.

The free SQL bar at the top of the table accepts any DuckDB query — the view t stands for the opened file. From a folder's context menu in the tree, Open folder as table reads every file of the same format as a single table; from the table's menu you can export the current view (CSV/Parquet/JSON), and from the tree's menu, convert a tabular file to another format. Free-form SQL is also available in the query command of the command line and in the MCP.

Excel spreadsheets (.xlsx) open as a read-only table with a sheet selector — a lightweight reader, no Excel installation needed.

Copy as. In the context menu of any LightNote table (Parquet/CSV/JSON, Excel, SQL results, Tasks, Bases), the Copy as item puts the selection on the clipboard already formatted. Formatted table (Teams, Outlook…) pastes as a real table, with borders and a header, into programs that understand rich text — Teams, Outlook, Word, Excel (where there is no rich text, it falls back to TSV automatically). The others paste as plain text: Markdown table (ready for a note), CSV (quoted per RFC 4180), TSV (tab-separated), HTML (the <table> markup), JSON, JSONL (one record per line), YAML, and the Code submenu, which generates a literal ready to paste into a source file: Python (list of dicts) or JavaScript / TypeScript (array of objects). In JSON, YAML and code, cells that are numbers come out unquoted — but the original text is preserved, so IDs like 007 stay text. Ctrl+C still copies as TSV, as before.

Every table behaves the same way: Ctrl+F focuses the quick filter ("contains in any column"), a counter shows how many rows are left, and there is Export to CSV — including in .xlsx spreadsheets, in Tasks and in Bases. The grid's context menu still offers Copy as.

Result chart. The table's side bar has a Chart button (bars, line or scatter): the aggregation runs in DuckDB (no raw rows are pulled), and an Add to today's note button saves the chart as an image. The Structure panel also includes a per-column profile — a mini-histogram of numeric columns and the most common values of the others.

PDF and images

.pdf files open in a native viewer (Qt6::Pdf, no heavy dependencies), rendered on the CPU and without WebEngine. Images open in the image view; animated GIFs play in the animated view.

The tab toolbar offers five side panels, one at a time: Outline (the table of contents stored in the file itself — when the PDF has none, the button is disabled and says so), Thumbnails (the pages at a glance, rendered as you scroll), Search, Links and Properties (title, author, dates, page and file size).

Search (Ctrl+F) looks through the whole document: matches are highlighted on the pages and listed with their surrounding text, and F3 / Shift+F3 step between them. The scan is progressive, so the list grows as the document is walked through.

The page field accepts the number or the printed label: in a document whose front matter is numbered in roman numerals, typing 1 goes to the printed page "1", not to the first sheet. The page mode button switches between continuous scrolling and one page at a time.

A password protected PDF asks for the password when opened (up to three tries); cancelling simply leaves the tab unopened. Within the same LightNote run the password is not asked again — the app reopens the tab by itself when it releases it for being idle, and it would be the app creating the annoyance. Ticking "Remember this file's password" in the prompt makes it last across runs too: it is protected by Windows (only for you, only on this machine), never goes to Git or to the cloud, and is not carried by the settings export. To erase them all: Settings → Features → PDF passwords. A protected PDF is not reopened on startup — instead of queueing password prompts before showing the window, it waits for you to open it.

From the toolbar action menu: copy the page text, export the whole document's text, copy or save the page as an image, and send the page to today's note. The Links panel exists because Qt's PDF component follows internal links on its own but ignores external ones — that is where a web address is opened, with a confirmation.

Limitation: there is no mouse text selection, because Qt's PDF component does not provide it. To take the content with you, use "copy this page's text" or the document export.

Images: marking up a screenshot

An image opens in a tab with its own toolbar: besides rotating, mirroring and zooming, it carries the markup tools — the path from taking a screenshot to pointing at what matters and carrying it off into the documentation.

The starting tool is Move: dragging still moves the image, as it always did. Select picks a part — drag to create it, drag from inside to shift it and use the handles on the corners and edges to resize; Esc deselects and Del erases the contents of the region. In Move mode, Shift+drag also selects. In any tool, the middle mouse button moves the image.

The Eyedropper picks a colour from the image itself: the left button sends it to the border colour, the right button to the fill. It reads from the already marked-up image, so it also repeats the colour of a mark you have just made.

The others draw: Rectangle, Ellipse, Arrow, Line, Highlight (translucent, like a marker pen), Pen (freehand), Brush, Numbered step (which numbers itself — 1, 2, 3...), Text, Blur and Spotlight (darkens everything except the chosen region). While drawing, Shift locks squares/circles and 45° angles.

There are two colours, in two buttons: the border one (which is also the stroke and the label colour) and the fill, which may be none. With no fill, the rectangle and the ellipse come out as outlines only, and the numbered step and the text use the border colour as their background, with the label in white or black — whichever contrasts. Choose a fill and it becomes the inside of the shape and the background of the label, while the border becomes the text colour.

The Brush paints with the fill colour, in a dab the size of the stroke width — round or square, by the button next to the width. A single click already leaves the mark. With a white fill it is the eraser: it covers whatever is underneath.

The width applies to the stroke, to the size of the label and to the block size of the blur; it is greyed out in the tools that ignore it. Colour and width are remembered across sessions. Ctrl+Z and Ctrl+Y undo and redo the markup, and Clear markup wipes it all at once (also undoable).

Blur is for hiding (a token, an e-mail address, a path). While the tab is open the markup is reversible, but on saving or copying the pixels of that region really are destroyed: the file that leaves does not keep the original anywhere.

Three operations have similar names and do different things. Cut (Ctrl+X) copies the selection to the clipboard and erases the region, painting it with the fill colour (white when there is none) — and the selection stays put, so Paste right afterwards brings the piece back exactly where it came from, floating: that is how you move a piece of the image. Del is cut without copying. Keep only the selection, in the Image menu, does the opposite: it keeps the region and throws the rest away, changing the size of the image.

The rest of the family: Copy takes the marked-up image or just the selection; Paste brings the image from the clipboard as a floating paste — move and resize it by the same handles and click outside (or press Enter) to keep it, Esc discards it; and Ctrl+A (or Ctrl+T) selects the whole image. There are also Save (writes the markup into the file itself), Save as... and Send to today's note, which writes the PNG into Anexos/ and inserts the ![]() in the note. While there is unsaved markup the tab keeps the asterisk, and closing it asks whether you want to save.

The Image button gathers everything that acts on the whole picture: rotate, mirror, resize by percentage, reduce to 1600 / 1200 / 800 px wide (a screenshot is born far too big for documentation), trim borders of a uniform colour, add a margin, drop shadow and burn the markup into the image — this last one turns the marks into pixels there and then, which is what lets you blur over a mark. Resizing carries the markup and the stroke width along.

To capture the screen without leaving LightNote: Capture screen... in the tray menu (or Ctrl+Alt+P) freezes the desktop, you drag to choose the area (Esc cancels) and the cut-out opens in a new tab, ready to mark up.

Limitations: a mark once drawn cannot be moved or edited — undo it with Ctrl+Z and draw it again; animated GIF and WebP open in the animation view, which has no markup; and an .svg is rasterised on reading, so saving asks for a PNG destination.

Zip as a folder (.zip)

A .zip opens in its own tab: the member tree on the left (name, size, date) and the selected member's content on the right — text/code, Markdown (with preview), image or PDF — opened in memory, without extracting anything to disk. Text and Markdown can be edited: Ctrl+S rewrites the member inside the .zip itself.

The same tab opens .7z, .rar, .tar (including .tar.gz, .tar.bz2 and .tar.xz), .cab and .iso — those are read-only: you can browse, view and extract members, but not edit. Only .zip is writable, because it is the one format we can safely rewrite (.rar is proprietary and not even free libraries compress it).

Images and PDFs are read-only; very large members (and .parquet) only offer Extract to…. Creating, renaming or deleting members is not supported.

Password protected members are read normally: when you open one, LightNote asks for the password (up to three tries) and, by ticking "Remember this file's password", does not ask again — within the same run by default, and across runs too if the box is ticked (protected by Windows, for you on this machine only; erase them all in Settings → Features). Note one difference of the format compared to PDF: in a .zip the encryption is per member and the index stays in cleartext, so the file listing shows in full even without the password — only the content is protected. A .zip with encrypted members is not reopened on startup.

Blocks (.lnb)

A Blocks bundle is a folder whose name ends in .lnb, treated as a single item in the tree (double-click opens it). Each block is a real file on disk; the order lives in a blocks.json at the bundle root. It works like a notebook: stacked cells of code or text.

Each cell has a name, a type button (sets the interpreter/lexer) and buttons to copy, insert, delete and run. Run up to here executes all code cells up to the current one in sequence; the output (stdout+stderr) appears in a panel right below the cell. Create one from the tree (New) or via File → New.

Ctrl+Enter runs the focused cell — the same gesture as the SQL editor.

Results are saved (like a lab notebook): when a run finishes it becomes a .md file under saida/<cell>/ inside the bundle — with the timestamp, exit code, duration, command and the output itself. Being Markdown, it reads in any editor, versions in Git alongside the notebook, and is picked up by AI Chat. Reopening the bundle brings back the Last run strip above the panel: click it to see the result without running again.

History: the History button next to that strip lists the previous runs of that cell (timestamp and exit code) — handy to compare what the same cell returned over time. We keep the 10 most recent per cell; to change that, edit the historyLimit key in the bundle's blocks.json (0 turns saving off). Very large output is cut (the file says truncated: true). Renaming a cell or changing its type takes the history along; deleting the cell sends its history to the Recycle Bin.

SQL cells against a real database: point the notebook at a .lnc connection from the strip at the top (Choose connection…) and cells of type sql start running on the database instead of through an interpreter. A SELECT result becomes a table in the output file (real Markdown, which any viewer renders formatted); INSERT/UPDATE and friends report how many rows changed, and a database error stops the script and records the statement that failed. We fetch up to 100 rows per query (the file says when there were more) — the result is a note, not a copy of the table.

The connection lives in blocks.json as a relative path, so the notebook keeps working when you move or sync the folder. For a self-contained notebook, keep the .lnc itself inside the bundle: it counts as configuration, not as a cell. It is the same connection as the Database tab — connecting in one place applies to the other, and the password follows the Passphrase rules. With no connection set, an sql cell still runs through the configured interpreter, as before.

Tasks (Kanban / Gantt)

A Tasks bundle (.lnt) opens a task board with Kanban (status columns, drag the cards), Gantt (effort-based schedule) and calendar views. Each task can have a title, a column (status), an effort in hours and an associated .md note. Tasks are also reachable by AI, via MCP and CLI (create, move, update, read/write the note).

Per-task fields: besides status and effort, each task has a priority (colors the card border and sorts the Table), a due date (red chip when overdue), multiple tags, a subtask checklist (progress badge on the card) and recurrence (completing a recurring task spawns the next occurrence). Edit them from the context menu (Table/Kanban) and in the Properties panel.

Capture and lists: the tray's Quick task understands natural language (e.g. Pay bill tomorrow 5pm #home !high). The Templates button saves/applies task templates; Due-date lists filter Today/Next 7 days/Overdue; Saved views store filter+sorting; and the tray/Launcher show reminders for tasks due today or overdue.

Kanban board: you can group the columns by status, priority or tag, create swimlanes, set per-column WIP limits (the header turns red when exceeded) and sort the cards. Linear-style keyboard navigation: ←/→ move the focus, Ctrl+←/→ move the card, N creates, Space completes/reopens and Delete deletes. There is also the Calendar view (by due date).

Embedded note: selecting a task shows its .md note next to the views (autosaved when you switch tasks); the Note button toggles the editor and Open note in a tab opens it in its own tab. Archiving a task hides it from all views; the Show archived toggle reveals the archived ones (dimmed).

In Task Settings you can set Archive completed tasks after N days: when the board opens, tasks that have stayed in the final column longer than that are archived automatically (0 = off).

The note opens embedded by default (double-click the task) and saves itself as you type — Tasks never ask "save?" on close. The AI actions (Ctrl+K / Ctrl+I) work inside the note.

Tab toolbar. The actions that depend on the selected task (Delete, Dependencies, History (Git)) and Export CSV live in the ⋮ button. The Views button gathers the due-date lists, the saved views and show archived — all of which act on the Table. Ctrl+F focuses the quick filter, and the counter on the right shows how many tasks the filter left.

Custom table (.lnd)

A Custom table (.lnd, under File → New) is your mini database: you define the columns at runtime — text, number, date, fixed list with colors, path, tags and password — and fill the rows like a spreadsheet, with sorting and filtering. A path field groups the rows into a tree (e.g. Home/Office).

Password cells are encrypted individually with the Passphrase and revealed on demand. Like Tasks, the bundle persists as Git-friendly text (NDJSON) — it can be versioned and merged across machines.

In text columns, opening a cell shows a floating multi-line editor: Enter inserts a line break and Ctrl+Enter confirms; the grid shows the text on a single line (with …) and the full content in the tooltip. To change a column's type, use the header menu: converting text → password encrypts the values with the Passphrase; converting password → text asks for confirmation and the PIN/Passphrase and writes the content as plain text (irreversible). Other conversions keep the values.

Bases (saved queries over your notes)

A Base (.lnq, under File → New → New Base) is a saved query over your notes: filter by type and by properties and see the result as a table or a board. A Base stores no data at all — the rows are your .md notes and the source of truth for each cell is the note's frontmatter. Deleting a .lnq loses no note.

Editing a cell writes to the note. In the table, changing a property rewrites only that line of the file's frontmatter. In the board, dragging a card from one column to another writes the new value of the grouping property (for example moving from reading to read).

Each note declares its properties in the frontmatter (type, status, author…). Use the note's Properties side panel to edit them as typed fields (text, number, date, checkbox) instead of raw YAML — see Markdown notes.

The .lnq file is NDJSON (one record per line), designed for Git: two machines can edit the same Base in parallel — one adds a column, the other tweaks a filter — and the merge keeps both changes without conflict.

Declared schema (optional). By default LightNote infers each type's fields from what your notes already use — you don't have to declare anything. When you want to pin the schema down, open Tools → Note types... (or the gear button on the note's Properties side bar): declare each type's fields, their data type (text, number, date, checkbox, option list) and a default template. With a schema, an option list field becomes a drop-down of the allowed values, declared fields show up in the Base's column and filter pickers even before any note uses them, and the Apply type template button drops in the note's skeleton. The schema lives in .lightnote/types.ndjson — mergeable NDJSON, versioned in Git along with your notes; deleting it changes no note, it just goes back to inference.

Search in files and Pending items

Use Ctrl+Shift+F for the global search in the sidebar's Search tab, powered by ripgrep: it supports regex, case sensitivity, whole word and bulk replace. Within the current file, Ctrl+F finds and Ctrl+H replaces.

Highlights and marks are different things. The quick find (Ctrl+F) only highlights the matches in amber: it is temporary and disappears when you close the bar or clear the field. Mark all in Edit → Advanced find…, on the other hand, is your decision — it paints the matches red and adds the bookmark (the blue dot in the margin) on the matching lines, which stay until you use Clear marks. The two are independent: closing the quick find does not erase what you marked, and clearing the marks does not erase the find highlight. Both show up in the minimap strip, each in its own colour.

The sidebar's Pending items section gathers in one place the TODO/FIXME markers from code and the tasks (- [ ]) from the workspace's Markdown notes — click to jump straight to the line.

Versioning (easy Git)

Versioning is opt-in per workspace. Enable it in Tools → Workspace Settings: LightNote creates the Git repository (if one does not exist yet) and shows the versioning sidebar (Ctrl+Shift+G).

In automatic mode, LightNote saves versions (commits) by itself at the moments chosen in the General Settings (on save, on tab close or on window close). In manual mode, you write the message and save the version in the panel. The status bar indicator shows the state (no changes, X changed…) and, when clicked, opens the workspace settings. You can view each file's diff and restore (discard) unsaved changes.

Automation has 3 levels per folder (in Workspace Settings): Manual (nothing automatic), Auto-commit (saves versions by itself, but does not sync) and Fully automatic (commits and syncs — push after commit + periodic pull; requires prompt-less Git credentials). The panel shows a status line with ↑ to send / ↓ to receive relative to the remote, and the main button changes from commit to Sync when there are versions to send — making it clear that, after saving, you still need to sync.

The Git panel and the tree's Git menu offer Add (git add) and Restore (git restore) per file, plus Compare side by side (the whole file against the last version).

Snapshots and backup

In the ⋯ menu of the versioning panel (or under Tools):

  • Create snapshot: marks the current state with a date/time label so you can come back to it later.
  • Restore snapshot: pick a snapshot and what to do — bring the files back keeping the history (recommended), rewind the history to that point, or open it as a separate copy.
  • Export copy (.zip): compresses the whole workspace into a self-contained file (with the project marker embedded) to send or store elsewhere.
  • Move Workspace Folder…: moves the root on disk and adjusts the session and registry paths.

Review changes (checkpoints)

Tools → Review changes… shows, in a single tab, the aggregated diff of everything that changed in the workspace since a base: the list of added/modified/deleted files on the left and the selected file's diff on the right. It was designed to review what an AI CLI session changed before accepting the work.

The base can be the last version (HEAD) or a checkpoint: create one before starting a task (button on the tab itself) and compare against it later. Checkpoints create no commits and never touch your history. Requires versioning enabled for the folder.

Batch comments. When reviewing an AI session, the Comment button (also in the file list context menu) notes a comment about the selected file — anchored to the snippet you pick. Comments pile up in a list and only reach the CLI terminal when you click Send to session, all in a single message. That is deliberate: sending them one at a time makes the agent fix one problem and break another, because each round cannot see the other remarks. After it revises, the comments stay in the list so you can check whether they were addressed; tick the resolved ones and whatever is left goes into the next send. If the agent rewrites the commented region, the comment is dimmed instead of disappearing. The send is confirmed in the status bar, and a hibernated session is resumed automatically to receive the batch.

Compare files (diff)

Tools → Compare Two Files… opens both side by side (two editors) and marks the differences line by line. The comparison is read-only.

The ◀ / ▶ buttons (or F8 / Shift+F8) jump to the previous/next change. From the Git panel you can also compare a file side by side with the saved version (HEAD vs. disk).

Run code (F5)

Tools → Run File (F5) saves the current file and runs it in the terminal, according to the interpreter registered for the extension. The defaults cover .py, .sh, .bat, .cmd and .sql; you can edit/add interpreters in Settings → Execution.

The command is a template with {file} (file), {folder} (folder) and {name} (name) — for example, for Python: python {file}. You can also send just the selection/current line to the terminal with Ctrl+Shift+Enter. In Blocks, each cell runs through the same mechanism.

The Run button has a dropdown to choose and remember the target terminal when more than one terminal is open.

Clickable errors. In the output panel (F6), references to file:line become links: Ctrl+click or double-click opens the file at that exact spot. It works with Python tracebacks, Node stacks, compiler errors (gcc/clang/MSVC) and linter output. Only paths that actually exist on disk become links — the rest stays plain text.

Stepping through errors. In the output panel, F8 jumps to the next error and Shift+F8 to the previous one (there are buttons on the panel’s bar as well). The jump wraps around: it scrolls the output to the reference, highlights it and opens the file at the exact spot.

Terminal and AI CLIs

Per-command status dot. A dot appears next to each command you run: blue if it succeeded, red if it failed (the tooltip shows the time, duration and exit code). LightNote enables this automatically in PowerShell and Git Bash, without changing your setup — toggle it in Settings → Terminal → Shell integration. Other shells (cmd, WSL) or custom commands don't show the dot.

Open an integrated terminal (full VT emulator, via ConPTY) with Ctrl+' (on the US keyboard layout, also Ctrl+`). It becomes a tab and can be moved between the window areas. The available shells and the AI CLIs detected on the PATH (e.g. claude) are configurable in Settings → Terminal and Settings → AI Assistants. In the New terminal menu, choosing an AI CLI opens that CLI as the terminal — the TUI/colors show up normally, and quitting it closes the tab.

Schedule a send. In the terminal context menu (right-click), Schedule send… lets you send an Enter (or some text) later — handy to resume an AI CLI when the usage limit resets, without watching for it. Pick a trigger: at a time, after some minutes, every interval (recurring), or when the terminal goes idle. The computer is kept awake until it fires. The schedule lasts while the terminal tab stays open.

You can have several schedules at once. When there is any, the menu item shows Scheduled sends (N)… and opens a manager: a table with the terminal, what will be sent, when, and a live countdown to the next fire, with New, Edit and Remove buttons. While there are schedules, a clock indicator with the count appears in the status bar (click it to open the manager) and a small clock marks the terminal tab that is armed.

AI turn-completion notice. When an AI CLI terminal falls silent — a sign the agent has finished its turn — LightNote lets you know: a toast appears (click it to focus that terminal) and the tab blinks a few times, then keeps a highlight until you open it. If the window is in the background, its taskbar button flashes too. The notice applies only to AI CLI terminals, and only when the tab is not focused. Turn it on/off and tune the silence threshold in Settings → Terminal → AI turn-completion notice.

Terminals come back with the window. When you close and reopen the workspace, plain shell terminals (Command Prompt, PowerShell, Bash) are reopened — and in the folder you were in, not the one the terminal started in. The screen contents do not come back, but the command history belongs to the shell itself and is still there: the ↑ key works as usual. AI assistant sessions are left out and keep being offered separately, because a new terminal is not the same conversation. Environment variables and environments you activated by hand in that session (a venv, for instance) do not come back either: the terminal reopens in the right folder, but it is a fresh shell.

AI assistant on the selection (Ctrl+K / Ctrl+I)

Default AI. At the top of Settings → AI Assistants, the Default AI chooses the assistant used by Ctrl+K/Ctrl+I, by the AI Chat chat (which you can change per session) and by the automatic tasks (rewrite the question, summarize, audio summary, generate context). It lists both the CLIs and the API providers. Audio transcription and embeddings have their own provider, and LightNote suggests a model based on the chosen provider.

Press Ctrl+K (Ask AI) or Ctrl+I (Edit with AI) in the editor — with or without a selection — to open a floating, inline-chat style popup: the prompt field comes pre-filled with the selection below a blank line; type the instruction above it and send with Ctrl+Enter. In the popup you pick the AI (the default one comes pre-selected) and the result mode: replace the selection through a diff (Original × Suggestion, with Accept / Copy / Reject) or just display the answer as text.

LightNote runs the AI CLI in "one-shot" mode (without opening a terminal). The CLIs and the default AI live in Settings → AI Assistants.

Models via API. Besides local CLIs, you can register LLM models via an OpenAI-compatible API (OpenAI, Groq, DeepSeek, OpenRouter, Gemini, Anthropic, local instances like Ollama/LM Studio…) under Settings → AI Assistants. Pick a provider from the catalog (base URL ready), paste the key (stored encoded only on this machine), use Fetch models… and Test. The registered models appear in the same Ctrl+K selector, alongside the CLIs.

Connecting in one step. The normal path is not filling in the table: under Settings → AI Assistants, click Connect an AI…, pick the provider (the list flags the ones that have a free plan and the ones that run on your computer, no key), follow the three steps, open the API keys page with the button and paste the key. LightNote fills in the address and the model on its own and tests the connection before saving — a wrong key shows up right there, not in the middle of a conversation. The list above shows what is already connected and, for whatever is incomplete, what is missing (“key not pasted yet”, “model not chosen yet”); a double click reopens the assistant on that provider.

Fine tuning. Address, model, MCP permission, CLI commands, audio transcription and embeddings are all still available under Advanced, at the end of the page — and inside the assistant itself, under Advanced options, you can change the base URL and the model before connecting. Nothing was removed: it just moved out of the way of someone starting out.

No AI yet? If you press Ctrl+K with no assistant connected, LightNote explains it and offers to connect one right there — and as soon as you do, the action you asked for goes ahead, with no need to press the shortcut again.

Local LLM (no API key). Local providers — Ollama, LM Studio, llama.cpp — need no API key: pick one under Add (the picker shows whether the server is running) and use Fetch models… to choose among the models you have pulled. If Ollama isn't installed, LightNote offers to install it for you. It comes pre-registered on the first run — you only pick the model. Because a local model can take much longer to answer (especially on the first generation, while the model loads), LightNote waits far longer for it than for a cloud service. None of your text leaves the machine.

Accept hunk by hunk. When the result comes as a diff, you don't have to take all of it: each changed block has a checkbox to include it or not, and the final text is rebuilt from just the blocks you keep. The prompt also carries automatic context from the file (path, language and the lines around the selection), so the AI answers more precisely without you pasting anything.

Prompt library. AI → Prompt library… keeps reusable prompts as .md files in a Prompts/ folder of your workspace — an open format, versionable in Git and part of your second brain. The picker offers search, a preview and a button to create a new prompt. When you pick one, the fields {selection}, {file}, {folder}, {name} and {language} are filled with the current editor context (your own variables are preserved), and the text is injected into the Ctrl+K field or sent to the active AI terminal, without submitting.

Not only in the code editor. The AI actions (Ctrl+K / Ctrl+I and the context menu) also work in the Markdown editor, in the embedded task note and in the database SQL query editor — in each one the popup opens over the cursor and applies the result in place.

All AI actions live in the AI menu (in the ☰ button and in the wand button of the activity bar): Ask AI (Ctrl+K), Edit with AI (Ctrl+I), AI sessions, AI Chat, Prompt library, Generate the project context file, Enable AI in this folder and Configure AI assistants.

AI sessions

AI → AI Sessions… opens a cockpit that lists, one card per session, every AI CLI terminal open in any LightNote window — with a coloured status dot, the CLI name, the window and badges for whatever needs attention (scheduled sends, isolated copy). Double-click focuses the terminal; the card's ⋯ menu (or right-click) offers Review that session's changes (opens the review screen with the base set to the checkpoint created when the session started — see Review changes) and Schedule a send. It's the way to keep an eye on several "vibe coding" sessions at once without getting lost between windows.

When you open an AI CLI as a terminal inside a Git repository, LightNote automatically saves a checkpoint (labelled "Session …"), so you can later see and revert exactly what that session changed. The feature can be turned off in Settings → General → Features.

Isolated copy (worktree): in Git folders, LightNote can run the AI assistant in an isolated copy of the folder (its own branch), without touching the files you edit by hand. The first time it asks; after that it is automatic (turn it on/off per folder in Workspace Settings → Integrations). An isolated copy badge marks the session (branch and path are in the tooltip), and the Merge… item (brings the changes into your folder — if you have pending changes it asks first) and Discard… (throws away the copy and the branch) handle the end of the cycle.

Idle-session notice. When an AI CLI goes idle (it finished or is waiting for you), LightNote shows a notification; clicking it opens the review of that session's changes. So you can start the task and step away. It can be turned off in Settings → Terminal.

Project context file. When you open an AI CLI in a folder without a context file (CLAUDE.md or AGENTS.md), LightNote offers to generate one — and you can do it anytime from Tools → Generate project context file…. A good context file describes the project's structure and conventions and helps the AI make fewer mistakes, without you re-explaining everything each session. If an AI provider is configured, it generates the content; otherwise you get a skeleton to fill in.

Hibernating idle sessions. An idle AI CLI keeps holding memory (the conversation and the model client). Under Settings → Terminal you can set a silence period after which LightNote ends the process and resumes it by itself when you return to that tab — the terminal history stays on screen. It ships on, at 30 minutes — three idle Claude Code sessions held over 1 GB when measured — and only applies to sessions in an isolated copy whose CLIs know how to resume the folder's conversation (today Claude Code and Antigravity), because otherwise resuming would bring back another session's conversation. A session with a scheduled send never hibernates. And what comes back is the conversation, not the tool's screen: text you typed but did not send is lost.

Activity tab. The table shows what is running now; the Activity tab keeps the history: every time an agent finished its turn, started in an isolated copy or hibernated, with the date and a snippet of the last reply. Unread entries appear in bold and the count also shows up in the tray menu — so whoever stepped away from the computer sees what they missed, since notifications are fleeting. Opening the tab marks everything as read; a double click takes you back to the session. The end of a session is recorded too — including when the CLI exits on its own — so a session that died while you were away leaves a trace instead of simply vanishing. If the event's session is no longer open, double-clicking says so instead of doing nothing.

AI Chat

AI → AI Chat… opens a chat that answers using your own notes as context. Instead of sending everything to the cloud, LightNote retrieves the most relevant snippets from your vault locally (via ripgrep, no embeddings and no external service), builds the question with those snippets and sends it to an API AI provider you have registered. The answer comes with the source notes as clickable citations — click to open the note. Great for "talking to your second brain" and finding what you already wrote down. The conversation history stays in memory only (it is not saved); the feature can be turned off in Settings → General → Features.

The window. The selectors sit in a single bar at the top: the AI, the notes folder and — when a text editor is active — the context; on the right are the two permissions (Tools and Allow changes) and the + button, which starts a new conversation. Before the first question the screen states what the window will answer about and offers one-click shortcuts such as Summarize this folder. In the question box, Enter sends and Shift+Enter breaks the line; while the answer is coming, the send button turns into Stop.

Letting the AI use tools. The Allow changes box changes how this works: instead of answering only from the excerpts the keyword search retrieved, the model can look things up itself — read a file, search notes, list tasks — and only then answer. When you turn it on, LightNote tests right away whether the chosen model can call tools: many providers accept the request and simply ignore the tools, which without that check would produce an invented answer that looks researched. The verdict is remembered for seven days per provider+model pair. Requires an API provider (a local CLI has no way to receive tools). The answer ends with the list of what was actually used, so you can judge it instead of trusting it. If the verdict is negative — the provider may simply have been down at that moment — a Check again button appears next to the message and redoes the test, ignoring what was cached.

Letting the AI change your things. The second box, Allow changes, is a separate step and starts off. With it, the AI can also create notes and tasks, change properties and write to today's note — but nothing happens without your confirmation: the change appears in the conversation in plain words ("create the task Buy bread"), with Allow and Deny. Denying does not end the conversation; the model is told and carries on, explaining or proposing something else. Reading never asks — only changing does. Overwriting arbitrary files and reaching the network are deliberately left out: while the AI only reads, hostile text arriving in a note synced from elsewhere has no way to become a change on your disk. When the change is an entry in the daily note, the request also says which folder it will land in — it is the only write whose target file is not part of what the AI asked for.

Notes or the open file. The Context: combo at the top of the window chooses what the conversation is about: Vault notes (the default, described below) or Current editor — which answers about the file open in the editor instead of the vault, using the selection and the surrounding lines (or the whole file, with the Whole file checkbox). So the same chat serves to talk about your notes and about the code you are editing, over several turns. The Current editor scope appears only when a text editor is active. And in the quick assistant (Ctrl+K), the result has a Continue in chat → button that reopens this window already in the Current editor scope, seeded with that round’s question and answer — to dig deeper without starting over.

Which notes? The window is a single one and answers about one folder at a time — the Notes from: combo, next to the AI selector in the top bar, shows and picks which. It opens already pointed at the folder of the window you opened the chat from, and lists the folders open right now, followed by the recent ones; Choose folder… points to any other. Switching folders applies to the next questions — including asking one project's notes while you work in another. Once picked by hand, that folder stays until you change it again (reopening the window does not pull the scope back). While a question is in progress — including while it waits for your confirmation — the AI, context and folder selectors are locked: the answer on its way belongs to the model and the folder you had when you asked.

How to ask. Retrieval is by subject, not by instruction: LightNote takes the words from your question and looks for notes that contain them. Name a topic that appears in the notes ("what did I note about Postgres?") instead of a generic request ("summarize this") — the latter has no content word to search for, so nothing is retrieved and the chat warns that the answer did not use your notes. Only .md/.markdown notes are read; in a folder without any, the chat says so and does not spend an AI call.

Better search, summary and rewrite. Retrieval uses a local index with BM25 ranking that ignores accents ("configuração" finds "configuracao") and also works in languages without spaces between words (Japanese, Chinese, Korean) — ripgrep is the fallback while the index is still being built. The Summarize this folder button produces an overview of all your notes when you don't have a specific question. And in Settings → General → Features, the Rewrite the question with AI option expands your question into keywords before searching (it costs one API call per question).

Just one key. On first run, LightNote already registers OpenAI, Google Gemini and Anthropic (Claude) under Settings → AI Assistants — you only need to paste your API key into the provider you use. If no provider has a key, the window shows a Configure now button that opens that screen directly.

Conversations are kept. The clock button at the top opens the list of previous conversations for that folder: click one to go back to it. New conversation archives the current one instead of deleting it, and right-clicking an entry deletes it for good (with confirmation). Conversations are stored per folder — switching the notes folder switches the list.

What to do with an answer. Under each answer there is Copy (puts the Markdown text on the clipboard, formatting intact) and Capture to note (sends the answer to today's note, along with links to the cited notes). The Conversation actions menu holds Copy conversation, Save conversation as note… (writes a .md in the queried folder), Regenerate last answer and Edit last question.

Attaching a file. When the search does not find what you had in mind, use the + button to attach a file: it always goes into the question, outside the search ranking. Notes, code, text and PDF all work (PDF text is extracted); a binary file is refused right away instead of becoming noise in the context. The attachment shows up as a pill (click it to detach) and is dropped when you start a new conversation. With providers that support it, the answer also appears gradually, as the model writes.

Test HTTP APIs (.lnh)

Tools → New API Test (.lnh)… opens an HTTP client saved to a .lnh file. One file represents an endpoint (method, URL, headers and body) and keeps several tests in the list on the left — each test with its values for the {name} variables used in the URL, headers and body, plus the result of the last run (status, time, date, response headers and body). It also shows the equivalent curl command. The same one-off operation is available via CLI (http) and MCP (http_request).

Ctrl+Enter sends the request.

Importing and exporting OpenAPI. The arrows button at the top of the test list opens Import OpenAPI… and Export OpenAPI…. The import reads a specification in YAML or JSON across the three generations in use — Swagger 2.0, OpenAPI 3.0 and 3.1 — and builds the test on its own: the path {parameters} already use the same syntax as the {name} variables of the .lnh, the declared examples become the test values, the security scheme becomes the Authorization header, and each declared server becomes a test of its own (staging and production side by side). Since a .lnh holds one endpoint, a specification with several operations asks which one to import — or writes all of them at once, one .lnh file per operation.

The export goes the other way and produces an OpenAPI 3.0.3 specification from the file: servers, parameters and body come from the template, and the example responses come from the recorded runs. It is a skeleton, not a full contract — the .lnh describes calls, so types, descriptions and schemas are not reconstructed. Your tests travel in the x-lightnote-tests field, which is why they come back intact when you re-import the file.

Importing a curl command. In the same button, Import curl command… opens a paste box — that is where the command comes from, not from disk, and the field is pre-filled when there is a curl on the clipboard. It understands the three dialects the same command travels in: Copy as cURL from Chrome/Firefox (single quotes), Copy as cURL (cmd) on Windows (with ^) and the documentation example broken with \. The method comes from -X — or is inferred: POST when there is a body, GET when there is not.

The import is literal: no value turns into a {name} variable on its own, because guessing which token is a secret would get it wrong. A few cases warn instead of lying — a body coming from a file (-d @file) cannot be read, and a multipart upload (-F) is not faithfully reproduced, so the fields go into the body as text for you to adjust.

Databases (.lnc)

A connection is a .lnc file (LightNote Connection) inside the workspace itself — versionable in Git and portable between machines. Create one via New → New connection (or open an existing .lnc): this opens the Database view, with the connection status bar (Connect / Disconnect / Reconnect / Edit), the Schema tree (schemas → tables → columns, loaded on demand) and internal .sql tabs. The opened .sql files and the recent ones are stored inside the .lnc, so the view reopens in its previous state. If nothing was open, it starts with an empty (untitled) query where you can type SQL right away; on save (Ctrl+S) LightNote asks only for a name and writes the file inside the project folder (no "save anywhere" dialog). The + Tab button opens a new empty query, lets you open a file (the picker opens at the project folder) or pick a recent / any .sql from the project folder.

A .sql opened straight from the tree is code only (SQL highlighting, no connection).

Drivers: SQLite and DuckDB (file) native; PostgreSQL, MySQL/MariaDB, SQL Server and generic via ODBC; native Oracle (no ODBC). SQL Server uses Microsoft's msodbcsql driver (install it on the machine) and offers Windows Authentication or user/password, plus the channel encryption options (Encrypt / trust the certificate). For Oracle, set the Oracle Instant Client folder in General Settings → Database — it is loaded at runtime, with nothing to install. The Oracle connection has four modes: Service Name (host/port/service), SID (host/port/SID), TNS Name (alias from the tnsnames.ora in the client folder) and Full TNS descriptor (pasted into a text field).

Password: check Store password to encrypt it inside the .lnc itself (portable crypto, opens on another machine); unchecked, the password is not saved and is asked on every connection. Encryption uses a per-workspace Passphrase, set in Help → Configure Passphrase; keep it safe — without it the password cannot be opened anywhere else. The Passphrase is cached only on the local machine (it never goes to Git).

Check Connect on open to have the connection open automatically when you open the .lnc. Auto-connect is silent: if the password must be typed (ask mode, or encrypted without the Passphrase cached on the machine), the file opens disconnected, without interrupting.

Run: Ctrl+Enter runs the statement under the cursor and Alt+X runs the whole script; results appear paginated, each in a Result tab with an action bar at the bottom: Fetch next block or all rows, Total count, change the row Limit, Refresh (re-runs), View/Copy SQL, Export... and Generate SQL from the selected row.

Result grid: a NULL is shown in faded italics, distinct from an empty string, and numbers are right-aligned; when you select several cells, the footer shows the selection count and, when they are numeric, their sum and average. The Value panel button in the footer bar (or Show value in panel from the context menu) opens a side panel with the full value of the selected cell, uncut, with a Format button that pretty-prints JSON/XML for display only. In a cell's context menu, Filter by this value / Exclude this value re-run the query with a WHERE on the cell, and Go to referenced record follows the column's foreign key and queries the parent table by the cell's value.

Execution plan: the Execution plan toolbar button shows the EXPLAIN of the statement under the cursor (SQLite, DuckDB, PostgreSQL and MySQL); on databases that do not expose the plan in a single statement (SQL Server, Oracle) the button is disabled, with the reason in its tooltip.

Object properties: double-click a table in the schema tree (or press F4, or choose Properties from the context menu) to open a tab with the object's structure, in four sub-tabs: Columns (#, name, type, nullability, default, and a key icon on primary-key columns), Keys (primary, foreign, unique and check constraints; double-clicking a foreign key opens the referenced table), Indexes and DDL — the object's CREATE TABLE, ready to copy, save as .sql or open in an editable tab. When the database does not provide ready-made DDL (PostgreSQL and SQL Server have no such command), LightNote reconstructs it from the metadata — the same happens when the DDL command is denied for lack of permission — and says so clearly in the tab. If not even the column catalog can be read (no permission, or the catalog is unavailable), there is nothing to reconstruct from: the tab says so instead of sitting silently empty. The table's context menu also offers Copy DDL without opening the tab.

Schema tree: the Schema tree separates Tables from Views (each with its own icon) and marks primary-key columns with a key icon. The filter box sifts only the objects already loaded (lazy loading is not forced just to filter).

Exploring the schema: Right-click a table to Insert SELECT into the editor, Preview data, Count rows, Copy qualified name or open the Generate SQL submenu → INSERT/UPDATE/MERGE: a screen lists the table's columns so you can check Include and Key, shows a live preview and drops the command into the editor (MERGE comes out in ANSI; if the driver does not support it, a warning appears). Right on the results grid, the Generate SQL button on the bottom bar builds an INSERT/UPDATE/DELETE pre-filled with the values of the selected row (available when the query is a single-table SELECT). The table and column names you browse in the tree also start showing up in the autocomplete (Ctrl+Space) of the connection's .sql editors, with no extra database queries.

Export results: right-click the results grid and choose Export results... to write CSV (delimiter, quote character, always quote, header row, NULL text), JSON Lines or SQL (INSERT statements with a table name), with an optional row limit. The export walks the whole query in streaming mode (paginated re-fetch), not just what is visible on screen.

Script variables: use @set name = value on a script line to define a variable — the @ prefix keeps it away from the database (it does not collide with the real SET of Postgres/DuckDB/SQL Server). References like :name are substituted before running (outside strings and comments; the ::type cast and binds like :1 stay intact); a :name without a value opens a prompt before running. The Variables button on the toolbar opens the screen with the defined variables (edit/add/remove).

Query history: the History button opens a window with the last statements successfully executed on this connection, in SQL / When / Duration / Rows columns. Select one to Re-run, Insert into editor or Copy (double-click inserts), or use Clear history. It is stored only on the local machine (it goes neither to Git nor to the .lnc).

Transactions: the Autocommit button (on by default) and the Commit/Rollback buttons live on the toolbar. With autocommit off, changes stay pending until you confirm (Commit) or discard (Rollback); disconnecting with an open transaction asks what to do.

SSH connection (.lns)

An SSH connection is a .lns file in the workspace — versionable and portable, like the .lnc. Create one via New → New SSH connection: the tab opens an integrated SSH terminal (through Windows' ssh.exe) and a remote files mini-bar (SFTP).

The file browser shows one folder at a time (MobaXterm/WinSCP style): the first row is always .. to go up one level, and double-clicking a folder enters it. The path bar at the top lets you type a remote path and press Enter to jump there. The Sync with terminal button makes the shown folder follow the SSH session's current directory (wherever you cd'd in the terminal). The right-click menu offers Open in editor (downloads the file, opens it in a tab and re-uploads on save), Download, Upload, New folder, Rename, Delete and Permissions (chmod). You can also drag files from Explorer onto the panel to upload them to the current folder.

The password can be encrypted inside the .lns with the workspace's Passphrase or asked on every connection. SSH keys from the Windows agent/profile work normally, since the connection uses the system's OpenSSH client.

The Connect on open option (in the connection dialog) starts the SSH session automatically when you open the .lns. If the password is not stored, the terminal itself asks for it on connect.

Security: Passphrase, PIN and Secure Markdown

The Passphrase is set per workspace in Help → Configure Passphrase… and is the key to everything LightNote encrypts: connection passwords (.lnc/.lns), password cells of the Custom table and .lne files. The encryption is strong and portable (Argon2id + XChaCha20-Poly1305): an encrypted file opens on another machine once you re-enter the same Passphrase there. Keep it safe: without it, the encrypted data cannot be recovered. The Passphrase is cached only on the local machine (it never goes to Git).

To change the Passphrase, open the same screen and edit the Passphrase field (it comes filled with the current one). On confirm, LightNote automatically re-encrypts all the workspace's secure data — passwords in .lnc/.lns, the contents of .lne files and the password cells of Custom tables (.lnd) — from the old Passphrase to the new one. Decryption is all or nothing: if a single item fails to decrypt, nothing is changed and LightNote tells you which one. During writing, each file is copied to a backup before being rewritten; if one fails to write, LightNote asks whether to undo everything (restore the backups) or skip that file and continue (it keeps the old Phrase, with a warning at the end). (Passwords in "ask" mode have nothing to re-encrypt.)

The PIN (4–8 digits) is an optional local lock: it guards sensitive UI actions (revealing passwords, opening secure notes) without typing the Passphrase every time. It encrypts nothing and applies only to this machine.

The Secure Markdown file (.lne, under New → Secure Markdown File) is a note encrypted on disk: on open, LightNote asks for the PIN (if set) and the Passphrase, decrypts in memory only and re-encrypts on save (Ctrl+S). For safety, it never reopens by itself when the session is restored.

Daily notes, quick capture and tray

Today's note is one .md per day in the Daily Notes folder — a single folder for all of LightNote, set in Settings → Notes & writing. From the tray menu: Today's note opens the note for the day; Quick capture… (Ctrl+Alt+N, a global Windows shortcut — or middle-click the tray icon) opens a small window where you type and press Ctrl+Enter: the text becomes a timestamped bullet in today's note, written straight to disk, without opening an editor window.

The tray menu also lists the open windows and the recent workspaces, and carries the power toggles: Keep computer awake and Keep screen on (handy for long tasks; LightNote already holds power by itself while running one-shot AI, Blocks cells or SQL scripts). The launcher (start window) has search, double-click to open, and a context menu to pin to top, open in Explorer or remove from the list.

Actions that apply to the whole of LightNote — not just to the window you are in — live in the General menu (☰ General, or the button with the app icon in the activity bar), which has exactly the same shape as the tray menu: at the root Today's note, Quick capture and Calendar; then the submenus Capture (quick task, record audio, resurface old notes, sticky notes), Open (launcher, open workspace, open standalone file, standalone files) and Power; and at the end General settings. The rule is simple: whatever is in the tray menu is in the General menu — and only there. Hovering an item shows the note “general feature: applies to the whole of LightNote, in any window”.

Where a capture goes. Daily notes and quick tasks have a single, predictable destination: the folder set in Settings → Notes & writing and the board set in Settings → General, valid in any window. On the first capture, if nothing is set, LightNote asks where to keep it and stores your answer — instead of sending you off to find the setting. A project that needs its own diary (a client under confidentiality, a log that must live in the repository) can claim the captures made in that window under Workspace Settings → Captures; the tray and the global shortcuts keep writing to the general destination. The confirmation always names where the text went.

The tray menu is deliberately short: the root holds the open windows and the three everyday actions — Today's note, Quick capture and Calendar. Everything else lives in the same submenus as the General menu: Capture, Open (which in the tray also carries the list of recent workspaces), AI (AI sessions and ask your notes — in a window that is the full AI menu) and Power. Settings and quit close the menu.

Resurface old notes

What makes a "second brain" fail most is not a missing feature — it is the note that is never re-read. From the tray menu (the Capture section), LightNote brings old notes back: Random note opens a random .md note from the workspace (avoiding the ones shown in the last two weeks), and On this day lists the notes whose creation anniversary is today (same day and month, in earlier years). Both actions are also in the window's General → Capture menu.

The creation date comes from the frontmatter created/date field, if present; otherwise from the file date. The feature never writes to your notes — it only opens them. It can be turned off in Settings → Features (“Resurface old notes”).

Your notes on your phone

Your workspace is plain Markdown in a folder — open formats, with no proprietary database or mandatory cloud. That's why any phone app reads and edits your notes, without LightNote needing an app of its own for the phone: just sync the folder with a file service and open it in a Markdown editor on your phone.

Step by step: sync the workspace folder with OneDrive, Google Drive, Dropbox or Syncthing and, on the phone, open that folder in a Markdown editor (for example Obsidian Mobile, iA Writer, GitJournal or Markor). Since everything is .md in text, both sides see and write the same notes.

Recommendations: on the phone, edit only .md files — LightNote's own types (secure .lne, .lnc, .lnt, .lnb, .lnd…) don't open outside the app, and .lne in particular is encrypted. If both sides edit offline and a conflict arises, resolve it through the Inbox folder: drop the capture (text, audio or photo) there and let LightNote merge it into the day's note, instead of overwriting. The positioning is deliberate — syncing is by files/Git, not by plugins: you own your data and choose the transport. To write straight into today's note, edit the file Daily Notes/yyyy-mm-dd.md — the folder name changes with the language.

Record audio (voice, meeting) with AI transcription

From the tray menu, Record audio… opens a floating, draggable window (drag it by the title bar) to record from the microphone, the system audio (what plays on the computer), or both at once — the chosen source is remembered for next time. Use ● Record, ‖ Pause and ■ Stop; the file goes to the Recordings folder of the workspace, compressed to .m4a when you stop.

Two ways to transcribe. In Settings → AI Assistants → Audio transcription, the How to transcribe selector chooses between the dedicated transcription model (Whisper-style: OpenAI whisper-1, Groq whisper-large-v3 — free — or a local Whisper) and the general model with audio in the chat — the audio goes inside a multimodal model's conversation, which is how Google Gemini (gemini-2.0-flash, good free tier) transcribes. Switching the provider pre-selects the right mode and suggests the model; long audio is sliced automatically in either mode. The suggested model can be overridden by hand — LightNote honors the id you type, even for a provider it doesn't yet recognize.

Once recording starts, the window collapses on its own into a compact pill (a blinking red dot, a timer, Pause/Stop) — easy to drag into a corner and keep almost out of sight during a long meeting; the minimize/expand button in the title bar toggles it manually, and stopping expands it back. Ctrl+Alt+R (global shortcut) is the quick voice note: press it to start recording from the microphone right away, press again to stop — no need to open the window with the mouse.

If an API-based AI provider is configured (in Settings → AI Assistants → Audio transcription), the Transcribe and Transcribe + Summarize buttons appear when you stop (disabled while the audio is still being compressed); the On stop combo can fire the transcription on its own as soon as the recording finishes. LightNote sends the audio for transcription (a Whisper-style model) and writes a .md note next to the audio with the text and, optionally, a summary. Turn the feature on/off in Settings → General → Features.

The same window is a mini-player: below the controls, a list of recordings in the folder shows each file with T (open the transcription) and R (open the summary) buttons when they exist, plus a ▶ to play right there (progress bar with seeking); each row's ⋮ menu plays, (re)transcribes or opens the note. Regenerating a transcription does not overwrite the previous one — it creates a new version alongside (note.md, note (2).md…), preserving the history. The capture source is a menu button (Microphone / System audio / Both), with Both as the default. The Open recordings folder link opens the folder in the main window.

Sticky notes

Sticky notes are small colored plain-text boxes that float over the desktop, in the style of the Windows Sticky Notes app. From the tray menu: New sticky note (Ctrl+Alt+S, a global shortcut) creates a box; Show sticky notes (Ctrl+Alt+H) shows or hides them all at once. Each note has a + to create another and a ☰ menu to change the color, Send to today's note (writes the text as a bullet in today's note and discards the box) or Delete. Drag the header to move and the corner grip to resize. Notes are saved automatically and reappear when you reopen LightNote.

Calendar

General → Calendar… opens a single window with a calendar that marks the days holding tasks from every registered .lnt board. Next to it, the Of the day list (tasks for the selected day) and the Pending list; the Day's note button opens the daily note for that date. Clicking a task opens the corresponding board.

In the grid, each day with tasks gets colored dots in the colors of the Kanban statuses (up to three), today is marked with a ring and the selected day with a filled circle; Today returns to the current month, and the month name opens a menu to jump by month or year. Pending items are grouped by situation — Overdue, Today, Next 7 days, Later and No date —, with the due date shown as a relative badge (“yesterday”, “today”, “3 days ago”). Double-clicking a day opens the quick task already dated.

Command palette

Ctrl+Shift+P opens the command palette (every action with its shortcut, filterable by typing). Ctrl+P opens the quick file picker and Ctrl+Shift+K opens the task picker.

MCP server (AI agents)

LightNote includes a headless MCP (Model Context Protocol) server that turns your workspace into a tool for AI agents (Claude Desktop, Claude Code, Cursor, and any MCP-speaking client). The agent can read and write files, search, query tabular data and databases, work with the tasks, use Git and fire HTTP requests — everything confined to the folder (directory jail: paths with .. or outside the root are refused). The transport is JSON-RPC 2.0 over stdin/stdout; each session spins up a lightweight lnote.exe process, separate from the editor window.

One-click shortcut: AI → Enable AI in this folder turns on MCP and writes the .mcp.json in one go (the click is the consent). If AI is already active in the folder, the item becomes Configure AI in this folder… and opens Workspace settings.

Two layers of safety: (1) the server only starts if you have opted in for that folder; (2) every tool is locked to the workspace root. On top of that, each tool is announced with annotations (read-only, destructive, idempotent, "touches the outside world") so the AI client can assess the risk before calling it.

Step-by-step setup

  1. Enable MCP for the folder. In Tools → Workspace Settings, check Enable MCP for this workspace. Without this opt-in the server refuses to start (it's the main gate). Alternatively, from the command line: lnote --mcp-enable "C:\Path\to\workspace" (and --mcp-disable to turn it off).
  2. Find the path to lnote.exe. It lives in the same folder as lightnote.exe (the app's install folder). It's the "slim" console executable, no UI — this is what the agent runs.
  3. Register the server in your AI client, pointing the command at lnote.exe and passing --mcp followed by the workspace folder. In the format used by Claude Desktop / Cursor and the like:
{
  "mcpServers": {
    "lightnote": {
      "command": "C:\\Path\\to\\lnote.exe",
      "args": ["--mcp", "C:\\Path\\to\\workspace"]
    }
  }
}

Configuration tips:

  • Backslashes in JSON must be doubled (C:\\Users\\...\\lnote.exe), as in the example.
  • To expose several workspaces, add one entry per folder, with distinct names ("lightnote-projectA", "lightnote-projectB"), each pointing at its own root.
  • After saving the configuration, restart the AI client so it starts the server. Once connected, the agent should list the lightnote_* tools; ask it to "list the workspace files" to confirm it works.
  • For Claude Code (CLI), the same server can be registered with claude mcp add lightnote -- "C:\Path\to\lnote.exe" --mcp "C:\Path\to\workspace".

Database password (optional). The db_query tool opens a .lnc connection. If the password is encrypted with the Passphrase, pass the phrase via the LNOTE_PASSPHRASE environment variable in the server block (never in command-line arguments) — connections whose password is in "ask" mode can't be used unattended.

AI queries are opt-in per connection. Enabling MCP in the folder does not expose the connections: each .lnc only answers db_query when “Allow AI queries (MCP)” is checked in the connection dialog. Access is read-only (SELECT).

Exporting from the database via the agent. Besides querying, the agent can materialize a SELECT into a file with db_export (Parquet, CSV, JSON or .xlsx) — useful for results too large to fit in a reply. The same three safeguards apply, in this order: the query must be read-only, the connection needs the «Allow AI queries (MCP)» opt-in (checked before the password is decrypted), and the destination must stay inside the workspace. Large exports use the system temp folder as scratch space, roughly the size of the result — keep disk space free.

Available tools

The agent sees the tools under the client's prefix (e.g. lightnote_read_file). By category:

  • Files: read_file (with optional line range), write_file, edit_file (replaces an exact snippet, without rewriting the whole file), append_file, list_files, move_file, make_dir and delete_file (goes to the Recycle Bin, not a hard delete).
  • Search and navigation: search_files (ripgrep, with subfolder/glob filter and limit), list_symbols (outline of a file's functions/classes) and open_in_editor (opens/focuses a file in the LightNote window, if it's open).
  • Data and SQL: query (DuckDB SQL over Parquet/CSV/JSON, tsv/json/markdown output), describe_table (schema + statistics, without dumping rows), export_query (materializes a SELECT into a file via COPY), sqlite_query (SQL on a .sqlite/.db), db_list_connections (lists the workspace's .lnc files) and db_query (read-only SQL on a .lnc connection). To send the result to a file instead of the reply, db_export (Parquet/CSV/JSON/.xlsx).
  • Also: search_notes (retrieves the most relevant note snippets for a question — the same engine as AI Chat), list_links (a note's outgoing links, resolved or broken), audit_vault_links (broken links and orphan notes across the vault), list_note_templates and the template parameter of create_note, list_due_tasks (tasks due today or overdue across all projects), xlsx_read (reads an .xlsx sheet as TSV), data_diff (compares two tabular files) and the database catalog db_list_objects/db_describe (tables/views and a table's columns, keys and DDL — same requirements as db_query).
  • Archives: zip_list (lists the members of a .zip/.isx) and zip_read (reads a member as text) — without extracting the archive to disk.
  • Tasks: list_task_projects (lists the workspace's .lnt task projects), list_tasks, list_task_statuses (board columns), create_task, update_task, update_task_status (move between columns), delete_task and task_note (read/write the task's .md note). A workspace may hold several .lnt projects: pick one with the project parameter (the name returned by list_task_projects; optional when there is only one). The id/status_id are session identifiers — do not read the internal .lnt files to obtain them; use the task tools.
  • Notes (PKM): create_note (create a .md note), append_daily_note (append a capture to today's note), list_backlinks (notes pointing to a note), list_note_tags and search_by_tag (the vault #hashtags and the notes using them) and add_task (create a task with due date/tags, accepting natural language in the title).
  • Git: git_status, git_log, git_diff and git_restore.
  • Web and alerts: http_request (fires an HTTP request and returns status/headers/body) and notify (shows a tray notification on the open window — handy for the agent to signal it's done).
  • AI proxy: list_ai_models and ask_ai (below).

The server also exposes the workspace files as MCP resources (resources/list and resources/read), for clients that prefer to "attach" files instead of calling read_file.

Your Prompt library (the workspace's Prompts/ folder) is exposed as MCP prompts (prompts/list and prompts/get). In Claude Code each prompt becomes a slash command — /mcp__lightnote__<name> — ready to use inside the AI CLI.

Write safety net. Before overwriting (write_file/edit_file) or removing (delete_file) a file, the server saves the previous version to the Local History — the editor's own safety net — so you can undo a change made by an agent even outside a Git repository.

Each tool declares whether it reads or writes: besides the MCP annotations (readOnlyHint/destructiveHint), the description starts with a [read-only], [writes] or [destructive] badge — handy for building allowlists safely.

AI proxy (delegate to another model)

The API providers you registered with the MCP column checked are exposed to the agent through two tools: list_ai_models (lists the allowed models, with id, name and model) and ask_ai ({model, prompt}). This lets the main agent delegate a sub-task to a cheaper or specialized model. The call is brokered by the running LightNote (the MCP's lnote.exe forwards the request to the app window over the internal bridge): the API key never leaves your machine and never reaches the agent. If LightNote isn't open, the tool returns an error asking you to open it.

Command line (lnote)

The same MCP operations live in a console executable, lnote, for scripts and automation (also reachable as lightnote cli <command>). Every action is confined to the root folder, set by --root (default: the current folder).

Examples:

lnote list --recursive
lnote read --path src/main.cpp --start-line 1 --end-line 40
lnote write --path note.md --content "Hello"
echo content | lnote write --path note.md --content -
lnote search --query TODO --regex
lnote query --sql "SELECT * FROM read_parquet('data.parquet') LIMIT 10"
lnote describe --path data.parquet
lnote search-notes --query "where did I write about the budget"
lnote audit-links
lnote xlsx-read --path spreadsheet.xlsx --sheet 0
lnote data-diff --a before.parquet --b after.parquet --mode changed --keys id
lnote db-describe --connection data.lnc --table customers
lnote db-export --connection dados.lnc --sql "SELECT * FROM clientes" --out clientes.parquet
lnote due-tasks
lnote export --sql "SELECT * FROM read_csv_auto('e.csv') WHERE state='NY'" --out ny.parquet
lnote zip-list --path export.isx
lnote zip-read --path export.isx --entry job/definition.xml
lnote task-projects
lnote tasks --project Backlog
lnote create-task --project Backlog --title "Review the text" --effort 2
lnote move-task --project Backlog --task-id 5 --status-id 2
lnote git-status
lnote http --url https://api.example.com --method GET
lnote notify --message "Processing finished"

Global options: --root <folder>, --json (structured {ok,data,error} output), --help (or lnote <command> --help) and --version. Unknown commands get a suggestion ("did you mean…?").

Bulk-update older data: lnote upgrade <folder> modernizes files written by earlier LightNote versions in one pass — currently the legacy .lnsh and .lnsm extensions, which became .lns and .lne. The app already does this on its own when you open each file; the command is for when you have dozens and don't want to open them one by one. Use --dry-run to preview what would change without touching anything. It is a convenience, not a requirement: your older files keep opening fine without it.

Settings and themes

In Tools → General Settings you adjust, in sections: General options (language, autosave, release idle tabs, tab color palette, window title, daily notes, spell checking), the application Theme, the Editor font and colors, the Markdown style, Execution (interpreters), the Terminal (shells), the AI Assistants (CLIs and the default AI), Versioning and the Database (pagination, Oracle Instant Client).

A search field at the top of the section list filters by the options on each page; and the Features section gathers the toggles for the optional features — connections graph, sticky notes, AI sessions, AI Chat, audio recording, resurface old notes, keep the computer awake and Windows Explorer menu integration. Turning a feature off removes it from the interface, the tray and the shortcuts, and stops consuming resources — but keeps the data already created; the change takes effect on restart.

The application theme changes the program's appearance (menus, tabs, panels, status bar). There are several ready-made themes — light ones (Light, Solarized Light, Catppuccin Latte, Gruvbox Light, One Light, Rosé Pine Dawn) and dark ones (Dark, Tokyo Night, Dracula, Ayu Mirage, Nord, Gruvbox Dark) — plus the Custom mode with an accent color. New themes arrive through the online catalog, without having to update the application.

The code Editor and Markdown colors are chosen separately, in their own sections, independent of the application theme. Each one has a Theme: combo with ready-made color schemes (Default, Dracula, One, Nord, Gruvbox and Tokyo Night, in light and dark variants), a live preview and a Save as… button to store your own colors as a reusable preset.

Per-window theme. Each folder (workspace) can have its own theme, so you can keep two windows open with different looks at the same time. In Workspace Settings → Appearance of this folder there are combos for the theme for this window (the application's look), the code theme and the Markdown theme — each with a Follow general theme/Keep default option to leave it unchanged. Overriding the code and Markdown themes is handy to match the editor colors to a dark theme in that folder only, without touching the general Settings. These choices stay on your machine (they are not committed to Git).

Install guide. When you pick a catalog tool (AI assistant, interpreter, formatter, linter or database driver) that is not on your computer yet — or you try to run/format/lint a file whose interpreter is missing — LightNote opens an install guide. When a safe command exists (via winget), the guide shows the exact command and runs it in an embedded console with one click; if the tool depends on another (for example, a CLI that needs Node.js), it offers to install the prerequisite first. Without an automatic installer, the guide opens the official download page with step-by-step instructions. When it finishes, it verifies the install and makes the tool ready to use, without restarting the app.

Formatting and Linters have their own sections (external formatter/linter per language, with Add from a catalog). To carry your preferences to another machine, the Settings migration group (General section) has Export/Import settings (a .lnconf file): the general options and content themes go, but not the API keys or local paths (re-enter those on the target).

The window title is a free-form template: the app name always comes at the end and you compose the rest with the variables {workspace} (workspace root folder), {file} (open file name) and {path} (full path). Decorations around an empty variable (e.g. the brackets in [ {workspace} ]) disappear on their own; leave the field blank for the default [ {workspace} ] {file} — .

Window layout. Under View → Window layout (or General settings → General → Window layout) you pick one of three presets — Modern (the default), Classic and Comfortable — or adjust each option on its own: show the menu bar at the top (with it on the ☰ button disappears, since both open the same menus), show labels next to the icons, put the toolbar and the sidebar on the left or on the right, and the icon size. Choosing a preset only fills in the options: changing any of them afterwards undoes nothing, the list simply starts showing "(custom)". The change takes effect right away, in every open window.

Keyboard shortcuts

  • F1 — this help (at the current screen's section)
  • Ctrl+N / Ctrl+O — new file / open file
  • Ctrl+S / Ctrl+W — save / close tab
  • Ctrl+Alt+Shift+S — save all (every modified tab)
  • Ctrl+F / Ctrl+H — find / replace in the file
  • Ctrl+Shift+F — global search (ripgrep)
  • Ctrl+Shift+G — versioning panel (Git)
  • Ctrl+Shift+E / Ctrl+Shift+M — Explorer panel / Pending items panel
  • Ctrl+B — show/hide the sidebar
  • Ctrl+' — terminal (on the US layout, also Ctrl+`)
  • Ctrl+/ — comment/uncomment; Ctrl+Shift+D — duplicate line
  • F5 — run file; Ctrl+Shift+Enter — send selection to the terminal
  • Ctrl+K / Ctrl+I — ask AI / edit with AI
  • Ctrl+B / Ctrl+I / Ctrl+E — in a Markdown note: bold / italic / toggle the view mode
  • Ctrl+Enter — “run here”: SQL statement, Blocks cell, API request
  • Ctrl+Shift+R / F4 — macro: record / replay
  • Ctrl+P — go to file; Ctrl+Shift+P — command palette
  • Ctrl+Shift+K — go to task; Ctrl+Shift+T — reopen closed tab
  • Ctrl+Alt+G — connections graph
  • Ctrl+Alt+N — quick capture (global, even outside LightNote)
  • Ctrl+Alt+D / Ctrl+Alt+T — today's note / quick task
  • Ctrl+Alt+R — record/stop audio (global, quick voice note)
  • F11 — Zen mode (the tab takes over the whole window)
  • Ctrl++ / Ctrl+- / Ctrl+0 — zoom

The full, filterable list lives in Help → Keyboard Shortcuts.

License, editions and community

LightNote ships in editions with the same features, differing only in licensing and delivery:

  • LightNote (free, from the website): for personal, non-commercial use.
  • LightNote Core (Microsoft Store): acquired as a contribution to the project; grants a commercial-use license and receives automatic updates through the Store.
  • LightNote Business (future): volume/enterprise licensing, reserved for future availability.

Your copy's edition — and therefore which clauses apply — is shown in Help → About. The full terms are in Help → About → License terms….

Join in and contribute:

  • Suggestions and questions: GitHub Discussions — github.com/nglczr/LightNote-Community/discussions
  • Found a bug? Report it on GitHub Issues — github.com/nglczr/LightNote-Community/issues
  • Support development on Ko-fi — ko-fi.com/lightnote (or get LightNote Core on the Store)
  • Contact: contato@lightnote.com.br · Website: lightnote.com.br