PyData Amsterdam 2026: three conversations from the NDSM Loods

PyData Amsterdam 2026 ran on September 10 and 11 at the NDSM Loods, a former shipyard hall across the IJ, with a tutorial day at Xebia on September 12. It is one of the largest PyDatas anywhere, and one of the most international. Ritchie Vink, who lives there, calls it a home game. For Structured Output it was the second stop of an Amsterdam week that began the evening before with the Rust, Data and AI meetup at Adyen.

We came with a talk, a session, and a microphone.

On stage

• On September 10, Alexy Khrabrov gave a lightning talk, The QueryGraph Stack: an open-source layer built on Sail, LakeSail's Rust implementation of Spark. pip install pysail, and Python UDFs run from Rust without ever crossing the JVM boundary.
• On September 11, Shehab Amin (LakeSail) and Santosh Pingale (Adyen) presented Modernizing Spark: Performance Boost without Rewrite, the conference-track companion to the Adyen meetup: accelerating Spark workloads via Spark Connect, Arrow, and Rust without rewriting code.

The conversations

All three interviews were recorded on September 11 on the conference floor. You can hear the Loods in the background.

• Matt Topol, Columnar, on ADBC — Interview with Alexy. Matt is a co-founder of Columnar and a PMC member of Apache Arrow, Apache Iceberg, and the new Apache Magpie. ADBC is the Arrow-native replacement for ODBC and JDBC that keeps data columnar end to end. We talk about dbc, Columnar's package manager for signed ADBC driver binaries; the ADBC community extension for DuckDB; Spark Connect and Sail returning Arrow natively; dbt building its adapters on ADBC; why agent protocols need a binary channel rather than JSON; and how Apache Magpie's skills help open-source maintainers use AI responsibly. (episode)
• Ritchie Vink, Polars — Interview with Alexy. Why Polars was written in Rust six years ago, and why Rust's compile-time guarantees now make it a strong language for AI-assisted coding. How database research shaped Polars in contrast to pandas: lazy evaluation, a query optimizer, a consistent relational data model, and strict column types. Polars as a Python-first library that catches type errors before a query runs, a growing focus on SQL for agents, and the goal of being the fastest engine at any scale, including distributed. (episode)
• Christophe Blefari, nao Labs — Interview with Alexy. Recorded after Christophe's keynote on the history of analytics from the warehouse to the lakehouse to today's agentic systems, which included a live demo of talking to data in DuckDB. We talk about what a semantic layer should be: unambiguous, human-readable definitions of metrics and dimensions rather than a pile of SQL queries; a two-layer approach where an agent falls back from the strict semantic layer to broader context; and nao, an open-source analytics agent that lets everyone in a company chat with its data while data people act as context engineers, with bring-your-own model and database. (episode)

The thread

Three different companies, one recurring shape. Polars keeps data columnar and typed inside a single node. ADBC keeps it columnar between systems. nao puts an agent on top and insists the business meaning be written down where the agent can read it. The Rust engines underneath are the same family as the one Adyen put into production the night before.

Where it lives

• Conference: PyData Amsterdam 2026, amsterdam.pydata.org
• The full lightning-talk session and the other PyData recordings belong to the conference; ours are on FunctionalTV.