VibeSQL

SQL:1999 compliant database in Rust, 100% AI-generated

Live Demo | CLI Guide | Python Bindings | Conformance Report

Highlights

• 100% SQL:1999 Core compliance - 739/739 sqltest tests passing
• 100% SQLLogicTest conformance - 622 files (~7.4M tests)
• 7,000+ unit tests - comprehensive test coverage
• Raft-based replication - single-group whole-database consensus via openraft
• MVCC - snapshot isolation with on-demand VACUUM garbage collection
• Real-time subscriptions - Convex-like reactivity with delta updates
• HTTP REST & GraphQL API - Full CRUD and query endpoints
• Vector search - AI/ML embeddings with similarity search
• File storage - Blob storage with SQL integration
• Full-featured CLI with PostgreSQL-compatible commands
• TypeScript SDK with React hooks and Drizzle ORM adapter
• Python bindings with DB-API 2.0 interface
• WebAssembly - runs in the browser

Built entirely by AI agents using Claude Code and Loom.

Quick Start

# Clone and build
git clone --recurse-submodules https://github.com/rjwalters/vibesql.git
cd vibesql
cargo build --release

# Run the CLI
cargo run --release --bin vibesql

# Or try the web demo
cd web-demo && pnpm install && pnpm dev

CLI Example

$ cargo run --release --bin vibesql
vibesql> CREATE TABLE users (id INTEGER, name VARCHAR(50));
vibesql> INSERT INTO users VALUES (1, 'Alice'), (2, 'Bob');
vibesql> SELECT * FROM users;
+----+-------+
| id | name  |
+----+-------+
| 1  | Alice |
| 2  | Bob   |
+----+-------+
vibesql> \q

See CLI Guide for meta-commands, output formats, and import/export.

Python

pip install maturin
maturin develop

import vibesql

db = vibesql.connect()
cursor = db.cursor()
cursor.execute("CREATE TABLE t (id INTEGER, name VARCHAR(50))")
cursor.execute("INSERT INTO t VALUES (1, 'Hello')")
cursor.execute("SELECT * FROM t")
print(cursor.fetchall())  # [(1, 'Hello')]

See Python Bindings Guide for full API reference.

Features

Real-Time Subscriptions

Subscribe to SQL queries and receive automatic updates when data changes—Convex-like reactivity with full SQL power.

import { VibeSqlClient } from '@vibesql/client';

const db = new VibeSqlClient({ host: 'localhost', port: 5432 });
await db.connect();

// Subscribe to a query - get updates when data changes
const subscription = db.subscribe(
  'SELECT * FROM messages WHERE channel_id = $1 ORDER BY created_at DESC LIMIT 50',
  [channelId],
  {
    onData: (messages) => setMessages(messages),
    onDelta: (delta) => {
      // Efficient incremental updates
      if (delta.type === 'insert') addMessage(delta.row);
      if (delta.type === 'delete') removeMessage(delta.row);
    },
  }
);

// React hook for easy integration
function ChatRoom({ channelId }) {
  const { data, isLoading } = useSubscription(db,
    'SELECT * FROM messages WHERE channel_id = $1',
    [channelId]
  );
  return <MessageList messages={data} />;
}

Features:

• Delta updates (only changed rows sent)
• Automatic reconnection with subscription restoration
• Configurable limits, quotas, and backpressure handling
• HTTP SSE endpoint for REST API consumers
• React hooks (useSubscription, useQuery)

SQL Support

• Queries: SELECT, JOINs (INNER/LEFT/RIGHT/FULL/CROSS), subqueries, CTEs, UNION/INTERSECT/EXCEPT
• DML: INSERT, UPDATE, DELETE, TRUNCATE
• DDL: CREATE/ALTER/DROP TABLE, views, indexes, schemas
• Aggregates: COUNT, SUM, AVG, MIN, MAX with GROUP BY/HAVING
• Window functions: ROW_NUMBER, RANK, DENSE_RANK, LAG, LEAD
• Transactions: BEGIN, COMMIT, ROLLBACK, savepoints
• Security: GRANT/REVOKE with full privilege enforcement

Advanced Features

• Views with OR REPLACE and column lists
• Stored procedures and functions (IN/OUT/INOUT parameters)
• Full-text search (MATCH AGAINST)
• Spatial functions (ST_* library)
• Triggers (BEFORE/AFTER, full SQLITE_MAX_TRIGGER_DEPTH parity)
• Scheduled functions (SCHEDULE AFTER/AT, CREATE CRON)
• Vector types for AI embeddings (VECTOR(n), distance functions)
• Blob storage with STORAGE_URL/STORAGE_SIZE functions
• MVCC with snapshot isolation, VACUUM / VACUUM INTO for on-demand GC
• Raft replication (vibesql-consensus crate) — leader leases, bounded-staleness follower reads, replicated HTTP/GraphQL/CRUD/subscriptions

Performance

• Columnar execution with SIMD acceleration
• Cost-based join reordering
• Hash joins for equi-joins
• Predicate pushdown
• Expression caching

Benchmarks

VibeSQL achieves 5,307 TPS on TPC-C mixed workload (6.7x faster than SQLite) and passes 100% of TPC-H and TPC-DS queries. Live numbers at vibesql.org.

Test Coverage

Suite	Coverage	Tests
SQL:1999 Core	100%	739/739 sqltest
SQLLogicTest	100%	622 files (~7.4M tests)
Unit Tests	-	7,000+ tests
TPC-DS	100%	102/102 queries
TPC-H	100%	22/22 queries
TPC-C	100%	All transactions

TPC-C (OLTP Transactions)

Database	TPS	vs SQLite
VibeSQL	5,307	6.7x faster
SQLite	795	baseline
DuckDB	95	8.4x slower

Scale Factor 1, 60-second duration, mixed workload (New Order, Payment, Order Status, Delivery, Stock Level). v0.2.0 cycle, 2026-06-15.

TPC-DS (Complex Analytics)

102/102 queries passing (100%) at SF 0.001. All queries complete within timeout.

Peak memory: ~141 MB. See full results.

TPC-H (Decision Support)

22/22 queries passing (100%). All queries optimized with columnar execution and cost-based join reordering.

Running Benchmarks

# Build release binaries first
cargo build --release

# Run all benchmarks
make benchmark          # TPC-H, TPC-C, TPC-DS, Sysbench

# Individual benchmarks
make benchmark-tpch     # TPC-H (22 queries, SF 0.01)
make benchmark-tpcc     # TPC-C (OLTP, SF 1)
make benchmark-tpcds    # TPC-DS (102 queries, SF 0.001)
make benchmark-sysbench # Sysbench (point lookups, range scans)

# With custom parameters
SCALE_FACTOR=0.01 PROFILING_ITERATIONS=3 cargo bench --bench tpch_profiling
TPCC_SCALE_FACTOR=1 TPCC_DURATION_SECS=10 cargo bench --bench tpcc_benchmark

See Benchmarking Guide for details on parameters and profiling.

Development

New to the repo? Run ./install.sh to install all macOS dev-environment prerequisites (Rust, wasm-pack, maturin, pnpm, etc. — see ./install.sh --check to preview what's missing) before make all.

# Full build + test (foreground by default)
make all            # Build, test, and run TCL tests (foreground)
make all-bg         # Same, in the background (long builds)
make status         # Check progress of a background run
make logs           # Follow full output of a background run

# Individual targets
make build          # Build all crates
make test           # Run all tests (unit + integration + sqllogictest)
make benchmark      # Run TPC-H/TPC-C/TPC-DS/Sysbench benchmarks
make help           # Show all targets

This repo also uses Loom for AI-powered development orchestration; ./loom.sh is a convenience wrapper to start the Loom daemon from the repository root (see ./loom.sh --help).

Documentation

Guide	Description
TypeScript SDK	Real-time subscriptions & React hooks
Drizzle ORM	Type-safe queries with Drizzle adapter
HTTP API	REST, GraphQL, and SSE endpoints
CLI Guide	Command-line interface
Python Bindings	Python API reference
Scheduled Functions	Cron jobs and scheduled tasks
Transactions	Durability hints and savepoints
Vector Search	AI/ML embeddings and similarity search
File Storage	Blob storage with SQL integration
ODBC/JDBC	Database connectivity
Roadmap	Future plans
History

Project Background

This project originated from a challenge about AI capabilities: implement a NIST-compatible SQL database from scratch. Core SQL:1999 compliance was achieved in under 2 weeks (Oct 25 - Nov 1, 2025).

Inspired by posix4e/nistmemsql.

License

MIT OR Apache-2.0. See LICENSE-MIT and LICENSE-APACHE.

Contributing

See CLAUDE.md for development workflow with Loom AI orchestration.

---

Try the Live Demo →