Reflect Open: a plain-Markdown notes app for Mac and iPhone

The problem Reflect Open targets: notes that stay files

Most note apps store your writing in a database only the app can read. Reflect Open takes the opposite position: a notes folder, which the project calls a graph, is the source of truth, and the app adds search, backlinks, tags and related notes on top of it. The README states that Markdown files remain usable in any Markdown editor. That single constraint decides most of the rest of the design.

The intended user is someone on Apple hardware who already keeps notes as files and wants the conveniences of a modern notes app without surrendering the folder. The project does not require a Reflect account. Optional services (AI providers, transcription, iCloud, GitHub, or another git remote) are connected directly by the user, according to the README. That is a meaningfully different posture from a hosted notes service: there is no account layer to opt out of, because there is no account layer.

The secondary audience is tooling. The repository ships a `reflect` CLI with `reflect today`, `reflect search` and `reflect show`, described in the README as available for scripts and agents. The topic list on the repository includes `agent`, which matches the CLI's framing rather than the GUI's.

How the graph, the index and the AI layer fit together

A graph is a folder with a predictable shape. The README gives this layout:

my-graph/
├── daily/2026-06-12.md     # Daily notes, named by date
├── notes/some-title.md     # Other notes, named from their titles
├── assets/                 # Images and attachments
└── audio-memos/            # Audio recordings and transcripts

Daily notes are named by date, other notes are named from their titles, and attachments and audio memos live in their own directories. The app opens to today's note and capture defaults there, so the daily file is the entry point rather than an afterthought.

Underneath, the workspace Cargo.toml is explicit about the storage layer. It pins one SQLite across the workspace with `rusqlite` built with the `bundled` feature, `rusqlite_migration` for schema changes, and `sqlite-vec` for vector search. The comment above the workspace members states the intent directly: one lockfile pins one SQLite everywhere, so the desktop writer and the CLI reader can never skew. That is a real design decision with a real cost, since it forces the CLI and the desktop app to move together, and it is the reason the shared `crates/index-schema` crate exists.

The AI layer is optional and sits on top of the index. The README says `⌘J` can query notes through user-provided OpenAI, Anthropic, Google or OpenRouter keys, and that answers cite source notes. Semantic search can be enabled locally. There is also a `private: true` frontmatter key that excludes a note's content from AI and other external services. That key is the mechanism that keeps the AI feature from being all-or-nothing per graph.

Installing Reflect Open and taking a first note

The README lists three install paths: a signed and notarized Mac build from GitHub Releases, an iOS beta through TestFlight, and a Chrome extension called Reflect Capture. Stable Mac builds are published as `Reflect_aarch64.dmg` for Apple silicon and `Reflect_x86_64.dmg` for Intel; beta builds live under the `updater-beta` release tag with the same two filenames prefixed by `Reflect.Beta_`. The README states that each build is signed, notarized and auto-updated from GitHub Releases.

If you would rather build it, the prerequisites are a recent stable Rust toolchain, Node.js with pnpm 10, and Xcode Command Line Tools. The README gives these commands from the repository root:

git clone https://github.com/team-reflect/reflect-open.git
cd reflect-open
corepack enable
pnpm install
pnpm tauri dev
pnpm tauri build

`pnpm tauri dev` starts the desktop app in development; `pnpm tauri build` produces a release build. If you only want the web front end, the README notes that `pnpm dev` runs Vite alone on `http://localhost:1420`.

Once the app is open, the first real step is choosing a graph folder. The README recommends creating it inside an iCloud-synced folder such as `iCloud Drive/ReflectGraph` if you want file sync across Apple devices. From there, the daily note is where capture lands, and typing `[[` starts a wiki link. Each note then shows what links back to it. To keep a note out of external calls, add the frontmatter key the README documents:

private: true

The CLI is the fastest way to confirm the graph is readable outside the app. The README lists three subcommands, and `docs/cli.md` holds the details:

reflect today
reflect search
reflect show

If `reflect today` prints the same file the app opened, the graph and the index agree.

Where Reflect Open is the wrong choice

The status section is unusually blunt. Reflect is in beta, and the current focus is the Mac app, iOS companion, browser capture, the local-first data model and sync reliability. Windows, Android and a plugin API are listed as out of scope for now. If any of those three is a requirement, this project is not a candidate today, and no amount of Markdown purity changes that.

The release history reinforces the beta framing. The three most recent releases are `v0.12.0-beta.4`, `v0.12.0-beta.3` and `v0.12.0-beta.2`, all published in September 2026, with the newest on 2026-09-10. The last push to the repository was also on 2026-09-10. There is no stable 1.0 line to point at, and the README directs readers to `apps/desktop/CHANGELOG.md` for release notes rather than promising an API or file-format stability guarantee.

The second limitation is structural. Because the workspace pins a single SQLite version across the desktop writer and the CLI reader, upgrading one side without the other is not a supported path. A user who builds the CLI from source against a newer lockfile than the app they installed from Releases can end up with a reader that does not match the writer. The Cargo comment frames this as a guarantee, and it is, but it is a guarantee that constrains how you upgrade.

A third case: if you want a hosted service with a web app, shared workspaces and no local folder, the design here works against you. Every sync option in the README (iCloud Drive, GitHub, any SSH git remote) assumes you own the storage and are willing to manage it.

Reflect Open versus Obsidian and other plain-file editors

The obvious comparison is Obsidian, which also treats a folder of Markdown as the source of truth and also offers wiki links and backlinks. The difference is in the extension model. Obsidian's plugin API is the center of its ecosystem; Reflect Open lists a plugin API as out of scope for now. If your workflow depends on community plugins, Reflect Open will feel closed in a way that has nothing to do with its licence.

The second difference is platform reach. Obsidian ships on Windows, macOS, Linux, iOS and Android. Reflect Open's README scopes the current work to the Mac app and an iOS companion, with Windows and Android explicitly deferred. On a mixed-device team, that is decisive.

The third difference is the AI layer's posture. Reflect Open ships `⌘J` for querying notes through your own OpenAI, Anthropic, Google or OpenRouter key, with answers citing source notes, plus a `private: true` key to exclude a note from external services and optional local semantic search backed by `sqlite-vec`. In Obsidian, comparable capability arrives through plugins you choose and configure yourself. Reflect Open's version is narrower but is part of the product rather than an add-on, and the privacy key is documented in `docs/privacy.md` rather than left to each plugin.

The CLI is the other axis worth weighing. A repo with `reflect today`, `reflect search` and `reflect show` is usable from a script or an agent without a GUI. Many plain-file editors have no first-party CLI at all.

Maintenance, upgrades and what the MIT licence means here

The repository is not archived, and the last push was on 2026-09-10, which is recent. The release cadence visible in the repository is dense: three beta releases between 2026-09-09 and 2026-09-10. That is the profile of a project under active work rather than one coasting on a finished release.

The upgrade cost is mostly in the monorepo. Reflect Open is a pnpm and Turborepo workspace, and the root `package.json` defines `pnpm check` as `pnpm typecheck && pnpm lint`, where lint runs `oxfmt --check`, `oxlint --max-warnings 0 apps packages` and `eslint --cache --max-warnings 0`. A contributor is expected to keep all three clean. The README also notes that Rust tests which compile the desktop crate need sidecars staged first:

pnpm --filter @reflect/desktop sidecar
cargo test --workspace

If you skip the sidecar step, the Rust tests that compile the desktop crate will not have what they need. That is a concrete setup detail, not a general warning.

On licensing: the project is MIT, and the README links to `LICENSE`. MIT is permissive, so redistribution and modification are permitted under its terms, but the licence says nothing about the third-party services you connect. Your OpenAI, Anthropic, Google or OpenRouter usage is governed by those providers' terms, and the git remotes you add are governed by whoever hosts them. Nothing in the repository grants you rights over those. Treat the licence question and the provider question as separate, and read `docs/privacy.md` for what leaves the device before you enable anything.

Editorial conclusion

Adopt Reflect Open if your working machine is a Mac, you are comfortable with a beta product, and you already treat a folder of Markdown as the source of truth. Do not adopt it if you need Windows or Android, if you need a plugin API, or if you expect a stable release channel rather than auto-updated beta builds. Before committing a real notebook, clone the repository, run `pnpm install` and `pnpm tauri dev`, open a throwaway graph, and confirm that `private: true` behaves the way docs/privacy.md describes on your own files.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. team-reflect/reflect-open on GitHub