A fully open-source local note-taking app that takes the best of Obsidian and pushes further on AI integration, CLI workflows and plugin sandboxing.

Features • Installation • Quick Start • Shortcuts • CLI • Development • License

🌐 README available in: English | 中文 | 日本語 | Français | Deutsch | Español

If you find MindZJ useful, consider supporting the project

MindZJ Main Interface

Math Formulas

Markdown Basics

MindZJ Plugins

MindZJ Welcome

Editing Markdown with live preview

• Offline, local-first — MindZJ is a fully offline note-taking app. Every note lives in your vault as a plain .md file on your own disk, all data is stored locally, and nothing is ever uploaded to any server
• AI-native kernel — Ollama (offline), Claude and OpenAI are first-class citizens, wired directly into the Rust kernel
• CLI-first — a full command-line interface that plays nicely with pipes, scripts and AI tool chains
• Lightweight — built on Tauri 2.0 (~10 MB installer) instead of Electron (~150 MB)
• Cross-platform — Windows, macOS, Linux, iOS and Android from a single code base
• Plugin sandbox — plugins run inside WebWorkers with declarative permissions, safer than the Obsidian model

• Live preview + source + reading — three editor modes, instantly toggled with Ctrl+E
• Markdown all the way — headings, lists, tables, code fences, math (KaTeX), callouts, Mermaid diagrams
• Smart list continuation — Enter extends the current list, Tab / Shift+Tab to indent/outdent
• Inline image paste — clipboard images are saved into the vault and referenced automatically
• Auto-save — every change is persisted atomically with fsync + rename, no data loss on power cuts
• Snapshots — every edit creates a timestamped snapshot so you can always roll back

• Wiki links — [[note]] style links with autocomplete and backlink tracking
• Outline view — jump through headings with a single click
• Full-text search — powered by the Rust tantivy engine, instant even on large vaults
• Command palette — Ctrl+P to launch any command
• Tabs & splits — right-click a tab to split right, left, up or down
• File tree — drag and drop, custom sort order, pinned folders

• Native .mindzj format — a dedicated mind-map editor ships as a built-in plugin
• Rainbow connections, drag & drop, copy / cut / paste — every feature from the standalone MindZJ plugin is available here too

• 6 languages out of the box — English, 简体中文, 日本語, Français, Deutsch, Español

• Theming — light / dark / system, with CSS variables you can override per vault
• Hotkeys — rebind every shortcut through a visual recorder in Settings
• Plugins — install community plugins, write your own against the Obsidian-compatible API

Coming soon — grab the latest installer from GitHub Releases.

git clone https://github.com/zjok/mindzj.git
cd mindzj
npm install
npm run tauri:build

The installer will be in src-tauri/target/release/bundle/.

• Rust ≥ 1.77
• Node.js ≥ 20 LTS
• Tauri 2.0 prerequisites

1. Launch MindZJ and pick a folder as your vault
2. Press Ctrl+N to create a new note, or drop existing .md files into the folder
3. Start typing — Markdown renders live as you go
4. Use [[wiki-link]] to cross-reference other notes
5. Open the command palette with Ctrl+P and type to find any action
6. Toggle view mode with Ctrl+E — live preview → source → reading → live preview
7. Press Ctrl+, to open Settings and customise everything to your taste

All shortcuts are rebindable in Settings → Hotkeys.

MindZJ ships with a standalone mindzj CLI that talks to the same Rust kernel as the desktop app.

# Open a vault
mindzj vault open ~/my-notes

# Create, list, search, read notes
mindzj note create "My new note"
mindzj note list
mindzj note search "keyword"
mindzj note read "My new note" | grep "TODO"

# AI integration
mindzj config api-key create
mindzj ai ask "How is my project going?"

Every kernel operation you can perform through the GUI is also reachable from the CLI — ideal for scripting, bulk imports, and AI tool chains.

1. Kernel / UI separation — every file operation goes through the Rust kernel API, the frontend never touches the file system directly
2. Atomic writes — every save is write temp → fsync → rename, survives power loss
3. Path traversal protection — every path is validated against the vault root
4. Automatic snapshots — each edit is backed up so you can always undo
5. Plugin sandbox — plugins run in WebWorkers with an explicit permission manifest

mindzj/
├── src-tauri/            # Rust backend (kernel + Tauri commands)
│   └── src/
│       ├── kernel/       # Core: vault, links, search, snapshots
│       └── api/          # Tauri command handlers
├── src/                  # SolidJS frontend
│   ├── components/       # UI components
│   ├── stores/           # Reactive state
│   └── plugin-api/       # Plugin API types
├── cli/                  # Standalone Rust CLI
└── docs/                 # Documentation

# Install dependencies
npm install

# Start the full Tauri dev app (Rust backend + Vite frontend + HMR)
npm run tauri:dev

# Frontend only (no native shell)
npm run dev

# Type check
npm run typecheck

# Production build
npm run tauri:build

If you find MindZJ useful, consider supporting the project:

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0-or-later).

Made with ❤️ by SuperJohn · 2026.04