• Hannu Krosing

From pl/v8 to pl/ < any > : towards easier extension development

`pg_tle` has made a nice opening to a world where any developer can write and deploy safe extensions without needing to be a superuser. It even has some hooks that trusted-language functions can use for things like enforcing password policies.

`pl/ < any > ` extends this ability to writing database functions , and thereby extensions, in any language. The main avenue for this is allowing writing Language Handlers in JavaScript which opens up way for any language, which has a JavasScript Transpiler to become a PostgreSQL embedded (or "pl/") language.
Some examples i will demonstrate:
- pl/jsonschema, which wraps AJV JSON Schema validation library into a language which lets one turn JSON Schema definition into a runnable schema validation function which is (sometimes a lot) faster than pg_jsonchema - a Rust library wrapped using PGRX.
- pl/wasm - a way to run a compiled WebAssembly function as a standard PostgreSQL function. Compute-intensive code is within 2-3 x of native code speed.
- pl/codelength - a sample handler that turns any source code into a function that returns the length of the original source code.

Other fun things than can be added to pl/v8 are
- possibility to write your own FDWs (like Multicorn does for Python)
- write custom logical decoding plugins
- expose certain hooks and tracepoints so that handlers can be added in JavaScript.
- let users directly construct plan trees, maybe even add new node types and/or monitoring probes.

• Andrey Borodin

Upgrade as an extension

ALTER SYSTEM UPGRADE TO 9.7;

• Paul Jungwirth

Inlining Postgres Functions, Now and Then

When Postgres calls a user-defined function (or a built-in one), it might try to inline it. This offers some opportunities to SQL developers and extension authors. I'll discuss two ways that Postgres does this already, which you can use today, as well as an in-progress patch to allow inlining most Set-Returning Functions. Your function will be able to replace itself with a plan tree, which the planner can then incorporate into the rest of the query. It is almost like being able to write a macro!

• Alvaro Hernandez

Postgres à la carte: dynamic container images with your choice of extensions

When generating container images for Postgres, you also want to pack the desired extensions with it. But due to security (and size) reasons, you should not pack the hundreds of available extensions in the Postgres ecosystem, but only those that you would be using.

Since you can have an arbitrary selection of an arbitrary number of extensions from all the available catalog, having Postgres containers with just the selected extensions would require generating more container images than the number of atoms in the Universe.

Enter the world of dynamic OCI (container) images, a breakthrough technology that enables generating in real-time, on-the-fly, container images. Ever wanted à la carte Postgres container images? Now you can have Postgres and any choice of extensions that you want!

These images can be used for running Postgres on containers, including Kubernetes; or also on any other environment capable of consuming OCI images.

This talk will explore the motivations and technology behind dynamic container images, and how they are applied to solve the problem of adding any subset of extensions to the Postgres container images.

Spoiler alert: talk plagued with demos!

• Yurii Rashkovskii

Extension Upgrades

In this talk, we'll provide an overview of existing extension upgrade mechanics, common pitfalls, and challenges, such as:

* Native code upgrades
* Type changes
* Extension-managed data preservation
* Versioned dependecies
* Co-existence of different versions

We'll touch on ideas that help overcome some of the challenges and make extension upgrades first-class citizens.

• Phil Eaton

Working with MemoryContexts and debugging memory leaks in Postgres

We'll explore practical usecases for creating and switching between MemoryContext's and Linux tools like ebpf that can help us discover memory leaks. The session will be a distillation of real-world scenarios and exploration of tools that have helped find bugs in production extensions.

• Sweta Vooda

Postgres as a Control Plane: Challenges in Offloading Compute via Extensions

As Postgres evolves beyond just storage into a control plane for orchestrating external systems like vector search engines, building effective extensions introduces new engineering trade-offs—around performance, consistency, and integration.

This talk explores how to design Postgres extensions that offload compute while preserving SQL simplicity and transactional guarantees. Drawing from real-world lessons with pgvector-remote, you'll learn practical patterns for buffering, predicate pushdown, connection pooling, and working with Postgres internals like VACUUM.

Perfect for engineers looking to offload compute from Postgres while maintaining SQL simplicity and performance.

Lunch

• Ruohang Feng

The Missing Postgres Extension Repo and Package Manager

Despite the power and flexibility that PostgreSQL extensions offer, most users just want them to work—without wrestling with source code or build pipelines. To address this, I’ve created a unified repo (pigsty.io/ext/list/) that packages more than 200+ extensions, complementing the official PGDG repos. The result is a streamlined catalog of RPM/DEB packages, covering 5 Linux distros and five major PostgreSQL versions on both x86 and ARM, all under one roof.

In this talk, we’ll explore how this repository was built, addressing key challenges such as cross-distro compatibility, multi-architecture support, and version alignment. We’ll also discuss lessons learned and propose future improvements to streamline extension distribution for everyone. If you’ve ever wished PostgreSQL extensions were easier to install and manage, This could be useful and fun topic.

• David Wheeler

How to automatically release your extensions on PGXN

Today there is no one central distribution point for PostgreSQL extensions. The largest the extension source distribution service PGXN. It contains approximately a third of all known publicly-available extensions, but even those are not all up-to-date.

PGXN aims to be the root registry for all extension releases, and plans to publish all releases to allow downstream registries to automate their build processes, as well. As such, it benefits extension developers and the broader PostgreSQL community when it contains up-to-date releases of all known extensions.

In this session, I'll show you the process to set up PGXN distribution for your extensions, and the tooling to automate releases to keep it up-to-date. The main things to understand are Git, JSON, and GitHub workflows. At the end of the session, you'l have all the information you need to quickly and automatically publish your extension on PGXN.

• Cary Huang

Extending PostgreSQL with Java: Overcoming Development Challenges in Bridging Java and C Application

Java and C are two powerful programming languages with distinct design philosophies and memory management models. At first glance, they may seem like opposites—one prioritizing portability, the other offering low-level control and raw performance. However, with the right techniques and mythologies, it is possible to bridge the gap and extend C based PostgreSQL to work together with Java based apps or libraries.

In this talk, we will explore the development story of the open-source SynchDB project—a tool designed to extend PostgreSQL’s logical replication to stream changes from MySQL, SQL Server, and Oracle. SynchDB achieves this by combining a C-based PostgreSQL extension with Java-based Debezium Embedded engine, allowing PostgreSQL to ingest real-time changes from heterogeneous data sources.

Through the SynchDB case study, we’ll dive into the core development challenges and solutions for integrating C and Java applications. This session will cover:

• inter-language (Java and C) communication with JNI library
• how to integrate Debezium Embedded engine to C extension
• technical hurdles such as memory management and performance overhead
• Key architectural decisions in architecting an extension with 2 language components.
• Best practices for error handling, monitoring, and maintaining both the C and Java parts of the extension

Attendees will walk away with a deeper understanding of how to extend PostgreSQL’s native replication capabilities, as well as insights into overcoming the technical hurdles of combining C and Java within one seamless extension.

• Cheng Chen

Rethinking OLAP Architecture: The Journey to pg_mooncake v0.2

In this talk, we’ll explore the shortcomings of pg_mooncake v0.1 and the major architectural changes in v0.2. We’ll also share the lessons learned while working with Postgres replication, background workers, and IPC as an extension.

• Florents Tselai

Spat: Hijacking Shared Memory for a Redis-Like Experience in PostgreSQL

Databases traditionally use shared memory as a transient workspace for query execution, caching, and transaction management, hidden from direct user control. But what if we could repurpose it for user-facing, high-performance data structures and general caching?

In this session, I’ll explore PostgreSQL’s shared memory APIs available to extension developers, including recent features like the DSM Registry. I’ll introduce Spat, a Redis-like in-memory data structure server embedded within PostgreSQL, where data is stored entirely in shared memory.

Spat provides an extended key-value model in which keys are strings, and values can be strings, lists, sets, or hashes. This offers a fast, lightweight alternative for ephemeral storage inside PostgreSQL.

This talk will explore the technical challenges and opportunities of using shared memory beyond its traditional scope, providing ideas for anyone interested in extending PostgreSQL.

• Yurii Rashkovskii

Cppgres: One less reason to hate C++

Writing Postgres extensions in C can feel cumbersome, error-prone, and repetitive. While many developers shy away from C++ due to its complexity and steep learning curve, modern C++ offers powerful features that make developing robust and maintainable Postgres extensions easier than ever before.

Instead of jumping on Rust's bandwagon, consider C++ – it can provide much of the ergonomics and safety with the same compiler you already have.

In this talk, we'll introduce Cppgres: a lightweight, header-only C++20 library designed to streamline, safety-proof, and simplify building Postgres extensions. With it, you can leverage modern C++ techniques like concepts, automatic type deduction, and minimal boilerplate to write clean, readable, and performant extensions.

Let me change your mind about C++ and make Postgres extensions safer and their development genuinely enjoyable.

• Alastair Turner

Extensibility - new options and a wish list

It's a great time to be an extension developer. There's a community growing specifically around extensions, there are even have dedicated events like Postgres Extensions Day.

More and more areas of Postgres are also becoming extensible. Highlights from the past year's commits include options for extending EXPLAIN, cumulative statistics and COPY. There are also a few flat spots where extensibility proposals have got stuck - particularly storage.

Join me for a look at the new areas of extensibility, with some code samples, and a look at where extensibility has stalled and could use a little help.

Dinner

• Mehmet Yilmaz

Scaling PostgreSQL with Citus: Distributed Data for Modern Applications

Explore how the Citus extension transforms PostgreSQL into a distributed, horizontally scalable database. This session will cover Citus’s architecture, its deployment as an extension, and the practical considerations of running it in production.

In this talk, I will dive deep into the inner workings of the Citus extension. The session will include:

An overview of how Citus extends PostgreSQL to support distributed query processing and data sharding.

Discussion on extension packaging, delivery methods, and best practices for deployment in diverse environments.

Insights into operational challenges, performance tuning, and security considerations when managing a distributed Postgres cluster.

Real-world examples and case studies demonstrating successful implementation and the lessons learned along the way.