# Reverie

*A journal that's quiet while you write, and alive when you look back.*

Welcome — you're one of the first people to use Reverie. This page is
everything you need to know, and it's deliberately short.

*(This is edition 49 of the manual, 21 October 2026 — what's changed since
you last read it is under "What's new" at the very end.)*

## Why Reverie

**Your words are yours, in the plainest sense.** Reverie doesn't have a
cloud, an account, or a database. Your journal is a folder you choose on
your own computer, full of ordinary Markdown files with your photos beside
them. You can open them in any text editor today or in thirty years,
back them up like any folder, and leave Reverie behind at any time
without losing a word.

**The page gets out of the way.** The sidebar keeps your place visible;
choose **Enter Quiet** in Commands when you want the page alone. Quiet leaves
no application chrome permanently visible. Formatting is light
Markdown (`**bold**`, `*italic*`, `#` headings, `-` lists, `>` quotes,
`---` on its own line for a separator), styled softly in place as you
type.

**Your past comes back to you.** Most journals are write-only; the words
go in and never come out. Reverie is built around looking back —
bringing back passages and questions from recent and older writing
(**Reflection**), and letting you mark what
matters as you re-read (**highlights and margin notes**, written into
the files themselves).

**You can watch yourself write.** Reverie can record the act of writing
a page — every pause and correction — and play it back later, like
watching yesterday think (**Replay**).

## Getting started

Open Reverie and choose a folder. That folder *is* your journal — pick
somewhere that gets backed up (iCloud Drive, Dropbox, or anywhere Time
Machine sees). Reverie organises it like this:

```
your-folder/
  entries/2026/2026-07-11_143022_a3f9.md     ← one file per entry
  entries/2026/2026-07-11_143022_a3f9/       ← that entry's photos & replays
```

On first run Reverie asks whether it may record replays of your writing.
Recordings are files in your folder like everything else; you can say no,
or change your mind later in Settings.

## Getting around

The sidebar holds **Reflection**, **Contents**, **Add Page** and **Settings**.
**Edit** (or **Write**, on the typewriter) sits just above **Add Page** and
takes you back to the page you have open for writing; with no page open it
is greyed out.
The **Commands** button at the top right opens the command palette without a keyboard.

Tab and Shift+Tab move between groups; arrows move within a group, and
in the sidebar they only move the highlight. Enter opens the focused page
or action. `⌃⌘S` (`ctrl+shift+E` on a PC, or `F6` anywhere) takes you to
the sidebar from wherever you are, even mid-sentence.

Escape steps back, one step at a time: out of the typewriter, then from
editing to reading, then back to where you came from. `⌘[` (`ctrl+[` on
a PC) goes back the same way — from a page you followed by a link, to the
page you came from, and then to Contents or Reflection, wherever you
opened it — and `⌘]` (`ctrl+]`) goes forward again. When browsing starts,
keyboard focus is on the selected sidebar destination. In a page, arrows
retain their reading or editing behaviour. When a page link has focus, arrows
move between its links instead; Page Up/Down still scroll the reading page.

Settings opens as a full page alongside the other sidebar destinations.
Choose **Enter Quiet** in Commands to hide the navigation. In Quiet, hover
at the top edge to reveal Commands; move to the left edge to reveal the sidebar
and Commands. Commands includes **Settings** and **Leave Quiet**.
Sidebar Settings opens as a page, including in Quiet. Opening Settings through
Commands or its shortcut shows a popover in Quiet. Dismissing the popover
preserves your place. Nothing stays permanently displayed over the resting page.

On a Mac, the native menus also offer Reflect (`⌘⇧R`), Contents (`⌘⇧C`),
New Page (`⌘N`) and Settings (`⌘,`). `⌘1` and `⌘2` still go to Reflect and
Contents too. On Windows and Linux use Ctrl instead.

And everywhere — Mac, PC, or the web — `⌘K` (`ctrl+K` on a PC) opens
the **command palette**: type a few letters of anything Reverie can do
and press return. "Import from Day One", "Dark appearance", "Replay this
page being written", "Rebuild the index" — every action and setting is
in there, searchable by what you'd naturally call it ("write" finds New
page). The list always keeps the same shape — commands that don't
apply where you are sit greyed out — `↑`/`↓` (or
`⌃N`/`⌃P` on a Mac) choose, and `esc` puts you back exactly where you
were, caret and all. If you remember nothing else, remember `⌘K` — it
remembers everything else.

(Help is always at `⌘?` — `ctrl+?` on a PC. It opens **the welcome**:
four short letters from Shahid, read on the same page you write on,
each one showing what it tells — the letter about highlights carries
one, the letter about photographs brings its own. They live in their
own small drawer, never in your journal, and they can't be edited or
lost. This guide — the longer reference — is a palette verb away:
**Open the user manual**. It opens on its contents: arrows choose a
section, `enter` goes there and `esc` comes back. Start typing to search
it, as you would on a page.)

**Add Page** in the sidebar starts a fresh page, as does `⌘N` (`Ctrl+N`
on Windows and Linux). Commands provides the same action in Quiet.

## Writing

A page in Reverie is in one of three modes, and the words are chosen
with care. **Read** is the finished page. **Edit** is the ordinary
page you type on — writing and revising at once, the cursor free to
go anywhere, as every modern editor conflates the two. **Write** is
the typewriter: every keystroke a commitment of ink to paper, nothing
removed, only struck through — the way writing was before it became
editing, and the mode where flow is the inevitable result. Most of
this section is about Edit; the typewriter has its own pages below.

Or skip even that: when Reverie opens, **just start typing** — the
first letter opens a fresh page with that letter already on the page.
The fastest thought-to-page path there is, for the moment you most
want it. (Only at launch: once you've moved to another screen, keys go
back to their ordinary meanings.) And if you step out to Contents
mid-page, `esc` takes you straight back to the page you were
writing, the cursor where you left it.

Press `⌘N` (or choose **Add Page**) and start. There's nothing to save —
Reverie saves as you type, one second behind your fingers. The date is
the page's title. When you're finished, choose **Read** in the page's ⋯ menu —
or press `⌘E` (`ctrl+E` on a PC) — and the page becomes the
finished page. (Or simply walk away; it's already saved.)

While you write, the chrome fades out, and it stays faded when you switch
the page to Read. Move the pointer to the top of the window or over the
sidebar — or tap `alt` on a PC — to summon it back.

**Indentation and navigation** — Tab inserts a literal tab by default, displayed
at four-column tab stops. Settings ▸ Writing lets you choose a width from two
to eight columns or insert spaces instead; preferences never rewrite existing
text. In Edit, Tab indents a selected block and Shift+Tab removes a level of
indentation, with one undo step for the whole change. In Typewriter, Tab moves
forward to the next stop and Shift+Tab does nothing.

Escape dismisses an open menu or dialogue first, then steps back: from
Edit to Read. To visit the sidebar without leaving the page, press `⌃⌘S`
(`ctrl+shift+E` on a PC, or `F6`). The page you are writing stays open while
you look at Contents, Reflection, Settings or another page: **Edit** (or
**Write**) in the sidebar returns you to it with your caret and selection
intact, and a typewriter session stays open too. It closes when you switch
it to Read, start another page or edit a different one. In Quiet, navigation
appears temporarily and disappears when you return to the text.
Ctrl/Cmd+E switches Read/Edit; Ctrl/Cmd+T or Escape leaves the typewriter.

**Formatting** — select some words and press `⌘B` (`ctrl+B` on a PC)
for **bold** or `⌘I` (`ctrl+I`) for *italic*; press again and it comes
off. With nothing selected, the word under the cursor takes the style.
The palette carries the full set — *Bold*, *Italicise*, *Highlight*,
*Strike through the selection*. And typing a quote, bracket, asterisk
or underscore over a selection wraps the words rather than replacing
them — type `*` twice and you've built bold by hand.

If you're of the underscore persuasion, Settings ▸ Writing has **Write
italics with underscores**: `⌘I` then writes `_like this_` instead of
`*like this*`. Both notations always read as italics either way, and
the toggle takes off whichever marker the text is actually wearing.

**Undo** (`⌘Z`, `⇧⌘Z` to redo — `ctrl+Z` / `ctrl+Y` on a PC) steps
through your edits one at a time, exactly as they happened: a typed
character is one step, a formatting command is one step (all its
marks together), wrapping a selection is one step. Redo walks back
precisely the way undo came. This works whether or not you record
your writing process — the steps live in memory for the current
sitting only, and are never written anywhere.

**Type size** — `⌘+` and `⌘−` (`ctrl+=` / `ctrl+-` on a PC) grow or
shrink the page's type, everywhere words are read or written; the
margins stay exactly where you set them. `⌘0` returns the designed
size, and Settings ▸ Page has the same control. The margins are
their own dial: **Narrower margins** / **Wider margins** (in the
palette, or the five presets beside the type control in Settings)
change the space either side of the page — the remedy if full-screen
margins ever feel too grand — and the narrowest setting lets the page
take the whole window, whatever the type size.

**Photos** — paste one straight in with ⌘V (`ctrl+V` on a PC), drag one
from Photos or Finder onto the page, or use the ⋯ menu → *Add photos…*.
A pasted photo lands in the text right at your cursor; a dragged one
lands where you let go. Either way it lives next to the page on disk,
and the text is the only place it shows: its line in Edit mode, the
picture itself in Read mode. The text is the truth: delete a photo's
line and the photo goes to the trash when the page saves, and *Remove
photo…* in the ⋯ menu (cursor on the photo's line) does the same in one
step, after asking. Nothing is deleted outright — the trash folder in
your journal keeps the file until you empty it. HEIC from an iPhone is converted
automatically, and if a photo carries its own date, Reverie offers to
use it as the page's date — handy when you're writing up yesterday's
walk.

**Writing up the past** — the date isn't fixed. Click the dateline at
the top — or ask the palette for *Change the date…* — and *write* the
date the page deserves, the way you would on a
paper page: `14 March 2019`, `last tuesday`, `yesterday 9pm`. Reverie
shows what it understood beneath as you type; `enter` sets it, `esc`
leaves things as they were. Notes from your phone, pages copied from a
paper journal — give them the day they belong to and they take their
place in the timeline, and in Reflect's on-this-day memories, as if
they'd always been there.

### Write mode — the typewriter

For the days when the only way forward is *forward*: press `⌘T`
(`ctrl+T` on a PC), or open the palette and choose **Write on the
typewriter**. The page clears to four lines
in a quiet band — the line you're typing, pinned in place, and the
three before it fading gently above as the paper rolls up. There is no
cursor to move, no palette, no undo, and no editing: `backspace`
strikes out the last word — ~~like so~~ — and that's all it does. It
reaches back only along the line you're on; press past its start and a
quiet *Can't go back* tells you so, because the platen never rolls
back. The crossings-out stay in your page, part of the writing. Everything you
type saves and records exactly as normal (a typewriter session makes a
lovely replay). When you're done, `⌘T` (`ctrl+T` on a PC) or `esc` sets the page
gently back down and hands you Edit mode, your cursor resting just after the last word
you typed — leaving the typewriter means you've finished with the
typewriter, not with writing. The typewriter also has no key for an
em-dash, curly quotes or an ellipsis: those are dropped without
ceremony (`--` is the typewriter's dash), while accents — `é`, `ß`,
`ø` — are spelling, and type as normal.
And if the typewriter becomes your way of writing, Settings ▸ Writing →
**New pages open in Write mode** makes every fresh page open on
it — even the letter that starts a page from the launch screen lands
on the typewriter.

## Reading and editing

**Contents** lists everything, newest first — and it has a second feed:
**Highlights**, every passage you've ever marked, each one a small card
of your own words. Tap a card and the page opens with that passage
briefly lit, so you land with your place already found.

Contents can also be read as **index cards**. The pair of small
glyphs beside the feed names switches how it's laid out: the list, or
5×3 cards arranged under quiet month headings — the date on each
card's ruled top line, as much of the page as fits beneath, and the
page's first photo featured at the right. Either feed reads either
way, and Reverie remembers which you prefer. If a page opens with a
`# heading`, Settings ▸ Reading can let the card wear that heading
as its title, the date stepping into the corner.

Contents walks from the keyboard, too. Press `↓` and the newest
page takes a quiet tint; `↑`/`↓` move from page to page with the
page following (in the card layout `↑`/`↓` move a row at a time and
`←`/`→` one card), `home` and `end` reach the ends, and `return` opens
the one you're on. Reverie remembers where you were walking, so coming
back from a page, `↓` picks up where you left off.

Open a page and it's a bare page — no bars, no buttons, just the
words. Park the pointer at the very top edge and a hairline bar appears:
back, the date, and the ⋯ menu. The date is alive here too — click it
and write a new one to move the page to the day it really belongs to. On the Mac that bar lives *in the
window's title bar*, the traffic lights resting at its left, and you can
drag the window by it — when it fades, they fade, and the page is truly
all there is.

Click any word to start editing *at that word* — or press `⌘E`
(`ctrl+E` on a PC), which flips between reading and writing from either
side; a small pill names the mode you've just entered.
The page's ⋯ menu offers **Edit** while reading and **Read** while editing.
While editing, `esc` steps back to reading. From reading, `esc` (or `⌘[`,
`ctrl+[` on a PC) goes back to where you came from. Everything the ⋯ menu offers is also a palette
command — `⌘K`, then "delete the replays", "add photos", anything —
so nothing here ever needs the mouse.

Reading is a keyboard place too. `↑`/`↓` glide the page a few lines at
a time (`⌃N`/`⌃P` do the same on a Mac — the system's own line keys),
`space` and `page up`/`page down` move by the screenful, and
`home`/`end` reach the covers. `←`/`→` turn to the neighbouring page —
newer to the left, older to the right, the way the timeline reads — and
a page you turn back to is still at the line you left. Each turn, the
page you land on announces itself — its title, or its date — in a
small pill near the top, so you always know where the turn took you.
The arrows stop at the last line rather than turning for you: a page
turn is always deliberate. The welcome's letters turn with the same
keys.

Deleting a page takes two deliberate taps (⋯ menu → *Delete page* →
confirm). Nothing in Reverie deletes anything with one click — and even
then, nothing is lost: the page moves, photos and replays included, to
a `trash` folder inside your journal, plain files like everything else.
*Put back the last deleted page* (in the palette) restores it to its
place, and the trash keeps everything until you empty it yourself in
Settings ▸ Maintenance. The one exception is *Delete the replays* —
that's a privacy decision, so deleted recordings are truly gone.

## Highlights and margin notes

Reading old pages is half of journaling; these are your pencil.

**Highlight** — select any passage while reading and a small strip
offers **Highlight**, **Note** and **Respond**. Take Highlight and the
passage glows softly from then on, wherever it shows up — the page,
Contents, Reflect. To remove one, right-click it (or select
within it) and take **Remove highlight**.

A highlight is real ink: it wraps the words in `==marks==` inside the
page file itself — the same syntax iA Writer and Obsidian use — so it
travels with your files, survives every export, and you can just as
happily type `==` around words yourself while writing.

**Notes and responses.** Select words on the reading page and choose
**Note** for an ordinary dated footnote, or **Respond** for a new page
linked to those words. Either opens a small writing box beside the passage.
`return` saves; `esc` closes the box and keeps your draft during the session.
On **Reflect**, rest the pointer on a line and choose **Respond**.

A response has its own date and its own page file. In Contents it is
indented beneath a link to the original, which keeps its original place.
Read responses beside their source in any of the three footnote views,
or choose **Open as page** to write, search, tag and revisit them like
other pages. **Follow this thought** lists the connected pages. In
Reflect, click the response text to revise it; empty it to move that response
page to the trash. Existing dated footnotes remain as they were.

In Read mode, Tab lands on an actionable page link or **Follow this thought**;
arrows move between these controls and Enter follows or opens them. Escape
returns from a linked page to the previous page, restoring its reading position,
focused link and expanded conversation. A page without links adds no passive
Tab stop. Page Up/Down can still scroll its text from the sidebar or Commands.

The response keeps a copy of the words it answered. If those words change,
Reverie shows it under **Responses to earlier wording** instead of guessing
where it belongs. If the original is unavailable, the response and saved
quote remain readable.

Use `shift` + `return` for a new line; press it twice for a new paragraph.
Pasted paragraphs stay intact. `return` on its own saves the response.

A note is real ink too. It's written into the page as a **dated
footnote** — a small `[^2026-07-27]` mark after the sentence, and your
words in the footnotes, below the page:

```
The swifts were out again.[^2026-07-27]

[^2026-07-27]: Still true, a month on.

    I noticed it again this morning.
```

Continuation paragraphs use four leading spaces or a tab. Reverie adds
that indentation when you write in the Note box. In an older file, an
unindented paragraph stays ordinary page text; indent it explicitly if
it belongs to the note.

You can write footnotes by hand
too — in Reverie's edit mode or in another editor entirely — and they'll
appear as margin notes all the same. The gloss belongs to reading: start
editing and you see the honest apparatus as plain text instead — the
marker sits slightly raised and tinted, so it reads as apparatus rather
than prose.

**Three ways to read your notes.** Inline is the default: each note under
its own sentence, wearing its date. If you'd rather read the way print
does it, choose **Traditional** under **Settings ▸ Reading ▸ Read
footnotes** (or ask the palette): the marks become small numbers in the
text and the notes gather in the footnotes. **Marginalia** puts
each note in a small box out in the page margin beside its line — and
when the window is too narrow for a margin, they read inline. The saved files
are identical in every view. Responses keep their relationship in their own
frontmatter; their displayed footnotes are not inserted into the original.
The read-only Welcome letters always demonstrate marginalia; this preference
changes the presentation of notes in your own journal.
In the traditional view, click a number to travel down to its note, and
click the number in the footnotes to travel back up. Resting the pointer on a
mark — in either mode of writing or traditional reading — shows the note
right there, no travel needed.

**Reaching a footnote while writing.** Clicking a marker in edit mode
just places your cursor, as clicking should. To visit the note itself:
`⌘`-click the marker (`ctrl` on a PC), or use the palette's **Go to the
footnote** — and **Back to the reference** returns you to the exact spot
you left.

## Finding things

A journal's question is never *which document* — it's *where did I
write that, and when?* Reverie answers both without a search screen.

**Across the journal — just start typing.** On Contents, type. The
words appear in a line above your pages and the timeline itself thins
to the days that answer: each result is a line of your own words with
the found word lifted, under the same month headings, newest first. If
several pages answer, `↑` `↓` walk them and `enter` opens the one
under the mark — the search rides along, so `enter` keeps stepping
through the matches inside the page. `esc` and your timeline is whole
again, exactly where you left it. Every word you type must appear, so
fewer words find more pages, and a slip of the fingers still finds
the word (`beleive` finds *believe*, listed under *Near matches*).

**Time is a place, not a word.** Write `march 2019` — or `2019`, or
`14/3/19`, or `yesterday` — and the timeline goes there, keeping
whatever layout you read it in. Mix freely: `beach 2019` finds the word
within the year.

**Within a page — `⌘F`** (`ctrl+F` on a PC). A slim field joins the
top bar and every match washes softly as you type; the one you're on is
inverted, like a letterpress mark. `enter` steps forward,
`shift+enter` back, `⌘G` does the same from anywhere on the page, and
the count keeps you honest. `esc` clears the search and leaves you
right where it took you. Pressing `⌘F` while writing flips the page to
reading first — searching is a reading act. And `⌘F` anywhere else in
the app simply takes you to Contents with the search ready.

**Tags, if you want them.** Some people connect their pages by theme;
Reverie keeps that deliberate. `⌘K` → *Tag this page…* opens a quiet
line in the top bar — write `coast, night walks`, press `enter`, and
the tags are written into the page file's front matter (the same place
Day One kept them — imported journals' tags already work). Tags never
print on the page; they answer when called: search `#coast` and the
Contents narrows to the pages that carry it, `lighthouse #coast`
finds the word among them. A `#tag` typed in your text is just your
text — Reverie won't turn prose into filing.

## Reflect

**Reflect** greets you with your own past words in a single column: a
line that stood out, any responses you've written to it, and beneath
them questions you yourself asked in past pages. Nothing is labelled
or filed — what you make of them is yours. Click any line to open the page
it came from — the line arrives briefly lit, so you see it in its home. It's a
conversation with yourself, on a delay.

Recent lines carry no date — they're current affairs. Older ones say
how far away they are, in words ("a year ago today", "last November")
rather than a stamp; the exact day is in the page, one click away.
Your responses work the same way: beneath a line you see the latest
one, marked by how long after the line it came ("three weeks later"),
and a quiet *2 earlier* above it unfolds the rest in place, oldest
first; the same words fold them away again. A long response shows its
first few lines with *more* beneath, so the questions stay in view.
Click any response to edit it.

When the standout line's page has a replay, the line doesn't fade in —
it **writes itself**, with your own keystrokes: the typos you corrected,
the pauses, the rhythm, compressed to a few seconds.

On a computer, rest the pointer on any line and a small rail appears
just beneath its words, above any responses (and only there — the rail
is dark until you ask). The keyboard reaches
everything too: **↑ ↓** move the highlight from item to item down the
page — the lead, its responses, each question and theirs — **Return** acts on what's highlighted
(a line opens its page, a response opens for editing, *2 earlier*
unfolds or folds), **⌘Return** opens the page from anywhere, and **Tab** opens
the highlighted line's rail: **← →** along it, **Return** to choose,
**Esc** to close. On the Mac **⌃P/⌃N/⌃B/⌃F** work as the arrows do.
On a touch screen, tap a line to select it and show its rail; tap
its words again to open the page, or tap elsewhere to let it go.
**Respond** leads it — a reply to the line, in your own words, which
creates its own dated page, linked to the words it answers and readable
beside its source; answering yourself is what Reflect is for. Then a **play**
button when the line's page has a
replay (**Replay this line**, jumping straight to the moment
those words appeared), then **highlight** (a highlighted line wears its colour here, as on the page), **hide**, and **another** —
a fresh passage in the lead's place, or another question in a
question's, while the rest of the page stays as it is. All taken
without leaving the screen.

What Reflect shows is chosen at random from your whole journal, nothing
scored or ranked: first how far back to look — this month, this past
year, or before — then a page, then a line on it, so recent writing
keeps its place without crowding out the rest. A line of eight to fifty words
can lead, everyday ones included, and a question of just four. A line you have highlighted
or answered is a little more likely to be chosen, and a question you
have answered stays in the conversation. Once shown, a line rests for a
month while there is anything else to show; a line you are in
conversation with rests for a week.

**Hide** takes the whole page out of Reflect — for the things you want
recorded but not brought back. Its lines leave at once; **Undo** in the
notice, or **⌘Z** (Ctrl+Z on a PC), puts them back. A hidden page never appears in Reflect; in
Contents its words are blurred, with a small eye beside the time, and it
opens and reads as ever. The page carries the same eye in its top bar:
click it to show the page in Reflect again. You can also hide a page
while you write it, from the **⋯** menu, and the palette has **Hide this
page from Reflect** and **Show this page in Reflect**. The choice is
written into the page itself (`reflect: hidden` at the top of the file),
so it travels with your journal.

A hidden response page is also left out of Reflect. It remains part of the
conversation when you read its source page.

The record of what was shown when, and what you opened, lives in one plain file inside your journal folder
(`reflect/engagement.json`): yours, portable, deletable without losing a
written word. Your highlights and notes are never in it; they're in the
pages.

And if this is more conversation than you want — it can sit a little
close to social media — switch it off in **Settings ▸ Reading**. The
rail disappears and nothing new is recorded; your highlights and notes,
ink in the pages themselves, stay visible and keep their gentle weight.
Anything already saved waits untouched in case you switch back on.

## Replay

Open a page's ⋯ menu → **Replay this page**, or use **Replay this page
being written** in the command palette, including while writing a new page.
Replay becomes available once a recording has been saved. The page writes
itself back onto the page, cursor and all — hesitations, deletions, the
lot. Playback starts on its own; the floating controls pause it, restart
it, change speed (1× / 4× / 16×), and skip the long pauses (on by
default — thinking time is long). `esc` leaves the replay at any point.

A page's whole history plays as **one film**. It opens with the
original writing session; every later edit follows as its own scene, in
order. A timeline runs along the bottom of the screen — the fill shows
where you are, small ticks mark where each edit begins, and the label
above it names the scene you're watching (**Written**, then **Edited**
with its date). Click anywhere on the timeline to jump there.

At the end of each scene the film pauses — a natural rest at the moment
you once closed the page. Press **play** to continue into the next
session, use the **skip** buttons to move between sessions, or switch on
**Play through** and the whole history rolls uninterrupted. When the
timeline is full, the film is over; play again to rewatch.

Two honest notes:

- **Every writing session is recorded** — the original one on the Write
  page, and each later edit session too. Even a highlight or note lands
  as its own tiny scene — your marginalia are part of the record.
- Recordings live inside your journal folder, next to the page. Delete
  them any time from the page's ⋯ menu (*Delete replays*), or switch
  recording off entirely in Settings.

## Settings

The sidebar opens Settings as a page, including in Quiet. `⌘,` or Commands
opens it as a page in normal mode and as a popover in Quiet. Down its left side,
a contents list in
Reverie's own typeface — **Page**, **Writing**, **Reading**, **Journal**,
**Import**, **Maintenance**, **About** — with a small amber mark beside
the one you're on; the rows for that tab sit to the right. Everything
applies as you change it; there is no OK.

The keyboard here follows the same container model as the rest of Reverie:
`tab` moves between the panel's parts — the find line, the contents
list, the rows — and the cursor keys move *within* the part you're in,
never out of it. A slim amber bar at the left shows which part the
cursor keys currently rule; inside the rows, a small amber underline
slides beneath the control you're on. `↑` `↓` walk the list or the
rows (`⌃N` `⌃P` too, on a Mac), `←` `→` move within a control that has
parts of its own (Appearance's three), `⏎` and `space` act on it, and
typing on the *Find a setting…* line filters every row across every
tab into one list — `⏎` takes you to the one you want. `esc` closes
the panel and puts you back exactly where you were, caret and all.

Import lives on its own tab: export your Day One journal as a `.zip`
(JSON format) and Reverie will bring your pages and photos across as
ordinary Markdown files, or import a folder of `.md` files from
Obsidian, iA Writer, Bear and the like. Nothing about either import is
destructive; your export is only read, never modified.

## Capturing from your phone

Inside your journal folder lives a folder called **`inbox`**. Save any
`.md` or `.txt` file into it — from an iOS Shortcut over iCloud Drive,
a text editor on your phone, anything that can put a file in a folder —
and Reverie turns it into a page when it next opens (or right away,
with Settings ▸ Journal → *Sweep inbox now*). The original file is
kept in `inbox/archive`, so nothing you captured can be lost half-way.

Settings ▸ Journal → *Set up the iPhone Shortcut…* walks you
through a thirty-second Shortcut that types or dictates an idea straight
into the inbox, timestamped so it takes its true place in the timeline.

If the timeline ever seems out of step with what's really in the folder
— pages edited in another app, iCloud conflict copies, something
missing — Settings ▸ Maintenance → *Rebuild index* remakes the
timeline's index from the page files themselves. Your pages are only
read, never modified.

## Buying Reverie

Reverie is a one-time purchase — no subscription, no trial timer, no
feature gating, and it never nags. Everything works before you buy,
exactly as it does after; the app trusts you to pay when it has earned
a place in your day. When it has: **Reverie → Buy Reverie…** (or the
link in Settings ▸ About) opens the buy page, and your licence key
arrives on the receipt. Paste it into Settings ▸ About ▸ Licence and the app is
registered to you — checked entirely on your machine, sent nowhere.
Early-access licences cover every future version, always.

## The fine print

There is no fine print. No account, no telemetry, no server. If you can
see your folder, you have your journal — all of it.

One ask, since you're first: when something feels even slightly off —
a jitter, a hidden button, a weird cursor jump — please tell us. That's
exactly the polish we care about.

Feel free to share your feedback via email to support@freeholder.dev

## What's new in Reverie

- Undo now works after switching between Edit and Read, opening another page, Find, tags or a replay.
- A highlight or note made straight after typing no longer loses the words you had just written.
- In Reflect, the underline no longer slides in from Commands when you move into a line's actions.
- Help ▸ Read the Welcome works again on the Mac.
- Moving the caret to Add Page in the sidebar now highlights Add Page correctly.
- In Reflect, a line's actions sit just beneath its words, even when it has responses.
- Earlier responses unfold above the latest and can be folded away again.
- Long responses show a few lines with “more”, so the questions stay in view.
- Escape now walks back through your navigation choices again. From the Typewriter, Esc goes to Edit, another Esc goes to Read, then another Esc goes back to where you came from.
- ⌘] (Ctrl+] on a PC) goes forward again after ⌘[ or Escape takes you back.
- ⌃⌘S (Ctrl+Shift+E on a PC, or F6) takes you to the sidebar from anywhere.
- The page you are writing stays open while you look elsewhere; Edit or Write in the sidebar takes you back to it.
- Moving the caret in the sidebar only moves the highlight. To navigate to the selected item, hit Enter.
- ⌘1 and ⌘2 (Ctrl+1 and Ctrl+2 on a PC) still go to Reflect and Contents, alongside ⌘⇧R and ⌘⇧C.
- Reverie says “page” throughout, and the mode pill names Reading, Editing and Writing.
- The user guide opens on a contents list, and you can search it by typing.
- Headings in Read, the user guide and the letters are set in the page’s own type and sized to stand out.
- Edit stays in the sidebar, greyed out until a page is open.
- Switching a page to Read keeps the screen quiet; move the pointer over the sidebar to bring it back.
- On a touch screen, tapping a line in Reflect shows its actions; tap it again to open the page.
- Lines you have highlighted show their highlight in Reflect too.
- Reverie opens much faster, without a white flash in dark mode.
- Contents (formerly Timeline) and Reflection have new keyboard shortcuts to keep navigation consistent with their names and roles.
- Open Commands with ⌘K (Ctrl+K) and search for Contents or Reflection to see their current shortcuts.
- Pending edits are saved before you leave a page, close the window or quit.
- Replay shows the original writing and later edits on one timeline, with speed controls and a play-through option.
- Replay is available while writing a new page, as soon as its first recording is saved.
- The command palette calls it Replay; searching for “watch” still finds it.
- The typewriter keeps four lines on screen; Backspace strikes out the last word instead of deleting it. You can only strike out words on the current line. It’s like not being able to roll the platen back on a real typewriter, and is intended to encourage flow.
- Press ⌘T (Ctrl+T on a PC) to enter or leave the typewriter; leaving returns to your editor.
- New pages can open on the typewriter if you prefer (it’s how I use it, but it’s not for everyone).
- Select words while reading to highlight them or add a dated note without entering Edit mode.
- Read footnotes beneath their words, together at the foot of the page, or in the margin.
- Footnote previews and links let you move between a note and the words it belongs to.
- Reflection brings back your own passages and questions in one column, with responses beneath their source and actions beside the words they belong to.
- Reflection chooses across recent and older pages at random; highlighted or answered lines are a little more likely to return, and an answered question remains in play.
- Hide takes a whole page out of Reflection until you show it again; it remains readable in Contents, and the choice can be undone.
- Recorded lines in Reflect play back as you wrote them; quotations, code and struck-out words are excluded from its selection.
- Respond creates a dated page of its own, linked to the words it answers; read it beside its source or open it as a page.
- “Follow this thought” connects the pages in a conversation and restores your reading place when you return.
- Responses can contain paragraphs, be edited later, and fold away beneath the latest response. Older footnotes stay as they were.
- Press Esc to close a response box; your draft will be there when you reopen it during the same session. Previously, if you hit Esc in a response, the text would be gone if you went back to respond again.
- Search the journal by words, dates or tags; use ⌘F (Ctrl+F) to find words within a page.
- Browse Contents as a list or index cards; Tab moves between groups, arrows move within them, and Return opens the selected page.
- The sidebar holds Reflection, Contents, Edit, Add Page and Settings; choose Enter Quiet in Commands for the page alone.
- In Quiet, mouse over the left edge for navigation or the top edge for the date and Commands.
- Open the command palette with ⌘K (Ctrl+K) to find actions and settings.
- Start typing from the opening screen to begin a page immediately.
- Choose Read or Edit in the page’s ⋯ menu, press ⌘E (Ctrl+E), or click a word in Read to edit it. The date keeps its place across modes.
- Formatting shortcuts, selection wrapping, undo and redo work on the ordinary Edit page; the typewriter keeps its forward-only rule.
- Rich text pasted into a page becomes Markdown.
- Clicking text to edit keeps your place.
- Drag or paste photos into the text; removing a photo from the page moves it to the journal’s trash when saved.
- Change a page’s date directly on its dateline, using natural dates such as “last Tuesday”.
- Capture files from your phone through the journal’s inbox or a folder you choose. This feature is still in active development.
- Captures keep their recorded times; different captures with the same opening words are no longer mistaken for duplicates.
- Deleted pages go to the journal’s trash, and the last deletion can be undone.
- Adjust text size and margins, choose a dark appearance, and search within Settings.
- The Welcome letters, user guide, capture guide and release notes are available inside Reverie.
- Import Day One journals or Markdown folders; Day One imports preserve tags, location, weather and other metadata.
- Linux has smoother keyboard scrolling, Wayland support and a signed package repository for Arch and Omarchy.
- Windows saves work on other drives, and its window controls fade away while you write.
- Reverie remembers your window size and position.
- Reverie checks for updates only when asked.
- Your journal remains Markdown in a folder you own, with no account or telemetry.
