Why I Built Claspt —
The Frustration That Started It All

I had three tools open. 1Password on the left. Obsidian on the right. A plain text file called creds-temp-DO-NOT-COMMIT.txt in the middle. It was 11 PM on a Thursday, and I was trying to deploy an app.

This was not an unusual evening. This was just how things worked. The database password lived in 1Password. The connection string format, including which environment variables to set and what port the staging proxy used, lived in an Obsidian note. And the actual assembled DATABASE_URL lived in that text file because I had pasted together the pieces twenty minutes ago and could not remember which 1Password entry had the right credentials for staging versus production.

That night, I spent twelve minutes looking for the right password. Not because 1Password is bad at what it does. 1Password is excellent at what it does. It fills browser forms. It generates passwords. It has Watchtower alerts. But what it does not do is let me write a paragraph of context next to a credential. It does not let me explain why the staging database uses a different user than production, or that the connection times out after 30 seconds if you forget to enable the VPN first.

The Moment

The specific moment I decided to build Claspt was not dramatic. I was copying a Stripe API key from 1Password, switching to Obsidian to find which environment variable it should be assigned to, then switching back to 1Password because I had already cleared my clipboard. Copy. Switch. Paste. Switch. Copy. Switch. Paste. A tool tax that adds up to hours over weeks.

I stopped and wrote a question in my notebook: Why can't the note and the secret live in the same place?

Not "why can't my password manager have a notes field" because they do, and those fields are 200-character plain text afterthoughts. I mean: why can't I write a full markdown document with headings and code blocks and checklists, and then drop an encrypted credential block right into the middle of it? Why can't my documentation be my vault?

Design Philosophy

I started with four principles that have not changed since that evening:

Surgical encryption

Most encrypted note apps encrypt everything. Your title, your folder names, your grocery list. This means you cannot search without decrypting. You cannot get meaningful Git diffs. You cannot open the file in another editor. In Claspt, only the secret blocks are encrypted. The rest of your content stays as plain markdown. You can grep your vault, diff your vault, and read your notes in any text editor. The secrets are the only part that is opaque.

Markdown-native

Every page in Claspt is a .md file on disk. Not a SQLite database. Not a proprietary binary format. Not a JSON blob inside an encrypted container. A markdown file. If Claspt disappears tomorrow, you still have all your notes. The encrypted blocks will show as enc:v1:<base64> strings, but every piece of non-secret content is immediately readable.

Portable, no vendor lock-in

Your vault is a folder of .md files. You can sync it with iCloud, Dropbox, Syncthing, a USB drive, or a Git repository. You are not locked into our cloud. We do offer optional sync for Pro users, but the app works completely offline with whatever sync method you prefer.

Git-versioned by design

Claspt initializes a Git repository in your vault directory. Every save is a commit. Every change is tracked. You can see the full history of any page, roll back to any version, and understand exactly what changed and when. Because non-secret content stays plaintext, your diffs are meaningful. You can see that you added a new section to your AWS notes or updated the port number in your connection instructions.

Technical Decisions

Why Tauri over Electron

Electron apps are 200MB web browsers masquerading as desktop software. Slack, VS Code, Discord, Notion — they each ship their own copy of Chromium. Claspt is built with Tauri, which uses the operating system's built-in WebView. The result: a ~5MB binary that starts in under 500 milliseconds and uses roughly 80MB of RAM. An Electron equivalent would be 300MB+ of RAM before you open a single note.

Why Rust for the backend

The backend of Claspt — file I/O, encryption, Git operations, search indexing — is written in Rust. This is not because Rust is trendy. It is because Claspt handles cryptographic operations, and Rust guarantees memory safety at compile time. No buffer overflows. No use-after-free bugs. No accidentally leaking decrypted data because a garbage collector did not run in time. When a secret is decrypted in memory, the zeroize crate ensures it is wiped immediately after use, not left floating in a heap until the GC feels like cleaning up.

Why CodeMirror 6

Most note apps use a <textarea> or a rich text editor like ProseMirror. Claspt uses CodeMirror 6, the same editor engine behind many professional code editors. This means proper syntax highlighting for 50+ languages, Vim and Emacs keybindings, multiple cursors, code folding, and a minimap. If you spend your day in VS Code, Claspt's editor will feel familiar, not like a toy.

What Claspt Does Not Do

Honesty matters more than marketing. Here is what Claspt does not do:

• No browser autofill. If your primary workflow is filling login forms in Chrome, use 1Password or Bitwarden. Claspt is not a browser extension.
• No team features. Claspt is a personal vault. There is no shared vault, no role-based access, no enterprise admin panel. If you need team password sharing, that is a different product.
• No plugin system. Obsidian has 1,800+ plugins. Claspt has zero. We ship a focused set of features that work together. No configuration hell, no breaking changes from third-party plugins, no hunting through community forums to find the right combination of extensions.

The Tool I Wished Existed

I built Claspt because I wanted one app where I could document a project, store its credentials, and find everything instantly with a keyboard shortcut. I wanted my notes and my secrets in the same place, encrypted with real cryptography, stored in files I actually own, versioned with a tool I already understand.

I did not build it to replace 1Password or to compete with Obsidian. Both are excellent tools that do things Claspt does not. I built it because the intersection of what they do — the place where notes and credentials meet — had no dedicated tool.

Now it does.