Cloud Parts

GlareDBDormant

A small, embeddable SQL engine in Rust for querying Parquet and CSV files locally, over HTTP or in S3 and GCS, from a CLI, Python or the browser. It began as a DataFusion-based federated query service and was rewritten in 2025 on its own engine, and it has had no release since June 2025.

What it is
Query engines
Type
Open source
Made by
GlareDB, Inc.
License
MIT since the rewrite (0.10.0, April 2025, onward); the DataFusion-based versions up to 0.9.5 were AGPLv3
Status
Dormant. No release since June 2025 and no commits since November 2025.
Facts checked
11 October 2026
Website Source code

What it is

Today’s GlareDB is a single binary (glaredb), a Python package, Rust crates and a WebAssembly build, all running the same engine in-process with no server. You point SQL at files: SELECT * FROM 's3://bucket/cities.csv' picks the S3 file system from the path prefix, gs:// picks Google Cloud Storage, an http(s) URL picks HTTP, and anything else is a local path. Extensions add readers and functions in their own schemas: parquet, csv, iceberg (functions that read a table’s metadata, snapshots, manifest list and data files) and tpch_gen, which generates TPC-H tables on the fly. Tables you create are temporary and last only for the session. The engine plans each query into partition pipelines that a runtime schedules as data becomes ready: on a laptop they run on many threads with network I/O on Tokio, and in the browser each one becomes a JavaScript Promise on a single thread. Its columnar format is inspired by Arrow, but it doesn’t use the arrow-rs libraries, so it can control buffer allocation and memory use itself. Lateral joins and correlated subqueries work out of the box.

This is a rewrite. Sean Smith founded GlareDB and launched it in May 2023 as a cloud query engine that joined live data from Postgres, MySQL, Snowflake, BigQuery, MongoDB and files in S3 and GCS without ETL, was Postgres-compatible, and ran as a hosted GlareDB Cloud or as a local CLI and Python library that could connect to a Cloud deployment (“hybrid execution”). That version was built on Apache DataFusion and licensed AGPLv3, and the last release was 0.9.5 in August 2024. In April 2025 Smith announced a fully custom engine that replaced DataFusion and dropped the connectors to external databases such as BigQuery and Postgres. The new engine shipped as 0.10.0 on 15 April 2025 under the MIT license, and from May 2025 releases used calendar versions (25.5.0 was the first release of May 2025).

Activity stopped soon after. The latest release is 25.6.3 from 19 June 2025, which published the Rust crates with an API marked unstable; the npm package still points at 0.9.5 from August 2024; the blog’s last post is from April 2025; and the last commit, on 5 November 2025, removed the benchmark schedule. GlareDB Cloud and the pricing page are gone from glaredb.com. The repository isn’t archived and the installers still work, but treat GlareDB as unmaintained until a new release appears.

Why teams pick it

  • Nothing to run: one binary or pip install glaredb, with the same engine compiled to WebAssembly so it can query S3 or HTTP files from a browser tab
  • Built for awkward SQL: lateral joins, correlated subqueries and table functions that take columns from the row to their left
  • Queries Parquet and CSV in place on S3, GCS, HTTP or local disk, finds an S3 bucket’s region by itself, and ships a built-in TPC-H generator for quick benchmarks
  • A permissive MIT license since the rewrite, where the earlier versions were AGPLv3

Watch out for

  • Effectively dormant: no release since 25.6.3 in June 2025 and no commits since November 2025, with no announcement either way
  • The rewrite dropped what GlareDB was first known for: there are no connectors to Postgres, MySQL, Snowflake or BigQuery, no Postgres-protocol server and no hosted service any more
  • Storage is session-only: CREATE TABLE supports temporary tables only, and the documented Iceberg functions read metadata (snapshots, manifests, data files), with the extension described as under heavy development
  • Narrow platform support: binaries for macOS 14+ on Arm64 and Linux on x86_64 or Arm64 only, an unstable Rust API, and single-threaded execution in WebAssembly

Alternatives

What all query engines have in common →
Amazon AthenaAWSAWS’s serverless SQL engine for data in S3: no cluster to run, and on-demand queries cost $5 per TB scanned.Apache Arrow AceroExperimentalOpen sourceThe streaming execution engine inside Arrow’s C++ library: you hand it an exact plan of nodes (scan, filter, project, aggregate, join, sort) and it streams Arrow record batches through them, with no SQL parser or optimizer of its own.Apache CalciteOpen sourceA Java framework with everything a database needs to understand a query (SQL parser, validator, relational algebra and a rule-based, cost-based optimizer) but no storage of its own, which Hive, Flink, Druid, Dremio, Beam and many other systems embed as their SQL front end and planner.Apache DataFusionOpen sourceA query engine library in Rust, built on Arrow, that other projects embed and extend to build their own databases and data tools.+1 Apache DataFusion CometApache HadoopOpen sourceThe project that made big-data clusters normal: a distributed file system (HDFS), a cluster scheduler (YARN) and the MapReduce engine.Apache HiveOpen sourceThe first SQL engine for Hadoop, and the source of the Hive Metastore, the table catalog that Trino, Spark, Impala and Flink still read.Apache ImpalaOpen sourceAn MPP SQL engine in C++ for interactive queries over Hive tables on HDFS, Kudu, Iceberg and object storage; built and mainly sold by Cloudera.Apache PigDormantOpen sourceA step-by-step scripting language, Pig Latin, that compiles to MapReduce, Tez or Spark jobs on Hadoop. Still released, but the project calls itself dormant.Apache SparkOpen sourceThe general-purpose distributed engine for large batch jobs, streaming and machine learning, in Python, SQL, Scala, Java or R.Apache ZeppelinOpen sourceA self-hosted web notebook where each paragraph runs through an interpreter: Spark, Flink, JDBC, Python and more. Maintained, but behind Jupyter and Databricks in reach.chDBOpen sourceThe ClickHouse engine packaged as a library: run ClickHouse SQL inside a Python, Go, Rust or Node.js program, with no server.Cloudflare Basin SQLRenamedCommercialCloudflare’s serverless, distributed SQL engine for Apache Iceberg tables in Basin Catalog on R2, called R2 SQL until it became generally available on 1 October 2026, billed by the data it scans.DuckDBOpen sourceAn in-process analytical SQL database: a library with no server that queries Parquet, CSV, Iceberg and S3 directly.GizmoSQLOpen sourceA database server that wraps DuckDB (or SQLite) and serves it to many clients over Arrow Flight SQL, with TLS and authentication.HotdataCommercialA managed SQL engine for AI agents, built in Rust on Apache DataFusion and Arrow: each agent gets short-lived “instant databases” to load data into, then runs read-only SQL, vector, full-text and geospatial queries over an HTTP API or CLI.IbisOpen sourceA Python dataframe API that compiles to SQL, so the same code runs on DuckDB on a laptop and on BigQuery, Snowflake, PostgreSQL or more than 20 other engines.PolarsOpen sourceA DataFrame library with a Rust query engine underneath: you write Python (or Rust, SQL, Node.js, R) and it plans, optimises and runs the query on every core, streaming data bigger than memory.Presto (PrestoDB)Open sourceFacebook’s distributed SQL engine, now governed by the Linux Foundation, moving its workers from Java to C++ on Velox. Trino is its 2019 fork.RayforceOpen sourceA small embeddable engine in pure C that runs columnar analytics, graph traversals and recursive Datalog queries in one optimised plan.Spice.ai OSSOpen sourceA single-binary SQL engine in Rust, built on DataFusion and Arrow, that federates queries across databases, warehouses and lakes, keeps hot datasets in a local accelerated copy, and adds search and LLM APIs on top.TrinoOpen sourceA distributed SQL engine that queries data where it lives, from Iceberg tables on S3 to a live PostgreSQL database, in one query.VeloxOpen sourceMeta’s open-source C++ execution engine library: it takes an already-optimized query plan and runs it with vectorized operators, and it is the engine inside Presto’s C++ workers (Prestissimo) and Apache Gluten’s native Spark.

How it fits with other technologies

A lateral join, generated TPC-H data and a Parquet file over HTTPS (run with the GlareDB 25.6.3 CLI: glaredb -f demo.sql) · sql

-- Temporary tables only; generate_series reads columns from the row on its left
CREATE TEMP TABLE ranges (range_start INT, range_end INT);
INSERT INTO ranges VALUES (1, 4), (5, 7);
SELECT range_start, count(*) AS n
FROM ranges, generate_series(range_start, range_end)
GROUP BY range_start ORDER BY range_start;
-- 1 | 4
-- 5 | 3

-- TPC-H data generated on the fly by the tpch_gen extension
SELECT n_name, count(*) AS suppliers
FROM tpch_gen.supplier(1) s JOIN tpch_gen.nation(1) n ON s.s_nationkey = n.n_nationkey
GROUP BY n_name ORDER BY suppliers DESC LIMIT 3;
-- IRAQ | 438
-- PERU | 421
-- ALGERIA | 420

-- A Parquet file over HTTPS, queried in place, and its footer metadata
SELECT count(*) AS rows, max(timestamp_col) AS latest
FROM 'https://raw.githubusercontent.com/apache/parquet-testing/master/data/alltypes_plain.parquet';
-- 8 | 2009-04-01 00:01:00 UTC
SELECT num_rows, num_row_groups
FROM parquet.file_metadata('https://raw.githubusercontent.com/apache/parquet-testing/master/data/alltypes_plain.parquet');
-- 8 | 1

See it in a real stack

No architecture uses GlareDB yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2022–2025

GlareDB’s repository dates from May 2022. In May 2023 its founder, Sean Smith, introduced it as a cloud query engine that “hooks directly into your data sources” so analysts could join a BigQuery table with a Postgres table in one statement instead of building ETL pipelines into a warehouse. It was Postgres-compatible so existing BI tools could connect, and it supported Postgres, MySQL, Snowflake, BigQuery, MongoDB and files on S3 and GCS at launch. Releases through 0.9 in February 2024 added SQLite, Cassandra, Excel and Lance, file uploads to GlareDB Cloud, and “hybrid execution”, which let the local CLI or Python library work with a Cloud deployment. Under the hood it used Apache DataFusion.

In April 2025 Smith wrote that GlareDB was getting “a whole new engine”, with “a complete shift away from DataFusion in favor of a fully custom execution engine”. The goals were SQL ergonomics (lateral and correlated subqueries), reliability under memory pressure, which meant leaving arrow-rs behind to control buffers directly, and compiling to WebAssembly as a first-class target. Querying external systems such as BigQuery and Postgres was removed because, in Smith’s words, the team “weren’t seeing enough value to justify the maintenance cost”, while CSV, Parquet, JSON, Iceberg and Delta Lake were to get deeper support.

The new engine shipped as 0.10.0 on 15 April 2025, under the MIT license instead of the AGPL. Eighteen calendar-versioned releases followed between 3 May and 19 June 2025, ending with 25.6.3. After a few dependency bumps that summer the commits stopped in November 2025.

Why it’s built this way

Federation first: query sources where they live
Copying data into a warehouse meant ETL pipelines, extra copies and stale results, so the first GlareDB pulled data from each source at query time and joined it in one engine.
Replace DataFusion with a custom engine
The team wanted control over how buffers are allocated and reused, how much memory each operator uses and where it can fail, so a heavy query fails gracefully instead of crashing. That was also a big reason for leaving arrow-rs.
WebAssembly as a first-class target
A self-contained engine in the browser can query S3 or HTTP files with nothing installed. That ruled out threads and blocking code, so pipelines are scheduled by readiness and dependencies were chosen to compile to WebAssembly.
Calendar versioning
With the rewrite, versions switched from 0.x to <year>.<month>.<release>, so 25.5.0 is the first release of May 2025.

Timeline

  1. 2022

    GlareDB repository created in May

  2. 2023

    Public launch in May as a federated, Postgres-compatible cloud query engine

  3. 2024

    0.9.0 in February adds SQLite, Cassandra and Excel sources and Cloud file uploads

  4. 2024

    0.9.5 in August, the last DataFusion-based, AGPLv3 release

  5. 2025

    April: a fully custom engine replaces DataFusion in 0.10.0, now MIT-licensed, and external database connectors are removed

  6. 2025

    Calendar versions from 25.5.0 in May; 25.6.3 on 19 June is the latest release

  7. 2025

    Last commit to the repository in November

Sources18 · facts checked 11 October 2026

Improve this page on GitHub