Back to Blog
2026-07-16•5 Tags

Building PaperCache: Why I Made a Floating Knowledge Manager

open-sourcetaurirustreactproductivity

Have you ever been deep in a coding problem or a fast-moving meeting, needed to jot down a quick note, do a fast calculation, or draft a thought, and felt the overwhelming friction of opening your heavy notes app?

Traditional knowledge bases are built like databases. They demand titles, folders, tags, and permanent structure before you even type your first word. But our actual day-to-day thinking isn't like that—it's messy, ephemeral, and fast.

I saw a beautifully designed app called Antinote that tackled this floating scratchpad concept, but it was locked behind a paywall. I wanted something just as sleek that fit my exact workflow as a developer without paying monthly rent for my own scratch notes. So I decided to build my own: PaperCache.

Once I built it and felt how much time it saved me every single day, I realized thousands of other developers and power users likely felt the exact same friction. So I made it 100% free, open-source, and local-first for everyone. You can explore the live web version, feature documentation, and downloads right now at papercache.vrbl.win.

What Exactly is PaperCache?

PaperCache is a floating, background-first knowledge manager that stays completely invisible until you need it. There's no window cluttering your desktop and no icon sitting in your macOS Dock.

When you press your global shortcut (Cmd+Shift+C or Cmd+Shift+N), a crisp, minimalist notepad materializes right on the active monitor where your mouse cursor is currently resting. You jot your thought, check off a task, or run an equation. The moment you click away or press Esc, it vanishes back into the background—using zero CPU and leaving your workspace spotless.

Core Philosophy: Active Over Passive

Most markdown editors are passive sheets of digital paper. I wanted PaperCache to feel like an active collaborator—a lightweight spreadsheet disguised as a clean notepad:

  • Reactive Math & Variables: Type an equation like 120 * 1.18 = and PaperCache instantly evaluates and appends the result. Even better, you can declare live variables right inline: /var rate = 85 and later write rate * 40 = to get 3400. If you update rate anywhere in the document, every dependent calculation instantly recalculates in real-time across your notes.
  • Invisible Inline AI: Instead of breaking your flow to open a browser tab for ChatGPT, you just type /ai summarize these bullet points right in your editor. Press Enter, and the response is streamed directly inline. Or use /ctx to automatically inject your entire note as context. It works out-of-the-box with free models on OpenRouter as well as local Ollama instances, with all API keys encrypted locally using your OS keychain.
  • Developer-First Micro-Interactions: Hex colors (like #D97757) render as clickable color pills—clicking the circle instantly copies the code. Dates and timestamps turn into neat badges. Interactive slash commands let you spin up strikethrough checkboxes (/check), countdown timers with native OS notifications (/timer), and due-date task reminders (/task @ 1d2h) with auto-expire cleanup.
  • Interactive Knowledge Graph: Press Cmd+G to launch a WebGL-powered 2D/3D knowledge graph that clusters notes by folder and lets you fuzzy-search (Cmd+F) to fly straight to any node.

The Journey: From Electron to Tauri & Rust

The early prototypes of PaperCache (originally called Antipaper) were built using web tech and Electron. Electron gave us rapid iteration, but shipping a complete Chromium browser and Node.js runtime inside a background hotkey tool felt wrong:

"For a utility whose entire purpose is to stay out of the way and consume near-zero resources while idling, sitting on 100+ megabytes of RAM just to render a notepad was unacceptable."

In v0.5.0-beta, we made the architectural leap to migrate the entire system to Tauri v2 and Rust. That rewrite transformed what the application could do:

  • 90% Smaller Binaries: Because we leverage the operating system's native webview (WebKit on macOS, WebView2 on Windows) instead of bundling Chrome, the macOS installer shrank from ~80MB down to a razor-thin ~6.8MB.
  • 66% Less RAM & Zero Idle CPU: Idle memory usage dropped under 38MB, and when hidden, the app uses literally 0.0% CPU.
  • Deep Native OS Hooks: Writing custom Rust allowed us to hook directly into low-level macOS Cocoa APIs to completely detach from the Dock as an accessory app, accurately calculate multi-monitor mouse coordinates to prevent space jumping, and fire reliable native desktop notifications.

Obsession with Speed & Security

As the project matured through recent releases (up to v0.5.9), the focus turned to ruthless optimization and self-reliance:

We discovered that third-party math parsers like expr-eval carried high-severity prototype pollution risks. Instead of accepting bloat, we built our own recursive-descent arithmetic and variable evaluator from scratch in ~150 lines of zero-dependency TypeScript with full unit test coverage. We offloaded the heavy Three.js knowledge graph to lazy-loaded WebGL chunks so the editor boots instantly. And we built custom visible-range regex scanning for our custom syntax highlighting, ensuring O(visible lines) performance regardless of how massive your notes grow.

Looking Forward

Building PaperCache has been a masterclass in local-first software, performance engineering, and opinionated UX design. It started as a personal itch—a developer wanting a fast, free, and private scratchpad without another monthly subscription—and has evolved into a robust tool that I rely on every single hour of the day.

If you want to give it a spin, visit the official live app and documentation at papercache.vrbl.win, or install it right now on macOS via Homebrew: 

brew tap variablethe/tap
brew install --cask papercache

You can also check out the source code, inspect our performance benchmarks, and contribute directly over on GitHub.

All PostsEND OF ENTRY