awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com

Edge SQLite Databases

Ranking updated Jun 30, 2026

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.

Edge SQLite Databases

Find the best repos with AI.We'll search the best matching repositories with AI.
  • tursodatabase/tursotursodatabase avatar

    tursodatabase/turso

    21,655View on GitHub↗

    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.

    RustSQLite DatabasesSQLite Integration
    View on GitHub↗21,655
  • tursodatabase/libsqltursodatabase avatar

    tursodatabase/libsql

    16,887View on GitHub↗

    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.

    CSQLite DatabasesHTTP-to-SQL Mappers
    View on GitHub↗16,887
  • simonw/datasettesimonw avatar

    simonw/datasette

    11,198View on GitHub↗

    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.

    PythonSQLite DatabasesSQLite Integration
    View on GitHub↗11,198
  • groue/grdb.swiftgroue avatar

    groue/GRDB.swift

    8,209View on GitHub↗

    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.

    SwiftSQLite DatabasesSQLite Integration
    View on GitHub↗8,209
  • ccgus/fmdbccgus avatar

    ccgus/fmdb

    13,851View on GitHub↗

    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.

    Objective-CSQLite DatabasesSQLite Integration
    View on GitHub↗13,851
  • pocketbase/pocketbasepocketbase avatar

    pocketbase/pocketbase

    59,120View on GitHub↗

    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.

    GoReal-Time
    View on GitHub↗59,120
  • instantdb/instantinstantdb avatar

    instantdb/instant

    10,330View on GitHub↗

    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.

    TypeScriptReal-time Data Synchronization
    View on GitHub↗10,330
  • pouchdb/pouchdbpouchdb avatar

    pouchdb/pouchdb

    17,583View on GitHub↗

    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.

    JavaScriptConflict Resolution Strategies
    View on GitHub↗17,583
  • dolthub/doltdolthub avatar

    dolthub/dolt

    23,592View on GitHub↗

    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.

    GoConflict ResolutionDatabase Replication
    View on GitHub↗23,592
  • stephencelis/sqlite.swiftstephencelis avatar

    stephencelis/SQLite.swift

    10,167View on GitHub↗

    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.

    SwiftSQLite Databases
    View on GitHub↗10,167
  • neondatabase/neonneondatabase avatar

    neondatabase/neon

    22,251View on GitHub↗

    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.

    RustHTTP-to-SQL Mappers
    View on GitHub↗22,251
  • sqlite/sqlitesqlite avatar

    sqlite/sqlite

    9,909View on GitHub↗

    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.

    CSQLite Databases
    View on GitHub↗9,909
Compare the top 10 at a glance
RepositoryStarsLanguageLicenseLast push
tursodatabase/turso21.7KRustMITJun 23, 2026
tursodatabase/libsql16.9KCMITJun 2, 2026
simonw/datasette11.2KPythonApache-2.0Jun 15, 2026
groue/grdb.swift8.2KSwiftmitFeb 16, 2026
ccgus/fmdb13.9KObjective-CNOASSERTIONMar 15, 2026
pocketbase/pocketbase59.1KGoMITJun 14, 2026
instantdb/instant10.3KTypeScriptApache-2.0Jun 15, 2026
pouchdb/pouchdb17.6KJavaScriptApache-2.0Jun 9, 2026
dolthub/dolt23.6KGoApache-2.0Jun 22, 2026
stephencelis/sqlite.swift10.2KSwiftMITJun 4, 2026

Related searches

  • an in-process SQL database for my app
  • a local database for offline-first mobile apps
  • an MCP server for querying SQLite databases
  • a desktop client for my SQL databases
  • a database library for Swift applications
  • a distributed SQL database for horizontal scaling
  • a database for maps and geo queries
  • a project for understanding databases by building one