Looking for a Cross-Platform, Private Note-Taking App? Meet VaultBook

The requirements list that serious cross-platform note-takers carry into their search for the right application looks deceptively simple when written down.

Works on every platform they actually use. Stores notes locally without forcing cloud synchronization. Provides real encryption rather than a superficial lock screen. Organizes notes at the depth that professional or academic work requires. Searches across everything - not just note titles but the full content of every note and every attached document. Does not require creating an account with a vendor whose data practices and business continuity are outside the user’s control. Can be moved between devices without complex configuration. And does all of this without a subscription model that is secretly funded by behavioral data collection or feature throttling designed to push users toward higher pricing tiers.

Each individual requirement on this list is satisfied by at least one available application. The difficulty is that no available application satisfies all of them simultaneously - at least not without significant compromise, without a technical setup that requires ongoing maintenance, or without accepting that some of the requirements will be met partially rather than fully.

Obsidian comes close. Its local-first markdown vault is genuinely local, and its core functionality is genuinely powerful. But Obsidian’s cross-platform story relies on Obsidian Sync - a paid cloud service - or on configuring a third-party sync solution like iCloud, Syncthing, or Dropbox with the Obsidian folder, each of which introduces its own complexity, its own privacy considerations, and its own failure modes. The plugin ecosystem that extends Obsidian’s capabilities is powerful but requires ongoing maintenance, introduces compatibility dependencies, and creates situations where the application’s behavior depends on the choices of plugin developers whose priorities may not align with the user’s.

Joplin offers end-to-end encrypted sync and cross-platform availability, but it requires a sync backend - typically a cloud service like Joplin Cloud, Nextcloud, or Dropbox - to provide cross-device access, which means the cross-platform story requires the user to maintain or pay for sync infrastructure alongside the application. Joplin’s organizational model is competent but not deep, and its attachment handling and search capabilities, while present, do not match the depth that serious professional knowledge management requires.

The pattern across every serious cross-platform option is the same: the cross-platform capability is delivered through cloud infrastructure, and the cloud infrastructure introduces the privacy compromises, the vendor dependencies, and the configuration complexity that the requirements list was trying to avoid.

VaultBook resolves this pattern at the architectural level. It is cross-platform because it runs as a single HTML file in any modern browser on any operating system - not because it maintains synchronization infrastructure that makes a cloud-based data store appear to be on every device simultaneously. The vault folder is portable in the literal sense: moving it to a different device by any means the user chooses - USB drive, encrypted external storage, manual cloud sync, peer-to-peer file transfer - makes the full vault immediately available on the destination device, with no reconfiguration, no account authentication, and no dependency on any service that was not already present on the original device. The cross-platform capability is a property of the application’s architecture, not of cloud infrastructure overlaid on a locally-stored application.

The True Cost of Cloud-Dependent Cross-Platform Access

Understanding why VaultBook’s approach to cross-platform availability is architecturally different from the alternatives requires being precise about what cloud-dependent cross-platform access actually costs - not in subscription fees, which are visible and explicit, but in the less visible costs of privacy exposure, vendor dependency, and organizational complexity.

The privacy cost of cloud-dependent sync is the cost that is most frequently underappreciated, because it does not arrive as an event but as a condition. When a note application stores its data in a cloud service - even a cloud service with strong encryption - the user’s notes, their behavioral patterns, and the metadata about their note-taking activity all exist on infrastructure that the user does not control. The vendor’s employees have varying degrees of technical access to that infrastructure. Legal process served on the vendor can compel production of the stored data. Security incidents at the vendor’s infrastructure can expose it. Changes in the vendor’s ownership, terms of service, or business model can alter how the data is used without the user’s active consent.

None of these events need to happen for the privacy cost to be real. The cost is the ongoing condition of having sensitive information on infrastructure whose future is outside the user’s control - the condition of being unable to answer the question “who has access to my notes?” with a complete and accurate answer, because the accurate answer depends on the vendor’s current and future practices rather than on facts the user can verify independently.

The vendor dependency cost of cloud-dependent sync is the cost of having the application’s core functionality - the ability to access notes from more than one device - depend on the continued operation of a service that the user does not control. Application companies are acquired. Services are discontinued. Pricing models change. APIs that third-party sync solutions depend on are deprecated. Each of these events is outside the user’s control and each can disrupt the cross-platform access that the user has built their workflow around. For a professional whose knowledge base represents years of accumulated work, the dependency on any single vendor’s continued operation and pricing decisions is a risk whose significance scales with the depth of the investment.

The configuration complexity cost of cloud-dependent sync is the cost of maintaining a setup that works reliably across multiple devices, multiple operating systems, and multiple platform updates over an extended period. The third-party sync setups that privacy-conscious users of Obsidian and similar applications build - Syncthing configurations, iCloud Drive folder setups, Nextcloud instances - are more complex than a single cloud service and require more ongoing maintenance. They also introduce multiple failure modes: sync conflicts when the same file is modified on two devices before sync occurs, permission issues when platform updates change how applications can access cloud storage folders, and configuration drift when device setups diverge over time.

VaultBook eliminates all three of these costs. The privacy cost is eliminated because the vault never reaches any external infrastructure in normal operation. The vendor dependency cost is eliminated because the vault is a folder of standard files on the user’s device - it does not depend on any service for its integrity or accessibility. The configuration complexity cost is eliminated because the cross-platform capability requires only that the vault folder be present on the device, not that any specific sync configuration be maintained in a specific state.

How VaultBook’s Cross-Platform Architecture Actually Works

VaultBook is a single HTML file. This is the complete description of what the application is as software - one file, containing all of the application’s code, that runs in a browser on any device that has a modern browser installed. The file does not require installation in the conventional sense. It does not depend on any runtime environment beyond the browser. It does not require administrator privileges to place on a device. And it runs identically on Windows, macOS, Linux, Android, iOS, and any other platform that runs a modern browser, because the browser provides the execution environment that makes the application platform-agnostic.

The vault data - notes, attachments, organizational metadata, version history, the analytics index - lives in a folder that the user creates and manages on their own device. The first time VaultBook is opened in a browser, the user connects it to the vault folder using the browser’s File System Access API, which provides the application with read and write access to the specified folder without transmitting anything to any external service. The application reads the vault’s repository file, loads the page structure and note content, and presents the full vault interface - entirely from local files, without any network request.

The repository.json file holds the vault’s complete organizational state: the pages tree, all entry metadata, labels, favorites, vote data, and the index of attachments. Entry bodies are stored as sidecar files in the /attachments directory under the naming pattern details-id.md. Attachments themselves live in the same /attachments directory with an index.txt JSON manifest that the application uses to rebuild the attachment index on load. The versions directory holds per-entry snapshots for VaultBook Pro’s Version History feature. The license.json file holds the subscription tier information.

Moving the vault to a different device requires moving this folder by any means the user chooses. This can be a USB drive transfer, a manual copy through a cloud storage service the user controls, a peer-to-peer file transfer using a tool like AirDrop or Syncthing, or any other file transfer mechanism. Once the vault folder is present on the destination device, opening VaultBook in that device’s browser and connecting it to the vault folder provides immediate access to the complete vault - all notes, all attachments, all organizational structure, all version history, all analytics data. No account authentication. No sync operation. No configuration required beyond pointing the browser to the vault folder.

The Rich Text Environment That Travels With the Vault

One of the capabilities that cross-platform portability must preserve is the editing environment - the formatting and structural features that make professional-grade notes possible. VaultBook’s rich text editor is implemented entirely within the single HTML file, requiring no external dependencies, no plugin installations, and no platform-specific components. It runs identically on every platform that runs the application.

The editing environment provides the full range of formatting that serious note-taking requires: bold, italic, underline, and strikethrough for text emphasis; ordered and unordered lists for structured content; headings at six levels for document organization within notes; font family selection for typographic distinction; case transformation between upper, lower, title, and sentence formats for rapid text reformatting; text color and highlight color pickers for visual organization and annotation; and tables with a size picker and right-click context menu for row and column operations including insertion, deletion, and reordering.

Beyond basic formatting, the editor supports code blocks with language labels and syntax display - essential for technical notes in development, data science, and engineering contexts; callout blocks with accent bars and title headers for highlighting important observations, warnings, and key conclusions; links and inline images for connecting notes to external resources and embedding visual content; and markdown rendering via the marked.js library for users who prefer composing in markdown and having it rendered on display.

The section architecture of VaultBook notes extends this editing environment into a structural dimension. Each note can contain multiple named sections, each with its own full rich text editor and its own set of file attachments. A note organized into sections for Summary, Background, Key Findings, Questions, and Action Items provides the structural organization of a professional document within a single vault entry, with each section’s content independently formatted and each section’s attachments independently managed. The collapsible accordion interface keeps the section structure navigable as notes grow in content, with collapsed sections presenting only their titles until expanded and a clip count badge on each section showing how many attachments it holds.

All entry fields travel with the vault on every device: title, details body, labels, page path, per-entry and per-section attachments, favorite status, protected/encrypted status, due date, expiry date, repeat/recurrence settings, and created-at/updated-at timestamps. Every piece of metadata that shapes how an entry appears and behaves is stored in the repository and is therefore immediately available on every device that opens the vault.

Deep Attachment Indexing Across Every Platform

The attachment and search capabilities that transform VaultBook from a note-taking application into a unified knowledge base are equally platform-agnostic - they run within the browser’s JavaScript environment and do not depend on any platform-specific libraries or native application components.

PDF text extraction via pdf.js covers PDF documents with proper text layers, making every word in every attached PDF searchable through VaultBook’s main search interface regardless of whether the vault is being accessed on Windows, macOS, Linux, or Android. OCR processing of rendered PDF pages extends this coverage to scanned PDFs - those that exist as image content without a text layer - processing them through VaultBook’s OCR capability and making their visual text content searchable alongside digitally-produced PDF content.

XLSX and XLSM spreadsheet files are indexed via SheetJS text extraction, covering cell content across all sheets in a unified search index alongside note text. PPTX presentation files have their slide text extracted through the JSZip-based extraction pipeline, making presentation content searchable without requiring any native Office application. DOCX files are indexed with OCR processing of any images embedded within the document - diagrams, screenshots, and other visual content that would otherwise be invisible to text search. ZIP archive contents are indexed for text-like inner files. MSG Outlook email files are parsed for subject line, sender information, body text, and deep indexing of attachments within the email, including OCR processing of image attachments.

The inline OCR capability processes images pasted directly into note bodies - not attached as files but embedded inline as part of the note’s visual content. A screenshot of an application interface, a photograph of a whiteboard, a captured image of a printed document - any of these pasted into a note body on any device that runs VaultBook is automatically OCR-processed when the note is accessed, with the extracted text cached in the entry’s inlineOcrText field and made available to search. The warm-up process pre-loads OCR results for the top twelve search candidates, ensuring that image-embedded text content appears in search results without additional user action.

This complete indexing pipeline runs identically on every platform because it is implemented in JavaScript running within the browser’s execution environment. The user who attaches a PDF on their Windows desktop and searches for its content on their Android tablet after transferring the vault folder experiences the same search capability on both devices - because the indexing is part of the vault’s stored state in index.txt rather than a platform-specific service.

Organization That Transfers Perfectly Between Devices

The organizational model that professionals and serious knowledge workers build within VaultBook is fully preserved across platform transitions because it is stored in the vault’s repository.json file rather than in any device-specific application state.

The Pages hierarchy - the nested structure of parent and child pages that constitutes the vault’s conceptual map - is stored in the repository alongside the entries it organizes. Moving the vault to a new device moves the hierarchy with it. The drag-and-drop ordering of pages, the page icons and color dots used for visual differentiation, the parent-child relationships that define the nesting structure, and the activity-based sorting preferences are all part of the vault’s data rather than the application’s configuration.

Labels and their color assignments are stored in the repository alongside the entries they categorize. The filtered views that the label system enables - showing all entries carrying a specific label regardless of their Page location - work identically on every device that opens the vault because the label data is part of the vault. Smart Label Suggestions analyze entry content and suggest labels from the vault’s existing label set, displayed as pastel-styled suggestion chips with usage counts - and because the label set is part of the vault, the suggestions are drawn from the same set of labels on every device.

The Favorites panel reflects the favorite status stored in the repository for each entry. An entry starred as a favorite on one device is a favorite on every device that opens the vault - the favorite status is a property of the entry rather than a device-specific preference. The sidebar Time Tabs - Recent, Due, and Expiring - each derive their content from entry metadata stored in the repository: access timestamps for Recent, due date fields for Due, and expiry date fields for Expiring. All of this temporal metadata travels with the vault.

The Multi-Tab Views available in VaultBook Pro allow multiple entry list tabs to be open simultaneously with independent view state per tab. The Sort Controls with multiple sort fields and sort order toggles, and the Advanced Filters with file type, date field, and date range filtering, operate on the vault’s own content as loaded from the repository. These organizational and filtering capabilities work identically across platforms because they are applied to locally stored data through application logic in the HTML file.

The AI Features That Work Without Internet

VaultBook’s AI capabilities are one of the most counterintuitive aspects of the application for users who associate AI features in software with cloud API calls to large language model services. VaultBook’s AI features are powered entirely by the vault’s own indexed content and by the patterns accumulated in the vault’s stored state - no external AI service is contacted, ever.

The AI Suggestions carousel - accessible through the Sparkle pager in the sidebar - provides four pages of intelligent content surfacing that operate entirely from local data. The Suggestions page learns from the user’s engagement patterns over the preceding four weeks, identifying which entries are typically accessed on the current day of the week and surfacing the top three as suggestions alongside any upcoming scheduled entry. This pattern learning is stored in the vault’s repository as part of the vault’s persistent state, meaning that the learned patterns are present on every device that opens the same vault folder.

The Recently Read page maintains a deduplicated list of up to one hundred recently accessed entries with timestamps. The Recent Files page tracks recently opened attachments. The Recent Tools page tracks recently used built-in tools. All of this state is stored in the vault’s repository and is available on every device that opens the vault.

The Related Entries feature in VaultBook Pro surfaces contextually similar entries when the user is viewing any specific note, assessed based on the vault’s indexed content. The vote-based learning that allows the user to train relevance over time - upvoting result pairs that are genuinely related, downvoting pairs that are not - is stored in the repository’s state.userVotes record. Votes applied on one device are reflected in the Related Entries behavior on every device that opens the vault.

The QA natural language search processes queries against the vault’s full indexed content with weighted scoring: titles at weight eight, labels at six, inline OCR text at five, body and details at four, section text at three, and attachment names and content at weights two and one respectively. Paginated results at six per page with navigable previous and next controls allow the user to browse large result sets systematically. The QA Actions upgrade in VaultBook Pro adds vote-based reranking - upvoting floats results in future queries, downvoting sinks them - with accumulated votes persisting in the repository across sessions and across devices.

The Typeahead Search provides real-time dropdown suggestions as the user types in the main search bar, drawing from titles, details, labels, attachment names, and content. The Query Suggestions from History feature surfaces past queries as the user begins typing, drawn from the vault’s own stored search history. The Smart Label Suggestions analyze entry content in the editing modal and suggest relevant labels from the existing label set as pastel chip suggestions with counts. All of these AI features run in the browser’s JavaScript environment, from the vault’s own stored data, without any network communication.

Security Architecture That Is Platform-Independent

VaultBook’s security features are implemented using the Web Crypto API - the browser’s native cryptographic interface that provides hardware-accelerated implementations of cryptographic operations across all modern browsers on all platforms. This means the security model is both technically sound and platform-agnostic.

The per-entry AES-256-GCM encryption uses PBKDF2 key derivation with 100,000 iterations of SHA-256, a random 16-byte salt, and a random 12-byte initialization vector generated freshly for each encryption operation. These parameters are standardized across the Web Crypto API in all modern browsers, meaning that an entry encrypted with a specific password on a Windows browser can be decrypted with the same password in a macOS browser, an Android browser, or a Linux browser. The encryption is not tied to any device-specific keychain or platform-specific key management infrastructure. The encrypted entry’s portability is the portability of the vault folder it lives in.

The session password caching allows per-entry passwords to be entered once per session, with the decrypted plaintext held in memory only in the entry’s runtime state (_plain field) and never written to storage in decrypted form. This session-local behavior is consistent across platforms: session state is a well-defined concept in browser implementations, discarded when the session ends. The lock screen - the full-page blur overlay via html.vb-blur with pointer event blocking and user selection blocking - is implemented in CSS and JavaScript that run identically across browsers and platforms.

For professionals working across multiple platforms with devices managed under different system-level encryption policies - FileVault on macOS, BitLocker on Windows, dm-crypt on Linux, device encryption on Android - VaultBook’s application-level AES-256-GCM encryption provides a consistent security layer above the platform-specific disk encryption, ensuring that the vault content is protected by cryptographic controls that operate independently of the platform’s own security implementation.

Version History and Persistent Records Across Devices

VaultBook Pro’s Version History feature maintains per-entry snapshots in the vault’s /versions directory - a subdirectory of the vault folder that travels with the vault when the folder is moved between devices. Version snapshots created on one device are accessible from any other device that opens the same vault folder.

The 60-day retention window for version snapshots is enforced by the application’s own logic rather than by any external service. The application checks snapshot timestamps when the vault is opened and purges snapshots older than the retention window - a process that runs on whatever device opens the vault and is consistent across devices because the snapshot timestamps are stored within the versions directory alongside the snapshot content.

For professionals who work across multiple devices and who need to review the development history of notes edited across different sessions on different machines - a document started on a desktop and refined on a tablet, or a research note updated across multiple work sessions - the version history provides a complete record because all edits are committed to the vault folder and all snapshots are stored in the versions directory. The history modal (newest to oldest, accessible via the clock button on entry cards) surfaces this record identically on every device that opens the vault.

The Built-In Tools That Need No Installation

VaultBook Pro’s built-in tools suite provides specialized workflow capabilities that are self-contained within the HTML file, requiring no separate installation on any device and working identically across every platform that runs VaultBook.

The Kanban Board generates a board view from the vault’s labels and inline hashtags automatically, with drag-and-drop card management that updates the underlying entry labels in the repository. The File Analyzer tool for CSV and TXT file analysis runs in the browser’s JavaScript environment using attachment content from the vault’s storage. The Reader tool - the RSS and Atom feed reader with folder organization - maintains feed subscriptions and read state in the vault’s storage, making the reading environment consistent across devices that open the same vault.

The Import from Obsidian tool accepts dropped markdown files and migrates them to vault entries using the browser’s standard drag-and-drop interface, which is available across desktop and mobile browsers. The PDF tools - Merge and Split, and Compress - process files using JavaScript-based PDF manipulation running entirely within the browser. The MP3 Cutter and Joiner trims silence, cuts clips, and joins segments locally. The Save URL to Entry tool creates notes directly from web page URLs. The Password Generator, Folder Analyzer, File Explorer, Photo and Video Explorer, and Threads chat-style note entry tool are each self-contained within the HTML file and run identically across all platforms.

Because all of these tools are part of the single HTML file that constitutes the application, every tool improvement in a new version of VaultBook is immediately available on every platform as soon as the updated HTML file is placed in the vault folder. There are no platform-specific builds to install, no app store updates to wait for, and no version mismatches between devices running the same vault.

The Subscription That Funds Platform-Agnostic Excellence

VaultBook operates on a yearly subscription that funds the continuous development of the application - development that benefits all platforms simultaneously because the single-file architecture means that improvements to the JavaScript codebase deploy everywhere at once. Faster indexing algorithms, deeper OCR capabilities, more precise natural language search, better relevance through vote-based QA Actions learning, richer analytics charts - each of these improvements is implemented once in the HTML file and is immediately available on Windows, macOS, Linux, Android, and iOS simultaneously.

The subscription revenue is the only revenue mechanism in VaultBook’s model. There is no advertising. There is no data monetization. There is no behavioral tracking that requires cloud connectivity to support - because an application that makes no network requests has no mechanism for collecting behavioral data and no telemetry pipeline to feed. The subscription is the revenue model because the architecture makes every other revenue model technically unavailable.

For the cross-platform note-taker who has been paying for multiple subscriptions - a sync service, a note application, a separate task management tool, a document storage service - and still working around privacy compromises and vendor dependencies, VaultBook’s single subscription that provides the full capability of all of these layers within a single private, portable, offline-first vault represents a consolidation that is both economically and architecturally simpler.

The vault that is truly yours. On every device that matters. Without the cloud that came at too high a price.

Private by design. Portable by architecture. Powerful across every platform you use.