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) and
gpui-component.
Developed in close collaboration with Claude (Anthropic).
- 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 for fractions, roots, and matrices, in the style of MathQuill; formulas can be copied as LaTeX or exported as PNG/SVG.
Details: Journal & pages · Math
- Wiki links create pages on first use. Every page lists its backlinks, plus
unlinked mentions that can be converted with a click.
Projects::Taskstitles form a namespace tree, and renaming a namespace renames its children. - Any line can be given a
^idanchor and linked with[[Note#^id]]; headings can be linked directly.![[Note]]embeds another note (or one of its sections or blocks) and updates live when the source changes. Both the reading view and the editor render all of this. key:: valuelines 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.
Details: Journal & pages · All pages & the graph
- 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, drag-to-highlight annotations that link back to notes, and AcroForm form filling — checkboxes, text fields, 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.
⌘Pexports 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.
Details: PDF & images · Whiteboards
- 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, and
⌘Fsearches within the open page.
Details: Search
- 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.
- Appearance: built-in and JSON-file themes, light/dark/auto, any installed or imported font, and an adjustable text size.
Details: Password & encryption · Import your notes · Themes
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
gpui-markdown as SNIPPETS.
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.
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/zoritewinget 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).
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.
The repo is a Rust workspace: the app plus six reusable crates.
git clone git@github.com:packetThrower/zorite.git
cd zorite
cargo run # debug build + launch
cargo build --release # optimized binary at target/release/zorite
cargo test --workspace # run the testsThe 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.
zorite/
├── src/ the app — journal feed, pages, search, slash menu, import, SQLite
└── crates/
├── gpui-editor/ a from-scratch WYSIWYG Markdown editor (live preview, tables, math hosting)
├── gpui-markdown/ a reusable Markdown renderer for gpui (clickable links, Mermaid, math)
├── gpui-pdf/ a page-virtualized PDF viewer (pure-Rust hayro) with highlight markup
├── gpui-whiteboard/ a host-agnostic infinite-canvas whiteboard
├── os-spellcheck/ native OS spell-checking (NSSpellChecker / ISpellChecker)
└── ratex-gpui/ a structural (MathQuill-style) math editor + LaTeX renderer (RaTeX)
Each crate is host-agnostic and carries its own README.
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 runHot-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).
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.
Third-party dependencies keep their own licenses (see
THIRD-PARTY-LICENSES.html); HEIC/AVIF decoding
bundles an AGPL-3.0 component (heic_decoder).
