---
title: "DuckDB Ecosystem Newsletter : September 2026"
canonical: "https://motherduck.com/blog/duckdb-ecosystem-newsletter-september-2026/"
---

# DuckDB Ecosystem Newsletter : September 2026

## HEY, FRIEND 👋

I hope you're doing well. I'm [Simon](https://www.ssp.sh/), and I am happy to share another monthly newsletter with highlights and the latest updates about DuckDB, delivered straight to your inbox.

In this September issue, I gathered the usual 10 updates, with the big two being the acquisitions (DuckLabs joins AWS, MotherDuck acquires Tower) and the upcoming 2.0 release, plus gains across the ecosystem, including table functions in pure Java, bulk loads into SQL Server, and Zarr for n-dimensional arrays, and the usual fun side project, such as an infinite canvas for your data.

<table class="newsheading" style="margin-bottom: 5px;">
  <tr>
    <td class="mobileoff"><span><img src="https://22616816.fs1.hubspotusercontent-na1.net/hubfs/22616816/featured_member_graphic.png" width="64" height="64" /></span></td>
    <td><h2>Featured Community Member</h2></td>
  </tr>
</table>

<div class="row">
  <div class="columnPic"><img src="https://motherduck-com-web-prod.s3.us-east-1.amazonaws.com/assets/img/articles/ecosystem-newsletter-september-2026/vladimir_gribanov_e42b3a1430.jpg" alt="Vladimir Gribanov"></img></div>
  <div class="columnText columnTextRight">
    <h3>Vladimir Gribanov</h3>
    <p>Vladimir is a software architect and the maintainer of <a href="https://hugr-lab.github.io">Hugr</a>, an open-source data mesh platform and GraphQL backend built on DuckDB. He is also the creator of the <a href="https://github.com/hugr-lab/mssql-extension">DuckDB MSSQL extension</a>, a community extension that talks native TDS to SQL Server without ODBC or JDBC drivers, with filter pushdown, transactions, and bulk loading.</p>
    <p>Alongside the code, he documents the journey in detail on <a href="https://medium.com/@gribanov.vladimir">Medium</a>, from Azure Entra ID authentication to this month's deep dive on optimizing bulk loads into SQL Server (see below). Thanks, Vladimir, for making SQL Server a first-class citizen in the DuckDB world!</p>
    <p>Connect with Vladimir on <a href="https://www.linkedin.com/in/vladimirgribanov/">LinkedIn</a>.</p>
  </div>
</div>

<table class="newsheading" style="margin-bottom: 5px;">
  <tr>
    <td class="mobileoff"><span><img src="https://22616816.fs1.hubspotusercontent-na1.net/hubfs/22616816/top_links_graphic.png" width="64" height="64" /></span></td>
    <td><h2>Top DuckDB Links this Month</h2></td>
  </tr>
</table>

### Acquisitions: [DuckLabs to Join AWS](https://ducklabs.com/news/2026/08/26/ducklabs-to-join-aws); [MotherDuck Acquires Tower](https://motherduck.com/blog/motherduck-acquires-tower/)

**TL;DR**: The two biggest ones first: AWS acquires DuckLabs, and MotherDuck acquires Tower.

**MotherDuck [acquired Tower.dev](https://motherduck.com/blog/motherduck-acquires-tower/)** to integrate its runtime infrastructure into MotherDuck Flights, enabling AI agents to perform data engineering tasks and expose data as APIs. [**DuckLabs**](https://ducklabs.com/news/2026/08/26/ducklabs-to-join-aws)**, the company behind DuckDB, joins Amazon Web Services (AWS)**, with its core open-source projects (DuckDB, DuckLake, Quack) remaining under the MIT license and stewarded by the DuckDB Foundation.

The [HN consensus](https://news.ycombinator.com/item?id=49448321) is a mix of concern and cautious optimism, given the independent foundation and MIT-licensed code. Read [Jordan's comment](https://motherduck.com/blog/duckdb-amazon/) on how MotherDuck thinks about it.

### [Try DuckDB v2.0-alpha](https://duckdb.org/2026/09/02/try-duckdb-20-alpha), and Upcoming Features

**TL;DR**: DuckDB v2.0-alpha (code-named Cyanoptera) is available, featuring a feature freeze, bug fixing, and preparation for an October release.

Key updates include the **quack extension moving to v1.0**, promising higher throughput for both server-to-client and client-to-server communication. The CLI and Python library have alpha releases available.

As a recap, the [Preview of DuckDB v2.0](https://duckdb.org/2026/08/17/duckdb-20-highlights) introduces a client/server mode via Quack and `CONNECT`, a new PEG-based SQL parser, a revised C API for extensions, and a new default storage format. Check out Mehdi's take on [Why DuckDB 2.0 is faster](https://motherduck.com/blog/why-duckdb-20-is-faster/) (or [video](https://www.youtube.com/watch?v=9s4n_j-Uv1k)): async I/O for S3, a rewritten recursive CTE engine, and a more efficient VARIANT data type.

### [sql.garden: An infinite canvas for your data](https://github.com/immannino/sql.garden)

**TL;DR**: sql.garden is an open-source, Wails-based infinite canvas for data exploration that leverages an in-process DuckDB instance and the Model Context Protocol (MCP) for autonomous AI interaction.

Tony built it with a Go backend and Vue 3 frontend, querying Parquet, CSV, and JSON files at native speed alongside Postgres and MySQL connections. It imports data directly via `s3://` URIs, offers a WebAssembly build for browser-based sandboxing, and ships an embedded MCP server. Try the [demo in the browser](https://sql.garden/sandbox/).

### [DuckDB Table Functions in Java](https://duckdb.org/2026/08/25/table-functions-in-java)

**TL;DR**: The DuckDB Java client now supports registering table functions in pure Java, allowing developers to query any JVM-accessible data source directly via SQL without native C++ extensions.

Geertjan and Alex show heterogeneous joins between remote systems like MongoDB and local files using the `DuckDBFunctions.tableFunction()` builder. The implementation follows a vectorized lifecycle: `bind` defines the output schema, `init` establishes the connection state, and `apply` streams data into a `DuckDBDataChunkWriter` in 2048-row batches. Source-side **predicate pushdown** works by passing **native filters**, such as `FROM mongo_query('coll', '{ "status": "shipped" }', ...)`, directly to vendor SDKs. Because functions run in-process, they eliminate intermediate export steps, giving engineers a high-performance path to integrate proprietary data sources or SOAP/REST services.

### [I put DuckDB behind the file viewer in my IDE: a 1B row, 29 GB Parquet opens in about a second](https://sh.reddit.com/r/DuckDB/comments/1wbh7mn/i_put_duckdb_behind_the_file_viewer_in_my_ide_a/)

**TL;DR**: A new JetBrains IDE plugin leverages DuckDB's engine to provide near-instant visualization of billion-row Parquet, Avro, and ORC files with full schema support.

Less-Entertainer on Reddit built the **Parquet, Avro & ORC Viewer** because existing viewers render nested types or string columns as raw byte arrays. A 29 GB Parquet file with 1B rows opens in about 1039ms, and paging to the end takes roughly 800ms. Version 0.1.1 added cell editing, but an edit rewrites the whole file, 17 minutes on that 29 GB one. A not-yet-shipped branch has DuckDB rebuild only the affected row group and splice it back in, bringing that down to 1.8 seconds. JetBrains user? Check out the [plugin](https://plugins.jetbrains.com/plugin/33899-parquet-avro--orc-viewer).

### [Optimizing Bulk Loads into SQL Server with DuckDB](https://medium.com/@gribanov.vladimir/the-plp-tax-and-seven-other-levers-optimizing-bulk-loads-into-sql-server-with-duckdb-da549a338f3e)

**TL;DR**: The DuckDB MSSQL extension v0.2.3 optimizes bulk loading into SQL Server through parallel writers and schema-aware target shaping, reducing ingestion times for 38M rows from 933s to 96s.

Vladimir's (our featured member this month) primary bottleneck is the "PLP tax": unsized strings default to `NVARCHAR(MAX)`, forcing data through a slower LOB path. Explicitly casting to `MSSQL_NVARCHAR(200)` gives a 2.45× speedup. `SET mssql_copy_parallel_writers = 8` scales ingest across sessions, and the `mssql_copy_flush_rows` default of 102,400 lets rows bypass the delta store for direct compressed rowgroup entry. Raising `mssql_tds_packet_size` to 16,384 reduces client CPU usage by 27%.

### [The small-file problem gets worse with CDC](https://streambed.dev/blog/ducklake-target-support/)

**TL;DR**: Vignesh describes Streambed's shift from Apache Iceberg to DuckLake to solve the small-file problem in Postgres-to-DuckDB CDC pipelines.

Frequent small commits from the Postgres WAL create metadata overhead and high object counts in Iceberg. DuckLake stores catalog metadata in a database like DuckDB or SQLite rather than in object-store files, which slims down the `Postgres WAL → Streambed → DuckDB` write path. [Benchmarks](https://github.com/viggy28/streambed/blob/main/docs/benchmarks/ducklake-vs-iceberg.md) for 1M rows with 100k updates at `flush=1,000` showed DuckLake with DuckDB finishing in 6,576 ms (405 objects) versus Iceberg COW's 269,344 ms (806 objects). Less commit work per batch means fresher analytical replicas.

### [duckdb-zarr: Query Zarr stores with SQL directly from DuckDB](https://github.com/xqlsystems/duckdb-zarr)

**TL;DR**: duckdb-zarr is a Rust-based extension enabling DuckDB to query Zarr stores (an open format for chunked, compressed, N-dimensional arrays) directly using SQL, supporting both local files and remote object storage like S3 and GCS.

Alex and Dave implemented `read_zarr()`, `read_zarr_metadata()`, and `read_zarr_groups()`. Users can select specific arrays with `array_path='0'` or define dimensions with `dims=['time','lat','lon']`, and S3/GCS credentials come from DuckDB's secrets manager. Multi-dimensional scientific datasets become relational tables without an external query engine, which simplifies spatial and climate data analysis.

### [DuckDB for Apache Iceberg](https://lakeops.dev/blog/duckdb-iceberg-lakehouse-guide)

**TL;DR**: Rob explains how DuckDB v1.5.3 enables full read/write lifecycle management for Apache Iceberg tables through REST catalogs and native V3 support without requiring a distributed cluster.

The release unlocks `MERGE INTO`, `ALTER TABLE`, and Iceberg V3 features like `VARIANT` types and `TIMESTAMP_NS` precision. Integration goes through `ATTACH 'uri' AS my_lake (TYPE ICEBERG)`, supporting REST, Glue, and S3 Tables. Performance relies on vectorized execution and metadata-driven pruning, but merge-on-read introduces "delete-file debt" and small-file I/O bottlenecks that degrade latency. DuckDB starts in milliseconds, yet query speed is dictated by table layout, so compaction and table maintenance still have to run outside DuckDB.

### [SQLite vs DuckDB on the same $16 box: every cliff moved 100x](https://tracewayapp.com/blog/sqlite-vs-duckdb)

**TL;DR**: Jovan benchmarked DuckDB against SQLite for observability data, finding that DuckDB moves "read cliffs" 100x further while increasing write throughput on identical $16 hardware.

As Traceway's embedded storage engine, DuckDB reached 254,242 metrics/sec (4x) and 75,225 logs/sec (15x). DuckDB's columnar engine served metrics dashboards at 100M rows with a 3.0s median latency, while spans and logs hit their "cliff" at 10M rows. The benchmark ran with a 4 GB `DUCKDB_MEMORY_LIMIT`, while the compose file ships 2 GB. The takeaway: for single-node self-hosting, DuckDB is the better choice for high-volume logs and metrics.

<table class="newsheading" style="margin-bottom: 5px;">
  <tr>
    <td class="mobileoff"><span><img src="https://22616816.fs1.hubspotusercontent-na1.net/hubfs/22616816/upcoming_events_graphic.png" width="64" height="64" /></span></td>
    <td><h2>Upcoming Events</h2></td>
  </tr>
</table>

### [Big Data London](https://www.bigdataldn.com/)

**2026-09-23. h: 09:00. Olympia, London, UK**

<p>The UK's largest data, analytics, and AI conference at Olympia London: two days, 400+ sessions, and exhibitors from Snowflake and Databricks to early-stage startups. Come find MotherDuck at booth P60.</p>

### [Duck In, Duck Out: London Edition](https://luma.com/mother-bdl)

**2026-09-23. h: 19:00. London, UK**

<p>MotherDuck is back for another good time on Night 1 of Big Data London, with beers, bites, and beats from DJ Joe Reis.</p>

### [Virtual Workshop: Build a Data Agent in 60 Minutes](https://luma.com/mother-x5x8)

**2026-10-01. h: 09:00 PT. Online**

<p>LLMs writing SQL is old news. The real challenge is the infrastructure around them. Jacob Matson builds a working data agent from scratch in 60 minutes: MCP tools, a 30-line agent loop, a solid system prompt, read-only guardrails, and telemetry.</p>

### [Ship, Scale, Sail - #SFTechWeek](https://partiful.com/e/ZVpoCf7Cu8AZyRSGekcv?c=xzOjlvTr)

**2026-10-05. h: 18:15. San Francisco Bay, CA**

<p>MotherDuck, Modal, and Braintrust host a small crew of AI and data builders for an evening cruise. Dinner, drinks, and a relaxed evening on the Bay.</p>

### [Data Outpost 2026](https://www.dataoutpost.ai/)

**2026-11-05. h: 08:30. Convene 100 Stockton, San Francisco, CA**

<p>Editorial AI + data conference for builders at the forefront of AI + data. Two days on memory, agents, trust, interfaces, and data that can act. Small-format, high-context.</p>