Local Databases for Offline-First Apps

Cashew is a local-first budgeting application and personal finance tracker designed to log income and expenses across multiple accounts. It functions as a multi-currency expense manager and personal net worth dashboard, storing financial records in an on-device database to ensure private financial data storage. The project distinguishes itself through a focus on privacy and flexibility, offering optional personal cloud synchronization for multi-device access and biometric security to protect sensitive information. It features a currency conversion engine that calculates total values across different currencies using real-time exchange rates. The application covers a broad range of financial management capabilities, including budget planning with category spending goals, credit and loan tracking, and inter-account fund transfers. It provides automation tools for transaction entry via custom URLs and artificial intelligence, as well as interactive data visualization for monitoring spending patterns. Data management is handled through local exports, template-based imports from spreadsheets, and automated recurring transaction scheduling.

This project is an asynchronous key-value store designed for client-side data persistence. It provides a unified interface that allows applications to save and retrieve complex data types, including binary objects, while maintaining responsiveness through non-blocking operations. By enabling offline-first functionality, it ensures that data remains accessible even when a network connection is unavailable. The library distinguishes itself through a driver-based abstraction layer that automatically detects the most efficient storage mechanism available in the current browser or mobile environment. It includes a pluggable architecture that supports custom storage backends and provides a fallback mechanism to ensure consistent performance across different platforms. To manage data organization, it features a containerized architecture that allows developers to isolate data sets into independent namespaces, preventing key collisions between different application modules. Beyond its core storage capabilities, the system handles the serialization of complex objects and binary data automatically. It supports both promise-based and callback-oriented syntax for asynchronous tasks and includes type definitions to facilitate integration into development workflows. Configuration options allow for the customization of storage parameters, such as driver selection and database sizing, to meet specific application requirements.

GarminDB is a local fitness data store and self-hosted health data archive designed to import, archive, and analyze health and activity metrics from Garmin accounts. It functions as a fitness data aggregator and metric analysis tool, maintaining a private database of health records for independent tracking and custom querying. The system features a GPS activity heatmap generator to visualize frequently traveled paths and a plugin system for integrating specialized third-party data fields and custom metrics. It employs a local-first persistence model that retains original source files on disk to allow for full database reconstruction without re-downloading data from external services. The software covers data management through incremental synchronization and fitness metric aggregation into daily, weekly, monthly, and yearly totals. Its analytical capabilities include activity performance comparison, statistics generation, and health trend visualization via command-line tools or interactive notebooks.

TypeORM is an object-relational mapper for TypeScript and JavaScript that bridges the gap between object-oriented application code and relational database tables. It provides a comprehensive data persistence layer that allows developers to define database entities using class decorators or configuration objects, enabling seamless interaction with data through object-oriented patterns. The project distinguishes itself through a flexible architecture that supports both the data mapper and repository patterns, alongside a fluent query builder that translates high-level method calls into platform-specific SQL. It includes a robust schema synchronization engine that automatically generates and applies migrations, ensuring that database structures remain consistent with application models. Furthermore, it offers specialized support for hierarchical data modeling, vector similarity search, and cross-database querying, allowing for sophisticated data management across diverse storage engines. Beyond its core mapping capabilities, the framework provides extensive tools for managing database connections, including support for replication, multi-database routing, and atomic transaction management. It also features a lifecycle event system for executing custom logic during data operations, as well as comprehensive performance optimization utilities like relation loading strategies, result caching, and query analysis. The project is designed for cross-platform compatibility, supporting various relational and document-based database drivers in environments ranging from Node.js servers to browser and mobile applications.

Jazz is a local-first relational database and synchronization framework designed for offline-capable applications. It functions as a reactive state management system that treats database records as the primary source of truth, automatically updating user interfaces in real time as underlying data changes. The project distinguishes itself through a collaborative data synchronization model that utilizes row-level versioning to track branching edit histories. It implements a security engine based on identity-claim row security, which enforces granular permissions on individual records, and supports end-to-end field encryption to protect sensitive data at the source. The system covers a broad range of distributed data capabilities, including relational schema definition via a domain-specific language, durable stream-based synchronization between local replicas and remote storage, and geo-optimized distributed hosting. It provides a programmable interface for standard database mutations and queries while ensuring consistency across different devices and environments.

GORM is a developer-focused object-relational mapping library for Go that provides a comprehensive data persistence framework. It serves as a database access layer, allowing developers to map application structures to database tables and perform CRUD operations using a fluent, type-safe query builder instead of writing raw SQL. The library distinguishes itself through its association-aware persistence, which automatically tracks and synchronizes complex entity relationships during database operations. It utilizes a driver-agnostic interface to maintain consistent behavior across various storage engines and employs a reflection-based system to map programming language types to database schemas. Developers can further customize behavior using a callback-based hook system that executes logic at specific points in the operation lifecycle. Beyond core mapping, the project provides robust support for transaction management, connection pooling, and automated schema migrations. It handles complex relational modeling, including one-to-one, one-to-many, and many-to-many associations, while offering advanced features like eager loading, soft deletes, and conflict resolution strategies for upsert operations. The framework is designed for integration into Go applications, providing a unified interface for managing database connectivity and transactional integrity.

Hydra is a cross-platform desktop application designed to serve as a centralized game library manager. It consolidates video games from multiple sources and platforms into a single, searchable interface, allowing users to organize their collections and manage installations through a unified dashboard. The application distinguishes itself through extensive support for interface personalization and data portability. Users can modify the visual appearance and notification sounds of the launcher by creating or installing community-shared themes. Furthermore, the tool includes integrated cloud synchronization for game save files, ensuring that progress remains consistent and accessible across different hardware devices. The platform utilizes a local-first database to maintain library metadata and user settings, providing high performance and offline functionality. It supports the integration of external game repositories by parsing structured data mappings, which link specific titles to their corresponding downloadable assets. The application is built using a component-based architecture that manages state-driven visual updates and user interactions.

Drizzle ORM is a TypeScript-native database toolkit providing type-safe SQL query building, schema management, and automated migrations across PostgreSQL, MySQL, SQLite, and SingleStore.

PouchDB is a JavaScript NoSQL document database that runs directly in the browser. It serves as an offline-first data store that allows applications to save state and user data locally using persistent storage. The database is compatible with CouchDB, implementing its API to enable synchronization between browser environments and remote servers. This allows for cross-device data syncing and the development of local-first software that operates without a constant internet connection. The project covers data storage and synchronization capabilities, including the ability to migrate database schemas when updating data formats.

Sequelize is an object-relational mapping library that provides a unified interface for managing relational data through code. By implementing the Active Record pattern, it maps database tables to application objects, allowing developers to perform standard create, read, update, and delete operations using high-level method calls. The library abstracts complex database interactions by translating these calls into optimized, engine-specific SQL statements, ensuring consistent behavior across different database systems. The project distinguishes itself through a comprehensive suite of tools for managing relational complexity and data integrity. It features a robust association system that supports one-to-one, one-to-many, and many-to-many relationships, including polymorphic associations and nested join mapping. To maintain consistency during complex operations, it includes an asynchronous transaction coordinator and a lifecycle management framework that triggers custom logic through hooks and validation rules. Furthermore, it provides a schema synchronization engine that aligns application model definitions with the underlying database structure, supporting versioned migrations to track changes over time. Beyond its core mapping capabilities, the library offers extensive support for database management and performance tuning. This includes connection pooling to manage concurrent requests, read replication for distributed query operations, and query scopes for reusable data retrieval patterns. It also provides native support for TypeScript, allowing for type-safe data definitions and model configurations. The library is designed for modular integration and includes utilities for query logging, custom data type definitions, and soft deletion.

Screenpipe is a local-first platform designed to record, index, and analyze desktop activity. By capturing screen, audio, and keyboard input, it creates a comprehensive and searchable history of computer usage. The system functions as an activity recorder and automation framework, providing a persistent, context-aware memory that allows artificial intelligence agents to observe and interact with local desktop environments. The platform distinguishes itself through a privacy-focused architecture that processes all data locally. It utilizes on-device computer vision and speech recognition to transcribe audio and extract metadata from screen content, while simultaneously applying automated redaction to filter sensitive information before storage. All captured logs are maintained in a local relational database, ensuring that user data remains under local control and is protected by authenticated encryption at rest. Beyond simple recording, the platform supports complex workflow automation and business process analysis. It exposes captured activity data to external tools through standardized protocols, enabling the execution of custom scripts and agents that can trigger actions across third-party software. These capabilities allow for the mapping of work patterns, the identification of process bottlenecks, and the generation of structured datasets for training computer-use models. The software provides a command-line interface for managing capture policies and supports fleet-wide deployment within organizational environments. All processing, including data sanitization and indexing, occurs on the host machine to maintain security and compliance.

Spacedrive is a decentralized storage client that functions as a distributed file manager, aggregating local, cloud, and network storage into a single virtual filesystem. It operates on a local-first design, prioritizing offline availability by caching metadata and file chunks locally before synchronizing them across devices. By coordinating data access without relying on a central server, it enables users to maintain a private and secure storage network across their own hardware and cloud accounts. The platform distinguishes itself through a virtual storage layer that maps disparate physical and cloud locations into a unified, searchable directory structure. It utilizes content-addressable storage to identify files by their cryptographic hash, which ensures data integrity and prevents duplicate storage. An event-driven sync engine monitors file changes in the background, propagating updates across connected devices through a distributed messaging protocol. The system is powered by a memory-safe core engine that manages file operations and synchronization logic. This backend connects to a graphical interface through a cross-platform bridge, providing a consistent experience for browsing and managing digital libraries across different operating systems.

NetNewsWire is a news aggregation tool and RSS feed reader designed for the macOS and iOS platforms. It serves as a client for subscribing to and reading syndicated web content and news feeds from various publishers. The application enables personal news curation and digital publication following by collecting content from multiple sources into a single unified interface. It supports cross-device content syncing to maintain consistent read and unread states across Apple devices. The system utilizes local-first database storage for offline access and periodic background fetching to check for new articles. It employs a platform-native UI framework and XML-based parsing to aggregate and display content streams.

Pocketbase is a backend-as-a-service platform that provides a self-contained, single-binary server for building full-stack applications. It integrates a relational database, authentication, and file storage into one executable process, eliminating the need for external infrastructure or complex server management. The platform distinguishes itself through an embedded database engine that runs directly within the application process and a reactive communication layer that pushes live updates to connected clients. By monitoring internal transaction logs, it synchronizes data across multiple users in real time. It also features a schema-aware data access layer that maps database tables to dynamic objects, allowing for data manipulation without the need for manual migration scripts. The system includes a built-in security layer for managing user accounts, session tokens, and access control rules. It handles binary asset management through a managed storage interface that supports local filesystem storage while maintaining metadata references within the database. The entire request lifecycle is managed through a modular pipeline that processes traffic for authentication and validation.

Codegraph is a local codebase indexer and static analysis graph database that serves as a context provider for AI agents. It parses multiple programming languages into a searchable knowledge graph of symbols and dependencies, exposing these relationships to AI tools through the Model Context Protocol. The project distinguishes itself by aggregating relevant code snippets and symbol flows to reduce token usage for large language models. It automates the configuration of server settings and steering instructions across various AI agent platforms and command line editors to enable automatic codebase navigation. The system covers broad capability areas including transitive dependency impact analysis, execution flow tracing, and framework route mapping. It utilizes a background daemon for incremental parsing and filesystem synchronization, ensuring the local symbol database remains current across multi-repo workspaces. The application is delivered as a self-contained bundle to ensure environment consistency on host systems.

Logseq is a privacy-focused, local-first knowledge base designed for personal information management and networked thought mapping. It functions as a bi-directional graph editor that organizes content into hierarchical, outliner-based structures, allowing users to connect related concepts through automated backlinking and visual relationship mapping. The platform distinguishes itself by maintaining all user data in plain text markdown files stored directly on the local device, ensuring offline availability and long-term portability. It employs a logic-based query engine to perform complex relational searches across the graph of notes and metadata, while a content-addressable storage model ensures data integrity for every information block. The application supports a broad range of information management tasks, including academic research synthesis and structured project documentation. Users can extend the core functionality through a sandboxed plugin system that allows for custom interface components and data manipulation. The software is documented through a dedicated resource library to assist with setup and configuration.

Chatbox is a cross-platform desktop application that provides a unified interface for interacting with a wide range of artificial intelligence models. It functions as a model-agnostic client, allowing users to connect to various third-party AI providers or execute open-source models directly on their own hardware. By centralizing these diverse services into a single workspace, the application enables users to manage multiple chat sessions, adjust model parameters, and switch between different AI backends with ease. The project distinguishes itself through a local-first architecture that prioritizes data privacy and user control. All conversation logs, settings, and uploaded documents are stored directly on the local device, ensuring that sensitive information remains private and accessible offline. Furthermore, the application features a built-in vector-based knowledge retrieval system that parses and indexes local files, allowing the AI to reference private documents during chat sessions to provide context-aware responses. Beyond its core chat capabilities, the application includes tools for productivity and workflow management. It supports real-time web search integration, image generation, and the ability to render professional content like formulas and charts. Users can navigate the interface efficiently using global keyboard shortcuts and automate the configuration of external services through deep-link injection, which simplifies the process of importing provider settings and credentials. The application is distributed as a native desktop shell that wraps web-based interface components to provide system-level window management. It is designed to be installed and run on standard desktop operating systems.

DuckDB is an in-process analytical database engine designed to run directly within an application process. As a zero-dependency, embedded system, it provides enterprise-grade SQL data processing capabilities without the overhead of managing a dedicated database server. It is built to handle complex analytical and aggregation tasks by storing and retrieving information in columns, allowing for high-performance relational data manipulation. The engine distinguishes itself through a columnar vectorized execution model that maximizes CPU cache efficiency during query operations. It employs adaptive query optimization to dynamically select execution plans at runtime and utilizes zero-copy ingestion to map external data formats directly into memory. To facilitate integration with analytical programming environments, the system supports high-performance data exchange through standardized memory formats and provides specialized connectors for Python, R, and Java. The project covers a broad capability surface, including advanced relational join operations, incremental result streaming for large datasets, and flexible data ingestion from various file formats. It supports complex data types and provides a comprehensive command-line interface for interactive session management and batch processing. The codebase is designed for portability, offering single-file amalgamation to simplify integration into external projects and build systems.

EcoPaste is a cross-platform clipboard manager designed to track and store a history of copied text, images, and files. It serves as a clipboard organization tool that allows for the categorization of saved snippets. The application focuses on local-first clipboard history, keeping all copied content and metadata on the local machine to ensure data privacy and offline access. It enables the organization of clipboard entries through the use of custom notes and labels for more efficient information retrieval.

Prisma is a database toolkit that provides a unified access layer for interacting with relational and document databases. It centers on a declarative schema modeling approach, where developers define their data structures in a human-readable language. This schema serves as the single source of truth, from which the toolkit automatically generates type-safe database clients that provide compile-time validation and editor autocomplete for all data operations. The project distinguishes itself through a high-performance, Rust-based query engine that handles query planning and connection pooling outside the application runtime. It further streamlines development by offering introspection-based synchronization, which updates the local data model by scanning existing database structures. Additionally, it includes a visual database explorer that allows developers to inspect records, navigate relational diagrams, and manage data configurations directly within their development environment or a web-based interface. Beyond core data access, the toolkit supports a range of operational workflows including automated database testing through isolated instance provisioning and performance optimization via integrated query analysis. The ecosystem is extensible through middleware for query interception and various generators that facilitate schema documentation and integration with other development tools.