notes that don't
corrupt when you
sync them.

outl is a local-first outliner — a bullet-point note-taking app where every line is a block you can move, reference and search. It stores plain markdown on disk (no UUIDs, no metadata pollution), has a tree-CRDT under the hood for sync that doesn't lose data, and ships as a single Rust binary with a vim-style TUI.

Three things. (1) Sync: outl syncs peer-to-peer over iroh — your devices talk straight to each other, end-to-end encrypted, with no third-party server holding or reading your notes. Roam round-trips through their cloud and loses data on offline conflicts, Logseq's built-in sync is rsync-flavored and overwrites, Obsidian's built-in sync is a paid cloud tier. Under the hood outl uses a Kleppmann tree-CRDT with five formal guarantees. (2) File format: Logseq writes UUIDs into your .md files. outl never does — IDs live in a sidecar. (3) Stack: outl is open source (MIT) and ships as a native binary; the others are Electron or proprietary.

Yes. outl is licensed under MIT and the entire codebase is on GitHub at github.com/outlmd/outl. There is no paid tier, no account, no telemetry. Free forever.

outl is local-first. Your notes live as .md files on your machine — you edit them with zero network. No account, no cloud requirement. You can use outl on a plane and lose nothing; when two devices reconnect, the tree-CRDT merges both edit streams without dropping a block.

No. outl syncs peer-to-peer over iroh: your own devices connect straight to each other and the notes are end-to-end encrypted in transit. There's no account to create and no third-party server that holds, stores or reads your notes — they live only on your devices. (iroh uses relay servers to punch through NATs, but a relay only forwards already-encrypted bytes; it never stores or decrypts anything.) Compare: Roam and Notion keep your notes in their cloud; Logseq and Obsidian gate their built-in sync behind a paid cloud tier. Self-hosting over a shared folder you control is an advanced opt-in, but P2P is the default and needs no setup.

Local-first means your data lives on your device as plain files you own. The app reads and writes them. If outl disappears tomorrow, you can open every note in VS Code, cat, or any markdown editor — nothing is trapped. Outliner means the editor is built around nested bullets (blocks) instead of long prose, so you can collapse, reorder and link individual thoughts.

Yes. Run `outl import logseq <path-to-graph> <dst>` for Logseq, or `outl import roam <backup.json> <dst>` for Roam. The importer strips id:: lines, resolves ((uid)) block references, slugifies filenames and seeds the sidecars. Unresolved refs are kept as ((unresolved:UID)) for manual triage.

Backlinks are first-class — every page has a backlinks panel showing what references it. Wiki-style [[page name]] links and #tags work out of the box. A visual graph view is on the roadmap.

Yes — this is a core feature, not a plugin. Drop a fenced code block in Python, JavaScript, Lua or Rust and the result lands as a markdown blockquote subblock right under the source. Re-runs are idempotent and cache-aware (SHA-256 of source). Set `auto-run:: on` and it re-runs every time you open the page. Lisp exists too, behind the `lang-lisp` build flag rather than in the default build, because the Scheme engine offers no way to build a host boundary you can trust with code you did not write.

Yes, if they are on the same network. outl discovers peers over mDNS (DNS-SD), so a laptop and a phone on the same Wi-Fi resolve each other's current address off the LAN itself and sync directly — no relay, no internet, no router configuration. It works on macOS, Linux, Windows, Android (which needs a multicast lock, because the Wi-Fi driver otherwise drops the packets below the socket API) and iOS (through Bonjour, so no special Apple entitlement is needed). If the LAN path is unavailable, sync falls back to the encrypted relay path exactly as before.

A fence body is not always written by the person running it — it can arrive over sync from a paired device, through an import of someone else's graph, or from an LLM agent driving outl over MCP. So every runtime is bounded. Rust compiles to wasm and runs in wasmtime with no filesystem, no environment and no sockets. Python is built without its standard library and JavaScript with no host bindings, so neither has a file or a socket to reach for. Lua runs behind an explicit stdlib allowlist, with the os, io and package libraries removed. Every block also runs under a deadline, so a runaway loop cannot freeze your editor.

Yes. A slash makes a real hierarchy: the parent page lists every descendant, at every level, and collects their mentions as backlinks of its own. The tree is derived from the page title rather than the filename, so os/linux still lives at a flat pages/os-linux.md and nothing on disk had to change — a graph imported from Roam years ago answers correctly without a migration. Matching compares slugified segments, so oscar/wilde is not in the os namespace even though it starts with those letters, and #os and #os/linux remain distinct tags.

Run `outl peer revoke-all` to empty the paired-device list, or `outl peer remove <device>` to drop one. Pairing is a grant and it is revocable. Your notes are on the devices themselves, not in a cloud account somebody else controls, so revoking membership is the whole of the operation — there is no vendor to email and no server-side copy to worry about.

No, and outl does not sell you one. Peer-to-peer is the default: your devices talk directly whenever both are awake. The gap is that peer-to-peer converges only when two devices can actually reach each other, and a laptop shut at 18:00 never overlaps a phone edited at 22:00. If that is your week, run `outl serve` on a machine you own — there is a Docker image for it. That box is one more peer holding a full replica, not a server your notes pass through. Turn it off and everything else carries on.

Yes — both in beta. macOS desktop ships as a Homebrew cask: `brew tap outlmd/outl https://github.com/outlmd/outl && brew trust outlmd/outl && brew install --cask outl-desktop-beta` (universal dmg, Apple Silicon + Intel). iOS is on public TestFlight, and Android ships a sideloadable .apk on every beta release (grab the latest from the [download page](/download)). All frontends share the same outl-core and outl-md Rust crates, so the algorithm and file format don't fork.

On macOS or Linux: `brew tap outlmd/outl https://github.com/outlmd/outl && brew trust outlmd/outl && brew install outlmd/outl/outl-beta` for the TUI, CLI and MCP server, plus `brew install --cask outl-desktop-beta` for the GUI. `cargo install outl` builds from source. Then `outl init ~/notes && outl --workspace ~/notes` opens the TUI on today's journal. First-run cost is about thirty seconds. Stable `brew install outl` lands with 1.0.