Encrypted notes that look and work like the Notes app. Folders, notes, Markdown that renders as you type, images pasted straight in — and all of it, images included, encrypted into one file, unlocked by an email and a password that are stored nowhere.
macOS, Windows and Linux. English, 简体中文, 繁體中文, 日本語.
Three panes — folders, notes, the note — laid out the way Notes lays them out. The editor shows headings, lists, quotes, code and images as you type, and what it keeps underneath is plain Markdown: nothing is rewritten, nothing is converted, and the text you get back is the text you wrote. Paste a screenshot or drop an image and it is encrypted into the vault with the note.
There is no account to sign in to, no server that holds anything, no sync service, no telemetry. The only thing the app ever connects to is a backup destination you set up yourself — and what arrives there is an opaque file.
The vault is one file, encrypted end to end. Copy it to a USB stick, keep it in a synced folder, put it anywhere. Someone who takes the file gets ciphertext.
Warning
There is no recovery. No reset link, no recovery phrase, no support that can help. Forget the email or the password and the notes are gone — you are in exactly the same position as someone who took the file. That is the design, not a gap in it. Set up a backup, and keep the password somewhere you will find it.
Nothing to build and no commands to run: download the installer for your machine from the latest release.
| Machine | Download | Then |
|---|---|---|
| macOS, Apple silicon | neko-note-<version>-macos-apple-silicon.dmg |
Open it and drag Neko Note into Applications. |
| macOS, Intel | neko-note-<version>-macos-intel.dmg |
Same. |
| Windows 10 / 11, 64-bit | neko-note-<version>-windows-x64-setup.exe |
Run it. It installs for the current user and needs no administrator rights. |
| Linux, x86_64 | neko-note-<version>-linux-x64.AppImage or .deb |
AppImage: allow it to run as a program in its file properties, then open it. .deb: open it with your package manager. |
The builds are not code-signed, so the first launch asks for one extra click:
- macOS says the app could not be opened because it cannot verify the developer. Open System Settings → Privacy & Security, scroll to the bottom, and press Open Anyway beside Neko Note. Once is enough.
- Windows SmartScreen says it protected your PC. Press More info, then Run anyway. Once is enough.
On Windows the app uses WebView2, which Windows 10 and 11 already include; the installer fetches it if it is missing.
The first run asks for an email and a password and creates the vault. The password meter measures what a password is actually worth, not how many symbol classes it uses. After that, the window is the whole interface:
| Shortcut | Does |
|---|---|
⌘N |
new note |
⌘⇧N |
new folder |
⌘F |
search — titles at once, full text as you keep typing |
⌘S |
save, and back up right now |
⌘L |
lock now |
⌘, |
settings |
⌘B ⌘I ⌘E ⌘K |
bold, italic, code, link |
⌘⌫ |
move the note to Recently Deleted |
On Windows and Linux, Ctrl stands in for ⌘, and the menus show the chord
the way your platform writes it. Right-click anywhere for the rest.
Notes save themselves as you type. Deleted notes wait thirty days in Recently Deleted before they are gone.
The vault locks itself after a period without input — one minute by default,
up to an hour — and by hand with ⌘L. Locking is not a screen in front of the
notes: the keys are erased from memory, the decrypted search index with them,
and the window is blurred in the same frame the lock begins, so a screen
share or a glance over your shoulder stops seeing text before the keys are
actually gone. Anything you were typing is sealed first, and offered back
when you unlock.
The timer runs in the app's core, not in the interface, so a background tab being throttled or a laptop lid being closed cannot postpone it.
Backups go to places you already have. Several at once, if you like — each one gets every backup.
| Destination | What it needs |
|---|---|
| GitHub | a private repository, created for you if it does not exist yet, and a fine-grained token limited to it |
| WebDAV | a server address and a login: Nutstore, Nextcloud, a Synology or QNAP NAS, anything that speaks WebDAV |
| FTP / FTPS | a host and a login, with or without TLS |
| Google Drive | a folder in your Drive that only this app can see, via your own OAuth client |
Backups happen on their own once the vault has been quiet for a while after
an edit — thirty seconds by default — and right away when you press ⌘S.
Locking takes one too, if anything is still unsent, and never cuts a running
backup off. The corner of the editor shows where the backup is going, and a
notice says when it has arrived, or why it has not.
What is stored is the vault, encrypted again before it leaves the machine: no folder names, no note count, no timestamps, only sealed blocks. Each block is sealed deterministically, so an unchanged block produces identical bytes and is stored once; editing one note uploads one block, not the whole vault. The cost, stated plainly: someone with access to the destination can see how much changed between two backups, though never what.
Every backup can be restored from inside the app, with its date and version number listed. On a machine that has nothing yet, the lock screen offers to restore from a backup directly: the destination, its login, and the email and password the backup was made with are all it needs.
vault.db ← the notes, the images, the settings. All of it.
No -wal, no -shm, no sidecar files: the database runs in
journal_mode = DELETE specifically so that copying the file copies
everything. It is encrypted end to end, so it is safe in places you would
never put a key.
| Where | |
|---|---|
| macOS | ~/Library/Application Support/dev.neko.neko-note/vault.db |
| Windows | %APPDATA%\dev.neko.neko-note\vault.db |
| Linux | ~/.local/share/dev.neko.neko-note/vault.db |
The NEKO_NOTE_DB environment variable points the app at a vault somewhere
else — a USB stick, say — for people who want that.
email + password
│ NFKC-normalised; email lower-cased, password case-preserved
│ length-prefixed, so no two credential pairs collide
↓ Argon2id — 128 MiB to 1 GiB, calibrated on this machine at setup
KEK ─────────────────────────── HKDF ──► BackupKey
│ unwraps (seals every backup)
↓
DEK ─┬─ HKDF ─► FieldKey note bodies, titles, folder names, images
└─ HKDF ─► MetaKey integrity MAC, image deduplication
Every field is sealed with XChaCha20-Poly1305 and bound to the table, column and row it lives in, so a ciphertext cannot be moved between notes or columns and still open. Field lengths are padded into 32-byte buckets, because the length of a title is itself information.
There is no separate password check. Unwrapping the DEK is the check, so a guess costs exactly one Argon2id evaluation, and a wrong email and a wrong password produce the same error — the tag check genuinely cannot tell them apart, and guessing on your behalf would be a lie.
The backup key hangs off the KEK rather than the DEK, which is what makes a restore onto a bare machine possible: the backup carries its own salt and cost parameters, so the email and the password are all it needs.
Inside the file: random row ids, the folder structure, and modification timestamps — the note list sorts on those, and decrypting every note to order a list is not acceptable. What leaks is an activity profile, never content.
It does not keep a password hint, a verifier, or an email hash, because each would make guessing cheaper than one Argon2id evaluation. And it keeps no log file in release builds, because a log file is where note text leaks.
English, 简体中文, 繁體中文, 日本語. Detected from your system, changed any time in settings, remembered in the vault so the lock screen is already in your language.
Fonts follow the language: 简体, 繁體 and 日本語 share many characters and draw them differently, and the interface changes typeface, line height and weight with the language rather than picking one and hoping. Every string is checked at build time — a missing key, a mismatched placeholder or a hard-coded date format fails the build rather than reaching a user.
Protects:
- The vault file being copied, leaked by a sync service, or recovered from a discarded disk — without the password it is ciphertext.
- A backup destination being read by whoever runs it, or breached — what it holds is sealed a second time with a key that never leaves your machine.
- Tampering with individual rows of the file.
- Weakening the KDF parameters in the file to make it easier to crack.
- Someone at your unattended desk, once the idle lock has fired.
Does not:
- Forgetting your password. Permanent, total loss. This is what "no recovery" means.
- A keylogger or remote-access trojan on the machine. While the vault is open, its keys are in this computer's memory.
- A weak password.
Password123with Argon2id is stillPassword123.
pnpm install
pnpm tauri devRust stable and Node 22. On Linux, libwebkit2gtk-4.1-dev and
libgtk-3-dev as well.
cargo test --workspace
cargo clippy --workspace --all-targets -- -D warnings
pnpm test # editor transforms
pnpm typecheck # includes locale key and placeholder parityThe cryptography is pinned against frozen vectors in vectors/, shared by
the Rust and TypeScript sides, so a refactor that changes a derived key fails
immediately.
note-crypto Argon2id / XChaCha20-Poly1305 / HKDF / padding. No IO, no SQL.
note-vault the key hierarchy, KDF profiles and calibration, password strength
note-store SQLite, migrations, field-level envelopes (never derives keys)
note-core sessions, locking, search, and the backup engine and its destinations
src-tauri the desktop shell: commands, events, the scheduler, the image protocol
src React + MUI: the panes, the CodeMirror editor, settings, i18n
scripts/build-windows.sh builds the Windows installer from a Mac; the
release workflow builds every platform's installer from a version tag.
MIT. See LICENSE.