ChaiSQL is a modern embedded SQL database, written in pure Go, with a PostgreSQL-inspired API. It’s designed for developers who want the familiarity of Postgres with the simplicity of an embedded database.

• Postgres-like SQL – the syntax you already know, embedded in your Go app.
• Pure Go – no CGO or external dependencies.
• Flexible Storage – keep data on disk or run fully in-memory.
• Built on Pebble – powered by CockroachDB’s Pebble engine.

ChaiSQL already supports a useful core of SQL features, including:

• Creating and dropping tables & indexes (with composite indexes)
• Inserting, updating, deleting rows
• Basic SELECT queries with filtering, ordering, grouping
• DISTINCT, UNION / UNION ALL

👉 Joins and many advanced features are not implemented yet. The goal is steady growth toward broader PostgreSQL compatibility, but today ChaiSQL is best suited for simpler schemas and embedded use cases.

ChaiSQL is still in active development and not production-ready. Planned milestones include:

• Finalize stable on-disk storage format (90% complete)
• Broader SQL-92 coverage
• Drivers for other languages (JS/TS, Python, …)
• RocksDB backend support
• Compatibility with PostgreSQL drivers/ORMs

Install the ChaiSQL driver and CLI:

go install github.com/chaisql/chai@latest
go install github.com/chaisql/chai/cmd/chai@latest

Here’s a simple Go example that creates a table, inserts rows, and queries them:

package main
import (
    "database/sql"
    "fmt"
    "log"
    _ "github.com/chaisql/chai"
)
func main() {
    // Open an on-disk database called "mydb"
    db, err := sql.Open("chai", "mydb")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    // Create schema
    _, err = db.Exec(`
        CREATE TABLE users (
            id          INTEGER PRIMARY KEY,
            name        TEXT NOT NULL UNIQUE,
            email       TEXT NOT NULL,
            age         INT  NOT NULL,
            created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        );
    `)
    if err != nil {
        log.Fatal(err)
    }
    // Insert some data
    _, err = db.Exec(`
        INSERT INTO users (id, name, email, age)
        VALUES
            (1, 'Alice', 'alice@example.com', 30),
            (2, 'Bob',   'bob@example.com',   25),
            (3, 'Carol', 'carol@example.com', 40);
    `)
    if err != nil {
        log.Fatal(err)
    }
    // Query active adults
    rows, err := db.Query(`
        SELECT id, name, email, age
        FROM users
        WHERE age >= 18
        ORDER BY age DESC
    `)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()
    for rows.Next() {
        var id, age int
        var name, email string
        if err := rows.Scan(&id, &name, &email, &age); err != nil {
            log.Fatal(err)
        }
        fmt.Printf("User %d: %s (%s), %d years old\n", id, name, email, age)
    }
}

For ephemeral databases, just use :memory::

db, err := sql.Open("chai", ":memory:")

The chai command-line tool provides an interactive SQL shell:

# In-memory database:
chai
# Disk-based database:
chai dirName

Contributions are welcome!

A big thanks to our contributors!

Made with contrib.rocks.

For any questions or discussions, open an issue.

SQLite is fantastic, but it has its own SQL dialect. ChaiSQL is designed for PostgreSQL compatibility, so it feels familiar if you already use Postgres.

Not yet. We’re actively building out SQL support and stability.

Not yet. ChaiSQL is PostgreSQL-API inspired, but it does not speak the Postgres wire protocol and is not compatible with psql, pg_dump, or drivers that expect a Postgres server.