Discover how PEP 810's explicit lazy imports can dramatically improve Python application startup times. Using a real CLI tool as a case study, that we totally use in our real business, this talk demonstrates practical techniques to optimize import performance while maintaining code clarity and safety.

Python’s Global Interpreter Lock has shaped the way developers build concurrent applications for nearly three decades. While the GIL simplified the CPython ecosystem, it also imposed well-known limits on CPU-bound work and multithreaded scalability. With the introduction of free-threaded Python (3.14t), that is about to change.

This talk explores the history and purpose of the GIL, why it existed for so long, and the innovations that finally made its removal viable. We’ll look at how free-threading affects real workloads through concrete benchmarks. We'll investigate the often overlooked effect of freethreading on webservers. You’ll see how modern servers like Granian, ASGI frameworks, and WSGI stacks behave when threads are no longer serialized by the interpreter.

By the end, you’ll understand not only what the GIL is, but what its disappearance means for scaling Python applications in production. Whether you're building high-throughput APIs, tuning async code, or planning future architecture, free-threaded Python opens the door to new performance ceilings - along with new tradeoffs every developer should know.

Apache Airflow is the most popular Data Workflow Orchestrator - developed under the Apache Software Foundation umbrella. We have 120+ Python distributions in our rep, and we often release ~ 100 of them every two week.

All those distributions are built from a single monorepo.

[jarekpotiuk:~/code/airflow] find . -name 'pyproject.toml' | wc 120 120 4248

This had always posed a lot of challenges and we had a lot of tooling to make it possible, however with the recent development of Python Packaging tools, multipel Packaging PEPs implemented, and with new wave of tools such as uv and prek, our setup is finally manageable and we removed 1000s of line of custom code we wrote before after we applied uv workspaces, switched to prek, started using inline script metadata.

It's a breeze to have monorepo now. This talk explains how.

Bonus content. If you know the differences between dynamically and statically linked libraries in C and other languages, or used NPM - you might recognise the need of being able to use different versions of the same library in the same system. It's not possible in Python. Or is it?

We've figured out a way to eat cake and have it too - and we have "statically linked" libraries in Python. How did we do it?

You will find out how from the talk.

Remember when we said "Infrastructure as Code"? Somehow, the industry heard "Infrastructure as YAML" and ran with it. Now we're drowning in a sea of indentation-sensitive, template-riddled, Jinja2-abused configuration files that make even the most battle-hardened sysadmins weep into their mechanical keyboards.

Enter PyInfra—where your infrastructure is actually code. Real Python. With loops that don’t require learning a DSL. With functions that are... wait for it... actual functions. With error handling that doesn’t involve praying to the YAML gods and sacrificing a virgin bracket.

In this talk, you’ll see how to: - Write infrastructure automation that your IDE actually understands - Debug with real stack traces instead of "ERROR: The task includes an option with an undefined variable" - Use actual Python conditionals instead of when: ansible_os_family == "Debian" and not (ansible_distribution == "Ubuntu" and ansible_distribution_version is version('20.04', '>=')) - Import and reuse code like a civilized developer, not copy-paste playbooks like it’s 1999 - Test your infrastructure code with pytest, not "let’s run it in staging and see what breaks"

We’ll explore how a typical Ansible playbook can be transformed into clean, maintainable Python with PyInfra, shrinking from 500 lines of YAML to 50 lines of readable code. You’ll discover the joy of list comprehensions over with_items, and the power of deployment logic that can actually think.

Stop treating your infrastructure like a configuration file. It’s 2026—your servers deserve better than YAML. They deserve Python.

Warning: This talk may cause uncontrollable urges to refactor all your Ansible playbooks. Side effects include increased productivity, better sleep, and colleagues actually understanding your infrastructure code.

Link to the marp: https://marp.kalvad.com/fosdem_2026 (gifs are not working in pdf)

Summary:

ETL stands for "extract, transform, load" and is a synonym for moving data around. This has traditionally often required managing complex systems in the cloud or large data centers. The talk will demonstrate how all this can be greatly simplified by applying modern tools for the task: Python and DuckDB, both open source and readily available to run on most systems - even your notebook.

Description:

ETL stands for "extract, transform, load" and is a synonym for moving data from one system to another.

Traditionally, ETL was done in exactly that order: first you extract the data you want to process, then you transform it and then you load it into the target system. More modern approaches based on data lakes, swap the T and L, since transformation is more efficiently done in a database system, especially when it comes to large volumes of data.

In order to make all this work, the usual approach is to have a workflow system, taking care of managing all the intermediate steps, a large data lake database and distributed storage systems. This results in lots of complexity, need for system/cluster administration and maintenance.

Now, with today's computers, most data sizes used in ETL no longer need all this complexity. Even notebooks or single VMs can handle the load, when used with external object storage, so all you really just need is the right software stack to manage your ETL - without all the overhead:

• Python has grown to be the number one programming language on the planet and is especially well suited for integration work due to its many readily available connectors to plenty of backend systems. It often comes preinstalled on Linux machines and is easy to install on most other systems.

• DuckDB has emerged as one of the most capable embedded OLAP database systems and supports data lakes with the DuckLake extension, right out of the box. Installation is just a uv add duckdb away.

Both can be run on the same machine and are very resource friendly.

The talk will give an overview of the typical steps involved in ETL processes, give a short intro to DuckDB and showcase how DuckDB can be put to good use when implementing ETL processes. If time permits, I can also cover a few advanced topics addressing optimization strategies.

Resources:

• Python.org

• DuckDB – An in-process SQL OLAP database management system

Django's built-in admin is powerful, but it's essentially a separate framework within Django and it's 20 years old.

Wouldn't it be nice to be able to work with an admin interface that works like the rest of Django, built on generic CBVs, plugins, and view factories? Django-Admin2, was an attempt at doing just that and it was a fairly successful ptoject.

10 years later, after looking at reviving that project, I realized we needed a fresh approach: Meet Django-Admin-Deux: a proof-of-concept Django admin replacement where CRUD operations are just actions, knowledge transfers both ways, and everything feels like Django.

Let's have a look at what python features and architecture makes this possible

The French digital agency (DINUM) has undertaken to develop an open-source collaborative digital workplace to make the work of public servants simpler and more effective.

This collaborative digital workplace is distributed under an open-source license to allow anyone who wishes to take its applications and integrate them into their preferred tools.

By participating in existing open-source communities, the digital workplace enables the emergence of digital commons that facilitate independence for those who wish to deploy and use them.

Designed with a modular approach, it can be partially or progressively adopted or complement an existing offer.

I propose to present two applications, both technically and functionally, that are integrated into this collaborative suite:

• Collaborative editing and documentation: The Suite Docs, based on Prosemirror and Blocknotejs. Developed jointly with Germany and the Netherlands.

• File sharing: Drive

These applications share the same technical stack, which relies on Python and the Django framework, Django Rest Framework, and PostgreSQL.

Beyond a list of libraries used, I will present the quality processes we have implemented, the complete workflow from the idea of a new feature to its implementation and deployment. I will share our dev handbook (also under an open-source license) that compiles our best practices.

How what could be qualified as a "Boring Stack" (meaning proven and battle-tested) allows us to focus on solving complex problems.

After the success of last year's impromptu lightning talks session, we will have an official one in the Python Devroom for 2026.

Please submit your talks using this form:

• Lightning Talk Submission Form

• The form will be opened for submissions at around 14:00 CET on Saturday, Jan 31, 2026.

Lightning Talks are at most 5 minutes and should be Python related.

Note: All presentations in this slot will be recorded and made available under a CC-BY license.

Thank you, Python Devroom Organizers

Opening of the Audio, Video & Graphics Creation Devroom

QtMultimedia is a submodule of the Qt framework that allows users to integrate various audio and video features into Qt-based cross-platform applications. https://doc.qt.io/qt-6/qtmultimedia-index.html

We, the QtMultimedia developers, are going to present the APIs and capabilities we provide, along with their use cases and limitations. We’re open to questions, feedback, and proposals.

F3D is a fast and minimalist open source 3D viewer designed to handle a wide range of formats, from simple 3D meshes to complex volumetric datasets. Its goal is to make 3D visualization accessible, lightweight, and efficient across platforms. Anyone with a 3D model on their computer definitely wants to install and use F3D to quickly and efficiently view their 3D models. From gamedev, to simulations researchers, via graphical artists, F3D provides value to many different fields.

• Generate thumbnails for all your 3D files in your file manager
• Double click and view your models easily
• Keyboard centric interactions for efficiency
• CLI oriented with dozens of options and configuration file support
• C++/Python/javascript API for devs

In this talk we will cover the different use cases the F3D can help with and solve actual issues the 3D users have been having for a long time without resorting to much bigger softwares like Blender or ParaView.

• https://f3d.app
• https://github.com/f3d-app/f3d

Graphite is reinventing open source design tools by combining vector and raster workflows through a node-based, procedural approach borrowed from the 3D industry. We did already give a lightning talk at the last FOSDEM, but since then a lot has changed. We now have a desktop app in addition to the web based UI and have worked on a bunch of features and UX improvements. In this talk, we'll give an Overview of what Graphite is and what we have achieved over the last year.

https://graphite.art/

The GNU Image Manipulation Program (GIMP) is Community-driven Free software for high-end image creation and manipulation. Last year GIMP celebrated its 30th birthday!

In March 2025 the GNU Image Manipulation Program team team was proud to release GIMP 3.0. This represented the culmination of 7 years of hard work done by members of the GIMP community. Many major and long-awaited features were introduced including non-destructive editing, multi-layer operations, infinite canvas, more advanced colour management and much more.

The GIMP team had made a decision that starting with the 3.0 release the length of development cycles would be reduced. This has been followed, and has lead to the next big release - the 3.2.

Today a core developer who joined the team within the past year presents the latest release of GIMP, takes a look at what's being worked on by the members of the GIMP community, and shares the experience of becoming a GIMP developer. You can look forward to hearing something about all the file formats GIMP aims to support, full CMYK mode, improved text support, hardware-accelerated image operations and more!

This talk will take the usual bird's eye look at what's been happening in and around the GStreamer multimedia framework in the last release cycle(s) leading up to the new 1.28 feature release, and look forward at what's next in the pipeline.

Whether codecs, closed captions, MPEG-TS, HLS + DASH adaptive streaming, speech-to-text transcriptions, text-to-speech synthesis, voice cloning, analytics, WebRTC, RTMP, Vulkan, Direct3D12, Wayland, VA-API, GTK, Qt/QML, AMD HIP + NVIDIA CUDA, bindings, or Rust - we've got you covered!

Bonnie and Øjvind are the host and editor of the FSFE's Software Freedom Podcast, a podcast dedicated to Free Software. In this talk they will share their knowledge and skills on how to produce podcasts using Free Software, sharing different tools and techniques with you to create your own podcast projects.

This is the perfect talk for everybody who wants to share their ideas and thoughts with others through podcasts. Learn the basics of recording, editing, and publishing podcasts with Free Software tools, and discover how to create quality content without relying on proprietary software. Everybody is welcome to join us from beginners and those looking to switch to Free Software!

We're building Podlibre—an open-source, cross-platform podcast editor designed specifically for podcasters' workflows, not adapted from music production tools. This is a work-in-progress demo and call for feedback from the FOSS audio community.

Why podcasters need their own tool:

Most podcasters currently rely on DAWs like Audacity, Ardour, or Reaper—tools designed for musicians with workflows that don't match podcast production. Podcasters need noise reduction, mouth click removal, transcript editing synchronized with audio, chapter markers, metadata management (ID3, RSS, Podcasting 2.0 tags), and one-click publishing—not MIDI sequencing or complex mixing boards.

What we'll show you:

• Live WIP demo of Podlibre's plugin-based architecture
• Automated transcription running locally on your laptop—no cloud services required
• Transcript correction UI optimized for keyboard-only editing (inspired by Aegisub but podcast-focused)
• Workflow customization: how our plugin system lets you build your own production pipeline
• Publishing integrations: direct export to Castopod, Funkwhale, Faircamp, and local storage

What we need from you:

Podlibre is funded by Ad Aures (creators of Castopod) and NLnet, currently in active development. We're here to gather feedback from the FOSS audio community: What features matter? What libraries should we integrate? How can we build bridges with existing audio tools (PipeWire, LV2, VST)?

Join us to shape a podcast editor that serves the 350,000+ active podcasters who deserve open-source tools built for their craft.

What does it take nowadays to get the most out of your Linux system so that it can be used as a music production power house? This talk will explore the possibilities and hand some guidelines to squeeze out as much headroom your system has for all those resource hungry plugins. Along the way some myths might get debunked and some helpful tools will get introduced.

During the talk I will walk through how to set up your system so it can do low-latency real-time audio. With low-latency I mean round-trip latencies below 10 ms. I will show which tools can help with getting your system to perform better for doing music production. Such tools include rtcqs and Millisecond for finding and fixing possible bottlenecks, jack_iodelay or Ardour for measuring round-trip latencies and xruncounter to do DSP load stress tests.

I will also look backward briefly to 15 years ago when I did a similar talk at the Linux Audio Conference in Maynooth, what has changed since then, what has improved? I will also glare a bit at the future as the Linux Audio Conference will be held in Maynooth again this year and chances are I will dive deeper into this matter during that conference.

After the talk you will hopefully have a better grasp of what the key factors are for getting a better performing machine that has as little of those dreaded xruns as possible!

This talk demonstrates how to build a wireless MIDI controller using Elixir, ESP32 microcontrollers, and AtomVM, proving that functional programming can run efficiently on resource-constrained embedded devices.

We'll explore how BEAM VM's lightweight processes and message-passing model naturally fit embedded systems programming, particularly for real-time applications like MIDI. The session covers practical implementation details: WiFi connectivity, UDP networking, MIDI message generation, and interfacing with physical controls like knobs and faders on ESP32-C3 hardware with just 400KB RAM.

Attendees will learn about AtomVM's subset of the BEAM VM designed for microcontrollers and the potential for building distributed music applications. We'll discuss how networked MIDI enables new possibilities for multi-device music systems and collaborative performance setups built on BEAM's distributed computing capabilities.

The project is fully open source and demonstrates a compelling use case for Elixir beyond traditional web services, showing how the language's concurrency model excels in IoT and real-time embedded systems.

Over the past years we developed Cardinal, an open-source eurorack simulation audio plugin based on VCV Rack. It integrates over 1300 modules, is available under the GPL-3.0-or-later license and comes in various plugin formats (lv2/vst2/vst3/clap/au) and configurations (synth/fx/main).

In this talk we explain the reasons for starting the project and how we think this improves the original Rack for running as an audio plugin. We will also showcase some tips and tricks for integrating with the plugin host and some advanced use cases like running it on embedded hardware.

Kotlin's Compose Multiplatform allows for the creation of beautiful user interfaces in a declarative, functional paradigm. But the Compose compiler isn't limited to creating UI or even visuals.

In this talk, we explore using the Compose compiler to create soundscapes and other pieces of music. I will present a library and domain-specific language (DSL) for musical composition.

We'll start by looking at the building blocks of musical compositions and how Kotlin and Compose Multiplatform can be used to implement them in a declarative and functional way. This includes tone generators/synths, shaping the envelope of a sound, playing samples, expressing various timings and simultaneously playing multiple tracks, and creating a drum machine. We'll also see how a powerful DSL allows us to more conveniently express complex rhythms.

Following that, we'll look at how to implement the audio generation backend on multiple platforms, and some ways to optimise the Compose code – the precise timings required for music present a particular challenge. We'll also see how the audio generation integrates with existing Compose components, and how to create enlightening visualisations of the code and music.

A couple of years ago I made a presentation called "Become a rockstar using FOSS!": it was a clickbait-y title, since I'm (obviously) not a rockstar at all, but it was a nice opportunity to introduce people to the music production ecosystem in Linux, which is huge and yet not that known to most. At the time, I mostly talked about the typical workflow for creating and recording music with either real or virtual instruments, but with a focus more on rock/pop music, in order to keep things simpler.

In this presentation I'll address a different point of view, that is how you can have a full symphonic orchestra in your laptop, write music for it and then have it performed in ways that are hopefully realistic enough to be used within the context of your compositions (unless you know 80 people that can play your music for you, that is!). I'll present my typical workflow, and the different pieces of software I used to make it possible for me to write purely classical music (symphonic poems), but also orchestral arrangements for songs in different genres (e.g., folk, progressive rock or metal) that I published as a hobby in my free time over the years.

Again, a clickbait title because I'm not really an orchestra composer... but FOSS definitely helped make me feel like one, and it can help you too!

How to produce music with Linux/FLOSS professionally

Real penguins do not need apples to make music...

A case study on how an entirely Linux/FLOSS based production chain can be a viable alternative to the proprietary/paid one(s). I will concentrate on the production of a pop song, from the draft to the full-fledged, platform-ready master.

Many topics will be briefly discussed here: hardware, tools, practices, objectives, comparisons and interoperability and whatever; all you need to know to get the job done, professionally.

Here are some links related to this talk:

• “Oh Nena”, the finished song
• Ardour, a DAW
• Hydrogen, a drum machine
• JACK Audio Connection Kit, low latency audio backend
• Fedora Linux, the underlying OS

JavaScript is a great language for it’s ease and low barrier to entry, fast turnaround workflows, and trying quick experiments. It’s generally not so great for real-time tasks, such as music playback or for working with live musicians.

And yet, that’s what this library does.

In this talk we look at how the midi-live-performer library can act as a real-time MIDI looper, echo unit, and auto-accompaniment system. There’s a slight detour to show midi-info, which provides user-friendly names for MIDI messages, both in real-time and not. Then we explain how it works, where the weaknesses in timing lay, and how it formed the basis for a solo recording of the multi-instrumentalist work “In C”

Over the past few years, I've been prototyping PAW, a DAW based on ideas from live coding and bidirectional programming. Like with live coding, in PAW you write code to describe a piece of music incrementally. As part of this, you also build a GUI for direct manipulation of that same code, providing similar affordances to traditional DAWs.

PAW stems from my observations that regular DAWs tend to be limited in what they let users do, due to fundamental limitations with traditional GUIs. I believe that mixing in ideas from live coding, and programming at large, can help savvy users shed those limitations, while retaining familiar GUI affordances and usability.

The software is open source, but not yet quite usable. My goal with this talk is to share ideas with other people in the field of music production software.

Music ensembles are moving from sheet music to tablets with PDFs. Many apps exists but all are focuses on individual musicians, not on bands. Rehorse is a web app with offline support that can be self-hosted by a band. The band librarian makes the music available to the band members. They can annotate the sheet music, practice with recordings with convenient section repeats. The app lists rehearsal and concert playlists and has (optional) access management to prevent members from downloading all parts, but e.g. only those from their section.

Recordings and sheet music are stored offline so the sheet music is available even at performances where no network is available.

Rehorse has been under development and in use in several bands for years. This talk invites new users and potential contributors. It goes into the workflows that musicians expect and the high standards that they are used to from other apps.

https://codeberg.org/vandenoever/rehorse

Faircamp is a static site generator for audio producers - a system that creates fast, maintenance-free and indestructible websites for music, podcasts and other types of audio on the web. In this talk I will introduce you to Faircamp - where it comes from, what it offers, and where the project is heading in 2026 and beyond.

At the end of this talk I would also like to introduce you to other projects and communities that are working hard to bring back dignity, agency, control and a chance for a livelihood to independent musicians, podcasters, labels and audio producers all over the world.

Links: - Website - Article: «Faircamp lets you put sound, podcasts, and music on your own site» (CDM) - Blog post: «2026 will be the year of the Faircamp desktop application»