RovaDB
Pure Go • Embedded SQL • No CGO

Embedded SQL for Go, without the extra baggage.

RovaDB is a small relational database engine for local, single-process Go applications. It is built for developers who want SQL, predictable behavior, understandable internals, and a Go-native implementation.

  • Pure Go implementation
  • No CGO dependency
  • Small, stable public API
  • Practical relational storage for local apps and tools
  • Readable engine internals
  • Focused SQL support with explicit scope
View on GitHub Get Started
Pre-release, but already at a practical baseline with focused SQL support, explicit transaction control through the Go API, and completed physical storage foundation and polish milestones.

Why RovaDB

RovaDB is for Go developers who want an embedded relational database with a clear scope, practical SQL support, and a codebase that stays approachable.

Go-native by design

RovaDB is implemented in pure Go and intended to feel natural in Go applications and Go development workflows.

SQL over ad hoc storage

Use relational storage, filtering, ordering, joins, aggregates, and schema visibility instead of stitching together file formats or key-value conventions.

Readable internals

The project emphasizes clarity, explicit boundaries, and a smaller surface area so adoption and contribution stay realistic.

Embedded relational database for Go Pure Go implementation No CGO Small public API Practical SQL support

Good fit for

  • Local Go applications that need embedded relational storage
  • Tools, utilities, and prototypes that want SQL instead of ad hoc file formats
  • Projects that value no CGO dependency and a Go-native implementation
  • Developers who care about understandable internals and explicit scope

Not aimed at

  • Client/server deployments
  • Distributed systems
  • Full SQL compatibility
  • Advanced query optimization workloads
  • Replacing mature database servers on breadth or raw performance

Why RovaDB instead of SQLite?

RovaDB is not trying to match the full breadth, ecosystem maturity, or performance profile of a long-established engine. Its appeal is different: pure Go implementation, no CGO dependency, a smaller surface area, and a codebase that is easier to study and evolve in Go-first projects.

Why RovaDB instead of a key-value store?

RovaDB gives you a relational model, SQL queries, joins, ordering, aggregates, catalog visibility, and a more familiar mental model for structured application data.

Quick Start

Try RovaDB without cloning the repository.

go install github.com/Khorlane/RovaDB/cmd/rovadb@latest
rovadb
rovadb> sample demo.db
  created sample database demo.db
  sample tables: customers, orders
SELECT a.cust_nbr AS customer_number, a.name, a.city, b.order_nbr, b.item, b.total_amt
FROM customers a
INNER JOIN orders b ON a.cust_nbr = b.cust_nbr
WHERE b.total_amt > 7
ORDER BY a.name DESC, b.total_amt;

Want to embed RovaDB in a Go program instead? See the example app in the GitHub repository.

Current Status

RovaDB is pre-release and actively evolving, but the core product boundary is already clear.

Current product shape

  • Small public Go API
  • Focused SQL support
  • Explicit public transactions through the Go API
  • Catalog introspection
  • Strict value support for INT, TEXT, BOOL, REAL, and NULL
  • Narrow index-only access for eligible query shapes

Storage baseline

  • Authoritative TableHeader roots per table
  • SpaceMap pages enumerate owned Data pages
  • Normal reads and writes operate on owned Data pages
  • Open and reopen strictly validate physical ownership invariants
  • Physical storage layer and physical storage polish milestones completed
Use case: local, single-process applications Model: embedded relational SQL engine Implementation: pure Go