The file.

Where it is

Each notepad is a folder holding log.md under the Notada folder, iCloud Drive › Notada when iCloud Drive is on and ~/Documents/Notada/ when it is not, and takes the folder’s name; the first is Notes. Plain UTF-8 text. Once an image has been pasted, an attachments/ folder sits beside the log. Nothing else: no index, no database, no hidden metadata, and nothing about your notes anywhere but in them. The trial date, the license, the usage-data switch, and the command line’s counts of its calls live under Application Support, never in the folder.

Days

A day is a heading with a date: ## 2026-09-11, two hashes, a space, the date as year-month-day, and nothing else on the line. Every line below it belongs to that day until the next heading. Days run oldest to newest; new lines go at the bottom. A heading that is not a date is prose. Lines above the first heading belong to no day; for their age the app uses the file’s creation date.

The app writes a heading in exactly one case: before the first line written on a new day, under everything else. It never writes one because time passed or because the file changed, and a day begins at 04:00, not midnight, so a note at one in the morning still belongs to the evening’s meeting.

Items

An item is a line that starts, in the first column, with a dash, a space, and a marker in square brackets, then one space, then its text. Five markers:

The marker is one character, so - [ ] has one space inside the brackets, and - [X] counts as done. A line indented before the dash is a bullet in prose, not an item; so is * [ ] or a marker the app does not know. An item with no text is an item in the file and nothing in the list: it appears the moment it has a word.

A line indented with a tab, or with two spaces or more, directly under an item is that item’s details: the context, a link, a nested list, one line or many, until the first line that is not indented. The app shows them indented and muted, with a thin line beside them; the list shows the item’s own line and the details when you hover it, and notada and the assistant’s tools carry them as details. In the app, Return after an item leaves an empty todo under it, and Return again on that empty todo starts the details; so do ⇧↩, Item › Add Details, and Details in the palette. A line under an item that is not indented is prose, as it is anywhere; an indented line anywhere else is set the same way and belongs to no item.

Dates on a line

Two words carry a date: due:2026-09-18 and done:2026-09-11, the word, a colon, and the date as year-month-day, with no space. They go at the end of the line, after the text, in the order written; the app reads them wherever they stand and moves them to the end the next time you type on the line. A first due: or done: on a line counts; a later one with a date is ignored: it stays in the file and drops out of the item’s text in the list. A due: with anything but a full date, due:fri, is text too: the short forms are what you type in the app or give to notada append, and both write the full date to the file.

done: is what the app stamps when an item is closed, dropped, or answered; on a question it is what says the question is settled. On an open todo it is a stray word. Three more prefixes are reserved and not read yet: @, #, and ~.

Code

A line that starts with three or more backticks, ```, and has none after them opens a block of code; a word after them, ```bash, names the language and is part of the line. The block ends at the next line that starts with at least as many backticks and holds nothing else, at the next day’s heading, or at the end of the file. Every line between is code: kept exactly as written and never read, so a - [ ] in a pasted log is not a todo and never reaches the list. One rule is Notada’s and not Markdown’s: a heading ends a block, so a fence left open ends with its day and never swallows the days after it. In the app, Edit › Paste as Code writes the two fences around what you paste. notada append refuses to add an item inside a block that is still open, since there it would be code.

Everything else

Every other line is prose, stored as typed and never changed. Three kinds the app renders but does not read: a quote, > text, which is what Answer writes under today with the question’s words, so the answer is typed beside them; a list, 1. or - , which hangs the way a list does; and links and images in standard Markdown, a bare address, [words](address), or ![](attachments/2026-09-15-143012.png), which is how a pasted image is written, the file beside the log and named by its time. Nothing is wrapped, fetched, retitled, or rewritten.

Keys

In the app, the keys for the caret’s line are also in the Item menu, which reads for that line; the rest are in the View, Notepad, and Edit menus.

What the app writes on its own

Eight things, each on the writer’s own action and nowhere else: today’s heading before the first line of a new day; the done: stamp when you close, drop, or answer, taken off again when you reopen; the marker when you make a line of prose an item, with ⌘↩ or a suggestion; the tab that starts an item’s details when you ask for them; the quote when you answer; the image reference when you paste or drop one; the fences around a block when you paste as code; and, on a first launch, a note from me as the first day of a new log.

And on a line you type into, one rewrite, the same every time: [] and todo: become - [ ], ? becomes - [?], ! and decided: become - [!]; and on an item, a short date like due:fri becomes the full one, and due: and done: move to the end of the line. That is the whole of it. A tool that writes the stored forms is never rewritten, a paste is kept as pasted, and nothing inside a block of code is touched. The app never deletes or reorders lines, and a change it makes touches only the line you are acting on.

The list, derived

The list beside the notes holds no state; anything that reads the file can derive it. Open todos are the - [ ] lines; open questions the - [?] lines without a done:; decisions the - [!] lines. An item’s age is today less its day: in days under two weeks, 12d, in weeks up to ten, 6w, and in months after, 3mo; an item written today has none yet, and a decision shows none. The app keeps ages out of sight until asked: a row’s tooltip says how long it has been open, holding ⌥ shows every age for as long as it is held, and View › Show Ages keeps them shown. An item with a due: before today is overdue; one without a date is only ever old. Todos come overdue first, most overdue at the top; then dated items by their date, soonest first; then the rest by age: the window lists the newest first, and notada and an assistant’s tools the oldest first. Questions come in the same order, and decisions most recent first. When the list outgrows the window, the older undated rows of each section step back behind a line, Show 9 older, that opens them; the newest of both sections share the room, three of each at least, and a dated item always shows.

In a shell, notada ledger --json prints exactly this: notepad, today, and open, questions, and decided, each entry with its line, counted from 1, state, text, date, due, done, ageDays, age, and overdue, a field with no value left out. The command lives in the app, at Notada.app/Contents/Helpers/notada; its MCP server gives an assistant the same view.

Writing to it from outside

Write the stored forms above and the app reads them as its own. Write the whole file at once, to a temporary name and then into place, so the app sees one change; that is how the app and notada write. A change that only adds lines at the end is merged into the open window, even while someone is typing, which is what notada append does. A change to a line that is already there is reloaded when the window has nothing unsaved; when it does, the window’s text wins and the other version is kept beside it as log.md.bak, with one line in the list saying so. Silently losing a line is the one thing this file’s app must never do, so it never does.

A day of the file, as the app writes it:

## 2026-09-11
Standup. Sam is out until Monday; the release goes out at four.
- [ ] Review the onboarding copy before the release due:2026-09-11
- [ ] Check https://github.com/notada/onboarding/pull/42 before it merges
- [?] Who writes the release notes now?
Anna's screenshot of the broken step: ![](attachments/2026-09-11-101512.png)
```
$ git push origin onboarding
 ! [rejected]        onboarding -> onboarding (fetch first)
```
- [x] Book the retro room done:2026-09-11

Questions go to hello@notada.app.