For a database at the edge near my users, the strongest matches are tursodatabase/turso (Turso is a managed edge SQLite database platform that), tursodatabase/libsql (LibSQL extends SQLite into a distributed, edge-ready database with) and simonw/datasette (Datasette publishes and serves static or WebAssembly-bundled SQLite databases). groue/grdb.swift and ccgus/fmdb round out the shortlist. Each is ranked by relevance to your query, popularity and recent activity.
Distributed database systems that replicate and run SQLite instances at the network edge for low-latency access.
Turso is a distributed SQL database platform that provides managed, edge-hosted SQLite instances. It functions as a serverless database provider, enabling the deployment of relational databases that synchronize data across multiple geographic regions to support high availability and performance. The platform distinguishes itself by utilizing a fork of SQLite as its core storage engine, which supports both local file storage and remote network-based replication. It employs an edge-optimized proxy to route queries through a global network, minimizing latency by connecting users to the nearest d
Turso is a managed edge SQLite database platform that synchronizes data across geographic regions via an edge-optimized proxy, giving you low-latency, SQLite-compatible access exactly as your distributed use‑case demands.
LibSQL is a high-performance, distributed SQL database engine that extends SQLite to support remote network access, edge computing, and real-time synchronization. It functions as an embedded database library that integrates directly into application processes while providing the infrastructure to maintain consistency across multiple geographic regions. The platform distinguishes itself by enabling database interaction over standard HTTP protocols, allowing applications to query remote data sources in serverless and edge environments without requiring local filesystem access. It includes nativ
LibSQL extends SQLite into a distributed, edge-ready database with real-time synchronization and an HTTP API, giving you low-latency access across geographic regions exactly as you need.
Datasette is a tool for publishing and sharing SQLite databases as public websites. It functions as a data publishing system that provides searchable interfaces and JSON APIs to expose the contents of SQLite files. The project enables both server-side and client-side execution. It can operate as an API server or as a database browser that runs entirely within a web browser using WebAssembly, allowing for serverless database access. The system supports a variety of deployment strategies, including containerized images for cloud hosting and a local development server for testing. It includes c
Datasette publishes and serves static or WebAssembly-bundled SQLite databases as websites, but it is a read-only data browser, not a distributed edge database service with real-time synchronization, conflict resolution, or a WebSocket API.
GRDB.swift is a comprehensive SQLite toolkit and object-relational mapper for Swift. It provides a database wrapper that handles local data persistence, connection management, and encrypted file storage for Apple platforms. The library features a dedicated observation framework that tracks database changes to automatically synchronize the application state and user interface in real time. It distinguishes itself with a type-safe query builder and a protocol-based mapping system that converts database rows into structured Swift objects. The toolkit covers a broad range of administrative and o
GRDB.swift is a local SQLite toolkit and ORM for Swift applications on Apple platforms, not a distributed edge database service that runs at edge locations with HTTP/WebSocket APIs or real-time synchronization across geographies.
fmdb is an object-oriented SQLite database library and persistence layer for native macOS and iOS environments. It provides an Objective-C wrapper that encapsulates the low-level C API, allowing applications to manage local relational data storage and embedded database connections through a high-level interface. The library focuses on thread-safe database access by synchronizing operations across multiple threads using serialized queues to prevent data corruption and race conditions. It includes specialized capabilities for secure local storage, such as database encryption and the management
fmdb is a local SQLite wrapper for macOS/iOS apps, not a distributed edge database service with real-time sync and HTTP/WebSocket APIs — it manages local storage on a single device rather than serving geodistributed clients.
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 user
PocketBase is a self-contained backend platform with an embedded SQLite database and real-time sync for live client updates, but it is not architected as a distributed edge database service with multi-region synchronization or built-in conflict resolution for geo-distributed deployments.
Instant is a real-time backend as a service and relational graph database designed to synchronize data across clients automatically. It functions as a data synchronization layer that provides authentication, permissions, and relational data storage for web and mobile applications. The platform includes an optimistic UI framework that updates local interfaces immediately during writes and handles automatic server rollbacks. It also features a real-time presence system to broadcast transient user states, such as cursor positions and online status, to other connected clients. The system manages
Instant is a real-time backend-as-a-service with automatic data synchronization and an optimistic UI layer, but it does not run SQLite at edge locations and is not specifically designed for low-latency access in geographically distributed deployments, so it falls short of being an edge SQLite database.
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 sc
PouchDB is a browser-based NoSQL document store with CouchDB sync, not an edge-deployed SQLite database — it runs on the client side rather than at network edge locations and uses a JSON document model instead of SQL.
Dolt is a relational database engine that integrates version control directly into the database management layer. It functions as a version-controlled SQL database that tracks every row and schema change using a commit-based history, allowing users to branch, merge, and audit data modifications. By implementing a wire-protocol-compatible server, the system enables standard SQL clients and tools to interact with versioned data as if they were connecting to a traditional relational database. The platform distinguishes itself by applying repository-style workflows to data management, including s
Dolt is a version-controlled MySQL-compatible database for data branching and merging, but it is not SQLite-based and does not target edge deployment or low-latency geo-distributed access, so it does not serve the core need of an edge SQLite service.
SQLite.swift is a type-safe Swift wrapper and object-relational mapping layer that provides a bridge for interacting with SQLite databases. It functions as a database driver that allows for embedded database management and local data persistence within Swift applications. The project distinguishes itself through a type-safe expression builder that verifies SQL statement syntax and intent at compile time. It includes specialized support for high-performance text matching via full-text search integration and provides mechanisms for securing sensitive data through database encryption. The libra
SQLite.swift is a type-safe Swift wrapper for local SQLite databases, not an edge-deployed database service with real-time synchronization, HTTP/WebSocket APIs, or conflict resolution — so it does not fit this search for a distributed edge database.
Neon is a serverless PostgreSQL database platform designed with a decoupled storage and compute architecture. It functions as a multi-tenant system that isolates data and compute resources for independent users on shared cloud infrastructure, utilizing a specialized PostgreSQL storage engine. The platform features a database branching system that allows for the creation of isolated, instant copies of a database for testing and development. It further distinguishes itself with an HTTP-based SQL gateway, enabling the execution of queries via HTTP requests and JSON responses without the need for
Neon is a serverless PostgreSQL database platform with an HTTP query API, not an SQLite database — because the visitor specifically requires SQLite compatibility for edge deployment, this PostgreSQL service is a neighbouring category rather than the right tool.
SQLite is a serverless relational database engine and C-based library that stores data in a single local disk file. It functions as an embedded SQL database, integrating directly into applications without the need for a separate server process. The engine includes specialized capabilities for full-text search indexing and spatial data querying using R-Tree structures for geographic or geometric coordinate ranges. The system provides broad support for SQL data manipulation, database recovery and repair, and change tracking for synchronizing modifications between databases. It also features a
SQLite is the embedded database engine that powers many edge services, but this repository is the core C library itself—not a deployable service with edge deployment, real-time sync, or an HTTP/WebSocket API.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| tursodatabase/turso | 21.7K | Rust | MIT | |
| tursodatabase/libsql | 16.9K | C | MIT | |
| simonw/datasette | 11.2K | Python | Apache-2.0 | |
| groue/grdb.swift | 8.2K | Swift | mit | |
| ccgus/fmdb | 13.9K | Objective-C | NOASSERTION | |
| pocketbase/pocketbase | 59.1K | Go | MIT | |
| instantdb/instant | 10.3K | TypeScript | Apache-2.0 | |
| pouchdb/pouchdb | 17.6K | JavaScript | Apache-2.0 | |
| dolthub/dolt | 23.6K | Go | Apache-2.0 | |
| stephencelis/sqlite.swift | 10.2K | Swift | MIT |