Local-first
Every feature works offline. Sync is an enhancement, never a requirement, so the vault keeps working when the network does not.
local-first · zero-knowledgeStableJune 2026 - PresentUpdated Nov 2026
Enclave
Knowledge that stays yours — encrypted on your device and synced only across your own network.
A zero-knowledge knowledge base with an offline AI assistant, moving from a shared Tauri app to dedicated native apps on one audited Rust core.
12-word
BIP39 phrase
4
Platforms
0
Cloud servers
MIT
Open source
vision
A private place only your key opens
Enclave treats data ownership as an engineering constraint rather than a promise: the vault is encrypted before it is stored, the key is derived from a phrase that never leaves the device, and devices sync directly over the local network. The native-app migration keeps that contract while removing the browser engine from the vault.
Zero-knowledge
There is no account and no telemetry. Notes are encrypted with SQLCipher, keys come from a 12-word BIP39 phrase through Argon2id, and no Enclave server ever sees plaintext.
One audited core
Desktop and Android consume the same versioned Rust core and the same contract — vault schema v1, block schema v1, sync protocol v3 and the FFI boundary — so the apps cannot drift.
Why it stands out
The decisions, trade-offs, and details that make Enclave worth your time.
01
Stable on Windows, Linux, macOS and Android beta from one codebase
02
Zero-knowledge by design: a BIP39 phrase, Argon2id-derived keys and SQLCipher-encrypted storage
03
mDNS discovery plus mutually authenticated, XChaCha20-Poly1305 sync — no servers
04
Offline RAG with in-process ONNX embeddings and sqlite-vec inside the encrypted vault
05
Moving to dedicated native apps on one versioned Rust core: Kotlin and Compose on Android next
Private by construction, useful by default
Enclave is a full knowledge workspace, not a locked box: documents, databases, whiteboards, an offline assistant and device-to-device sync, with the security model shaping every layer.
Encrypted at rest
The SQLite vault is encrypted with SQLCipher (AES-256-CBC with HMAC-SHA512) before it touches disk. A 12-word BIP39 phrase derives the 256-bit master key through Argon2id (64 MiB, 3 iterations, 4 parallelism); the phrase is never written to disk in clear.
Sync without a server
Devices discover each other with mDNS and sync directly over WebSocket. Peers must prove knowledge of the vault-derived sync key in a challenge-response handshake, and every frame after it is sealed with XChaCha20-Poly1305. Other devices on the Wi-Fi see only challenges and ciphertext.
An offline AI assistant
Ask questions across the vault with retrieval-augmented generation. In-process ONNX embeddings (all-MiniLM-L6-v2) and a sqlite-vec ANN index live inside the encrypted file, with exact-cosine re-ranking in Rust, so with offline embeddings enabled retrieval never leaves the device.
A real editor
Paper mode has slash-command blocks, code, callouts, toggles, page links and backlinks, mentions, PDFs and files. Typed databases add 12 column types and five views — table, kanban, list, gallery and timeline — with grouping, sorting and filters.
Whiteboards and graph
Every page can switch to an infinite whiteboard with stickies, shapes, arrows, frames, page embeds and mind maps, presented frame by frame or exported as PNG. The graph view maps the connections between pages.
A native Android app
The next stable is a Kotlin and Jetpack Compose app on the same core: four note layouts, a create stack with user templates, widgets, a share target, auto-lock and a branded vault gate. It is verified on a real device and is not part of the current stable yet.
Updates you approve
Enclave never phones home. Update checks are opt-in, every release is reviewed individually, and the download is verified against GitHub's SHA-256 and a pinned Ed25519 signature before the installer is allowed to run.
Portable by design
Export a page as Markdown or HTML, or take the whole vault as a still-encrypted backup. Android restores a backup from the gate or Settings after re-authentication, and the restore is refused if the backup belongs to another vault or a newer schema.
One core, dedicated apps
The rebuild removes the webview: Kotlin and Compose on Android, Qt 6 on desktop, and the same Rust core behind a versioned contract. Android is the next stable; the desktop decision and its verification gate are recorded in ADR 0004.
Create → write → sync → ask
The security model is a sequence a user can follow: a phrase creates the vault, the key never leaves the device, and the same key authorises every peer.
Create the vault
Enclave generates a 12-word BIP39 phrase client-side and asks you to save it. Argon2id derives the master key, which becomes the SQLCipher key for the database; the phrase is kept only as a re-encrypted vault.key file.
Write offline
Create pages, databases, whiteboards and folders without a network. The vault is the source of truth and every edit is local first.
Sync on your network
Start sync to advertise over mDNS. Peers authenticate with HMAC-SHA256 proofs, exchange encrypted full snapshots, and merge at document level with last-write-wins and tombstones.
Ask your vault
Enable the assistant and point it at any OpenAI-compatible endpoint. With offline embeddings on, retrieval runs entirely on the device and answers list the pages they used.
Move to native
The same contract now drives a Kotlin and Compose Android app and the planned Qt 6 desktop app, with golden fixtures and version checks keeping every client interoperable.
One core, every app
Tauri v2 + SvelteKit ──────────────┐
Windows · Linux · macOS · Android ├──▶ Rust core (core-db · core-network · core-api)
Kotlin + Compose (Android, next) ──┘
│
▼
SQLCipher vault (SQLite)
├─ documents, blocks, folders
├─ FTS5 + sqlite-vec ANN
└─ mDNS + WebSocket sync
HMAC-SHA256 auth · XChaCha20-Poly1305
full snapshots · doc-level last-write-winsTech stack
One Rust core, one versioned contract and a deliberately small stack that a single owner can audit and run.
RustTauri v2Svelte 5SQLCipherP2P syncXChaCha20-Poly1305sqlite-vecAndroid
Licensed under MIT.
Repositorygithub.com/Pranesh-Selvaraj/Enclave
LicenseMIT
Latest releasev1.15.0 — Tauri desktop and Android builds
PlatformsWindows, Linux, macOS + Android (beta)
Native appsKotlin + Jetpack Compose (Android, next stable); Qt 6 (desktop, planned — ADR 0004 accepted)
ShellTauri v2 (Rust) — one SvelteKit frontend and one Rust core
FrontendSvelteKit (static adapter) + Svelte 5
EditorTiptap 3 (ProseMirror) + custom Svelte 5 extensions
StorageSQLite + SQLCipher (AES-256-CBC + HMAC-SHA512)
KeysBIP39 12-word phrase → Argon2id → HKDF-SHA256 sync key
SyncmDNS discovery, WebSocket, HMAC-SHA256 peer auth, XChaCha20-Poly1305 frames, doc-level LWW
Local AIOpenAI-compatible /v1 — Ollama, llama.cpp, LM Studio, vLLM or a frontier API
EmbeddingsIn-process ONNX all-MiniLM-L6-v2 (offline) or /v1/embeddings
Vector searchsqlite-vec ANN inside the encrypted vault, exact-cosine re-ranked in Rust
ContractVault schema v1 · block schema v1 · sync protocol v3 · FFI, with golden fixtures
UpdatesOpt-in checks; SHA-256 + pinned Ed25519 signature verification
CI/CDGitHub Actions — Rust tests, Windows .msi/.exe, Linux .deb/.AppImage, macOS .dmg, signed Android APK/AAB
Built in the open. Star it, try it, break it.
Enclave is MIT-licensed and developed in public. Feedback, issues, and contributions are genuinely welcome.