Zorite

Minimum OS versions

macOS (Apple Silicon and Intel)

Windows (x64 and ARM64)

Linux (amd64 and arm64)

Linux additionally needs a Vulkan-capable GPU with current Mesa drivers.

Zorite is a daily-journal note app for the desktop, organized like Logseq but edited like an ordinary document rather than an outliner. Notes are Markdown in a local SQLite database. Pages link to each other with [[wiki-links]], and the app also handles PDFs (viewing, annotating, form filling), images, whiteboards, and LaTeX math. There is no cloud and no account; everything stays on your machine. Written in Rust with GPUI (Zed's UI framework) through GPUI Kit.

Developed in close collaboration with Claude (Anthropic).

📝 Changelog · 🗺️ Roadmap

Features

Writing

• The journal is a feed of days, newest first. Everything is plain text, and clicking anywhere places the caret. Markdown renders as you type; the markers reappear when the caret is on them.
• CommonMark and GFM, plus a few extras: tables are edited cell by cell, GitHub alerts work (including Obsidian's foldable > [!NOTE]- form), headings can be collapsed, code blocks are syntax-highlighted, and Mermaid diagrams render in the current theme's colors.
• A / menu inserts Markdown constructs, the current date or time, a table via a size picker, a property row, and your own templates (see below).
• [[ completes page names, # completes tags, and {{ completes template placeholders. Brackets auto-pair, and an optional auto-linker turns existing page titles into links as you type.
• Inline $…$ and display $$…$$ LaTeX render as typeset math. Clicking into a formula opens a structural editor in the style of MathQuill: fractions, roots, matrices, delimiters, and accents (\hat, \bar, \vec, …) are live slots you arrow through; type \ for an autocomplete of commands, or select part of a formula with the mouse and wrap it. Formulas can be copied as LaTeX or exported as PNG/SVG.
• Right-to-left text. Arabic, Hebrew, Persian, and mixed-direction notes lay out correctly in both the editor and the reading view — paragraphs, headings, lists and tasks, tables (columns mirror), quotes, alerts, properties, links, and inline math — with the caret, selection, and clicks following the visual order.
• Lines can be reordered by dragging the six-dot grip in the gutter, and Copy puts formatted rich text on the clipboard alongside the Markdown, so a paste into a mail client or document keeps headings, bold, and lists.

Details: Journal & pages · Math

Linking and organization

• Wiki links create pages on first use. Every page lists its backlinks, plus unlinked mentions that can be converted with a click. Projects::Tasks titles form a namespace tree, and renaming a namespace renames its children.
• Any line can be given a ^id anchor and linked with [[Note#^id]], or type (( and pick any block from a searchable list, Logseq-style; headings can be linked directly. ![[Note]] embeds another note (or one of its sections or blocks) and updates live when the source changes. A page's alias:: names complete in [[ too. Both the reading view and the editor render all of this.
• key:: value lines render as a properties panel with per-key icons; tags and links in values are clickable. Panels are edited in place, and a Properties page indexes every key and value across the database.
• For navigation there's an all-pages list, a graph view, a calendar marking days with entries, favorites, and tabs that can be torn off into separate windows (and restored on relaunch). Right-click any page — in the sidebar, a tab, a link, search results — for the same page menu.

Details: Journal & pages · All pages & the graph

Files, PDFs, and whiteboards

• Images can be pasted or dropped in (HEIC and AVIF included) and resized by dragging a corner. An image in the middle of a sentence displays as a thumbnail. Duplicate files are stored once, and unused files can be swept.
• The PDF viewer virtualizes pages, so long documents open and scroll without loading everything. It has a table of contents, text search, password support, fit-width / fit-page zoom, text you can select and copy, drag-to-highlight annotations (text or a drawn area) that link back to notes, and AcroForm form filling — checkboxes, text fields, dropdowns, Tab between fields — with saved files that render correctly in other viewers. A file that can't be opened says why instead of loading forever, and offers to open it in the system viewer.
• ⌘P exports the current note as a styled PDF, including tables, images, math, and diagrams. No browser involved. (One quirk: the export writes glyphs directly, so font ligatures render in the app but not in the PDF.)
• Whiteboards are infinite pan-and-zoom canvases with shapes, arrows, freehand drawing, images, text, templates, and cards that link back to pages — plus mindmap and flowchart connectors that stay attached when you move things.

Details: PDF & images · Whiteboards

Search

• Full-text search runs on a trigram index and updates on every keystroke, staying fast into the tens of thousands of pages (numbers below). Results are grouped by type — pages, PDFs, images, whiteboards — with filter chips. ⌘F finds within the open page or across the journal feed, while you edit.

Details: Search

Privacy, customization, and languages

• More than one set of notes? Notebooks are self-contained data folders (a work set, a personal set, a folder in Dropbox) switched from a chip at the bottom of the sidebar or Settings → Notebooks; switching relaunches into the picked one.
• Notes live in one local SQLite file, with images and PDFs beside it. The whole database can be encrypted (SQLCipher, AES-256), with an unlock screen, optional keychain storage of the password, and an idle auto-lock.
• Importers exist for Obsidian (vault, links, properties, callouts, canvas boards) and Logseq (graph, whiteboards, PDF highlights); imports don't touch the source. And the way out is just as open: File → Export Notebook as Markdown writes the whole notebook as plain markdown + assets (whiteboards as JSON Canvas), readable by any other app.
• The app speaks English and 简体中文 (Settings → General → Language); the Chinese localization is community-contributed. Translations are plain YAML files, so adding a language is a pull request, not a rebuild.
• Appearance: built-in and JSON-file themes, light/dark/auto (Auto follows the OS), any installed or imported font, an adjustable text size, an optional line-number gutter, a sidebar that docks left or right, and custom mouse cursor themes (any XCursor pack) — all without forking the UI toolkit.
• A command palette (⌘⇧P) runs any menu command, current-page action, navigation (today, a date, All pages, Graph), or quick setting (WYSIWYG, theme, line numbers, sidebar) by name, showing its shortcut. Every keyboard shortcut is listed under Settings → Shortcuts, grouped by where it applies (app, editing, whiteboard, PDF). The app checks for updates on launch (pre-releases opt-in) and links to the release notes.
• Hardened by a security audit: links open only http, https, and mailto; imports and exports can't read or write outside their folders; the database and data folder are created private to your user.

Details: Password & encryption · Import your notes · Themes · Cursors · Shortcuts

Templates

Create a page named Templates and define snippets with !name headers — every line under a !name (until the next !name) is that template's body:

!meeting
## Meeting {{date}}
- Attendees:
- Notes: {{cursor}}

!standup
- Yesterday:
- Today:
- Blockers:

Then type /meeting in any day or page to insert it. Placeholders expand on insert: {{date}}, {{time}}, {{title}} (the current page/day), and {{cursor}} (where the caret lands). Built-in Markdown commands live in zorite-markdown as SNIPPETS.

Themes

Zorite ships several built-in themes (Zorite, Nord, Solarized, Dracula, Tokyo Night, Foundry, Cyberpunk, CRT, E-Ink), each with a light and dark variant (Cyberpunk and CRT are dark-only). Open Settings (the ⚙ in the title bar) to pick a theme and choose Light / Dark / Auto (Auto follows your system appearance). A quick light/dark toggle also lives in the title bar.

Settings → Appearance also picks the app font (any installed family, or import a .ttf/.otf) and the note text size; a custom theme can name its own font and override every palette token — see the themes docs.

Drop a .json file in your themes folder (Settings → Reveal themes folder) and click Reload. Any color you omit falls back to the base palette, so a theme can be just a few colors:

{
  "id": "midnight",
  "name": "Midnight",
  "dark": {
    "bg_window": "#0d1117",
    "bg_sidebar": "#161b22",
    "bg_content": "#0d1117",
    "fg": "#e6edf3",
    "accent": "#ff7b72",
    "tag": "#d2a8ff",
    "code": "#79c0ff"
  },
  "light": { "accent": "#0969da" }
}

Tokens (each #RRGGBB): bg_window, bg_sidebar, bg_content, fg (text), accent, tag, code. Provide a dark and/or light block. Add "dark_only": true for an always-dark theme.

Install

Every release attaches .dmg, .exe/.msi, .deb, .AppImage, .rpm, and .pkg.tar.zst artifacts plus SHA256SUMS on the Releases page. On macOS and Windows, the package managers track the latest stable tag and get you past the first-launch Gatekeeper / SmartScreen warnings.

# macOS — Homebrew (6.0.0+ requires trusting the tap before installing)
brew tap packetThrower/tap
brew trust packetThrower/tap
brew install --cask zorite                          # stable
brew install --cask zorite@alpha                    # pre-release

# Windows — winget (Microsoft's package manager, preinstalled)
winget install packetThrower.Zorite                 # or: winget install zorite

# Windows — Scoop
scoop bucket add packetThrower https://github.com/packetThrower/scoop-bucket
scoop install zorite                                # stable
scoop install zorite-prerelease                     # pre-release

# NixOS / Nix (Linux) — builds from source via the repo flake
nix run github:packetThrower/zorite

winget carries stable only; for pre-release builds on Windows use Scoop or the Releases page directly. Linux users grab the matching .deb / .rpm / .AppImage / .pkg.tar.zst from Releases (pacman -U for the Arch package). The AppImage carries update information and ships a .zsync, so AppImageUpdate, AppImageLauncher, and friends can delta-update it (from 0.11.0 onward).

To install by hand, download from Releases and drag Zorite.app to /Applications on macOS, or run the installer on Windows. The macOS builds are ad-hoc signed, so the first launch needs a right-click → Open (or xattr -cr Zorite.app); the Windows installer is unsigned, so SmartScreen needs More info → Run anyway. Notarized macOS and signed Windows builds are planned — see TODO.md.

Building from source

The repo is a Rust workspace: the app plus six reusable crates.

git clone [email protected]:packetThrower/zorite.git
cd zorite
cargo run                       # debug build + launch
cargo build --release           # optimized binary at target/release/zorite
cargo test --workspace          # run the tests

The first cargo build compiles gpui's full dependency graph and takes a few minutes; incremental builds are fast. Toolchain: a recent stable Rust (via rustup). Platform libraries:

• macOS: Xcode command-line tools (xcode-select --install).
• Debian / Ubuntu: sudo apt install libxkbcommon-dev libxkbcommon-x11-dev libwayland-dev libx11-dev libxcb1-dev libxcb-randr0-dev libxcb-xkb-dev libxcb-cursor-dev libxcb-shape0-dev libxcb-xfixes0-dev libxcb-render0-dev libfontconfig1-dev libfreetype-dev pkg-config
• Windows: nothing extra; the gpui DirectX backend ships with Windows 10+.

Your data lives at:

OS	Path
macOS	~/Library/Application Support/zorite/zorite.db
Linux	$XDG_DATA_HOME/zorite/ (or ~/.local/share/zorite/)
Windows	%APPDATA%\zorite\

ZORITE_DATA overrides the whole data directory (and ZORITE_DB just the database file), so you can run against a throwaway data set without touching your real notes.

Workspace layout

zorite/
├── src/                       the app — journal feed, pages, search, slash menu, import, SQLite
└── crates/
    ├── zorite-editor/         a from-scratch WYSIWYG Markdown editor (live preview, tables, math hosting)
    ├── zorite-markdown/       a reusable Markdown renderer for gpui (clickable links, Mermaid, math)
    ├── gpui-bidi/             bidirectional text for gpui (RTL caret/selection/row layout)
    ├── gpui-pdf/              a page-virtualized PDF viewer (pure-Rust hayro) with highlight markup
    ├── gpui-whiteboard/       a host-agnostic infinite-canvas whiteboard
    ├── os-cursors/            custom mouse cursors without forking the toolkit
    ├── os-spellcheck/         native OS spell-checking (NSSpellChecker / ISpellChecker)
    └── ratex-gpui/            a structural (MathQuill-style) math editor + LaTeX renderer (RaTeX)

Each crate is host-agnostic, MIT-licensed, and published on crates.io:

Crate
zorite-editor	crates.io	docs.rs
zorite-markdown	crates.io	docs.rs
gpui-bidi	crates.io	docs.rs
gpui-pdf	crates.io	docs.rs
gpui-whiteboard	crates.io	docs.rs
os-cursors	crates.io	docs.rs
os-spellcheck	crates.io	docs.rs
ratex-gpui	crates.io

Each carries its own README and a complete API.md.

Performance

The numbers below come from synthetic databases built by scripts/gen_perf_db.py — a 3-level Area::Topic::Note namespace tree with [[wiki-links]], inline images, and a couple weeks of journal days. ZORITE_DB points the app at a throwaway database, so your real notes are never touched:

python3 scripts/gen_perf_db.py 10000 /tmp/zorite-perf.db
ZORITE_DB=/tmp/zorite-perf.db cargo run

Hot-path query timings (SQLite, best of several runs on a development Mac):

Operation	1,000	10,000	50,000
Load the page list (list_pages)	0.3 ms	4.4 ms	26 ms
Search per keystroke (FTS5 trigram)	0.07 ms	0.11 ms	0.09 ms
Backlinks for a page (indexed)	0.005 ms	0.005 ms	0.005 ms
Seed the recent list (first launch only)	0.1 ms	2.3 ms	12 ms

list_pages loads only id/title, not page content, which keeps it fast and memory flat. Search is a trigram FTS5 index, so it stays around 0.1 ms whether the database holds a thousand pages or fifty thousand. Memory (resident set size):

Metric	Empty DB	10,000 pages	50,000 pages
RAM (RSS)	~86 MB	~135 MB	~138 MB
Database file (incl. index)	60 KB	48 MB	229 MB

RAM barely moves from 10k to 50k pages: the page list holds only id/title (about 2 MB at 50k), not the note bodies, which load one page at a time as you open them. The database file grows mostly with the FTS trigram index. At 50,000 pages, launch, navigation, search, and scrolling remain fast, and the sidebar's cost is independent of the total (it's capped to recently-viewed pages).

License

GNU General Public License v3.0 or later. Forks are welcome; derivative works must stay open under the same license. Commercial use is permitted but can't close the source.

The reusable crates under crates/ are licensed MIT so any gpui application can use them.

Third-party dependencies keep their own licenses (see THIRD-PARTY-LICENSES.html); HEIC/AVIF decoding bundles an AGPL-3.0 component (heic_decoder).