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
• 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
• 485,000+ lines of Rust across 12 crates

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 && npm install && npm run 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)
• Scheduled functions (SCHEDULE AFTER/AT, CREATE CRON)
• Vector types for AI embeddings (VECTOR(n), distance functions)
• Blob storage with STORAGE_URL/STORAGE_SIZE functions

Performance

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

Benchmarks

VibeSQL achieves 10,758 TPS on TPC-C mixed workload (5.5x faster than SQLite) and passes 100% of TPC-H and TPC-DS queries.

Test Coverage

TPC-C (OLTP Transactions)

Scale Factor 1, 60-second duration, mixed workload (New Order, Payment, Order Status, Delivery, Stock Level).

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 (99 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

# Full build, test, and benchmark (runs in background)
make all            # Starts in background, shows monitoring instructions
make status         # Check progress
make logs           # Follow full output

# 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 all-fg         # Run everything in foreground (blocking)
make help           # Show all targets

Documentation

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.

VibeSQL Challenge

Can you build a SQL database faster than we did?

The VibeSQL Challenge: pass all 622 SQLLogicTest files using AI tools. Our benchmark is 25 days from first commit to 100% conformance—but we spent significant time on features beyond the core challenge (storage engine, server mode, i18n, benchmarks). A focused effort could beat this.

How to participate:

1. Fork a seed repo or start from scratch
2. Use any AI tools—Claude, Copilot, Cursor, or your own agents
3. Run make test to track progress against 622 SQLLogicTest files
4. When all tests pass, submit to the leaderboard

Starter templates:

See the challenge page for full details.

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 →