ormDB vs Turso
ormDB is a new relational database engine written in Rust with native graph-fetch queries, built-in vector search, geo search, and change streams, designed for ORM workloads. Turso distributes SQLite (via libSQL) to edge locations worldwide for ultra-low-latency reads with embedded replicas for local-first development. ormDB rethinks query semantics; Turso extends SQLite's reach.
Verdict: ormDB is a new database engine with native graph queries; Turso distributes SQLite to the edge for low-latency reads worldwide.
ormDB strengths
- Native graph-fetch queries eliminate N+1 at the engine level
- Entity/relation query language instead of SQL
- Built-in vector search, geo search, and change streams
- Safe migrations with A-D grading
- Row-level security and query budgets built into the engine
Turso strengths
- Distributes SQLite to edge locations for ultra-low-latency reads
- SQLite compatibility -- works with existing SQLite tooling
- Embedded replicas for local-first development
- Managed platform with a generous free tier
- Built on libSQL, an open-source fork of SQLite
Overview
ormDB is a relational database engine written in Rust that replaces SQL databases like SQLite (and by extension, Turso) underneath your ORM. Turso is a managed platform that distributes SQLite to edge locations worldwide using libSQL, an open-source fork of SQLite.
The core difference: ormDB is a new database engine. Turso distributes an existing one.
Query Model
Turso speaks SQL because it is SQLite-compatible. Your ORM generates SQL queries, and Turso executes them on the nearest edge replica. The N+1 problem persists because SQL has no concept of object graphs, regardless of where the query runs.
ormDB speaks entity/relation/graph-fetch natively. A single graph-fetch query retrieves users, their posts, comments, and tags in one round-trip. The database understands the graph and resolves it internally.
Edge Distribution
Turso’s defining feature is edge distribution. It places read replicas of your SQLite database at edge locations globally. Reads are served from the nearest replica with minimal latency. Writes route to a primary instance.
ormDB does not have edge distribution. If your application’s primary bottleneck is read latency across geographies, Turso addresses that directly. If your bottleneck is query complexity and N+1 problems, ormDB addresses that.
Concurrency
Turso inherits SQLite’s concurrency model. There is one writer, and writes are serialized through the primary instance. Reads scale across edge replicas, but write throughput is limited by the single-writer architecture.
ormDB supports concurrent writers. For write-heavy workloads with multiple simultaneous users, ormDB does not have the single-writer constraint.
Built-In Capabilities
Turso, through libSQL, is adding capabilities to SQLite: vector search via extensions, and improvements to the replication protocol. These are evolving additions to the SQLite foundation.
ormDB builds vector search, geo search, full-text search, change streams (CDC), row-level security, query budgets, and safe A-D migration grading natively into the engine. These are not extensions — they are core features.
When to Choose
Choose ormDB when your application uses an ORM, N+1 queries are your bottleneck, and you need a modern database engine with graph queries and built-in capabilities. Choose Turso when you need low-latency reads from edge locations, SQLite compatibility, or embedded replicas for local-first development.
Feature Comparison
| Feature | ormDB | Turso |
|---|---|---|
| Native Graph Queries | Yes | No |
| ACID Transactions | Yes | Yes |
| N+1 Elimination | Yes | No |
| Edge Distribution | No | Yes |
| Change Streams (CDC) | Yes | No |
| Vector Search | Yes | Partial |
| Full-Text Search | Yes | Yes |
| Embedded Replicas | No | Yes |
| Concurrent Writers | Yes | Partial |
| Row-Level Security | Yes | No |
| Safe Migration Grading | Yes | No |
| Query Budgets | Yes | No |
Choose ormDB when
- → Your application uses an ORM and N+1 queries are a performance bottleneck
- → You want the database to understand entity relations natively
- → You need vector search, geo search, and CDC in one engine
- → You want migration safety enforced at the database level
- → You need concurrent writers without SQLite's single-writer limitation
Choose Turso when
- → You need low-latency reads from edge locations worldwide
- → You want SQLite compatibility with distribution built in
- → You are building a local-first application with embedded replicas
- → You want a managed database with minimal operational overhead
- → Your workload is read-heavy and benefits from edge caching
Frequently Asked Questions
Is ormDB based on SQLite?
No. ormDB is a new database engine written in Rust with its own storage engine and native entity/relation/graph-fetch query language. Turso is built on libSQL, a fork of SQLite.
Can I migrate from Turso to ormDB?
If you use a supported ORM (Prisma, Drizzle, etc.), you swap the database adapter from Turso/libSQL to ormDB. Your application code stays the same.
Does ormDB work at the edge?
ormDB does not have edge distribution. Turso's core feature is placing SQLite replicas at edge locations worldwide for low-latency reads.
How do they handle concurrent writes?
Turso inherits SQLite's single-writer model, routing writes to a primary instance. ormDB supports concurrent writers natively.
Does Turso solve N+1?
No. Turso is SQLite-compatible, so ORMs generate the same SQL queries with the same N+1 patterns. ormDB eliminates N+1 with native graph-fetch queries.
What about libSQL extensions?
Turso's libSQL fork adds vector search (via libsql-vector) and other extensions to SQLite. ormDB builds vector search, geo search, and full-text search natively into the engine.
Which is better for local-first apps?
Turso's embedded replicas are designed for local-first development. ormDB can embed but does not have the replica sync model that local-first architectures need.