tursodatabase/turso
39.5
Weak · 14 November 2026
644.8k
lines of production code
Rust
with C
7
measurements over time
What this system is
Features
Add CSV virtual table extension
Users can now query CSV files as if they were database tables using the new \csv\ virtual table extension. This feature allows specifying input via a \filename\ or inline \data\, with options to control header parsing (\header=yes/no\) and define custom schemas or column counts. The extension is implemented in \extensions/csv/src/lib.rs\ and registers the \CsvVTabModule\ to handle these virtual table operations.
extensions/csv · high confidence
Add Go SDK examples for encryption and sync
New example applications have been added to the Go examples directory to demonstrate key Turso Go SDK capabilities. The encryption example shows how to create and use a local database encrypted with the aegis256 cipher, including verification that data is not stored in plaintext on disk. The sync example demonstrates how to open a local database that synchronizes with a Turso Cloud remote, featuring background workers for periodic Push/Pull operations and WAL checkpointing.
examples/go · high confidence
Add Java example project demonstrating Turso JDBC usage
A new Gradle-based example project has been added to the Java bindings, providing a runnable demonstration of connecting to a Turso database via JDBC. The example, located in the \tech.turso\ package, shows how to establish a connection, create a table, insert data, and query results, serving as a starting point for developers integrating with the library.
bindings/java/example · high confidence
Add PostgreSQL parser crate
Introduces a new \postgres/parser\ crate that provides a complete SQL parser and translator for PostgreSQL syntax. The crate includes a custom lexer and recursive-descent parser to build a PostgreSQL-specific AST (defined in \ast.rs\), error handling (\error.rs\), and a translator (\translator.rs\) that converts the PostgreSQL AST into the core Turso SQL AST. This enables the system to parse and translate a wide range of PostgreSQL-specific features, including complex DDL, DML, and session management commands, into the internal representation used by the database engine.
postgres/parser · high confidence
Add REGEXP SQL extension with scalar functions
The \extensions/regexp\ module introduces a new SQL extension providing five scalar functions for regular expression operations: \regexp\ (returns 1 if the pattern matches), \regexp\_like\ (matches pattern against string), \regexp\_substr\ (extracts the first match), \regexp\_replace\ (replaces matches with a replacement string), and \regexp\_capture\ (extracts a specific capture group). These functions are registered via the \turso\_ext\ API and rely on the \regex\ crate for pattern matching.
extensions/regexp · high confidence
Add TATP benchmark harness for SQLite and Turso
Added a new performance benchmark harness in \perf/tatp\ that implements the Telecom Application Transaction Processing (TATP) workload to compare SQLite and Turso. The Rust-based tool populates databases with subscriber data and runs a standard transaction mix (80% reads, 20% writes) under closed-loop conditions, measuring Mean Qualified Throughput (MQTh) and response times. It supports configurable database sizes (10K–1M subscribers), connection counts (1, 4, 16), and transaction mixes, while including Python scripts to generate publication-ready figures from the results.
perf/tatp, perf/tatp/upstream · high confidence
Add TLA+ specifications for SQLite WAL mode concurrency
Added formal TLA+ specifications and model-checking infrastructure for SQLite Write-Ahead Log (WAL) mode concurrency. This includes a new \multiprocess\ specification modeling Turso's multi-process WAL coordination (reader/writer/checkpoint interactions) and a \sqlite-tx\ specification modeling standard SQLite WAL transaction semantics (single-writer, multi-reader, snapshot isolation). Both specs include Makefiles to run the TLC model checker and generate PDF documentation, allowing verification of invariants like single-writer enforcement and snapshot validity.
tlaplus · high confidence
Add TPC-C benchmark harness for SQLite and Turso comparison
Introduces a new TPC-C benchmark suite in perf/tpc-c that allows users to build and run performance tests against both system SQLite3 and Turso (a SQLite-compatible database written in Rust). The harness includes C source files implementing the five standard TPC-C transactions (New-Order, Payment, Order-Status, Delivery, Stock-Level), SQL scripts for schema creation and indexing, and a Makefile that supports building binaries for either backend. A shell script (run\_bench.sh) automates the process by detecting or cloning the Turso repository, building both benchmarks, loading test data, running the workloads with configurable parameters (warehouses, connections, warmup, measurement time), and generating a side-by-side comparison report of throughput (TpmC) and response times.
perf/tpc-c · high confidence
Add TPC-H benchmark plotting and result conversion tools
New scripts have been added to the performance benchmarking suite to visualize and process TPC-H query results. The \results2csv.sh\ utility converts raw benchmark output logs into structured CSV files, while the \plot-tpch.py\ script generates publication-quality grouped bar charts (PNG, PDF, and TikZ) from these CSVs. The plots display query runtimes on a linear axis, using whiskers to indicate the range between the fastest and slowest runs across multiple executions, and highlight the fastest median runtime in bold within the accompanying data table.
perf/tpc-h/plot · high confidence
Add Tursodb corruption debug tools for WAL analysis
A new collection of Python scripts has been added to \scripts/corruption-debug-tools\ to help diagnose database corruption issues by analyzing Write-Ahead Log (WAL) files. The suite includes utilities to inspect WAL headers and commit frames (\wal\_info.py\, \wal\_commits.py\), perform binary searches to pinpoint the exact WAL frame that introduces corruption (\find\_corrupt\_frame.py\), and compare page states between frames to identify lost or gained rowids and keys (\page\_diff.py\, \page\_history.py\, \track\_rowid.py\). These tools rely on a shared library (\lib/\) for parsing SQLite WAL formats, page headers, and record payloads, enabling users to trace data integrity issues back to specific transaction boundaries.
scripts/corruption-debug-tools · high confidence
Add async Python driver with sync capabilities
The Python bindings now include an asynchronous API (\lib\_aio.py\) that wraps the existing blocking connection in a background worker thread, allowing non-blocking database operations via \asyncio\. This async layer exposes standard DB-API methods (\execute\, \executemany\, \batch\) as coroutines and supports context managers. Additionally, a synchronized async connection (\lib\_sync\_aio.py\) is provided, enabling local-to-remote data synchronization (\pull\, \push\, \checkpoint\) and statistics collection within the async environment. The package is renamed to \pyturso\ and includes type hints (\py.typed\).
bindings/python/turso · high confidence
Add connection performance benchmark comparing rusqlite and limbo
A new benchmark suite in perf/connection allows users to measure and compare the database connection open times of rusqlite and limbo across databases with varying table counts (10, 1,000, 5,000, and 10,000 tables). The change introduces a Python script to generate test databases, shell scripts to build and run the benchmarks for both libraries, and a visualization tool to plot the resulting latency percentiles (p50 through p99.999) as a log-scaled bar chart.
perf/connection · high confidence
Add dbhash tool for computing logical content hashes of SQLite databases
A new \dbhash\ CLI tool has been added to compute a SHA1 hash of a SQLite database's logical content, ensuring that databases with identical data produce the same hash regardless of physical differences like page size or encoding. The tool excludes system tables, virtual tables, and statistics tables, and supports filtering tables via a SQL LIKE pattern. Users can choose to hash only the schema, only the content, or both, and can enable debug tracing to print hashed values to stderr. The implementation uses a type-prefixed encoding for values to ensure platform-independent hashing.
tools/dbhash · high confidence
Add iOS project scaffolding for the TursoExample React Native app
The iOS directory for the TursoExample React Native application has been initialized with the standard project structure required to build and run the app on iOS devices. This includes the Xcode project file, workspace configuration, and scheme definitions, along with the native Swift AppDelegate that bootstraps the React Native runtime. The configuration enables the New Architecture (RCTNewArchEnabled) and includes the necessary Info.plist settings, such as allowing local networking for development, and a PrivacyInfo manifest to comply with Apple's data collection requirements.
examples/react-native/ios · high confidence
Added Android native export validation script
A new Python script, check\_elf\_dynsym\_exports.py, has been added to the bindings/dotnet/scripts directory to verify that specific symbols are correctly exported in Android native shared libraries (ELF files). This tool parses the dynamic symbol table (.dynsym) to ensure required exports are present, helping to prevent build-time or runtime linking errors for the .NET bindings on Android.
bindings/dotnet/scripts · high confidence
Added ClickBench performance benchmark suite for Turso and SQLite
The perf/clickbench directory now includes a complete benchmark suite that compares Turso (formerly Limbo) against SQLite using the standard ClickBench dataset. This addition provides a modified benchmark script, SQL schema, and a comprehensive set of 45 queries covering aggregation, filtering, and pattern matching, enabling users to evaluate and compare the performance characteristics of the two database engines.
perf/clickbench · high confidence
Added MVCC checkpoint benchmark tool
A new multithreaded benchmark tool has been added to compare TRUNCATE (blocking) and PASSIVE (non-blocking) MVCC checkpoint modes. The tool measures per-operation latency, throughput, and file sizes under concurrent read/write loads, outputting time-series data in CSV and SVG formats to help visualize contention and checkpoint performance.
perf/checkpoint-bench · high confidence
Added Mobibench evaluation tool for SQLite vs Turso performance comparison
A new benchmarking suite has been added to the \perf/mobibench\ directory to evaluate and compare the transaction throughput of SQLite against Turso. The suite includes a shell script (\run-eval.sh\) that executes Insert, Update, and Delete workloads under WAL journal mode with FULL synchronous settings, and a Python script (\plot/plot.py\) that generates a grouped bar chart visualizing the results. This allows users to assess performance differences between the two database engines using the Mobibench framework.
perf/mobibench · high confidence
Added React Native example application for Turso
A new React Native example application named 'TursoExample' has been added to the repository, providing a starting point for developers to integrate Turso with React Native. The entry includes the initial Android application entry point (MainApplication.kt) which sets up the React Native host and loads the React Native runtime, serving as a reference implementation for this specific platform integration.
app · high confidence
Added TPC-H benchmark queries to performance suite
The performance suite now includes the full set of TPC-H benchmark queries (1–22) in the \perf/tpc-h/queries\ directory. These SQL files have been adapted for the current engine by replacing non-standard date casting syntax (e.g., \cast({'month': 3} as interval)\) with standard string literals (e.g., \'1994-01-01'\) and replacing \date\_part\ calls with \substr\ where necessary. Some queries include skip markers for engines that cannot handle specific patterns (e.g., SQLite skip for decorrelation issues in Q20), indicating this change enables standardized performance testing across different database backends.
perf/tpc-h/queries · high confidence
Added connection performance benchmark for Limbo
A new benchmark tool has been added to the \perf/connection/limbo\ directory to measure the time required to open a database connection and prepare a statement. The tool accepts a database file path and an iteration count, runs the specified number of connection cycles, and outputs latency percentiles (p50 through p99.999) in CSV format to help track performance changes over time.
perf/connection/limbo · high confidence
Added encryption usage examples for Java and .NET SDKs
New example files have been added to demonstrate local database encryption capabilities in the Java and .NET SDKs. The Java example (EncryptionExample.java) and the .NET example (Encryption.cs) show how to create encrypted databases, insert and query sensitive data, verify that data is encrypted on disk, and handle incorrect decryption keys. These examples support multiple ciphers including AES\_128\_GCM, AES\_256\_GCM, and various AEGIS variants.
bindings/java/src/main/java/examples, examples/dotnet, examples/java · high confidence
Added graph query benchmark with complex multijoins
The perf/graph-queries location now includes a synthetic seed data generator and a suite of SQL benchmark queries designed to test graph performance with complex multijoins. The seed generator creates a university course catalog graph (nodes, edges, messages, conversations, journals) to populate a SQLite database. The benchmark suite includes queries for aggregate OR/IN operations, co-occurrence analysis, edge counting, IN-list unions, activity aggregation, and streak detection (current and longest), providing a comprehensive set of complex graph traversal and aggregation patterns for performance testing.
perf/graph-queries · high confidence
Added minimal synchronous PostgreSQL client for test tooling
A new minimal synchronous PostgreSQL wire-protocol client has been added to the \postgres/client\ crate. This client implements protocol 3.0 over TCP, including the startup handshake with optional cleartext password authentication and decoding of backend messages from the simple query protocol. It is designed specifically for Turso's test tooling (\sqltest\), providing both raw frame access for byte-for-byte transcript reproduction and higher-level APIs for reading rows and errors, without performing type conversion on returned values.
postgres/client · high confidence
Added replica pooling and automatic sync coordination
The Turso .NET binding now supports pooling embedded database replicas and automatically scheduling data synchronization. A new \TursoReplicaRegistry\ manages shared database instances by path, allowing multiple connections to reuse a single underlying database file when pooling is enabled. It also introduces an automatic sync coordinator that handles periodic data pulls based on a configurable interval, ensuring replicas stay in sync without manual intervention.
dotnet · high confidence
Antithesis testing infrastructure and targeted coverage script
Added a new set of scripts under \scripts/antithesis\ to integrate Antithesis fuzzing into the CI pipeline. This includes \diff\_to\_targeted\_coverage.py\, which parses unified diffs to generate JSONL-formatted targeted coverage files focusing only on changed Rust source lines, and shell scripts (\launch.sh\, \publish-config.sh\, \publish-workload.sh\, \publish-docker.sh\) to build Docker images for the config and workload, authenticate with the Antithesis registry, and launch experiments with configurable durations and notification recipients. Tests for the diff parser are also included.
scripts/antithesis · high confidence
Automated environment setup for Orb agents
The Orb agent environment now includes an automated setup script that configures the development environment by installing system packages, toolchains (Rust, Go, Node.js v24, Python via uv), and dependencies (Cargo, Go modules, Yarn). It also installs the gh-stack extension and updates shell profiles to ensure tools are available in the PATH.
.agents · high confidence
Automatic terminal theme detection for CLI output colors
The CLI now automatically detects whether your terminal uses a light or dark background theme and adjusts its table and syntax highlighting colors accordingly. This is handled by new configuration modules in \cli/config\ that detect the terminal theme via ANSI queries (on Unix and Windows) and apply optimized color palettes for \TableConfig\ and \HighlightConfig\. If detection fails or the output is not an interactive terminal, the CLI falls back to a no-color mode to ensure readability.
cli/config · high confidence
Enable automatic JDBC driver detection for Turso
The Java binding now supports automatic discovery of the Turso JDBC driver. A new META-INF/services/java.sql.Driver file registers the driver class (tech.turso.JDBC), allowing applications to load the driver without explicit class loading. Additionally, a properties file provides metadata including the driver name and a placeholder version.
bindings/java/src/main/resources · high confidence
Expose async and sync partial sync APIs in the Python SDK
The Python SDK now exposes asynchronous and synchronous partial synchronization capabilities. Users can import \ConnectionSync\, \PartialSyncOpts\, \PartialSyncPrefixBootstrap\, and \PartialSyncQueryBootstrap\ from \turso.aio.sync\, along with a \connect\ function for establishing sync connections, enabling direct integration of partial sync features into Python applications.
bindings/python/turso/aio · high confidence
Imported PostgreSQL 18 regression test corpus for conformance validation
Added a curated subset of 103 upstream PostgreSQL regression tests (from tag REL\_18\_4) to the \postgres/conformance/upstream\ directory. This corpus, covering core SQL semantics such as aggregates, table alterations, arrays, bit types, and booleans, serves as the primary yardstick for measuring tursopg's PostgreSQL compatibility. The tests are executed via the \pgregress\ runner, with results tracked in a pass/fail status table to monitor regression and compatibility progress.
postgres/conformance/upstream · high confidence
Initial Android native bindings for React Native integration
This change introduces the Android-side native implementation for the Turso React Native library. It adds the CMake build configuration, a C++ JNI adapter, and the necessary Java classes (TursoModule, TursoBridge, TursoPackage) to register the native module with React Native. The build system is configured to link against the pre-built Rust shared library (.so) and includes specific linker options to ensure 16KB page alignment compatibility with Android 15+. This enables the JavaScript layer to communicate with the native Turso sync SDK on Android devices.
bindings/react-native/android · high confidence
Initial Android native configuration for the TursoExample React Native app
The Android side of the TursoExample React Native application has been scaffolded from scratch. This includes the AndroidManifest.xml declaring internet access and the launcher activity, the MainActivity.kt entry point configured to use the React Native New Architecture (Fabric), and standard resource files (styles, strings, drawables) to support the app's UI and build process.
examples/react-native/android · high confidence
Initial Java bindings for Turso database engine
This change introduces the initial Java Native Interface (JNI) bindings for the Turso database engine, exposing core database operations to Java applications. The Rust source files in \bindings/java/rs\_src\ implement the bridge, including \TursoDB\ for opening databases (with optional local encryption support via \openWithEncryptionUtf8\), \TursoConnection\ for managing connections and preparing SQL statements, and \TursoStatement\ for executing queries and binding parameters. The implementation maps internal error codes to Java exceptions and handles data type conversions between Rust and Java, establishing the foundational connectivity layer for the Java SDK.
_bindings/java/rs\src · high confidence
Initial React Native example app with performance and concurrency testing
The \examples/react-native\ directory now contains a fully bootstrapped React Native application that serves as a functional testbed for the \@tursodatabase/sync-react-native\ bindings. The app includes a UI that displays results for database open time, query throughput, and various concurrency smoke tests (sequential reads, multi-connection parallelism, and prepared statement reuse). It also supports optional sync and encryption tests via environment variables and includes the necessary configuration files (Metro, Babel, ESLint, Prettier) to link against the local bindings and run on both Android and iOS.
examples/react-native · high confidence
Initial release of Turso .NET ADO.NET bindings
This change introduces the initial set of .NET bindings for Turso, providing a SQLite-compatible ADO.NET facade (\Turso.Data.Sqlite\) that supports local embedded replicas, remote libSQL databases via Hrana, and connection-string-based replica pooling with automatic sync. The packages target .NET 8.0, 9.0, and 10.0, include native runtime assets for Windows, Linux, macOS, Android, and iOS, and support NativeAOT static linking. The release also adds an EF Core provider, batch execution support, and a complete build/packaging infrastructure for NuGet distribution.
bindings/dotnet · high confidence
Initial release of the Turso JDBC driver
This change introduces the \tech.turso\ Java package, providing a new JDBC driver for connecting to Turso (LibSQL) databases. The implementation includes the core \JDBC\ driver class, \TursoDataSource\ for connection pooling, and \JDBC4Connection\/\JDBC4Statement\ wrappers that delegate to the native \TursoConnection\ and \TursoStatement\ classes. It supports standard JDBC features such as transaction management, prepared statements with parameter binding, and result set iteration, while also introducing local database encryption support via \TursoEncryptionCipher\ and specific error handling through \TursoErrorCode\.
bindings/java, bindings/java/src/main/java/tech · high confidence
Introduce .NET serverless database driver for Turso Cloud
Adds the Turso.Serverless.Client package, a pure managed HTTP client for connecting to Turso Cloud databases over the SQL over HTTP protocol (Hrana 3). This driver supports executing single statements with positional or named arguments, running atomic batches in a single round trip, and performing interactive transactions with automatic rollback on disposal. It features streaming cursor support for large result sets, encrypted database connectivity via the x-turso-encryption-key header, and a single-stream concurrency model that requires multiple connections for parallelism.
bindings/dotnet/src/Turso.Serverless.Client · high confidence
Introduce @tursodatabase/sync JavaScript package for database synchronization
This change introduces a new \@tursodatabase/sync\ npm package that enables JavaScript applications to sync local Turso databases with Turso Cloud. The package exposes a \connect()\ function that returns a database instance with \pull()\, \push()\, and \sync()\ methods. It supports configuration options for remote encryption (\remote\_encryption\_cipher\, \remote\_encryption\_key\), partial sync strategies (\partial\_sync\_opts\), and experimental features. The implementation bridges the Rust \turso\_sync\_engine\ to JavaScript via N-API, handling HTTP requests, file I/O, and data transformations through a custom protocol interface.
bindings/javascript/sync · high confidence
Introduce C API bindings for the Turso Sync SDK Kit
The sync/sdk-kit module now exposes a C-compatible interface (capi.rs) and corresponding Rust API (rsapi.rs) to manage synced databases. This includes functions to create, open, and connect to a synced database, as well as to push changes, wait for changes, apply incoming changes, and retrieve sync statistics. The bindings support configuration options such as remote URL, encryption keys, partial sync strategies, and pull/push thresholds, enabling external applications to integrate with the Turso sync engine via a stable C ABI.
sync/sdk-kit · high confidence
Introduce Clock trait and dedicated time types for I/O backends
The core I/O layer now exposes a \Clock\ trait with \current\_time\_monotonic\ and \current\_time\_wall\_clock\ methods, allowing backends to provide time sources that can be controlled in simulations. This is implemented via new \MonotonicInstant\ and \WallClockInstant\ types in \core/io/clock.rs\, and all I/O backends (Generic, Unix, io\_uring, Memory, VFS) now implement this trait to supply time for timeouts, WAL timestamps, and deterministic testing.
core/io · high confidence
Introduce DBSP-based incremental view maintenance for materialized views
The incremental view engine now uses a DBSP-style circuit compiler to maintain materialized views. This change adds new core components in core/incremental, including an aggregate operator (supporting COUNT, SUM, AVG, MIN, MAX, and their DISTINCT variants), a filter operator, a join operator, and a merge operator for UNION/UNION ALL. The compiler translates SQL logical plans into these DBSP circuits, allowing the system to incrementally update view results based on underlying table changes rather than recomputing from scratch. Also in this area: Schema objects are now keyed by namespace; Structured constraint errors and dialect-specific behavior hooks.
core/incremental · high confidence
Introduce Go bindings for embedded database and remote sync
The Go bindings package is now available, providing an embedded SQLite-compatible database driver and a remote sync driver. The embedded driver registers as the "turso" driver for the standard \database/sql\ interface, supporting in-memory and file-based databases with optional encryption and async I/O. The sync driver enables local databases to bootstrap from and synchronize with remote Turso instances via push/pull operations, supporting partial sync strategies and configurable busy timeouts.
bindings/go · high confidence
Introduce JSON and JSONB support with SQLite-compatible functions and virtual tables
This change adds a complete JSON processing engine to the core, introducing a binary JSONB format for efficient storage and manipulation alongside standard JSON text. It implements a suite of SQLite-compatible scalar functions including json\_valid, json\_extract, json\_set, json\_insert, json\_replace, json\_remove, json\_patch, json\_array, json\_object, json\_array\_length, json\_type, json\_pretty, and json\_quote, as well as the json\_each and json\_tree virtual tables for traversing JSON structures. The implementation includes a JSON5 parser, a path resolution engine, and a caching layer to optimize repeated access to JSON values.
core/json · high confidence
Introduce Limbo SQLite C API header
A new \sqlite3.h\ header is added under \bindings/c/include\, defining the core SQLite C API surface for the Limbo project. This includes standard return codes (e.g., \SQLITE\_OK\, \SQLITE\_ERROR\), open flags (e.g., \SQLITE\_OPEN\_READONLY\, \SQLITE\_OPEN\_READWRITE\), and type definitions for database and statement handles. It exposes key functions such as \sqlite3\_open\, \sqlite3\_prepare\_v2\, \sqlite3\_step\, and \sqlite3\_exec\, along with statement introspection utilities like \sqlite3\_changes64\ and \sqlite3\_stmt\_readonly\. This header serves as the interface for C bindings to interact with the underlying database engine.
bindings/c/include · high confidence
Introduce MVCC concurrency control module
Adds a new core/mvcc module implementing multiversion concurrency control (MVCC) for the database engine. This includes a mutex-guarded logical clock for atomic timestamp generation, a state-machine-driven cursor that coordinates between the MVCC index and the underlying B-tree, and a portable logical log for capturing schema changes to support cross-platform synchronization. The module also provides yield and failure injection hooks to enable robust testing of concurrent transaction behaviors.
core/mvcc · high confidence
Introduce Pyturso: SQLite-compatible Python bindings with sync and async support
This change introduces the \pyturso\ Python package, providing a SQLite-compatible database driver built on the Turso SDK kit. The bindings expose a standard DB-API 2.0 interface for local in-memory or file-based databases, along with full \asyncio\ support for non-blocking operations. A key addition is the synchronization driver (\turso.sync\), which allows local databases to bootstrap from and sync bidirectionally with remote Turso/libsql servers, including support for partial sync strategies and remote encryption. The package also includes a SQLAlchemy dialect (\sqlite+turso://\) for easy integration with existing Python ORM workflows.
bindings/python · high confidence
Introduce SDK kit for Turso Sync with C API bindings
This change adds the \sync/sdk-kit\ component, which exposes the sync engine's functionality through a C API (\turso\_sync.h\) and a \bindgen.sh\ script to generate Rust bindings. This enables external applications to integrate Turso Sync capabilities, including database configuration, connection management, and async operations, into their own codebases.
sync · high confidence
Introduce SQL generation model for tables, columns, and indexes
Added a new \sql\_generation/model\ module containing data structures (\Table\, \Column\, \Index\, \JoinedTable\) and traits (\TableContext\) that represent the schema and data state for SQL generation. This includes support for column constraints (UNIQUE, PRIMARY KEY, Generated), index definitions, and join types, providing the foundational model for generating SQL queries from simulated data.
_sql\generation/model · high confidence
Introduce TPC-H benchmark suite for Turso vs SQLite performance comparison
Added a new TPC-H benchmark harness in the perf/tpc-h directory that enables performance comparison between Turso and SQLite. The suite includes scripts to run queries with cache dropping, measure execution times using EPOCHREALTIME, and generate visual plots of results. It supports manual regression testing via a comparison script that benchmarks two different binaries, and includes a README documenting the setup and usage for evaluating query performance.
perf/tpc-h · high confidence
Introduce Turso CLI with syntax highlighting, MCP, and sync server capabilities
The CLI application has been renamed to Turso and rebuilt from the ground up using Clap for argument parsing and Rustyline for the interactive shell. This release introduces built-in SQL syntax highlighting via a generated syntect syntax set, configurable via a TOML config file. New operational modes include an MCP server (--mcp) for AI tool integration and a sync server (--sync-server) for remote database access. The shell now supports dot commands with robust path tokenization, history persistence, and various experimental features gated behind flags such as MVCC, encryption, and custom types.
cli · high confidence
Introduce Turso EF Core SQLite provider with remote and replica support
This change adds the Turso Entity Framework Core provider for SQLite, enabling applications to connect to Turso's remote and replica backends. The provider replaces standard EF Core SQLite services with Turso-specific implementations, including a custom query SQL generator that handles decimal collation and optimizes JSON array checks, and a database creator that manages local WAL mode and remote existence checks. It also registers custom SQL functions (such as regex, modulo, and arithmetic operations) and aggregates (avg, max, min, sum) to support Turso's specific capabilities, while ensuring proper connection handling for both direct remote and replica modes.
bindings/dotnet/src/Turso.EntityFrameworkCore.Sqlite · high confidence
Introduce Turso SDK Kit as a low-level C ABI for language bindings
The sdk-kit module is introduced as a low-level, SQLite-compatible API designed to facilitate the creation of language bindings for Turso. It exposes the core Rust logic through a portable C ABI (turso.h) and a Rust API (rsapi), allowing developers to generate bindings for other languages without reimplementing database semantics. Key features include explicit ownership models, clear status codes (e.g., Done, Row, Io, Error), and optional caller-driven async I/O. The kit also supports external page codecs for legacy encryption compatibility and includes a build script to generate Windows version resources. This module is distinct from the high-level \turso\ Rust crate and is intended for SDK authors.
sdk-kit · high confidence
Introduce core extension API for virtual tables, VFS, and custom functions
The \extensions/core\ module now provides the foundational public API for building database extensions, introducing support for Virtual Tables (vtab), Virtual File Systems (VFS), and custom scalar/aggregate functions. Developers can now register custom SQL functions via the \ScalarFunc\ and \AggFunc\ traits, implement file system operations through the \VfsExtension\ trait (feature-gated for WASM compatibility), and define virtual table modules using the \VTabModule\ trait with full query planner integration via \xBestIndex\. The API exposes standardized types like \Value\, \ResultCode\, and \Connection\ to ensure safe, cross-language interoperability for extension authors.
extensions/core · high confidence
Introduce core vector types and distance operations
The core module now includes a new vector subsystem that defines support for multiple vector data formats, including dense Float32, dense Float64, sparse Float32, quantized Float8, and binary Float1Bit vectors. This change adds the underlying data structures and parsing logic for these types, along with execution functions for computing vector distances using cosine, L2 (Euclidean), dot product, and Jaccard similarity metrics, as well as functions for concatenating vectors and extracting vector data.
core/vector · high confidence
Introduce extensible IndexMethod framework with FTS and sparse vector support
The core now exposes an \IndexMethod\ trait that allows custom index implementations to register with the database engine. This change introduces a pluggable architecture where index methods can define their own backing storage schemas (managed via \BackingStore\ and \BackingBtree\) and declare their MVCC capabilities (e.g., \TransactionalBackingStore\). Specifically, this location adds the foundational infrastructure for Full-Text Search (FTS) using Tantivy and a toy sparse vector inverted index (\toy\_vector\_sparse\_ivf\), including the necessary traits, configuration structures, and MVCC-aware cursor handling to support these new index types.
_core/index\method · high confidence
Introduce extension API for dynamic libraries and virtual tables
The core now supports loading external shared libraries (extensions) at runtime via a new \Connection::load\_extension\ method, which registers scalar functions, aggregate functions, and virtual table modules exposed by the library. This change introduces the \turso\_ext\ crate (renamed from \limbo\_ext\) as the standard interface for extensions, enabling features like virtual table execution through \xConnect\ callbacks and dynamic VFS module registration. The implementation uses thread-safe \Arc\ and \Mutex\ structures to manage extension state and ensures that schema parsing is re-triggered after extension loading to reflect new tables or functions.
core/ext · high confidence
Introduce managed ADO.NET provider with batch execution and automatic sync
The Turso.Data package now provides a managed ADO.NET implementation, allowing applications to connect to Turso databases using standard .NET data access patterns via TursoConnection, TursoCommand, and TursoDataReader. This release adds support for executing SQL batches through TursoBatch, enabling multiple statements to be sent in a single round-trip for both remote and embedded replica connections. It also introduces automatic background synchronization via TursoAutomaticSyncCoordinator, which periodically pulls changes from the primary and exposes status events, while connection options now support advanced replica configuration, partial sync, and remote encryption settings.
bindings/dotnet/src/Turso.Data · high confidence
Introduce native Node.js sync package with remote writes and partial sync
The \@tursodatabase/sync\ package for Node.js is now available, providing a native embedded database with bidirectional sync capabilities. This release introduces experimental remote writes, allowing changes to be pushed directly to the remote database without an explicit push call, and partial sync with prefix and query-based bootstrap strategies to optimize data transfer. The package also supports remote encryption, configurable long-poll timeouts, and includes full TypeScript definitions and comprehensive test coverage for these new synchronization features.
bindings/javascript/sync/packages/native · high confidence
Introduce new @tursodatabase/database-wasm package with async-first API and build-specific entry points
The new \@tursodatabase/database-wasm\ package provides an embedded SQLite database for JavaScript in the browser, featuring an async-first API where \connect()\ returns a Promise and \Database.prepare()\ returns a Promise. It uses a Web Worker for I/O completion and includes specific entry points (\index-bundle\, \index-default\, \index-turbopack-hack\, \index-vite-dev-hack\) to handle WASM loading quirks in different build environments like Vite and Turbopack. The package also includes comprehensive tests for large schemas, vector operations, and OPFS file handling.
bindings/javascript/packages/wasm · high confidence
Introduce new MVCC-based sync engine with logical-log replication
The sync engine has been restructured into a new \sync/engine\ module that replaces the previous page-stream replication model with a Multi-Version Concurrency Control (MVCC) approach. This change introduces a portable logical log format (using \LogicalOp\ and \LogicalTxnData\ structures) to replicate row-level changes (upserts, deletes) and schema operations (create, drop, alter) rather than raw database pages. The engine now supports auto-detection of the remote pull protocol (MVCC logical log vs. page streams), allows for partial sync via configurable page thresholds, and includes a new \DatabaseReplayGenerator\ to safely apply these logical changes to the local database. This provides a more robust and efficient synchronization mechanism, particularly for large databases or sparse updates.
sync/engine · high confidence
Introduce npm-packaged Turso CLI for cross-platform use
Users can now install and run the Turso CLI via npm (\npx turso\ or \npm install -g turso\), which automatically resolves and executes the correct native binary for the current platform. This package supports macOS (ARM64, x64), Linux (ARM64, x64), and Windows (ARM64, x64), enabling consistent CLI access across all supported architectures without manual binary management.
packages/turso-cli · high confidence
Introduce pure-Python serverless driver for Turso Cloud
Adds a new \turso\_serverless\ Python package that implements the DB-API 2.0 interface for connecting to Turso Cloud over HTTP, designed for serverless and edge environments without persistent connections or native extensions. The driver supports parameterized queries, interactive transactions, and customer-managed remote encryption keys via the \remote\_encryption\_key\ parameter. To ensure reliability, the release includes DB-API 2.0 integration tests against a live database and property-based differential tests that verify behavioral parity with the embedded \pyturso\ driver.
serverless/python · high confidence
Introduce raw .NET bindings for local SQLite and Turso sync operations
This change adds the \Turso.Raw\ public API surface in the .NET bindings, providing low-level access to database operations. Users can now open SQLite databases with optional local encryption (supporting AES-128/256-GCM and AEGIS ciphers), prepare and execute statements, and register custom scalar/aggregate functions or collations. Additionally, the bindings expose a synchronous API for Turso database synchronization, allowing developers to configure, create, connect, push, and pull changes from remote replicas using a state-machine-driven operation model.
bindings/dotnet/src/Turso.Raw/Public · high confidence
Introduce sdk-kit as the unified SDK layer with C and Rust APIs
The sdk-kit module is now available, providing a unified SDK layer that exposes both a C API (capi.rs) and a Rust API (rsapi.rs) for interacting with the database. This includes generated bindings (bindings.rs) for C interoperability, an IoBackend enum for selecting I/O backends (memory, syscall, io\_uring, experimental Windows IOCP), and concurrency guards to prevent concurrent access issues. The C API exposes functions for database setup, opening, connection management, and statement execution, while the Rust API provides idiomatic wrappers and internal synchronization mechanisms like SyncBusyGate.
sdk-kit/src · high confidence
Introduce shared JavaScript SDK common library with async, batch, and encryption support
The JavaScript SDK now includes a new \@tursodatabase/database-common\ package that provides shared utilities and base implementations for both Node and Browser (WASM) builds. This change introduces a promise-based \Database\ API where \prepare()\ returns a Promise, enabling async execution and per-statement query timeouts. Users can now execute multiple statements at once using the new \Database.batch()\ method, which supports various locking modes (write, read, deferred, immediate, exclusive, concurrent) and returns per-statement result details. The SDK also adds support for local database encryption via \EncryptionOpts\, allows enabling experimental features (such as views, triggers, and without\_rowid) through \DatabaseOpts\, and improves transaction safety with an \AsyncLock\ to prevent race conditions during concurrent execution within a transaction.
bindings/javascript/packages/common · high confidence
Introduce shared sync-common library with remote write and resilient fetch capabilities
The \@tursodatabase/sync-common\ package is now available as a shared library for the Node and Browser sync builds. It introduces \RemoteWriter\ and \RemoteWriteStatement\ to support an experimental remote-write mode where write statements execute on the remote server and are followed by a pull for read-your-writes consistency. The package also provides \retryFetch\ for resilient HTTP transport with configurable backoff, and exposes configuration options in \DatabaseOpts\ such as \remoteWritesExperimental\, \pullBytesThreshold\ for bootstrap size limits, \pushOperationsThreshold\ for batching, and \partialSyncExperimental\ for loading subsets of data.
bindings/javascript/sync/packages/common · high confidence
Introduce sql\_generation crate with module structure
A new sql\_generation crate has been added to the project, establishing the initial module structure with public exports for generation and model components. This change organizes SQL generation logic into a dedicated library, separating it from the simulator codebase while providing the foundational module layout for future implementation.
_sql\generation · high confidence
Introduce the Turso Rust SDK with async database operations and cloud sync
The Rust bindings are now available as the \turso\ crate (version 0.4.3), providing a high-performance, SQLite-compatible interface with native async/await support. Users can create local in-memory or file-based databases using the \Builder\ API and execute parameterized queries via \Connection\. The SDK includes a \sync\ feature that enables bidirectional cloud synchronization with Turso Cloud, allowing applications to push local changes and pull remote updates. The release also introduces parameterized batch execution for running multiple statements efficiently and supports custom I/O backends for advanced integration scenarios.
bindings/rust · high confidence
Introduces a pluggable, subsystem-scoped allocation framework with fault injection and fallible paths
The \core/alloc\ module now provides a unified allocation infrastructure that allows the database to use a custom, process-wide memory backend (configurable via \set\_allocator\) and routes allocations through distinct subsystem-specific allocators (MVStore, FTS, B-tree, etc.) defined in \DatabaseAllocators\. This change introduces \TryClone\ and fallible collection helpers (e.g., \try\_clone\, \try\_push\) to handle allocation failures gracefully instead of panicking, and adds an \AllocationSite\ tracking system to instrument and inject faults into specific memory operations for testing and observability.
core/alloc · high confidence
Introduces fallible allocation support for standard collections
This change adds a new \core/alloc/collections\ module that provides fallible (result-returning) variants for standard Rust collections, including \Vec\, \HashMap\, \HashSet\, \BinaryHeap\, \VecDeque\, \Box\, \Arc\, and \Rc\. It introduces a suite of traits (such as \TursoFromIterator\, \TryClone\, and \TursoVecExt\) and their implementations, enabling operations like \try\_push\, \try\_insert\, \try\_clone\, and \try\_collect\ to handle allocation failures gracefully instead of panicking. This allows users to build systems that can recover from memory pressure rather than crashing.
core/alloc/collections · high confidence
Introduces low-level native bindings for Turso database operations
The new Turso.Raw package exposes the underlying native SDK runtime (turso\_sdk\_kit) to .NET applications via P/Invoke, providing direct access to database lifecycle, connection management, statement execution, and sync-specific operations. This includes support for local encryption, custom scalar and aggregate functions, collations, and extension loading, along with a native library resolver to handle platform-specific loading (e.g., iOS frameworks). Application projects should reference higher-level provider packages like Turso.Data.Sqlite.Provider rather than this raw binding directly.
bindings/dotnet/src/Turso.Raw · high confidence
Introducing the @tursodatabase/serverless JavaScript driver
The \@tursodatabase/serverless\ package is now available, providing a native, fetch()-based SQL driver for Turso Cloud optimized for serverless and edge environments like Cloudflare Workers and Vercel. This new driver introduces a Connection/Statement pattern with native streaming support via \iterate()\, batch execution with per-statement statistics, and configurable request headers. It also includes a libSQL compatibility layer (\@tursodatabase/serverless/compat\) for drop-in replacement with existing applications, supporting features like remote encryption keys and interactive transactions.
serverless/javascript · high confidence
Java bindings now support Maven Central publishing with GPG signing
The Java bindings build system has been updated to facilitate publishing to Maven Central. A new \publish.gradle.kts\ script configures Maven publication metadata, enforces GPG signing (supporting both local GPG and CI-based in-memory keys via environment variables), and generates MD5/SHA1 checksums. It also includes a task to bundle the JAR, sources, javadoc, POM, and signatures into a zip file ready for upload, while explicitly blocking SNAPSHOT versions. The Gradle wrapper has been updated to version 8.10.
bindings/java/gradle · high confidence
Local seeded runner for Antithesis Test Composer templates
A new local CLI tool (\thesis\) has been added to allow running Antithesis Test Composer templates locally with reproducible, seeded execution. Users can now execute test templates via the \thesis run\ command, specifying parameters such as a random seed, step count, duration, and work directory. The tool ensures reproducibility by seeding Python's global RNG and supports options like verbose output, strict property checking, and keeping work directories for debugging.
tools/thesis · high confidence
MVCC logical log now supports encryption and defines a crash-recovery contract
The MVCC persistent storage layer now includes a new logical log format (v3) that supports optional encryption. When enabled, transaction payloads are split into fixed-size chunks and encrypted using AEAD, with the log header, transaction headers, and trailers remaining in plaintext. The log format includes a defined recovery process that validates frames using chained CRC32C checksums and replays only committed transactions that have not yet been checkpointed, ensuring durability and consistency after a crash. A regression test ensures that aborted deferred writes correctly clear staged CRC state to prevent corruption.
_core/mvcc/persistent\storage · high confidence
Native JavaScript SDK now supports local database encryption and async transactions
The \@tursodatabase/database\ native package for Node.js now includes local database encryption, allowing users to open encrypted files by passing an \encryption\ option with a cipher (such as \aegis256\) and a hex-encoded key. The SDK also introduces an asynchronous API via the \connect()\ function and \db.transactionAsync()\, enabling non-blocking database operations and concurrent transaction handling. Additionally, the package now supports the \REINDEX\ statement, handles \INSERT ... RETURNING\ correctly, and provides a compatibility layer that collapses duplicate column names in expanded rows to match \better-sqlite3\ behavior.
bindings/javascript/packages/native · high confidence
Native extension support for scalar functions, aggregates, and virtual tables
The core now supports registering and executing native Rust extensions, including scalar functions, aggregate functions, and virtual tables. Users can define custom logic using the new \ScalarFunction\, \AggregateFunction\, and \VirtualTableModule\ traits, which are registered via \OpenOptions\ and executed within the database engine. This enables high-performance, native implementations of database features without relying on external shared libraries.
_core/native\ext · high confidence
Native in-process Tcl extension for SQLite test harness
A new native Tcl extension (libturso\_tcl) replaces the previous subprocess-based shim, enabling the SQLite conformance test suite to run in-process. This change provides accurate engine error codes, real DML change counters, in-process Tcl function registration, multi-statement result accumulation, ATTACH/DETACH support, Tcl variable binding, and transaction handling directly within the Tcl environment.
bindings/tcl · high confidence
New .NET client for the Turso Platform API
Added the Turso.Platform.Client package, a pure managed HTTP client for managing Turso platform resources such as databases, groups, auth tokens, organizations, members, and invites. The client is generated via NSwag from the official OpenAPI specification and includes a custom tool (OpenApiTitler) to improve generated type names. It provides methods like CreateDatabaseAsync, CreateDatabaseTokenAsync, and ListDatabasesAsync, and includes a hand-written Extensions class to handle the API's group-extension union serialization.
bindings/dotnet/src/Turso.Platform.Client · high confidence
New FTS memory benchmarking tool and analysis scripts
Added a new \perf/memory\ benchmark suite to profile Full-Text Search (FTS) query memory usage. This includes a Rust binary (\fts-memory\) that runs FTS workloads under the \dhat\ heap profiler, supporting configurations for different query types, connection counts, and MVCC/WAL modes. A Python script (\analyze-dhat.py\) is also provided to parse the resulting allocation data into human-readable reports. This tool allows users to investigate memory allocation patterns and regressions specific to FTS operations.
perf/memory · high confidence
New FTS search latency and throughput benchmarks with CPU profiling support
Added a new performance benchmarking suite in \perf/fts\ to measure Full-Text Search (FTS) latency and throughput for SQLite FTS5/WAL, Turso/WAL, and Turso/MVCC. The suite includes scripts to run search latency (measuring p50/p95/p99 per-query times) and throughput (completed searches per second) benchmarks, along with a memory peak heap measurement tool. It also introduces optional CPU flamegraph profiling via the \pprof\ crate and the external \inferno\ renderer, allowing developers to analyze CPU usage during search operations. Results are automatically plotted using a new Python script that generates comparison charts and speedup ratios.
perf/fts · high confidence
New Go serverless driver for Turso Cloud
Introduces a new Go package (turso.tech/database/tursogo-serverless) that implements the database/sql interface for Turso Cloud via the SQL over HTTP protocol. Designed for serverless and edge environments, it avoids persistent connections and native dependencies. The driver supports authentication via auth tokens, customer-managed remote encryption keys (sent via the x-turso-encryption-key header), and interactive transactions spanning multiple HTTP requests. It includes a Connector API to keep credentials out of connection strings and provides conformance tests to ensure compatibility with the Turso protocol.
serverless/go · high confidence
New IP address scalar functions in the ipaddr extension
The new ipaddr extension adds five scalar functions to SQLite for working with IP addresses and CIDR networks: ip\_contains checks if an IP is within a network, ip\_family returns 4 or 6, ip\_host extracts the IP from a CIDR, ip\_masklen returns the prefix length, and ip\_network returns the full CIDR string.
extensions/ipaddr · high confidence
New JavaScript SDK examples for Node, Web, encryption, and sync
Added a suite of new examples in the \examples/javascript\ directory demonstrating the Turso JavaScript SDK across different environments. The \database-node\ example shows basic local database usage in Node.js, while \database-wasm-vite\ provides a browser-based guestbook using the WASM build with Vite, including configuration for required COOP/COEP headers. New \encryption\ and \sync-encryption\ examples demonstrate local database encryption (using ciphers like Aegis256) and remote sync with optional encryption support. Additionally, \concurrent-writes\ illustrates handling MVCC conflicts with retry logic, and \sync-node\ and \sync-wasm-vite\ showcase bidirectional synchronization between local and remote databases.
examples/javascript · high confidence
New JavaScript concurrent write example and updated examples documentation
The examples directory now includes a new JavaScript example demonstrating MVCC concurrent writes using \BEGIN CONCURRENT\, alongside existing Node.js and browser-based examples. The examples README has been updated to document these JavaScript samples, and a .gitignore file has been added to exclude database artifacts and node\_modules. Additionally, the Rust examples are now accessible via a symlink to the bindings directory.
examples · high confidence
New Python SDK examples for concurrent writes, encryption, and cloud sync
Added four new example scripts in the Python examples directory: \basic.py\ demonstrates local embedded database usage; \concurrent\_writes.py\ shows how to handle MVCC mode with conflict retries for concurrent writers; \encryption.py\ illustrates local database encryption using various ciphers like aegis256; and \sync\_example.py\ demonstrates syncing with Turso Cloud, including optional remote encryption support.
examples/python · high confidence
New Python bindings and serverless driver for Turso
This change introduces the initial Python bindings for the Turso engine, providing a DB-API 2.0 compliant interface in \bindings/python/turso/lib.py\ that maps engine errors to standard Python exceptions. It also adds a dedicated serverless driver (\serverless/python/turso\_serverless/\) that communicates with remote Turso instances over HTTP, supporting features like parameterized batches, remote encryption keys, and autocommit tracking. Additionally, a sync module (\bindings/python/turso/lib\_sync.py\) is included to handle local synchronization with remote databases via HTTP IO, and a suite of CLI tests (\testing/cli\_tests/\) is added to validate collation, constraint, and MVCC behaviors.
limbo · high confidence
New React Native JSI C++ bindings for Turso database operations
This change introduces a new set of C++ JSI HostObjects in the React Native bindings, providing a thin 1:1 mapping of the Turso C API to JavaScript. The new files include \TursoHostObject\ (the entry point for installing the module), \TursoDatabaseHostObject\ (for opening and connecting to local databases), \TursoConnectionHostObject\ (for executing SQL statements and managing connections), \TursoStatementHostObject\ (for binding parameters and fetching results), and several sync-related objects (\TursoSyncDatabaseHostObject\, \TursoSyncOperationHostObject\, \TursoSyncIoItemHostObject\, \TursoSyncChangesHostObject\) to handle remote synchronization operations. These bindings expose methods like \prepareSingle\, \prepareFirst\, \getAllRows\, \pushChanges\, and \applyChanges\ directly to the JS runtime, enabling React Native apps to interact with Turso's local and sync capabilities.
bindings/react-native/cpp · high confidence
New Rust SDK examples for basic usage, MVCC concurrency, and cloud sync
The \bindings/rust/examples\ directory now includes a set of runnable examples demonstrating key Turso SDK capabilities. The \example\ and \example\_struct\ files show basic database operations, including prepared statements, FTS indexing, and mapping query results to Rust structs within transactions. The \concurrent\_writes\ example illustrates MVCC mode using \BEGIN CONCURRENT\ to handle multiple simultaneous writers with conflict resolution. Additionally, \sync\_example\ demonstrates syncing a local database to Turso Cloud, including optional remote encryption configuration and network statistics reporting.
bindings/rust/examples · high confidence
New SQL generation engine with configurable random data and schema generation
The \sql\_generation/generation\ module has been replaced with a new, standalone SQL generation engine that creates random SQL schemas and queries. This engine introduces a \GenerationContext\ trait and \Arbitrary\ traits to drive the creation of tables, columns, and expressions. It supports generating virtual generated columns with type-safe expressions, configurable table sizes (including large tables), and various query structures like SELECT with joins and ORDER BY. The generation behavior is controlled via \Opts\ structs, allowing users to adjust probabilities for features like generated columns, large tables, and compound selects.
_sql\generation/generation · high confidence
New SQLAlchemy dialects for local, async, and sync Turso connections
Users can now connect to Turso databases using SQLAlchemy via three new dialects: \sqlite+turso://\ for local connections, \sqlite+aioturso://\ for async operations, and \sqlite+turso\_sync://\ for sync-enabled connections with remote support. The dialect requires SQLAlchemy \>= 2.0.45 to ensure compatibility with async adaptation and constraint reflection. It handles Turso-specific behaviors such as unsupported temporary tables, isolation level management at connect time, and remote synchronization via a helper function.
bindings/python/turso/sqlalchemy · high confidence
New SQLite3 C API compatibility layer for Turso
This change introduces a new Rust-based implementation of the SQLite3 C API in the \bindings/c\ directory, acting as a compatibility layer that allows existing applications using SQLite to work with Turso without modification. The implementation includes the full C header definitions, a build script handling variadic C entry points and MSVC dependencies, and a comprehensive Rust source file exposing standard SQLite functions (such as \sqlite3\_open\, \sqlite3\_prepare\_v2\, and \sqlite3\_step\) alongside advanced features like authorizers, database configuration, and printf utilities. It also provides a dual-testing strategy with C and Rust test suites to ensure behavioral parity with the official SQLite library. Also in this area: 1 commit (0 fixes) modifying bindings/c; Structured constraint errors now map to SQLite constraint codes.
bindings/c · low confidence · unverified
New Turso Database for JavaScript in Browser (WASM) package
The \@tursodatabase/database-wasm\ package is now available, providing an embedded SQLite database that runs directly in the browser via WebAssembly. This new package supports in-memory and file-based databases, includes full TypeScript definitions, and enables bidirectional sync with Turso Cloud through the \SyncEngine\. It introduces experimental features such as partial sync (with prefix and query bootstrap strategies), remote writes, and configurable pull thresholds, while also providing specific build entry points to handle WASM loading quirks in bundlers like Vite and Turbopack.
bindings/javascript/sync/packages/wasm · high confidence
New Turso Serverless Driver for Rust
Introduces the \turso\_serverless\ crate, a Rust driver for Turso Cloud that communicates via the SQL over HTTP protocol, designed for serverless and edge environments without persistent connections. The driver provides a \Connection\ API that mirrors the embedded \turso\ driver, supporting parameterized queries, prepared statements, and interactive transactions. It includes support for parameterized statement batches (\Connection::batch\ and \transactional\_batch\) to execute multiple statements in a single HTTP request, and allows for rotating authentication tokens via \Builder::with\_auth\_token\_fn\. The release also includes conformance tests that validate the driver's public API and the underlying wire protocol against a live Turso Cloud instance.
serverless/rust · high confidence
New concurrent write throughput benchmark for SQLite and Turso
A new benchmark harness (\txn-throughput\) has been added to the \perf/throughput\ directory to measure and compare the concurrent write throughput of SQLite and Turso. The tool runs small, back-to-back write transactions across multiple connections (1 to 64) in a closed-loop fashion, reporting transactions per second alongside CPU utilization and service time percentiles. It supports comparing SQLite's WAL mode with Turso's MVCC mode, including configurable checkpointing strategies and IO backends (io\_uring on Linux, syscall elsewhere). The benchmark includes a Python plotting script to visualize results and shell scripts to automate runs with controlled drive state and caching.
perf/throughput · high confidence
New crypto extension with hashing and encoding functions
The new \extensions/crypto\ module introduces a set of SQL scalar functions for cryptographic operations. Users can now compute SHA-256, SHA-512, SHA-384, SHA-1, MD5, and Blake3 hashes via \crypto\_sha256\, \crypto\_sha512\, \crypto\_sha384\, \crypto\_sha1\, \crypto\_md5\, and \crypto\_blake3\. Additionally, data encoding and decoding are supported for Base32, Base64, Hex, Base85, and URL formats through \crypto\_encode\ and \crypto\_decode\.
extensions/crypto · high confidence
New developer tooling and automation scripts
The repository now includes a comprehensive suite of new scripts to support development, testing, and release workflows. These include \scripts/cargo-target-dir\ to resolve the Cargo build directory, \scripts/clone\_test\_db.sh\ to create writable test database clones, and \scripts/clean\_interactions.sh\ to extract SQL statements from simulator logs. For benchmarking, \scripts/compare-divan-std-turso.py\ compares standard library performance against Turso, while \scripts/nightly-bench.sh\ manages nightly Criterion benchmarks with memory caps and timeouts. Debugging is aided by \scripts/diff.sh\ for quick output comparisons, \scripts/corruption\_bisecter.py\ to find minimal failing SQL prefixes, and \scripts/run-sqlancer.sh\ for fuzzing. Release and CI automation is provided by \scripts/merge-pr.py\ (GitHub PR merging), \scripts/gen-changelog.py\ (changelog generation), \scripts/publish-crates.sh\ (Rust crate publishing), \scripts/pypi-cleanup\ (PyPI RC cleanup), and \scripts/release-status.py\ (milestone status reporting). Additional utilities include \scripts/install-sqlite3.sh\ for portable SQLite installation and \scripts/run-sim\ for running the simulator.
scripts · high confidence
New encryption throughput benchmarking tool
Added a new \encryption-throughput\ benchmark tool in the \perf/encryption\ directory to measure database performance with and without encryption. The tool allows users to configure thread count, batch size, iterations, read/write ratios, and specific encryption ciphers (defaulting to aegis-256) to evaluate throughput and latency impacts of enabling database encryption.
perf/encryption · high confidence
New fuzzy string matching and phonetic algorithms added to the fuzzy extension
The fuzzy extension now includes several new SQL scalar functions for string similarity and phonetic matching. Users can calculate edit distances using \fuzzy\_editdist\ (based on the sqlean algorithm), \fuzzy\_leven\ (Levenshtein), and \fuzzy\_damlev\ (Damerau-Levenshtein). Additionally, new phonetic hashing functions are available: \fuzzy\_soundex\ and \fuzzy\_rsoundex\ for Soundex variants, \fuzzy\_phonetic\ for a custom phonetic hash, \fuzzy\_caver\ for the Caverphone algorithm, and \fuzzy\_translit\ for transliterating Unicode characters to ASCII. These functions enable more robust fuzzy searching and name matching capabilities directly within SQL queries.
extensions/fuzzy · high confidence
New internal async operation and IO processing drivers for React Native sync
Added new internal modules (asyncOperation.ts and ioProcessor.ts) that drive sync operations to completion and handle I/O requests using React Native's standard APIs (fetch, file system). This enables network requests to be visible in the React Native debugger, allows customization of fetch (e.g., proxies, custom headers), and supports dynamic auth tokens and base URLs via functions.
bindings/react-native/src/internal · high confidence
New join execution benchmark tool for performance analysis
Added a new \turso-join-benchmark\ tool in the \perf/join-benchmark\ directory that measures query execution performance without printing result rows. The tool outputs JSON records containing elapsed time and detailed work counters, including split B-tree seek metrics (total, table, index, and deferred seeks) and in-memory hash probe calls. It supports running against specific query directories, filtering queries, setting timeouts, and printing query plans in JSON format, enabling users to analyze join execution efficiency using release builds. Also in this area: 1 commit (0 fixes) modifying (repo-wide).
perf/join-benchmark · low confidence · unverified
New procedural macros for assertions, atomic enums, and tracing
The macros crate now provides a suite of new procedural macros: \turso\_assert!\ and related variants that integrate with the Antithesis SDK for autonomous testing (behaving as standard assertions when the \antithesis\ feature is disabled), an \AtomicEnum\ derive macro for generating lock-free atomic wrappers for enums with unit or single-field variants, a \trace\_stack\ attribute for scoped tracing spans, and test-harness helpers like \run\_test\ for configuring database options (MVCC, encryption, init SQL).
macros/src · high confidence
New procedural macros for registering SQLite extension components
The \macros/src/ext\ module now provides a suite of procedural macros to simplify the creation of Turso extensions. The \register\_extension!\ macro allows developers to declaratively list scalar functions, aggregate functions, virtual tables, and VFS modules for automatic registration. Additionally, \\#\[scalar\]\ and \\#\[derive\_scalar\]\ macros generate the necessary C-ABI glue code for scalar functions (including stateful ones), \\#\[derive\_agg\_func\]\ handles aggregate function registration, \\#\[derive\_vtab\_module\]\ implements the virtual table interface, and \\#\[derive\_vfs\_module\]\ generates the VFS implementation. A \match\_ignore\_ascii\_case\ macro is also included to optimize case-insensitive string matching.
macros/src/ext · high confidence
New scalar functions for math, string manipulation, and printf formatting
The core functions module now includes new SQL scalar functions: \gcd\ and \lcm\ for greatest common divisor and least common multiple calculations (with overflow handling), \repeat\, \lpad\, and \rpad\ for string padding and repetition, and a comprehensive \printf\ implementation supporting SQLite-compatible format specifiers (including \%c\, \%e\, \%E\, \%f\, \%i\, \%o\, \%u\, \%x\, \%X\). These additions expand the database's capability for mathematical operations, text manipulation, and formatted string output.
core/functions · high confidence
New secure, multi-language devcontainer environment
Developers now have a pre-configured development container that includes Go, Rust, and Python toolchains, along with VS Code extensions for language server support. The environment is secured by a Squid proxy and a strict iptables firewall that restricts outbound network access to a specific allowlist of domains (such as GitHub, package registries, and Anthropic services), ensuring that development work remains isolated and safe.
.devcontainer · high confidence
New signature validation macro for SDK bindings
A new proc-macro attribute \signature\ has been added to the \sdk-kit-macros\ crate. This macro ensures that the signature of a Rust function matches the signature of a corresponding C API function (extern "C") by generating a compile-time check. This helps prevent mismatches between the internal Rust API and the exported C bindings, improving reliability for users integrating with the SDK's C interface.
sdk-kit-macros · high confidence
New stack profiling and measurement tools
Added a suite of scripts in scripts/stack to analyze and measure stack usage for the tursodb binary. frame-sizes.sh inspects release binaries to report the stack frame size of each function by parsing assembly prologues, supporting comparison against a baseline binary. min-stack.sh performs a binary search to determine the minimum main-thread stack size required to successfully run SQL scripts, allowing comparison between different binaries or against sqlite3. stack-profile.sh uses lldb to capture backtraces during stack overflows, identifying which functions consume the most stack space at runtime. These tools also include a shared library for Rust symbol demangling and a small C helper to set stack limits for debugging.
scripts/stack · high confidence
New transaction latency benchmark harness for SQLite and Turso
Added a new benchmark tool in the \perf/latency\ directory that measures write transaction latency distributions for SQLite and Turso. The harness runs both engines under identical, fixed-schedule arrival loads (Poisson or fixed) across varying connection counts (1, 8, 16, 32) to expose contention and queuing effects that standard benchmarks might hide. It outputs raw latency samples, checkpoint timings, and system metrics, which are then plotted as empirical cumulative distribution functions (eCDFs) showing percentiles like p50, p90, and p99.9. The benchmark supports configurable modes (SQLite WAL with \BEGIN IMMEDIATE\ vs. Turso MVCC with \BEGIN CONCURRENT\), passive checkpointing, and detailed restart counting to accurately reflect real-world stall behavior.
perf/latency · high confidence
New vector operations for concatenation, conversion, and distance metrics
The \core/vector/operations\ module now provides a comprehensive set of vector manipulation functions. Users can concatenate vectors of the same type (excluding Float1Bit and Float8), convert between dense (f32/f64), sparse, 1-bit, and 8-bit quantized formats, and slice vectors. Additionally, new distance metrics are available: L2 (Euclidean), Cosine, Dot product, and Jaccard, all supporting dense, sparse, 1-bit, and 8-bit vector types where applicable. The Cosine distance now returns NaN for zero vectors instead of an error, and the implementation uses \simsimd\ for optimized performance on supported platforms, with Rust fallbacks for WASM and Windows AArch64.
core/vector/operations · high confidence
SQL keyword autocomplete via virtual table extension
A new \completion\ virtual table extension has been added to the \extensions/completion\ crate, enabling SQL keyword autocompletion. The extension registers a \CompletionVTabModule\ that exposes a virtual table with columns for completion candidates, prefixes, and the full query line. It leverages the \turso\_ext\ crate (renamed from \limbo\_ext\) to implement the virtual table API, including \best\_index\ for query planning and cursor filtering to match input against a static list of 147 SQL keywords defined in \keywords.rs\.
extensions/completion · high confidence
Vendor lock-free concurrent SkipMap and SkipSet with custom allocator support
The core module now includes a vendored, lock-free concurrent skip list implementation (SkipMap and SkipSet) that supports safe concurrent access across multiple threads. This change introduces a parameterized allocator interface, allowing the data structures to use a custom \SkiplistAllocator\ (such as \TursoAllocator\) instead of relying on a process-wide default, which improves memory management flexibility and isolation. The implementation includes comprehensive test coverage for insertion, removal, iteration, and concurrent edge cases.
core/skiplist · high confidence
WAL encryption support for database pages and frames
The storage layer now encrypts database pages and WAL frames using AES-256-GCM. Users can configure the cipher algorithm via the \PRAGMA cipher\ command and set the encryption key through connection methods. The pager and WAL modules handle encryption and decryption transparently during read and write operations, and the database header is also encrypted to prevent reading unencrypted data on corrupted or improperly initialized files.
core/storage · high confidence
Architecture
MVCC checkpoint and group commit logic moved to core/mvcc/database
The MVCC checkpoint state machine and group commit coordinator have been relocated into the core/mvcc/database module. This change consolidates the checkpoint logic (including row collection, pager transactions, WAL truncation, and garbage collection) and the group commit batching mechanism into a single, dedicated location, improving code organization and maintainability without altering the external behavior of MVCC transactions.
core/mvcc/database · high confidence
Refactor SQL translation emitter into modular submodules
The core SQL bytecode emitter has been reorganized from a single monolithic module into distinct, focused submodules: delete, select, update, and gencol. This structural change improves code maintainability and readability by separating the logic for different SQL operations (DELETE, SELECT, UPDATE) and generated column handling into their own files, while the main mod.rs now acts as the central coordinator for these specialized emitters. Also in this area: 11 commits (0 fixes) modifying core/translate; Schema objects are now keyed by namespace; Corrects query execution order and filtering for materialized hash joins; Structured constraint errors and dialect-specific behavior hooks; Schema-qualified PRAGMAs, robust view column allocation, and CDC update record accuracy.
core/translate/emitter · medium confidence · unverified
Refactor query translation to use modular emitter contexts and new data structures
The query translation logic in core/translate has been restructured to improve modularity and reduce stack usage. INSERT translation now uses a dedicated InsertEmitCtx, and the main Plan struct has been split into distinct Select and Delete variants. To handle the increased complexity of these plans without exhausting the call stack, large structures like ProgramBuilder, Plan variants, and TranslateCtx are now heap-allocated (boxed). Additionally, the module has been reorganized by splitting the monolithic emitter.rs into smaller, focused sub-modules.
core/translate · high confidence
Refactored main loop translation into modular components
The main loop translation logic in core/translate/main\_loop has been restructured from a monolithic implementation into distinct modules (body, close, conditions, hash, in\_seek, init, multi\_index, open, seek). This refactoring improves code maintainability and clarity by separating concerns such as loop initialization, cursor management, condition evaluation, hash join handling, and multi-index scan logic, while preserving the existing query execution behavior. Also in this area: 24 commits (0 fixes) modifying core; Schema objects are now keyed by namespace; Corrected hash join behavior for unmatched rows and correlated subqueries; Structured constraint errors and dialect-specific behavior hooks; Refined page size handling and stricter SQL validation in core.
_core/translate/main\loop · medium confidence · unverified
Behavioural changes
1 commit (0 fixes) modifying sqlite
A change to existing behaviour in sqlite — 1 commit, 1 file: “sqlite: Define supported version in \sqlite/version\”.
sqlite · low confidence · unverified
115 commits (1 fix) modifying postgres
A change to existing behaviour in postgres — 115 commits (1 fix), 4 files: “postgres: report errors with SQLSTATE codes and structured constraint fields”; “core: keep namespaces in a table instead of in sqlite\_schema”; “postgres: add relation catalog table”; and 112 more.
postgres · medium confidence · unverified
15 commits (1 fix) modifying bindings/dotnet/src/Turso.Data.Sqlite
A change to existing behaviour in bindings/dotnet/src/Turso.Data.Sqlite — 15 commits (1 fix), 22 files: “bindings/dotnet: pool local databases in Turso.Data.Sqlite”; “bindings/dotnet: route sqlite facade through managed backends”; “bindings/dotnet: let native code own function callback handles”; and 12 more.
bindings/dotnet/src/Turso.Data.Sqlite · medium confidence · unverified
16 commits (0 fixes) modifying core/security
A change to existing behaviour in core/security — 16 commits, 4 files: “core/vdbe: Allow only superusers to load extensions”; “core/security: improve API docs”; “core/security: Add role catalog”; and 13 more.
core/security · medium confidence · unverified
16 commits (0 fixes) modifying postgres/conformance/pg-sqltests/row-security
A change to existing behaviour in postgres/conformance/pg-sqltests/row-security — 16 commits, 5 files: “postgres/conformance: move policy write tests to row-security/writes.sqltest”; “postgres/conformance: move ENABLE ROW LEVEL SECURITY owner test to row-security/enable.sqltest”; “postgres: refuse unsupported statements with SQLSTATE 0A000”; and 13 more.
postgres/conformance/pg-sqltests/privileges, postgres/conformance/pg-sqltests/roles, postgres/conformance/pg-sqltests/row-security · medium confidence · unverified
17 commits (1 fix) modifying postgres/conformance
A change to existing behaviour in postgres/conformance — 17 commits (1 fix), 5 files: “postgres: compare pg\_dump files byte for byte”; “postgres: add sqltest pg backend and conformance corpus”; “postgres/conformance: gate the upstream corpus with pass/fail statuses”; and 14 more.
postgres/conformance · medium confidence · unverified
2 commits (0 fixes) modifying perf/job, perf/tpc-ds
A change to existing behaviour in perf/job, perf/tpc-ds — 2 commits, 217 files: “sqlite: move SqliteDialect into a new sqlite/frontend crate”; “core/bench: add Join Order Benchmark and TPC-DS prepare corpora”.
perf/job, perf/tpc-ds · medium confidence · unverified
210 commits (9 fixes) modifying postgres/conformance/pg-sqltests
A change to existing behaviour in postgres/conformance/pg-sqltests — 210 commits (9 fixs), 21 files: “postgres: let frontend scalars take precedence over same-named SQLite builtins”; “postgres: test default ACLs against PostgreSQL behavior”; “core: keep exact results exact for round(), mod() and the like”; and 207 more.
postgres/conformance/pg-sqltests · medium confidence · unverified
239 commits (5 fixes) modifying sqlite/conformance/turso-sqltests
A change to existing behaviour in sqlite/conformance/turso-sqltests — 239 commits (5 fixs), 87 files: “core: check COLLATE operands when expressions are bound”; “add tests”; “core: give the numeric type a % operator”; and 236 more.
sqlite/conformance/turso-sqltests · medium confidence · unverified
24 commits (0 fixes) modifying core/incremental/vdbe\_maintenance
A change to existing behaviour in core/incremental/vdbe\_maintenance — 24 commits, 14 files: “postgres: report errors with SQLSTATE codes and structured constraint fields”; “core/incremental: build with the nightly allocator cfg”; “core: name the collation of comparisons between internal values”; and 21 more.
_core/incremental/vdbe\maintenance · medium confidence · unverified
25 commits (0 fixes) modifying postgres/cli
A change to existing behaviour in postgres/cli — 25 commits, 5 files: “postgres: report errors with SQLSTATE codes and structured constraint fields”; “Simplify the change”; “postgres: implement current\_setting for search\_path”; and 22 more.
postgres/cli · medium confidence · unverified
26 commits (1 fix) modifying sqlite/conformance/sqlite-sqltests/snapshots
A change to existing behaviour in sqlite/conformance/sqlite-sqltests/snapshots — 26 commits (1 fix), 59 files: “core/fkeys: match child keys to parent keys with the parent column's collation”; “add snapshot tests for multi-index with intersection”; “core: reuse generated column values in strict update checks”; and 22 more.
sqlite/conformance/sqlite-sqltests/snapshots · medium confidence · unverified
260 commits (8 fixes) modifying postgres/frontend
A change to existing behaviour in postgres/frontend — 260 commits (8 fixs), 19 files: “postgres: let frontend scalars take precedence over same-named SQLite builtins”; “postgres: test default ACLs against PostgreSQL behavior”; “postgres: report errors with SQLSTATE codes and structured constraint fields”; and 256 more.
postgres/frontend · medium confidence · unverified
262 commits (13 fixes) modifying core/translate/expr
A change to existing behaviour in core/translate/expr — 262 commits (13 fixs), 17 files: “core: check COLLATE operands when expressions are bound”; “core: answer questions about a type chain with ResolvedType methods”; “core/fts: allow highlighting without an index query”; and 256 more.
core/translate/expr · medium confidence · unverified
3 commits (0 fixes) modifying postgres/conformance/pgdump
A change to existing behaviour in postgres/conformance/pgdump — 3 commits, 2 files: “postgres: compare pg\_dump files byte for byte”; “schema: separate declared table names from engine identity”; “postgres: preserve foreign-key names and targets in dumps”.
postgres/conformance/pgdump · medium confidence · unverified
3 commits (0 fixes) modifying postgres/dump-fuzzer
A change to existing behaviour in postgres/dump-fuzzer — 3 commits, 18 files: “postgres: add structural dump differential fuzzer”; “postgres: Pin Postgres version to 18”; “postgres: Translate CREATE ROLE”.
postgres/dump-fuzzer · medium confidence · unverified
3 commits (0 fixes) modifying sqlite/frontend
A change to existing behaviour in sqlite/frontend — 3 commits, 2 files: “sqlite: move SqliteDialect into a new sqlite/frontend crate”; “core: require a session role to open a connection”; “core/dialect: centralize shared SQLite behavior in Dialect defaults”.
sqlite/frontend · medium confidence · unverified
30 commits (1 fix) modifying sqlite/conformance/sqlite-sqltests/pragma
A change to existing behaviour in sqlite/conformance/sqlite-sqltests/pragma — 30 commits (1 fix), 18 files: “skip automatic index for subqueries when pragma is off”; “core: implement rank() window function”; “core: implement percent\_rank() and cume\_dist() window functions”; and 27 more.
sqlite/conformance/sqlite-sqltests/pragma · medium confidence · unverified
31 commits (0 fixes) modifying postgres/server
A change to existing behaviour in postgres/server — 31 commits, 1 file: “postgres: report errors with SQLSTATE codes and structured constraint fields”; “postgres/server: add pgwire server”; “postgres: add relation catalog table”; and 28 more.
postgres/server · medium confidence · unverified
4 commits (0 fixes) modifying sqlite/conformance/sqlite-sqltests/where
A change to existing behaviour in sqlite/conformance/sqlite-sqltests/where — 4 commits, 4 files: “Skip result expressions for constant-false WHERE”; “core/translate: keep date functions and RIGHT JOIN rows correct for per-row WHERE terms”; “testing: move .sqltest corpora to sqlite/conformance”; and 1 more.
sqlite/conformance/sqlite-sqltests/where · medium confidence · unverified
419 commits (22 fixes) modifying sqlite/conformance/sqlite-sqltests
A change to existing behaviour in sqlite/conformance/sqlite-sqltests — 419 commits (22 fixs), 230 files: “core/fkeys: match child keys to parent keys with the parent column's collation”; “core/vdbe: read text values without rendering them again”; “core: apply probe-side filters to hash join null-extended rows”; and 413 more (refs \#8690).
sqlite/conformance/sqlite-sqltests · medium confidence · unverified
5 commits (0 fixes) modifying benches
A change to existing behaviour in benches — 5 commits, 32 files: “benches: free batched outputs after the measurement; keep memory benchmarks at one call”; “benches: measure prepare\_benchmark with one call per CodSpeed measurement”; “benches: batch divan calls through a Bencher type, so helpers batch too”; and 2 more.
benches · medium confidence · unverified
58 commits (3 fixes) modifying core/dialect
A change to existing behaviour in core/dialect — 58 commits (3 fixs), 2 files: “postgres: let frontend scalars take precedence over same-named SQLite builtins”; “postgres: report errors with SQLSTATE codes and structured constraint fields”; “core: register dialect native extensions at open”; and 55 more.
core/dialect · medium confidence · unverified
6 commits (0 fixes) modifying sqlite/conformance/sqlite-sqltests/math
A change to existing behaviour in sqlite/conformance/sqlite-sqltests/math — 6 commits, 3 files: “core/vdbe: read the X argument of log(B, X) like sqlite3\_value\_double”; “core: match SQLite's logFunc bit-for-bit in log, log2, log10”; “sqltest: add JS-backend expectations for the two-argument log tests”; and 3 more.
sqlite/conformance/sqlite-sqltests/math · medium confidence · unverified
6 commits (0 fixes) modifying sqlite/conformance/turso-sqltests/snapshots
A change to existing behaviour in sqlite/conformance/turso-sqltests/snapshots — 6 commits, 2 files: “sqlite/conformance: show that CHECK on integer types emits no CAST”; “sqlite/conformance: show ConvertToType's storage class as INTEGER in the CHECK snapshot”; “core: convert ENCODE results with STRICT rules only”; and 3 more.
sqlite/conformance/turso-sqltests/snapshots · medium confidence · unverified
6 commits (1 fix) modifying core/time
A change to existing behaviour in core/time — 6 commits (1 fix), 2 files: “core/time: return NULL instead of panicking when time\_date overflows”; “Move time extension to core”; “core/time: return an error for a time blob whose seconds overflow”; and 3 more.
core/time · medium confidence · unverified
63 commits (5 fixes) modifying sqlite/conformance/sqlite-sqltests/json
A change to existing behaviour in sqlite/conformance/sqlite-sqltests/json — 63 commits (5 fixs), 17 files: “core/json: compare value type in the JSON cache lookup”; “core/json: decode object keys in json\_each and json\_tree”; “core/json: return JSONB containers from jsonb\_extract”; and 60 more.
sqlite/conformance/sqlite-sqltests/json · medium confidence · unverified
7 commits (0 fixes) modifying sqlite/conformance/sqlite-sqltests/snapshot\_tests/setops
A change to existing behaviour in sqlite/conformance/sqlite-sqltests/snapshot\_tests/setops — 7 commits, 17 files: “tests: refresh group by and order by collation snapshots”; “sqlite/conformance: refresh bytecode snapshots for ColumnRange fusion”; “core: make the collated MIN join test say its collation, update snapshots”; and 4 more.
_sqlite/conformance/sqlite-sqltests/snapshot\tests/setops · medium confidence · unverified
74 commits (1 fix) modifying sqlite/parser
A change to existing behaviour in sqlite/parser — 74 commits (1 fix), 10 files: “parser/fmt: separate combined table options with a comma”; “core: support NULLS FIRST/LAST in table PRIMARY KEY constraints”; “core: keep namespaces in a table instead of in sqlite\_schema”; and 70 more.
sqlite/parser · medium confidence · unverified
Added debugging skill with corruption analysis instructions
The debugging skill now includes specific instructions for handling database corruption, directing users to the corruption debug tools located in the scripts directory and the detailed usage guide in the references folder.
.claude/skills/debugging · high confidence
Added script to inline WASM as base64 data URL
A new Node.js script (inline-wasm-base64.js) has been added to the JavaScript bindings to address build system issues in Vite and Next.js. This script reads a WebAssembly file, converts it to a base64 data URL, and injects it into a JavaScript file by replacing a placeholder, effectively inlining the WASM binary to bypass specific bundler limitations.
bindings/javascript/scripts · high confidence
CLI refactored to use Clap with new commands and improved import behavior
The CLI command parser has been rewritten to use the Clap library, introducing structured argument definitions and subcommands for existing and new features. Users can now use the .clone command (renamed from .copy) to duplicate the database, .parameter to manage SQL statement bindings, .read to execute SQL from files, and .indexes to list table indexes. The .import command now validates that the target table exists before importing data and supports path completion for input files. Additionally, new commands include .headers to toggle column headers, .stats for database statistics, .timer for performance metrics, .dbconfig for database configuration, .manual for help pages, and .echo to repeat commands. The .exit command now accepts an exit code, and aliases like .q for .quit are supported.
cli/commands · high confidence
Codex skills directory now points to Claude skills
The .codex/skills path is now a symbolic link pointing to ../.claude/skills, meaning any skills configured for the Claude environment are automatically available to Codex as well.
.codex · high confidence
Expose synchronous connection and DB-API 2.0 attributes in the sync module
The \bindings/python/turso/sync\ package now explicitly exports the \ConnectionSync\ class and the \connect\_sync\ function (aliased as \connect\), along with partial sync configuration options (\PartialSyncOpts\, \PartialSyncPrefixBootstrap\, \PartialSyncQueryBootstrap\) and encryption cipher types. Additionally, the module exposes required DB-API 2.0 module-level attributes such as \apilevel\, \paramstyle\, \threadsafety\, and SQLite version information, enabling compatibility with libraries like SQLAlchemy that rely on these standard interface markers.
bindings/python/turso/sync · high confidence
Fixes hash-join correctness and ensures sqlite\_stat1 creation during ANALYZE
This change addresses two distinct areas. First, it fixes a correctness bug in the hash-join engine where spilled hash joins would produce incorrect or inconsistent results across multiple probe passes; the VDBE bytecode now includes a \HashProbeInit\ step to reset the join state before each pass, and new snapshot tests confirm that queries with multiple identical outer rows now return consistent counts. Second, it ensures that the \ANALYZE\ command creates the \sqlite\_stat1\ table even when no user tables are present (e.g., in a database with only views or an empty schema), as verified by new snapshot tests for \ANALYZE\ on main, temp, and view-only databases. Also in this area: Added snapshot tests for ANALYZE statement behavior.
_sqlite/conformance/sqlite-sqltests/snapshot\tests/analyze · high confidence
Full-text search now supports concurrent writes via MVCC segment registry
The FTS index method has been rewritten to use a new on-disk format (v2) backed by a segment registry stored in the core B-tree. This change replaces the previous file-based storage model with an append-only, MVCC-compatible design where segment builds and merges operate on immutable segments and coordinate via a registry of versioned rows. Users benefit from safe concurrent writes to the same FTS index from multiple transactions without locking conflicts, as deletes and merges commute and do not interfere with each other. The implementation also introduces document identities for reliable tombstone handling across merges, explicit merge phases for better I/O pause management, and stricter validation for field weights and query inputs.
_core/index\method/fts · high confidence
Introduce arbitrary-precision numeric type and overhaul numeric handling
The core numeric system now supports a new \numeric(precision, scale)\ type that stores values as arbitrary-precision blobs using the \BigDecimal\ library, allowing for exact decimal arithmetic beyond standard floating-point limits. This change introduces a new \Numeric\ enum variant within the \Value\ type to hold these high-precision numbers alongside integers and floats, and implements custom serialization/deserialization logic to ensure data integrity and prevent crashes from malformed inputs. Additionally, the system now uses a \NonNan\ wrapper for float operations to prevent NaN-related panics and ensures consistent comparison behavior compatible with SQLite, while also fixing rounding behavior in the \round()\ function to break ties away from zero.
core/numeric · high confidence
Introduce concurrency locking and path simplification in React Native bindings
The React Native bindings now serialize database operations using a new AsyncLock mechanism to prevent concurrent access to the native SQLite connection, ensuring thread safety during query execution. Additionally, the public API surface has been simplified to expose only the \paths.database\ property for automatic path resolution, and the \connect\ function now supports passing the remote URL as a function for dynamic authentication scenarios.
bindings/react-native/src · high confidence
New SQL generation model for query types and predicates
The \sql\_generation/model/query\ module has been refactored to introduce a comprehensive, structured model for generating SQL statements. This change adds dedicated data structures and serialization support for \CREATE\, \ALTER TABLE\ (including column and table renaming, adding/dropping columns), \DROP TABLE\, \CREATE INDEX\, and \DROP INDEX\ operations. It also expands \INSERT\ handling to support \ON CONFLICT\ (upsert) logic and \INSERT ... SELECT\ patterns, while introducing a new \Predicate\ model that wraps the parser's AST to enable evaluation against table rows. Additionally, the module now supports generating \PRAGMA\ statements (such as \wal\_checkpoint\ and \foreign\_key\_list\) and defines explicit models for transaction control (\BEGIN\, \COMMIT\, \ROLLBACK\).
_sql\generation/model/query · high confidence
New modular query optimizer with configurable cost model
The query optimizer has been restructured into a dedicated module (\core/translate/optimizer\) with separate files for access methods, constraints, cost estimation, join ordering, and common subexpression lifting. This introduces a new cost-based planning system that supports hash joins, multi-index scans, and expression-based index seeks. The cost model is now configurable via a JSON file loaded from the \TURSO\_OPTIMIZER\_PARAMS\ environment variable, allowing tuning of selectivity fallbacks, cache reuse factors, and CPU/IO weights for specific workloads.
core/translate/optimizer · high confidence
Predicate generation now supports IS comparisons and handles NULL values correctly
The SQL predicate generator in \sql\_generation/generation/predicate\ has been refactored to support \IS\ comparisons (treating NULLs as equal, similar to \=\) and to correctly generate \GTValue\ and \LTValue\ expressions that accommodate NULL values. This change ensures that generated predicates are valid and deterministic even when table rows contain NULL data, improving the reliability of the deterministic simulator's fuzzing and query generation capabilities.
_sql\generation/generation/predicate · high confidence
Refactored SQL value generation for comparison and pattern matching
The value generation logic in the SQL simulator has been reorganized into dedicated modules (cmp.rs, pattern.rs) to support more robust random data creation. This change introduces specific generators for less-than (LTValue) and greater-than (GTValue) comparisons, ensuring correct handling of edge cases such as integer overflow, float ranges, and NULL values (where NULL is treated as less than any other value). It also adds a LikeValue generator for creating pattern-matching strings with wildcards. These updates improve the accuracy and coverage of simulated SQL queries by aligning value generation with SQL semantics for comparisons and text patterns.
_sql\generation/generation/value · high confidence
Remove \`log\` crate and switch to \`tracing\` for logging
The core module has replaced the \log\ crate with the \tracing\ framework for all internal logging. This change standardizes the logging infrastructure, allowing for more structured and performant log output across the database engine.
core · high confidence
Renamed Turso Sync SDK Kit framework in React Native templates
The Turso Sync SDK Kit framework included in the React Native templates has been renamed from \turso\_sync\_sdk\_kit\ to \turso-sync-sdk-kit\. This change updates the bundle identifiers, executable names, and framework paths within the XCFramework metadata to use hyphens instead of underscores, ensuring consistency with the new naming convention for iOS builds.
bindings/react-native/templates · high confidence
Updated Gradle wrapper to version 9.0.0
The React Native example app now uses Gradle 9.0.0 for building the Android project. This change updates the distribution URL in the gradle-wrapper.properties file, ensuring that the build process relies on the latest Gradle release for dependency resolution and task execution.
examples/react-native/android/gradle · high confidence
Updated subquery and CTE execution plan snapshots
The conformance test snapshots for correlated subqueries, CTEs, and materialized orders have been refreshed to reflect new optimizer and bytecode-generation behaviors. Correlated subqueries now utilize ephemeral subquery indexes for efficient probing, and CTEs with explicit materialization correctly preserve or discard sort orders depending on whether the outer query's sort direction matches, reuses, or conflicts with the CTE's ordering. These snapshot updates document the resulting query plans and bytecode for these specific subquery and CTE patterns. Also in this area: ORDER BY support in aggregate functions and stricter constraint validation.
_sqlite/conformance/sqlite-sqltests/snapshot\tests/subqueries · high confidence
VDBE performance optimizations and bug fixes
The VDBE (Virtual Database Engine) core has been optimized for performance and stability. Key changes include inlining the dispatch loop and comparison opcodes to reduce overhead, reusing registers and cursor states to minimize allocations, and fixing several correctness bugs related to affinity handling, MVCC transaction states, and error propagation. These updates improve query execution speed and reliability.
core/vdbe · high confidence
iOS module now supports invalidation and app group storage paths
The React Native iOS binding for Turso has been updated to implement the RCTInvalidating protocol, allowing the module to properly clean up resources when the bridge is destroyed. Additionally, the module now exports iOS-specific document and library paths, and respects the Turso\_AppGroup Info.plist key to store database files in shared app group containers, enabling data sharing between the app and its extensions.
bindings/react-native/ios · high confidence
Fixes
Windows build fix for extensions by gating advapi32 linkage
The build scripts for all extensions (completion, core, crypto, csv, fuzzy, ipaddr, regexp) now conditionally link the Windows \advapi32\ library only when the target OS is Windows, rather than linking it unconditionally. This ensures that extensions build correctly on non-Windows platforms where \advapi32\ is not available, fixing previous build failures or unnecessary dependencies on those systems.
extensions · high confidence
Test coverage
1 commit adding/updating tests in bindings/rust/tests/fixtures; 117 commits adding/updating tests in postgres/tests/integration/postgres; 13 commits adding/updating tests in bindings/c/tests/compat; 19 commits adding/updating tests in postgres/frontend/tests; 22 commits adding/updating tests in testing/sqltest; 6 commits adding/updating tests in postgres/server/tests; Add Antithesis testing suite for multiprocess WAL and stress-composer workloads; Add CodSpeed memory benchmarks for FTS queries and workload profiles; Added .NET benchmark suite for Turso and SQLite providers; Added .NET test suite for Turso bindings; Added C API test suite and randomized differential oracle; Added CLI test coverage for sync isolation, exit codes, parameter bindings, and VDBE tracing; Added Go-based stress testing tool; Added SQLite conformance test suites for SQL functions and clauses; Added SQLite test extension for KV store compatibility verification; Added benchmark to compare Turso and SQLite query batch performance; Added comprehensive test suite for Turso Java JDBC bindings; Added conformance test suites for SELECT operations; Added conformance tests for join edge cases and identifier handling; Added integration and regression tests for Rust bindings; Added integration test infrastructure for PostgreSQL frontend; Added integration tests for SQLite dbhash compatibility; Added integration tests for the JavaScript serverless driver; Added integration tests for the tursopg CLI; Added memory profiling tests for FTS queries and concurrent transactions; Added micro-benchmarks for Turso and better-sqlite3 performance comparison; Added sample applications to validate NuGet package and NativeAOT integration; Added serverless driver test suite for encryption headers and API parity; Added snapshot tests for ANALYZE statement behavior; Added snapshot tests for SQL aggregation query plans; Added test coverage for the PostgreSQL parser; Added test extension for validating virtual table and VFS behaviors; Aggregate function conformance tests added; Comprehensive conformance test suite for SQLite window functions; Comprehensive test suite for Python bindings; Conformance test suite for GROUP BY behavior; Conformance tests for ATTACH database operations; Conformance tests for OFFSET behavior with joins and type casting; Expanded conformance tests for SQLite integrity\_check and quick\_check pragmas; Import upstream SQLite TCL conformance test suite; New SQL generation test oracle with coverage tracking and capability restrictions; New conformance tests for index usage patterns and query plans; New conformance tests for subquery and CTE behaviors; New fuzz testing infrastructure for CTEs, custom types, expression indexes, and FTS; New fuzz testing targets for schema, expressions, and scalar functions; Rust serverless differential testing harness for encryption and API parity; SQLite conformance test suite for join operations; Snapshot tests for RETURNING clause bytecode generation; Snapshot tests for data modification query plans; Snapshot tests for join query plans and bytecode; TPC-H snapshot tests updated to reflect new optimizer and bytecode behavior; Updated ORDER BY conformance test suite; Updated bytecode snapshots for window function tests.
Dependencies
Initial release of Turso 0.8.0-pre.13 workspace and dependencies
This change introduces the initial commit for the Turso 0.8.0-pre.13 workspace, establishing the foundational dependency graph and project structure. It adds the \Cargo.lock\ file and root \Cargo.toml\, defining workspace members for core database components, CLI, and bindings across Rust, JavaScript, Python, Java, and .NET. The dependency manifest pins key libraries including \rusqlite\ 0.37.0, \mimalloc\ 0.1.47, \clap\ 4.5.47, and \tracing\ 0.1.41, while also adding Python test dependencies (\faker\ 26.0.0) and .NET sample projects for NativeAOT and mobile targets.
(dependencies) · high confidence
JavaScript bindings now use Yarn 4.9.2 for package management
The JavaScript bindings directory has been updated to use Yarn 4.9.2 as the package manager, replacing the previous version. This change includes the addition of a Yarn 4.9.2 release file and updated configuration files (such as .gitignore and .npmignore) to support the new tooling, ensuring consistent dependency resolution and installation for the JavaScript SDK.
bindings/javascript · high confidence
Housekeeping
Initial project scaffolding and configuration
The repository is initialized with essential configuration files including .gitignore, .dockerignore, .gitattributes, and .python-version (3.13). Documentation is established via AGENTS.md (replacing CLAUDE.md as a symlink), CONTRIBUTING.md, CHANGELOG.md, and COMPAT.md. Build and testing infrastructure is set up with a Makefile, Dockerfiles (cli, antithesis), and a .rp.yml file defining SQL test guidance. A .github.json file maps contributor identities.
(repo-wide) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 41 → 39 (-1.8)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 60 → 49 (-11.1)
- Architecture 82 → 83 (+0.7)
- Maturity 74 → 79 (+5.3)
- Readiness 66 → 53 (-12.9)
- Security 12 → 17 (+4.7)
- Event-Driven 80 → 80 (+0.0)
- Event Sourcing 100 → 100 (+0.0)
- Performance 69 → 74 (+5.1)
Resolved (453)
- BTreeTable::to_sql (cognitive 127) (core/schema.rs)
- BTreeTable::to_sql (cyclomatic 68) (core/schema.rs)
- Change coupling: cli.rs ↔ js.rs (testing/sqltest/src/backends/cli.rs)
- Change coupling: display.rs ↔ subquery.rs (core/translate/display.rs)
- ClassTooLong: FtsCursor (core/index_method/fts/mod.rs)
- ClassTooLong: Resolver (core/translate/emitter/mod.rs)
- Connection::attach_database_with_config (cognitive 40) (core/dialect/sqlite/attach.rs)
- Connection::attach_database_with_config (cyclomatic 22) (core/dialect/sqlite/attach.rs)
- Critical vulnerability: [GHSA redacted] (uv.lock)
- Duplicated block (10 lines × 2) (core/incremental/vdbe_maintenance/set_op.rs)
- Duplicated block (10 lines × 2) (core/index_method/toy_vector_sparse_ivf.rs)
- Duplicated block (10 lines × 2) (core/json/jsonb.rs)
- Duplicated block (10 lines × 2) (core/schema.rs)
- Duplicated block (10 lines × 2) (core/schema.rs)
- Duplicated block (10 lines × 2) (core/schema.rs)
- Duplicated block (10 lines × 2) (core/storage/encryption.rs)
- Duplicated block (10 lines × 2) (core/translate/emitter/mod.rs)
- Duplicated block (10 lines × 2) (core/translate/expr/translator.rs)
- Duplicated block (10 lines × 2) (core/translate/index.rs)
- Duplicated block (10 lines × 2) (core/translate/view.rs)
- …and 433 more
New (1060)
- BTreeCursor::try_save_position_for_external_balance (cognitive 16) (core/storage/btree.rs)
- BTreeTable::to_sql_as (cognitive 122) (core/schema.rs)
- BTreeTable::to_sql_as (cyclomatic 66) (core/schema.rs)
- Boundary-crossing change coupling: mcp_server.rs ↔ fmt.rs (cli/mcp_server.rs)
- BuildLocalSchemaViewStateMachine::step (cognitive 24) (core/mvcc/database/checkpoint_state_machine.rs)
- BuildLocalSchemaViewStateMachine::step (cyclomatic 19) (core/mvcc/database/checkpoint_state_machine.rs)
- Change coupling: cli.rs ↔ rust.rs (testing/sqltest/src/backends/cli.rs)
- Change coupling: connection.rs ↔ journal_mode.rs (core/connection.rs)
- Change coupling: delete.rs ↔ update.rs (core/translate/delete.rs)
- Change coupling: mcp_server.rs ↔ mod.rs (cli/mcp_server.rs)
- Change coupling: mcp_server.rs ↔ util.rs (cli/mcp_server.rs)
- ClassCatalog::apply (cognitive 30) (postgres/frontend/classes.rs)
- ClassCatalog::apply (cyclomatic 22) (postgres/frontend/classes.rs)
- ClassTooLong: PageCache (core/storage/page_cache.rs)
- ClassTooLong: PageInner (core/storage/pager.rs)
- ClassTooLong: Pager (core/storage/pager.rs)
- ClassTooLong: ShadowTablesMut (testing/simulator/runner/env.rs)
- CommandTag::of (cyclomatic 62) (postgres/parser/cmdtag.rs)
- Connection::attach_database_with_config (cognitive 40) (core/attach.rs)
- Connection::attach_database_with_config (cyclomatic 22) (core/attach.rs)
- …and 1040 more
Changes since last survey
- 300 commits — 299 feature/other, 1 fixes
By area
- (repo) — 81 commits
- postgres/conformance — 50 commits
- core/translate — 42 commits
- postgres/frontend — 27 commits
- (root) — 9 commits
- postgres/parser — 9 commits
- core/connection.rs — 8 commits
- postgres/COMPAT.md — 8 commits
- core/dialect — 7 commits
- core/vdbe — 7 commits
- .github/workflows — 5 commits
- bindings/javascript — 4 commits
- sqlite/conformance — 4 commits
- testing/concurrent-simulator — 4 commits
- docs/sql-reference — 3 commits
- tests/integration — 3 commits
- bindings/rust — 2 commits
- core/schema.rs — 2 commits
- postgres/MANUAL.md — 2 commits
- postgres/tests — 2 commits
Notable commits
- fix: postgres: fix error SQLSTATE mappings and INSERT DEFAULT VALUES
- change: AGENTS.md: state that unsupported PostgreSQL statements fail with 0A000
- change: Guide the clankers towards our mode of working
- change: Merge 'bindings/c: convert sqlite3_value reads between text, numbers and blobs' from app/turso-github-handyman
- change: Merge 'bindings/dotnet: page codec API and TursoConnection.PageCodec' from Marc-André Moreau
- change: Merge 'bindings/javascript: bind typed arrays and DataViews as their bytes' from app/turso-github-handyman
- change: Merge 'bindings/javascript: make sync close() release the connection' from Mikaël Francoeur
- change: Merge 'bindings/rust: expose the progress handler on Connection' from Karel L. Kubat
- change: Merge 'bindings/rust: load Android system roots and return sync startup errors' from Justin LeFebvre
- change: Merge 'build(deps): bump minimatch and react-native-builder-bob in /bindings/react-native' from app/dependabot
- change: Merge 'ci: add nightly steps for checkpoint_n_rows and overflow_scan_benchmark' from Pekka Enberg
- change: Merge 'ci: build macOS release binaries on macos-15 runners' from Pekka Enberg
- change: Merge 'ci: make CodSpeed results stable and report slower benchmarks weekly' from Jussi Saurio
- change: Merge 'core/dialect: centralize shared SQLite behavior in Dialect defaults' from Suraj
- change: Merge 'core/dialect: import names instead of spelling out their paths' from Pekka Enberg
- change: Merge 'core/dialect: move scalar function dispatch into the dialect' from Glauber Costa
- change: Merge 'core/pragma: keep schema-only constraints from naming a table' from gasmyr
- change: Merge 'core/security: improve API docs' from Pekka Enberg
- change: Merge 'core/storage: Ensure b-tree pages do not have overflow cells before use' from app/turso-github-handyman
- change: Merge 'core/time: return NULL instead of panicking when time_date overflows' from
- …and 280 more
Architecture
- Unchanged — 1 containers · 4 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
tursodatabase/turso was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 50db016d5337c75c3d245f7d5b6f93a0eb2c7c57 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.