0.23 europython-2026 2026-07-13 2026-07-19 7 00:05 https://programme.europython.eu https://programme.europython.eu/media/europython-2026/img/logo_tulfAOz.webp Poland S3A Announcements 2026-07-13T08:30:00+02:00 08:30 01:00 Welcome to EuroPython 2026! Please notice the registration will happen on the TBD. You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday! Enjoy the conference! europython-2026-97546-monday-registration-welcome-tbd-floor en false https://programme.europython.eu/europython-2026/talk/CSDM3D/ https://programme.europython.eu/europython-2026/talk/CSDM3D/feedback/ S3A Tutorial 2026-07-13T09:30:00+02:00 09:30 01:30 Ever wondered how a computer actually understands your logic? While Python interprets code line-by-line, WebAssembly allows us to compile high-performance modules that run at near-native speed in the browser. This tutorial breaks open the black box of language design, showing you how to translate human-readable logic into raw, executable power. We will use Python to build a functional compiler from scratch, translating a simple language into **WebAssembly (Wasm)**: the industry standard for high-performance web and cloud computing. ### Why Build a Compiler? (It’s Not Just for Language Designers) Learning compiler logic isn’t just about creating the next C++ or Rust; it’s about mastering **data transformation**. The patterns used in compilers (lexing, parsing, and code generation) are the exact same patterns used in: * **Data Engineering:** Writing custom Extract, Transform, and Load (ETL) tools to transform massive datasets. * **Domain Specific Languages (DSLs):** Creating custom internal tools for finance, science, or game logic. * **Performance Optimization:** Understanding how code is “lowered” into machine instructions to write faster, leaner programs. * **Security:** Auditing how code is executed to prevent injection attacks and vulnerabilities. ### The Project: *chiqui_forth* to Wasm We will build a compiler for **chiqui_forth**, a tiny, stack-based language inspired by the legendary Forth (1970). Because both *chiqui_forth* and WebAssembly use **Reverse Polish Notation (RPN)**, they are a perfect match for a first-time compiler project. You’ll see exactly how high-level logic is mapped to the “bare metal” of a virtual machine. ### Outcomes By the end of this session, you won’t just have a Wasm file; you’ll have a new mental model for software: * **The Compiler Pipeline:** Implement the full flow from raw text to executable binary. * **Wasm Mastery:** Gain a practical understanding of WebAssembly, the technology powering modern browser-based video editors, games, and serverless clouds. * **Custom Tooling:** Leave with a working Python-based compiler that you can extend to your own custom syntax. ### Prerequisites * **Python Proficiency:** Comfort with variables, loops, lists, dictionaries, and file I/O. * **Terminal Basics:** Ability to navigate folders and run scripts from a command line. *No prior knowledge of compiler design, Wasm, or web development is required.* europython-2026-89641-0-crafting-your-own-compiler-from-python-logic-to-high-speed-webassembly Python Core, Internals, Extensions Ariel Ortiz en false https://programme.europython.eu/europython-2026/talk/QWEJWT/ https://programme.europython.eu/europython-2026/talk/QWEJWT/feedback/ S3A Tutorial 2026-07-13T11:15:00+02:00 11:15 01:30 Ever wondered how a computer actually understands your logic? While Python interprets code line-by-line, WebAssembly allows us to compile high-performance modules that run at near-native speed in the browser. This tutorial breaks open the black box of language design, showing you how to translate human-readable logic into raw, executable power. We will use Python to build a functional compiler from scratch, translating a simple language into **WebAssembly (Wasm)**: the industry standard for high-performance web and cloud computing. ### Why Build a Compiler? (It’s Not Just for Language Designers) Learning compiler logic isn’t just about creating the next C++ or Rust; it’s about mastering **data transformation**. The patterns used in compilers (lexing, parsing, and code generation) are the exact same patterns used in: * **Data Engineering:** Writing custom Extract, Transform, and Load (ETL) tools to transform massive datasets. * **Domain Specific Languages (DSLs):** Creating custom internal tools for finance, science, or game logic. * **Performance Optimization:** Understanding how code is “lowered” into machine instructions to write faster, leaner programs. * **Security:** Auditing how code is executed to prevent injection attacks and vulnerabilities. ### The Project: *chiqui_forth* to Wasm We will build a compiler for **chiqui_forth**, a tiny, stack-based language inspired by the legendary Forth (1970). Because both *chiqui_forth* and WebAssembly use **Reverse Polish Notation (RPN)**, they are a perfect match for a first-time compiler project. You’ll see exactly how high-level logic is mapped to the “bare metal” of a virtual machine. ### Outcomes By the end of this session, you won’t just have a Wasm file; you’ll have a new mental model for software: * **The Compiler Pipeline:** Implement the full flow from raw text to executable binary. * **Wasm Mastery:** Gain a practical understanding of WebAssembly, the technology powering modern browser-based video editors, games, and serverless clouds. * **Custom Tooling:** Leave with a working Python-based compiler that you can extend to your own custom syntax. ### Prerequisites * **Python Proficiency:** Comfort with variables, loops, lists, dictionaries, and file I/O. * **Terminal Basics:** Ability to navigate folders and run scripts from a command line. *No prior knowledge of compiler design, Wasm, or web development is required.* europython-2026-89641-1-crafting-your-own-compiler-from-python-logic-to-high-speed-webassembly Python Core, Internals, Extensions Ariel Ortiz en false https://programme.europython.eu/europython-2026/talk/QWEJWT/ https://programme.europython.eu/europython-2026/talk/QWEJWT/feedback/ S3A Tutorial 2026-07-13T13:45:00+02:00 13:45 01:30 Learn how to use uv for fast, reliable Python development. Created by Astral (the makers of Ruff), uv is a modern Python package and project manager written in Rust that can replace pip, pip-tools, virtualenv, poetry, pyenv, and more—with dramatic speed improvements. This hands-on tutorial teaches you how to use uv for managing Python projects, dependencies, and tools. uv is designed to be a drop-in replacement for pip while offering a complete development workflow: project management, dependency resolution, virtual environments, Python version management, and tool installation. Key advantages of uv: * **Speed**: 10-100x faster than pip for most operations * **Compatibility**: Works with existing pip workflows and requirements.txt files * **Complete workflow**: Replaces multiple tools with a single, unified interface * **Reliability**: Deterministic dependency resolution with lock files You will learn: * How to replace pip with uv for faster package installation * How to manage Python projects with `pyproject.toml` and `uv.lock` * How to handle multiple Python versions without external tools * How to manage workspaces for multi-package projects * How to use `uvx` for running Python tools without installation * How to run single-file scripts with inline dependencies * How to build and publish Python packages * Best practices for using uv in real-world projects A brief comparison with Pixi and other dependency management tools is included. europython-2026-91357-0-fast-python-development-with-uv Tooling, Packaging, Developer Productivity Mike Müller en false https://programme.europython.eu/europython-2026/talk/RARRL7/ https://programme.europython.eu/europython-2026/talk/RARRL7/feedback/ S3A Tutorial 2026-07-13T15:30:00+02:00 15:30 01:30 Learn how to use uv for fast, reliable Python development. Created by Astral (the makers of Ruff), uv is a modern Python package and project manager written in Rust that can replace pip, pip-tools, virtualenv, poetry, pyenv, and more—with dramatic speed improvements. This hands-on tutorial teaches you how to use uv for managing Python projects, dependencies, and tools. uv is designed to be a drop-in replacement for pip while offering a complete development workflow: project management, dependency resolution, virtual environments, Python version management, and tool installation. Key advantages of uv: * **Speed**: 10-100x faster than pip for most operations * **Compatibility**: Works with existing pip workflows and requirements.txt files * **Complete workflow**: Replaces multiple tools with a single, unified interface * **Reliability**: Deterministic dependency resolution with lock files You will learn: * How to replace pip with uv for faster package installation * How to manage Python projects with `pyproject.toml` and `uv.lock` * How to handle multiple Python versions without external tools * How to manage workspaces for multi-package projects * How to use `uvx` for running Python tools without installation * How to run single-file scripts with inline dependencies * How to build and publish Python packages * Best practices for using uv in real-world projects A brief comparison with Pixi and other dependency management tools is included. europython-2026-91357-1-fast-python-development-with-uv Tooling, Packaging, Developer Productivity Mike Müller en false https://programme.europython.eu/europython-2026/talk/RARRL7/ https://programme.europython.eu/europython-2026/talk/RARRL7/feedback/ S3B Tutorial 2026-07-13T09:30:00+02:00 09:30 01:30 Asynchronous programming is infamous for leading to confusing projects with non linear code paths and all sorts of nasty bugs… But with the right mental models and a cooking analogy, you will find yourself writing async code with confidence. Come to this tutorial if you’re prepared to challenge your understanding of how programs run, if you want to create a simple Human-to-Human asynchronous chat application, or ir you want to critique my culinary taste. europython-2026-91785-0-cooking-with-asyncio-an-introduction-to-asynchronous-programming Python Core, Internals, Extensions Rodrigo Girão Serrão en false https://programme.europython.eu/europython-2026/talk/WYBHCE/ https://programme.europython.eu/europython-2026/talk/WYBHCE/feedback/ S3B Tutorial 2026-07-13T11:15:00+02:00 11:15 01:30 Asynchronous programming is infamous for leading to confusing projects with non linear code paths and all sorts of nasty bugs… But with the right mental models and a cooking analogy, you will find yourself writing async code with confidence. Come to this tutorial if you’re prepared to challenge your understanding of how programs run, if you want to create a simple Human-to-Human asynchronous chat application, or ir you want to critique my culinary taste. europython-2026-91785-1-cooking-with-asyncio-an-introduction-to-asynchronous-programming Python Core, Internals, Extensions Rodrigo Girão Serrão en false https://programme.europython.eu/europython-2026/talk/WYBHCE/ https://programme.europython.eu/europython-2026/talk/WYBHCE/feedback/ S3B Tutorial 2026-07-13T13:45:00+02:00 13:45 01:30 Have you ever opened a piece of code that seems to break just by looking at it—and noticed that your coworker wrote it? You don’t want to be *that* person. While tangled, hard-to-maintain code can emerge for many reasons, it should never be by accident. In this hands-on workshop, you will learn how to make code easier to maintain and to evolve. We will gradually refactor a messy Python web application into a well-organized, testable software. You will develop a mental model for organizing code effectively and understand how its structure impacts code quality. Ultimately, this will inform future decisions on design and code organization. This workshop is specifically designed for people who don't identify as software engineers or don't perform typical software engineering tasks as part of their daily work. Participants should be familiar with basic Python programming and the concept of automated (unit) tests. europython-2026-91428-0-code-organization-for-non-engineers Testing, Quality Assurance, Security Michael Seifert en false https://programme.europython.eu/europython-2026/talk/JRMSZT/ https://programme.europython.eu/europython-2026/talk/JRMSZT/feedback/ S3B Tutorial 2026-07-13T15:30:00+02:00 15:30 01:30 Have you ever opened a piece of code that seems to break just by looking at it—and noticed that your coworker wrote it? You don’t want to be *that* person. While tangled, hard-to-maintain code can emerge for many reasons, it should never be by accident. In this hands-on workshop, you will learn how to make code easier to maintain and to evolve. We will gradually refactor a messy Python web application into a well-organized, testable software. You will develop a mental model for organizing code effectively and understand how its structure impacts code quality. Ultimately, this will inform future decisions on design and code organization. This workshop is specifically designed for people who don't identify as software engineers or don't perform typical software engineering tasks as part of their daily work. Participants should be familiar with basic Python programming and the concept of automated (unit) tests. europython-2026-91428-1-code-organization-for-non-engineers Testing, Quality Assurance, Security Michael Seifert en false https://programme.europython.eu/europython-2026/talk/JRMSZT/ https://programme.europython.eu/europython-2026/talk/JRMSZT/feedback/ S4A Tutorial 2026-07-13T09:30:00+02:00 09:30 01:30 In this workshop, you will create practical internet-connected sensors with MicroPython. We will cover the basics of setting up the development environment, both for developing on PC and deploying/developing on a microcontroller device. Targeted towards those that are already comfortable programming in Python, but that have little exposure to embedded/hardware/electronics. We will provide some MicroPython-capable hardware to develop against, pre-flashed with MicroPython. You may need to sit together in pairs or small groups for the on-device part. #### Prerequisites Participants must bring: - Laptop with Linux/MacOS/Windows Subsystem for Linux - Have Python 3.12+ with virtualenv support installed - USB-C to USB-C cable or USB Type A adapter (our kit only has Type A plug) europython-2026-91591-0-developing-iot-sensors-with-micropython IoT, Embedded Systems, Hardware Integration Jon Nordby en false https://programme.europython.eu/europython-2026/talk/NQGSY7/ https://programme.europython.eu/europython-2026/talk/NQGSY7/feedback/ S4A Tutorial 2026-07-13T11:15:00+02:00 11:15 01:30 In this workshop, you will create practical internet-connected sensors with MicroPython. We will cover the basics of setting up the development environment, both for developing on PC and deploying/developing on a microcontroller device. Targeted towards those that are already comfortable programming in Python, but that have little exposure to embedded/hardware/electronics. We will provide some MicroPython-capable hardware to develop against, pre-flashed with MicroPython. You may need to sit together in pairs or small groups for the on-device part. #### Prerequisites Participants must bring: - Laptop with Linux/MacOS/Windows Subsystem for Linux - Have Python 3.12+ with virtualenv support installed - USB-C to USB-C cable or USB Type A adapter (our kit only has Type A plug) europython-2026-91591-1-developing-iot-sensors-with-micropython IoT, Embedded Systems, Hardware Integration Jon Nordby en false https://programme.europython.eu/europython-2026/talk/NQGSY7/ https://programme.europython.eu/europython-2026/talk/NQGSY7/feedback/ S4A Tutorial 2026-07-13T13:45:00+02:00 13:45 01:30 > *"There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery"* If this made you curious, this tutorial is the right place to dive deeper into the interesting (sometimes weird) world of Distributed Systems. When you think of constructing systems that can scale to billions of people, you have to think beyond single node programming patterns. This introduces a couple of intriguing challenges like how do you make thousands of nodes agree? Or jargons like *CAP Theorem*. To make matters even more complicated, most of the material on this subject is highly theoretical & geared towards advanced learners. This quickly discourages a lot of programmers who tend to learn better by doing rather than just reading about things. Python has always been a great vehicle to learn complex technologies efficiently. It enables a programmer to cut through the weeds to focus on the core concepts. This was recently exemplified when Andrej Karpathy taught a way to train a GPT in pure python with [microgpt.py](https://gist.github.com/karpathy/8627fe009c40f57531cb18360106ce95). Similarly, it can be an efficient vehicle to deconstruct the fundamentals of large scale systems, which are essential for a holistic view of modern day applications. In this tutorial, we will have several hands on exercises to dive deeper into the tenets of reliability, availability & scalability. By simulating a Distributed Cluster with pure python code we'll poke the system, make it fail & closely study the perils of planet scale systems & how to overcome them. Towards the end of the tutorial, you'll have a clear mental model of some of the most confusing concepts (Consistency, Consensus, Clocks etc) in distributed systems. The ultimate goal is to give you enough knowledge, curiosity & tooling so that you can explore this field on your own & be confident about building the next planet scale system. europython-2026-91171-0-deconstructing-the-tenets-of-planet-scale-systems-with-python DevOps, Cloud, Scalable Infrastructure Abhimanyu Singh Shekhawat en false https://programme.europython.eu/europython-2026/talk/SNKUW7/ https://programme.europython.eu/europython-2026/talk/SNKUW7/feedback/ S4A Tutorial 2026-07-13T15:30:00+02:00 15:30 01:30 > *"There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery"* If this made you curious, this tutorial is the right place to dive deeper into the interesting (sometimes weird) world of Distributed Systems. When you think of constructing systems that can scale to billions of people, you have to think beyond single node programming patterns. This introduces a couple of intriguing challenges like how do you make thousands of nodes agree? Or jargons like *CAP Theorem*. To make matters even more complicated, most of the material on this subject is highly theoretical & geared towards advanced learners. This quickly discourages a lot of programmers who tend to learn better by doing rather than just reading about things. Python has always been a great vehicle to learn complex technologies efficiently. It enables a programmer to cut through the weeds to focus on the core concepts. This was recently exemplified when Andrej Karpathy taught a way to train a GPT in pure python with [microgpt.py](https://gist.github.com/karpathy/8627fe009c40f57531cb18360106ce95). Similarly, it can be an efficient vehicle to deconstruct the fundamentals of large scale systems, which are essential for a holistic view of modern day applications. In this tutorial, we will have several hands on exercises to dive deeper into the tenets of reliability, availability & scalability. By simulating a Distributed Cluster with pure python code we'll poke the system, make it fail & closely study the perils of planet scale systems & how to overcome them. Towards the end of the tutorial, you'll have a clear mental model of some of the most confusing concepts (Consistency, Consensus, Clocks etc) in distributed systems. The ultimate goal is to give you enough knowledge, curiosity & tooling so that you can explore this field on your own & be confident about building the next planet scale system. europython-2026-91171-1-deconstructing-the-tenets-of-planet-scale-systems-with-python DevOps, Cloud, Scalable Infrastructure Abhimanyu Singh Shekhawat en false https://programme.europython.eu/europython-2026/talk/SNKUW7/ https://programme.europython.eu/europython-2026/talk/SNKUW7/feedback/ S4B Tutorial 2026-07-13T09:30:00+02:00 09:30 01:30 We know we should write automated tests. But too often, it is a real chore: they may be slow, unreliable, difficult to run, to maintain, even to write! Why is it so hard? How to take back control? For that, you will work on a realistic project: a Python app with FastAPI backend, a PostgreSQL database, configuration files, third-party APIs, ... and tests that are awful. You will review: - the quality culture of the project - how it is architectured - the existing tests - and the code quality Then you will prepare the plan: - your own test pyramid / strategy - testing tools needed - essential scenarios - the CI to have your back And start coding: - updating the existing tests - adding new tests using powerful tooling - minimal refactoring to enable testing - creating fakes/mocks/simulators to enable testing You'll leave able to: * diagnose what makes tests slow or convoluted * design a pragmatic test strategy for your codebase * implement reliable tests, with fakes and testcontainers * refactor just enough to make code testable It will be around 65% hands-on, and 35% guided analysis. The first two parts will take the first half of the session, so that you have plenty of time to actually implement the strategy during the second half. The code repository will stay available to you after the workshop, along with an example of the end-result. Setup : * [`uv`](https://docs.astral.sh/uv/) * (optional) docker or podman, to run TestContainers * (optional) a GitHub or GitLab account, to run CI europython-2026-89372-0-getting-out-of-the-testing-hell Testing, Quality Assurance, Security Julien LenormandGAFFIOT Jonathan en false https://programme.europython.eu/europython-2026/talk/GCWCEU/ https://programme.europython.eu/europython-2026/talk/GCWCEU/feedback/ S4B Tutorial 2026-07-13T11:15:00+02:00 11:15 01:30 We know we should write automated tests. But too often, it is a real chore: they may be slow, unreliable, difficult to run, to maintain, even to write! Why is it so hard? How to take back control? For that, you will work on a realistic project: a Python app with FastAPI backend, a PostgreSQL database, configuration files, third-party APIs, ... and tests that are awful. You will review: - the quality culture of the project - how it is architectured - the existing tests - and the code quality Then you will prepare the plan: - your own test pyramid / strategy - testing tools needed - essential scenarios - the CI to have your back And start coding: - updating the existing tests - adding new tests using powerful tooling - minimal refactoring to enable testing - creating fakes/mocks/simulators to enable testing You'll leave able to: * diagnose what makes tests slow or convoluted * design a pragmatic test strategy for your codebase * implement reliable tests, with fakes and testcontainers * refactor just enough to make code testable It will be around 65% hands-on, and 35% guided analysis. The first two parts will take the first half of the session, so that you have plenty of time to actually implement the strategy during the second half. The code repository will stay available to you after the workshop, along with an example of the end-result. Setup : * [`uv`](https://docs.astral.sh/uv/) * (optional) docker or podman, to run TestContainers * (optional) a GitHub or GitLab account, to run CI europython-2026-89372-1-getting-out-of-the-testing-hell Testing, Quality Assurance, Security Julien LenormandGAFFIOT Jonathan en false https://programme.europython.eu/europython-2026/talk/GCWCEU/ https://programme.europython.eu/europython-2026/talk/GCWCEU/feedback/ S4B Tutorial 2026-07-13T13:45:00+02:00 13:45 01:30 The majority of the new modules that we see out there including the word "performance" in their campaigns are Python modules with extensions in other languages. This has been very clear with languages like Rust, and C++, which has been the core of many popular modules in the recent years. But how difficult is to extend CPython? and more importantly, what are the steps of doing it with other languages? This tutorial aims to be a good starting point for people that wants to familiarize themselves with the CPython internal, and how to do extensions with languages like C, C++, Rust, and Zig, by developing a series of small exercises that will enable you to get more familiar with the processes. On this tutorial you will learn to: - Explore the core of the standard Python implementation - Modify the interpreter by adding new functions - Extend Python with C, Rust, and Zig. The session will be a combination of a theoretical introduction of the topics, followed by a hand-on experience on each step. Some knowledge with C, C++, Rust or Zig is encouraged, but not required. europython-2026-91712-0-understand-and-expand-python-a-hands-on-experience-on-python-internals Python Core, Internals, Extensions Cristián Maureira-Fredes en false https://programme.europython.eu/europython-2026/talk/K7XNTF/ https://programme.europython.eu/europython-2026/talk/K7XNTF/feedback/ S4B Tutorial 2026-07-13T15:30:00+02:00 15:30 01:30 The majority of the new modules that we see out there including the word "performance" in their campaigns are Python modules with extensions in other languages. This has been very clear with languages like Rust, and C++, which has been the core of many popular modules in the recent years. But how difficult is to extend CPython? and more importantly, what are the steps of doing it with other languages? This tutorial aims to be a good starting point for people that wants to familiarize themselves with the CPython internal, and how to do extensions with languages like C, C++, Rust, and Zig, by developing a series of small exercises that will enable you to get more familiar with the processes. On this tutorial you will learn to: - Explore the core of the standard Python implementation - Modify the interpreter by adding new functions - Extend Python with C, Rust, and Zig. The session will be a combination of a theoretical introduction of the topics, followed by a hand-on experience on each step. Some knowledge with C, C++, Rust or Zig is encouraged, but not required. europython-2026-91712-1-understand-and-expand-python-a-hands-on-experience-on-python-internals Python Core, Internals, Extensions Cristián Maureira-Fredes en false https://programme.europython.eu/europython-2026/talk/K7XNTF/ https://programme.europython.eu/europython-2026/talk/K7XNTF/feedback/ 2.017/2.018 Summit 2026-07-13T09:30:00+02:00 09:30 01:30 ## Important links: - Request to attend (required): https://forms.gle/cNZU3NnbeFY1aiqw6 - Propose a topic (optional): https://forms.gle/GCBvWQW25QxKJLZu5 - Summary Notes: [2026 (this year)](https://hackmd.io/@jezdez/europython2026-packaging-summit), [2025 (previous year)](https://hackmd.io/@jezdez/europython2025-packaging-summit) ## About the Packaging Summit Co-Chairs: Pradyun Gedam and Jannis Leidel Following the great success of the Packaging Summit at PyCon US we're looking to bring the same event again to EuroPython. Python packaging is a rapidly changing (and hopefully improving) landscape, historically and currently plagued by many problems. Solving these problems requires a high degree of coordination between various stakeholders; to name a few: - Creators of packaging tools (e.g., Setuptools, pip, conda, Poetry, uv) - Maintainers of Python libraries - Developers of Python applications - Distributors of downstream packages (e.g., Fedora, Debian) - Consumers of Python packages (e.g., end-users, corporate developers) The goal of this summit is to try to take advantage of the fact that, at EuroPython we can get a high concentration of these stakeholders in one room at the same time. This allows us to sync up on current and future best practices and to quickly come to agreements that would take months or even years over higher-latency media of discussion (e.g., mailing lists, forums, issue tickets). ## Request to attend Are you involved in Python packaging in some capacity, have a unique perspective to share, and ready to participate in intense discussions helping continue to hash out the present and future of Python packaging? If so, you're a great candidate to attend! ### Go here to request to attend: https://forms.gle/cNZU3NnbeFY1aiqw6 _The registration will close on [Monday June 29 2026, AoE](https://www.timeanddate.com/worldclock/fixedtime.html?msg=EuroPython+2026+-+Python+Packaging+Summit+Attendance+Request+Deadline&iso=20260629T2359&p1=3399), and selected attendees will be notified by email._ We will be evaluating all requests on a rolling basis, and aim to confirm your attendance by July 4. ## Propose a topic Do you have a particular topic in mind you want to share or discuss? Great! Keep in mind that time allows for a limited number of topics, and we'll need to select those that pose the broadest interest and applicability to the community and would benefit most from a hands-on, interactive discussion. Submitting multiple topics is allowed (and encouraged, within reason), and you don't have to be selected to attend to have your topic discussed. ### Go here to submit a topic (optional): https://forms.gle/GCBvWQW25QxKJLZu5 _You can submit your topic until [Monday June 29 2026, AoE](https://www.timeanddate.com/worldclock/fixedtime.html?msg=EuroPython+2026+-+Python+Packaging+Summit+Topic+Proposal+Deadline&iso=20260629T2359&p1=3399). We'll email out and publish a final schedule within about a week or so thereafter, before the opening of the conference. We're looking forward to hearing your ideas!_ ## Schedule Please start arriving at 9:25 am. NOTE: **The schedule will be published here on July 6, 2026.** ## Code of Conduct The [EuroPython Society Code of Conduct](https://www.europython-society.org/coc/) applies and will be enforced. If you have any questions, the [Packaging Category](https://discuss.python.org/c/packaging) section of the [Python Discourse](https://discuss.python.org/) is the best place to ask. You may also reach out to the organizers privately if needed. Thanks! europython-2026-99349-0-packaging-summit Tooling, Packaging, Developer Productivity Jannis Leidel en false https://programme.europython.eu/europython-2026/talk/SBREFN/ https://programme.europython.eu/europython-2026/talk/SBREFN/feedback/ 2.017/2.018 Summit 2026-07-13T11:15:00+02:00 11:15 01:30 ## Important links: - Request to attend (required): https://forms.gle/cNZU3NnbeFY1aiqw6 - Propose a topic (optional): https://forms.gle/GCBvWQW25QxKJLZu5 - Summary Notes: [2026 (this year)](https://hackmd.io/@jezdez/europython2026-packaging-summit), [2025 (previous year)](https://hackmd.io/@jezdez/europython2025-packaging-summit) ## About the Packaging Summit Co-Chairs: Pradyun Gedam and Jannis Leidel Following the great success of the Packaging Summit at PyCon US we're looking to bring the same event again to EuroPython. Python packaging is a rapidly changing (and hopefully improving) landscape, historically and currently plagued by many problems. Solving these problems requires a high degree of coordination between various stakeholders; to name a few: - Creators of packaging tools (e.g., Setuptools, pip, conda, Poetry, uv) - Maintainers of Python libraries - Developers of Python applications - Distributors of downstream packages (e.g., Fedora, Debian) - Consumers of Python packages (e.g., end-users, corporate developers) The goal of this summit is to try to take advantage of the fact that, at EuroPython we can get a high concentration of these stakeholders in one room at the same time. This allows us to sync up on current and future best practices and to quickly come to agreements that would take months or even years over higher-latency media of discussion (e.g., mailing lists, forums, issue tickets). ## Request to attend Are you involved in Python packaging in some capacity, have a unique perspective to share, and ready to participate in intense discussions helping continue to hash out the present and future of Python packaging? If so, you're a great candidate to attend! ### Go here to request to attend: https://forms.gle/cNZU3NnbeFY1aiqw6 _The registration will close on [Monday June 29 2026, AoE](https://www.timeanddate.com/worldclock/fixedtime.html?msg=EuroPython+2026+-+Python+Packaging+Summit+Attendance+Request+Deadline&iso=20260629T2359&p1=3399), and selected attendees will be notified by email._ We will be evaluating all requests on a rolling basis, and aim to confirm your attendance by July 4. ## Propose a topic Do you have a particular topic in mind you want to share or discuss? Great! Keep in mind that time allows for a limited number of topics, and we'll need to select those that pose the broadest interest and applicability to the community and would benefit most from a hands-on, interactive discussion. Submitting multiple topics is allowed (and encouraged, within reason), and you don't have to be selected to attend to have your topic discussed. ### Go here to submit a topic (optional): https://forms.gle/GCBvWQW25QxKJLZu5 _You can submit your topic until [Monday June 29 2026, AoE](https://www.timeanddate.com/worldclock/fixedtime.html?msg=EuroPython+2026+-+Python+Packaging+Summit+Topic+Proposal+Deadline&iso=20260629T2359&p1=3399). We'll email out and publish a final schedule within about a week or so thereafter, before the opening of the conference. We're looking forward to hearing your ideas!_ ## Schedule Please start arriving at 9:25 am. NOTE: **The schedule will be published here on July 6, 2026.** ## Code of Conduct The [EuroPython Society Code of Conduct](https://www.europython-society.org/coc/) applies and will be enforced. If you have any questions, the [Packaging Category](https://discuss.python.org/c/packaging) section of the [Python Discourse](https://discuss.python.org/) is the best place to ask. You may also reach out to the organizers privately if needed. Thanks! europython-2026-99349-1-packaging-summit Tooling, Packaging, Developer Productivity Jannis Leidel en false https://programme.europython.eu/europython-2026/talk/SBREFN/ https://programme.europython.eu/europython-2026/talk/SBREFN/feedback/ 2.017/2.018 Summit 2026-07-13T13:45:00+02:00 13:45 01:30 ## Important links: - Request to attend (required): https://forms.gle/cNZU3NnbeFY1aiqw6 - Propose a topic (optional): https://forms.gle/GCBvWQW25QxKJLZu5 - Summary Notes: [2026 (this year)](https://hackmd.io/@jezdez/europython2026-packaging-summit), [2025 (previous year)](https://hackmd.io/@jezdez/europython2025-packaging-summit) ## About the Packaging Summit Co-Chairs: Pradyun Gedam and Jannis Leidel Following the great success of the Packaging Summit at PyCon US we're looking to bring the same event again to EuroPython. Python packaging is a rapidly changing (and hopefully improving) landscape, historically and currently plagued by many problems. Solving these problems requires a high degree of coordination between various stakeholders; to name a few: - Creators of packaging tools (e.g., Setuptools, pip, conda, Poetry, uv) - Maintainers of Python libraries - Developers of Python applications - Distributors of downstream packages (e.g., Fedora, Debian) - Consumers of Python packages (e.g., end-users, corporate developers) The goal of this summit is to try to take advantage of the fact that, at EuroPython we can get a high concentration of these stakeholders in one room at the same time. This allows us to sync up on current and future best practices and to quickly come to agreements that would take months or even years over higher-latency media of discussion (e.g., mailing lists, forums, issue tickets). ## Request to attend Are you involved in Python packaging in some capacity, have a unique perspective to share, and ready to participate in intense discussions helping continue to hash out the present and future of Python packaging? If so, you're a great candidate to attend! ### Go here to request to attend: https://forms.gle/cNZU3NnbeFY1aiqw6 _The registration will close on [Monday June 29 2026, AoE](https://www.timeanddate.com/worldclock/fixedtime.html?msg=EuroPython+2026+-+Python+Packaging+Summit+Attendance+Request+Deadline&iso=20260629T2359&p1=3399), and selected attendees will be notified by email._ We will be evaluating all requests on a rolling basis, and aim to confirm your attendance by July 4. ## Propose a topic Do you have a particular topic in mind you want to share or discuss? Great! Keep in mind that time allows for a limited number of topics, and we'll need to select those that pose the broadest interest and applicability to the community and would benefit most from a hands-on, interactive discussion. Submitting multiple topics is allowed (and encouraged, within reason), and you don't have to be selected to attend to have your topic discussed. ### Go here to submit a topic (optional): https://forms.gle/GCBvWQW25QxKJLZu5 _You can submit your topic until [Monday June 29 2026, AoE](https://www.timeanddate.com/worldclock/fixedtime.html?msg=EuroPython+2026+-+Python+Packaging+Summit+Topic+Proposal+Deadline&iso=20260629T2359&p1=3399). We'll email out and publish a final schedule within about a week or so thereafter, before the opening of the conference. We're looking forward to hearing your ideas!_ ## Schedule Please start arriving at 9:25 am. NOTE: **The schedule will be published here on July 6, 2026.** ## Code of Conduct The [EuroPython Society Code of Conduct](https://www.europython-society.org/coc/) applies and will be enforced. If you have any questions, the [Packaging Category](https://discuss.python.org/c/packaging) section of the [Python Discourse](https://discuss.python.org/) is the best place to ask. You may also reach out to the organizers privately if needed. Thanks! europython-2026-99349-2-packaging-summit Tooling, Packaging, Developer Productivity Jannis Leidel en false https://programme.europython.eu/europython-2026/talk/SBREFN/ https://programme.europython.eu/europython-2026/talk/SBREFN/feedback/ 2.017/2.018 Summit 2026-07-13T15:30:00+02:00 15:30 01:30 ## Important links: - Request to attend (required): https://forms.gle/cNZU3NnbeFY1aiqw6 - Propose a topic (optional): https://forms.gle/GCBvWQW25QxKJLZu5 - Summary Notes: [2026 (this year)](https://hackmd.io/@jezdez/europython2026-packaging-summit), [2025 (previous year)](https://hackmd.io/@jezdez/europython2025-packaging-summit) ## About the Packaging Summit Co-Chairs: Pradyun Gedam and Jannis Leidel Following the great success of the Packaging Summit at PyCon US we're looking to bring the same event again to EuroPython. Python packaging is a rapidly changing (and hopefully improving) landscape, historically and currently plagued by many problems. Solving these problems requires a high degree of coordination between various stakeholders; to name a few: - Creators of packaging tools (e.g., Setuptools, pip, conda, Poetry, uv) - Maintainers of Python libraries - Developers of Python applications - Distributors of downstream packages (e.g., Fedora, Debian) - Consumers of Python packages (e.g., end-users, corporate developers) The goal of this summit is to try to take advantage of the fact that, at EuroPython we can get a high concentration of these stakeholders in one room at the same time. This allows us to sync up on current and future best practices and to quickly come to agreements that would take months or even years over higher-latency media of discussion (e.g., mailing lists, forums, issue tickets). ## Request to attend Are you involved in Python packaging in some capacity, have a unique perspective to share, and ready to participate in intense discussions helping continue to hash out the present and future of Python packaging? If so, you're a great candidate to attend! ### Go here to request to attend: https://forms.gle/cNZU3NnbeFY1aiqw6 _The registration will close on [Monday June 29 2026, AoE](https://www.timeanddate.com/worldclock/fixedtime.html?msg=EuroPython+2026+-+Python+Packaging+Summit+Attendance+Request+Deadline&iso=20260629T2359&p1=3399), and selected attendees will be notified by email._ We will be evaluating all requests on a rolling basis, and aim to confirm your attendance by July 4. ## Propose a topic Do you have a particular topic in mind you want to share or discuss? Great! Keep in mind that time allows for a limited number of topics, and we'll need to select those that pose the broadest interest and applicability to the community and would benefit most from a hands-on, interactive discussion. Submitting multiple topics is allowed (and encouraged, within reason), and you don't have to be selected to attend to have your topic discussed. ### Go here to submit a topic (optional): https://forms.gle/GCBvWQW25QxKJLZu5 _You can submit your topic until [Monday June 29 2026, AoE](https://www.timeanddate.com/worldclock/fixedtime.html?msg=EuroPython+2026+-+Python+Packaging+Summit+Topic+Proposal+Deadline&iso=20260629T2359&p1=3399). We'll email out and publish a final schedule within about a week or so thereafter, before the opening of the conference. We're looking forward to hearing your ideas!_ ## Schedule Please start arriving at 9:25 am. NOTE: **The schedule will be published here on July 6, 2026.** ## Code of Conduct The [EuroPython Society Code of Conduct](https://www.europython-society.org/coc/) applies and will be enforced. If you have any questions, the [Packaging Category](https://discuss.python.org/c/packaging) section of the [Python Discourse](https://discuss.python.org/) is the best place to ask. You may also reach out to the organizers privately if needed. Thanks! europython-2026-99349-3-packaging-summit Tooling, Packaging, Developer Productivity Jannis Leidel en false https://programme.europython.eu/europython-2026/talk/SBREFN/ https://programme.europython.eu/europython-2026/talk/SBREFN/feedback/ Fishbowl Summit 2026-07-13T09:30:00+02:00 09:30 01:30 ## Rust in Python: Deep Dive and Experience Sharing This full-day summit is dedicated to exploring the intersection of Rust and the Python ecosystem. Attendees can expect an intensive schedule built around in-depth discussions, collaborative problem-solving, and practical experience sharing focused specifically on integrating Rust into Python projects and the development of high-performance Python tools (e.g., using technologies like PyO3, Maturin, or writing performant native extensions). The goal is to move beyond introductory concepts to tackle real-world challenges, performance optimizations, and best practices in production environments. This summit is designed for developers who already possess some practical experience in these topics and are looking to deepen their expertise, share lessons learned, and contribute to the community's collective knowledge. # Registration and Participation Participation in the Rust Summit is by invitation only to ensure a focused and high-value experience for all attendees. 1. **Sign-Up Form:** Individuals interested in attending must first complete the [sign-up form](https://forms.gle/bh2WKoUFYBJ6YzibA). 2. **Topic Submission:** This form also provides the opportunity for prospective attendees to suggest talks and/or discussion topics they would like to contribute or see covered during the summit. 3. **Invitation:** After the sign-up period closes, the organizers will review submissions. Successful applicants will receive an official email invitation confirming their attendance in advance of the event. 4. **EuroPython Ticket Requirement:** Please note that all participants *must* also be registered ticket holders for the main EuroPython conference. Holding a EuroPython ticket is a mandatory prerequisite for attending the Rust Summit. europython-2026-93918-0-rust-summit-at-europython ~ None of these topics Cheuk Ting Ho en false https://programme.europython.eu/europython-2026/talk/VYUNHG/ https://programme.europython.eu/europython-2026/talk/VYUNHG/feedback/ Fishbowl Summit 2026-07-13T11:15:00+02:00 11:15 01:30 ## Rust in Python: Deep Dive and Experience Sharing This full-day summit is dedicated to exploring the intersection of Rust and the Python ecosystem. Attendees can expect an intensive schedule built around in-depth discussions, collaborative problem-solving, and practical experience sharing focused specifically on integrating Rust into Python projects and the development of high-performance Python tools (e.g., using technologies like PyO3, Maturin, or writing performant native extensions). The goal is to move beyond introductory concepts to tackle real-world challenges, performance optimizations, and best practices in production environments. This summit is designed for developers who already possess some practical experience in these topics and are looking to deepen their expertise, share lessons learned, and contribute to the community's collective knowledge. # Registration and Participation Participation in the Rust Summit is by invitation only to ensure a focused and high-value experience for all attendees. 1. **Sign-Up Form:** Individuals interested in attending must first complete the [sign-up form](https://forms.gle/bh2WKoUFYBJ6YzibA). 2. **Topic Submission:** This form also provides the opportunity for prospective attendees to suggest talks and/or discussion topics they would like to contribute or see covered during the summit. 3. **Invitation:** After the sign-up period closes, the organizers will review submissions. Successful applicants will receive an official email invitation confirming their attendance in advance of the event. 4. **EuroPython Ticket Requirement:** Please note that all participants *must* also be registered ticket holders for the main EuroPython conference. Holding a EuroPython ticket is a mandatory prerequisite for attending the Rust Summit. europython-2026-93918-1-rust-summit-at-europython ~ None of these topics Cheuk Ting Ho en false https://programme.europython.eu/europython-2026/talk/VYUNHG/ https://programme.europython.eu/europython-2026/talk/VYUNHG/feedback/ Fishbowl Summit 2026-07-13T13:45:00+02:00 13:45 01:30 ## Rust in Python: Deep Dive and Experience Sharing This full-day summit is dedicated to exploring the intersection of Rust and the Python ecosystem. Attendees can expect an intensive schedule built around in-depth discussions, collaborative problem-solving, and practical experience sharing focused specifically on integrating Rust into Python projects and the development of high-performance Python tools (e.g., using technologies like PyO3, Maturin, or writing performant native extensions). The goal is to move beyond introductory concepts to tackle real-world challenges, performance optimizations, and best practices in production environments. This summit is designed for developers who already possess some practical experience in these topics and are looking to deepen their expertise, share lessons learned, and contribute to the community's collective knowledge. # Registration and Participation Participation in the Rust Summit is by invitation only to ensure a focused and high-value experience for all attendees. 1. **Sign-Up Form:** Individuals interested in attending must first complete the [sign-up form](https://forms.gle/bh2WKoUFYBJ6YzibA). 2. **Topic Submission:** This form also provides the opportunity for prospective attendees to suggest talks and/or discussion topics they would like to contribute or see covered during the summit. 3. **Invitation:** After the sign-up period closes, the organizers will review submissions. Successful applicants will receive an official email invitation confirming their attendance in advance of the event. 4. **EuroPython Ticket Requirement:** Please note that all participants *must* also be registered ticket holders for the main EuroPython conference. Holding a EuroPython ticket is a mandatory prerequisite for attending the Rust Summit. europython-2026-93918-2-rust-summit-at-europython ~ None of these topics Cheuk Ting Ho en false https://programme.europython.eu/europython-2026/talk/VYUNHG/ https://programme.europython.eu/europython-2026/talk/VYUNHG/feedback/ Fishbowl Summit 2026-07-13T15:30:00+02:00 15:30 01:30 ## Rust in Python: Deep Dive and Experience Sharing This full-day summit is dedicated to exploring the intersection of Rust and the Python ecosystem. Attendees can expect an intensive schedule built around in-depth discussions, collaborative problem-solving, and practical experience sharing focused specifically on integrating Rust into Python projects and the development of high-performance Python tools (e.g., using technologies like PyO3, Maturin, or writing performant native extensions). The goal is to move beyond introductory concepts to tackle real-world challenges, performance optimizations, and best practices in production environments. This summit is designed for developers who already possess some practical experience in these topics and are looking to deepen their expertise, share lessons learned, and contribute to the community's collective knowledge. # Registration and Participation Participation in the Rust Summit is by invitation only to ensure a focused and high-value experience for all attendees. 1. **Sign-Up Form:** Individuals interested in attending must first complete the [sign-up form](https://forms.gle/bh2WKoUFYBJ6YzibA). 2. **Topic Submission:** This form also provides the opportunity for prospective attendees to suggest talks and/or discussion topics they would like to contribute or see covered during the summit. 3. **Invitation:** After the sign-up period closes, the organizers will review submissions. Successful applicants will receive an official email invitation confirming their attendance in advance of the event. 4. **EuroPython Ticket Requirement:** Please note that all participants *must* also be registered ticket holders for the main EuroPython conference. Holding a EuroPython ticket is a mandatory prerequisite for attending the Rust Summit. europython-2026-93918-3-rust-summit-at-europython ~ None of these topics Cheuk Ting Ho en false https://programme.europython.eu/europython-2026/talk/VYUNHG/ https://programme.europython.eu/europython-2026/talk/VYUNHG/feedback/ S3A Announcements 2026-07-14T08:30:00+02:00 08:30 01:00 Welcome to EuroPython 2026! Please notice the registration will happen on the TBD You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday! Enjoy the conference! europython-2026-97547-tuesday-registration-welcome-tbd en false https://programme.europython.eu/europython-2026/talk/EKE78F/ https://programme.europython.eu/europython-2026/talk/EKE78F/feedback/ S3A Tutorial 2026-07-14T09:30:00+02:00 09:30 01:30 Quantum computing is often introduced either through high-level circuit abstractions or through heavy theoretical formalism. Developers frequently struggle to bridge the gap between textbook concepts, real algorithms, and hardware-aware execution. This tutorial provides a practical, hands-on introduction to quantum computing using QiliSDK, a Python framework designed to support both digital and analog workflows in a unified and modular way. The session begins with the foundations: qubits, quantum states, gates, and measurement. Participants will implement basic circuits and understand how quantum programs are constructed, simulated, and executed. From there, we move to algorithmic patterns such as variational circuits and Hamiltonian-based workflows, demonstrating how quantum programs can be expressed in a clean and composable API. The core value of the tutorial is depth without unnecessary abstraction. Attendees will not only build and simulate quantum circuits, but also explore time evolution, noise models, and backend selection. We will demonstrate how the same high-level program can target different execution layers, including simulators and hardware-oriented backends. For advanced participants, we will introduce pulse-level programming concepts, showing how quantum operations map to control-level primitives and how pulse-based experiments can be expressed in the SDK. By the end of the tutorial, participants will have: - A clear understanding of core quantum computing concepts. - Hands-on experience building and simulating quantum circuits. - Exposure to variational and Hamiltonian-based workflows. - Insight into noise modeling and realistic execution. - An understanding of how circuit-level abstractions connect to pulse-level control. This tutorial is designed for developers and researchers who want a practical entry point into quantum computing without sacrificing architectural clarity. Prior experience with Python is required. No prior quantum computing knowledge is assumed, though basic linear algebra familiarity is helpful. europython-2026-91791-0-learn-quantum-computing-with-qilisdk-from-circuits-to-pulse-level-control Jupyter and Scientific Python Vyron Vasileiadis en false https://programme.europython.eu/europython-2026/talk/3FDLUS/ https://programme.europython.eu/europython-2026/talk/3FDLUS/feedback/ S3A Tutorial 2026-07-14T11:15:00+02:00 11:15 01:30 Quantum computing is often introduced either through high-level circuit abstractions or through heavy theoretical formalism. Developers frequently struggle to bridge the gap between textbook concepts, real algorithms, and hardware-aware execution. This tutorial provides a practical, hands-on introduction to quantum computing using QiliSDK, a Python framework designed to support both digital and analog workflows in a unified and modular way. The session begins with the foundations: qubits, quantum states, gates, and measurement. Participants will implement basic circuits and understand how quantum programs are constructed, simulated, and executed. From there, we move to algorithmic patterns such as variational circuits and Hamiltonian-based workflows, demonstrating how quantum programs can be expressed in a clean and composable API. The core value of the tutorial is depth without unnecessary abstraction. Attendees will not only build and simulate quantum circuits, but also explore time evolution, noise models, and backend selection. We will demonstrate how the same high-level program can target different execution layers, including simulators and hardware-oriented backends. For advanced participants, we will introduce pulse-level programming concepts, showing how quantum operations map to control-level primitives and how pulse-based experiments can be expressed in the SDK. By the end of the tutorial, participants will have: - A clear understanding of core quantum computing concepts. - Hands-on experience building and simulating quantum circuits. - Exposure to variational and Hamiltonian-based workflows. - Insight into noise modeling and realistic execution. - An understanding of how circuit-level abstractions connect to pulse-level control. This tutorial is designed for developers and researchers who want a practical entry point into quantum computing without sacrificing architectural clarity. Prior experience with Python is required. No prior quantum computing knowledge is assumed, though basic linear algebra familiarity is helpful. europython-2026-91791-1-learn-quantum-computing-with-qilisdk-from-circuits-to-pulse-level-control Jupyter and Scientific Python Vyron Vasileiadis en false https://programme.europython.eu/europython-2026/talk/3FDLUS/ https://programme.europython.eu/europython-2026/talk/3FDLUS/feedback/ S3A Tutorial 2026-07-14T13:45:00+02:00 13:45 01:30 You’ve likely used a tool like black, flake8, or ruff to lint or format your code, or a tool like sphinx to document it, but you probably do not know how they accomplish their tasks. These tools and many more use **Abstract Syntax Trees (ASTs)** to analyze and extract information from Python code. An AST is a representation of your code's structure that enables you to access and manipulate its different components, which is what makes it possible to automate tasks like code migrations, linting, and docstring extraction. In this workshop, you’ll learn how to use the Python standard library’s ast module to parse and analyze code. Using just the standard library, we will implement a couple of common checks from scratch, which will give you an idea of how these tools work and help you build the skills and confidence to use ASTs in your own projects. europython-2026-89760-0-process-analyze-and-transform-python-code-with-asts Python Core, Internals, Extensions Stefanie Molin en false https://programme.europython.eu/europython-2026/talk/3TZHB9/ https://programme.europython.eu/europython-2026/talk/3TZHB9/feedback/ S3A Tutorial 2026-07-14T15:30:00+02:00 15:30 01:30 You’ve likely used a tool like black, flake8, or ruff to lint or format your code, or a tool like sphinx to document it, but you probably do not know how they accomplish their tasks. These tools and many more use **Abstract Syntax Trees (ASTs)** to analyze and extract information from Python code. An AST is a representation of your code's structure that enables you to access and manipulate its different components, which is what makes it possible to automate tasks like code migrations, linting, and docstring extraction. In this workshop, you’ll learn how to use the Python standard library’s ast module to parse and analyze code. Using just the standard library, we will implement a couple of common checks from scratch, which will give you an idea of how these tools work and help you build the skills and confidence to use ASTs in your own projects. europython-2026-89760-1-process-analyze-and-transform-python-code-with-asts Python Core, Internals, Extensions Stefanie Molin en false https://programme.europython.eu/europython-2026/talk/3TZHB9/ https://programme.europython.eu/europython-2026/talk/3TZHB9/feedback/ S3A Announcements 2026-07-14T17:00:00+02:00 17:00 01:00 Are you new to EuroPython? Or perhaps you're feeling overwhelmed by all the activities, sessions, and networking opportunities happening at EuroPython 2026? Whether you're a first-time attendee or a returning participant looking to make the most of your conference experience, this session is designed for you. Join us to discover essential tips and strategies for navigating the conference smoothly and efficiently. We'll cover everything from understanding the schedule and choosing the right sessions to attend, to making meaningful connections with fellow developers and speakers. You'll learn insider tricks for managing your time effectively, finding the best networking opportunities, and ensuring you don't miss out on the most valuable experiences the conference has to offer. By the end of this session, you'll feel confident and prepared to dive into EuroPython 2026 with a clear plan for maximizing your learning and networking potential. europython-2026-97548-beginner-s-orientation en false https://programme.europython.eu/europython-2026/talk/3APM9B/ https://programme.europython.eu/europython-2026/talk/3APM9B/feedback/ S3B Tutorial 2026-07-14T09:30:00+02:00 09:30 01:30 Decorators are one of Python's most powerful features. But for many developers, they remain somewhat mysterious and intimidating, because they combine a number of complex ideas -- among them, functions as objects, and nested function definitions. In this tutorial, you'll learn what decorators are, how they work, how to write them, and when you should use them. Along the way, you'll write a bunch of decorators that will demonstrate their power and practical use cases. This is a highly interactive, learn-by-doing tutorial in which you'll be actively encouraged to ask questions, challenge the instructor, and share your code (including code that doesn't work), to maximize everyone's learning. europython-2026-90832-0-let-s-write-some-decorators Python Core, Internals, Extensions Reuven M. Lerner en false https://programme.europython.eu/europython-2026/talk/MENRZG/ https://programme.europython.eu/europython-2026/talk/MENRZG/feedback/ S3B Tutorial 2026-07-14T11:15:00+02:00 11:15 01:30 Decorators are one of Python's most powerful features. But for many developers, they remain somewhat mysterious and intimidating, because they combine a number of complex ideas -- among them, functions as objects, and nested function definitions. In this tutorial, you'll learn what decorators are, how they work, how to write them, and when you should use them. Along the way, you'll write a bunch of decorators that will demonstrate their power and practical use cases. This is a highly interactive, learn-by-doing tutorial in which you'll be actively encouraged to ask questions, challenge the instructor, and share your code (including code that doesn't work), to maximize everyone's learning. europython-2026-90832-1-let-s-write-some-decorators Python Core, Internals, Extensions Reuven M. Lerner en false https://programme.europython.eu/europython-2026/talk/MENRZG/ https://programme.europython.eu/europython-2026/talk/MENRZG/feedback/ S3B Tutorial 2026-07-14T13:45:00+02:00 13:45 01:30 In this tutorial, we'll discuss how to build the basic components that make up a modern digital synth from scratch using Python. In the process, learn some DSP and audio programming concepts. By the end, you’ll be able to define your own synthesizer make music with code!! This tutorial aims to break down the abstractions that make up a synthesizer by building one using Python, its scientific computing libraries, & Librosa. We will discuss how to build the basic components that make up a modern digital synth from scratch! In the process, learn some DSP and audio programming concepts! By the end, you’ll be able to make your own tunes with Python! We will start with theory, then work through Jupyter notebooks both individually and as a group. europython-2026-89389-0-build-a-synthesizer-with-python Python for Games, Art, Play and Expression Sangarshanan en false https://programme.europython.eu/europython-2026/talk/NELACW/ https://programme.europython.eu/europython-2026/talk/NELACW/feedback/ S3B Tutorial 2026-07-14T15:30:00+02:00 15:30 01:30 In this tutorial, we'll discuss how to build the basic components that make up a modern digital synth from scratch using Python. In the process, learn some DSP and audio programming concepts. By the end, you’ll be able to define your own synthesizer make music with code!! This tutorial aims to break down the abstractions that make up a synthesizer by building one using Python, its scientific computing libraries, & Librosa. We will discuss how to build the basic components that make up a modern digital synth from scratch! In the process, learn some DSP and audio programming concepts! By the end, you’ll be able to make your own tunes with Python! We will start with theory, then work through Jupyter notebooks both individually and as a group. europython-2026-89389-1-build-a-synthesizer-with-python Python for Games, Art, Play and Expression Sangarshanan en false https://programme.europython.eu/europython-2026/talk/NELACW/ https://programme.europython.eu/europython-2026/talk/NELACW/feedback/ S4A Tutorial 2026-07-14T09:30:00+02:00 09:30 01:30 This hands-on workshop introduces gRPC, a modern RPC framework for building microservices. Learn Protocol Buffers, implement gRPC services from scratch, and explore communication patterns in Python. Discover how gRPC compares to REST APIs and use pre-configured Docker environments to test, benchmark, and monitor your services. By the end, you'll have practical knowledge to build microservices with gRPC. Basic Python knowledge required. All tools and infrastructure provided—bring a laptop with Docker installed. europython-2026-91739-0-grpc-for-beginners ~ None of these topics Kamil KuligAdam Gorgoń en false https://programme.europython.eu/europython-2026/talk/TGGHKC/ https://programme.europython.eu/europython-2026/talk/TGGHKC/feedback/ S4A Tutorial 2026-07-14T11:15:00+02:00 11:15 01:30 This hands-on workshop introduces gRPC, a modern RPC framework for building microservices. Learn Protocol Buffers, implement gRPC services from scratch, and explore communication patterns in Python. Discover how gRPC compares to REST APIs and use pre-configured Docker environments to test, benchmark, and monitor your services. By the end, you'll have practical knowledge to build microservices with gRPC. Basic Python knowledge required. All tools and infrastructure provided—bring a laptop with Docker installed. europython-2026-91739-1-grpc-for-beginners ~ None of these topics Kamil KuligAdam Gorgoń en false https://programme.europython.eu/europython-2026/talk/TGGHKC/ https://programme.europython.eu/europython-2026/talk/TGGHKC/feedback/ S4A Tutorial 2026-07-14T13:45:00+02:00 13:45 01:30 Benchmarking is hard. Ever wondered how reliable is your system? How many requests per second can it handle? How about the average response time: what do you do to measure that? How does the system behave during events like black friday, christmas sales, or any other important date that may cause an outage? Have no idea where to start answering these questions? Fear not, because you are in the right place! In this tutorial I will introduce you to locust: probably the most awesome pythonic tool to perform load tests against websites, REST APIs, GQL, and many other ways of contacting and using systems. You'll be able to understand how to structure your stress tests projects, and get your hands dirty in creating tests against a REST API, while visually being able to tell where is the threshold point and what happens after that. This tutorial is targeted for intermediate Pythonistas. Some recommended requirements (or things that will not be covered in a greater level of details) include: basics of git, simple Docker commands (to get a container up and running), classes in Python, some understanding of REST APIs. Will do my best to make it possible so anyone/any level of knowledge can join. After this presentation, participants will be able to create tests that benchmark applications in the most realistic way: exactly how users would use a system - and with that, answer the initial questions proposed, as well as create reports to display anywhere necessary (such as your job). europython-2026-89392-0-load-testing-1-on-1-discovering-the-limits-of-your-system Testing, Quality Assurance, Security Vinícius Gubiani Ferreira en false https://programme.europython.eu/europython-2026/talk/N39TFS/ https://programme.europython.eu/europython-2026/talk/N39TFS/feedback/ S4A Tutorial 2026-07-14T15:30:00+02:00 15:30 01:30 Benchmarking is hard. Ever wondered how reliable is your system? How many requests per second can it handle? How about the average response time: what do you do to measure that? How does the system behave during events like black friday, christmas sales, or any other important date that may cause an outage? Have no idea where to start answering these questions? Fear not, because you are in the right place! In this tutorial I will introduce you to locust: probably the most awesome pythonic tool to perform load tests against websites, REST APIs, GQL, and many other ways of contacting and using systems. You'll be able to understand how to structure your stress tests projects, and get your hands dirty in creating tests against a REST API, while visually being able to tell where is the threshold point and what happens after that. This tutorial is targeted for intermediate Pythonistas. Some recommended requirements (or things that will not be covered in a greater level of details) include: basics of git, simple Docker commands (to get a container up and running), classes in Python, some understanding of REST APIs. Will do my best to make it possible so anyone/any level of knowledge can join. After this presentation, participants will be able to create tests that benchmark applications in the most realistic way: exactly how users would use a system - and with that, answer the initial questions proposed, as well as create reports to display anywhere necessary (such as your job). europython-2026-89392-1-load-testing-1-on-1-discovering-the-limits-of-your-system Testing, Quality Assurance, Security Vinícius Gubiani Ferreira en false https://programme.europython.eu/europython-2026/talk/N39TFS/ https://programme.europython.eu/europython-2026/talk/N39TFS/feedback/ S4B Tutorial 2026-07-14T09:30:00+02:00 09:30 01:30 Implementing high-performance deep learning models often feels like a struggle between readable Python code and the low-level optimizations required for modern GPUs and TPUs. JAX bridges this gap by treating neural networks as pure mathematical transformations. In this session, we will move beyond the abstractions of high-level frameworks to build a Denoising Diffusion Probabilistic Model (DDPM) from the ground up. We will explore how JAX’s functional programming paradigm is uniquely suited for the stochastic nature of diffusion. You will learn how to: - Master the JIT (Just-In-Time) compilation: See how @jax.jit transforms Python functions into optimized XLA kernels for massive speedups. - Leverage Vectorized Mapping: Use @jax.vmap to handle data parallelism across batches without the overhead of manual loops. - Dissect the Diffusion Pipeline: Step through the forward noise process (SDEs) and the reverse denoising process (Score-matching). - Manage State and PRNGs: Navigate JAX’s unique, explicit handling of random number generation and stateless transformations. This tutorial is designed for Python developers and ML engineers who want to understand the "how" and "why" behind state-of-the-art text-to-image models. You will leave with a deep understanding of the diffusion objective and the practical skills to deploy high-performance model architectures using the JAX ecosystem. europython-2026-91653-0-let-it-rip-a-diffusion-tutorial Machine Learning, NLP and CV Mai Giménez en false https://programme.europython.eu/europython-2026/talk/ZPCDKE/ https://programme.europython.eu/europython-2026/talk/ZPCDKE/feedback/ S4B Tutorial 2026-07-14T11:15:00+02:00 11:15 01:30 Implementing high-performance deep learning models often feels like a struggle between readable Python code and the low-level optimizations required for modern GPUs and TPUs. JAX bridges this gap by treating neural networks as pure mathematical transformations. In this session, we will move beyond the abstractions of high-level frameworks to build a Denoising Diffusion Probabilistic Model (DDPM) from the ground up. We will explore how JAX’s functional programming paradigm is uniquely suited for the stochastic nature of diffusion. You will learn how to: - Master the JIT (Just-In-Time) compilation: See how @jax.jit transforms Python functions into optimized XLA kernels for massive speedups. - Leverage Vectorized Mapping: Use @jax.vmap to handle data parallelism across batches without the overhead of manual loops. - Dissect the Diffusion Pipeline: Step through the forward noise process (SDEs) and the reverse denoising process (Score-matching). - Manage State and PRNGs: Navigate JAX’s unique, explicit handling of random number generation and stateless transformations. This tutorial is designed for Python developers and ML engineers who want to understand the "how" and "why" behind state-of-the-art text-to-image models. You will leave with a deep understanding of the diffusion objective and the practical skills to deploy high-performance model architectures using the JAX ecosystem. europython-2026-91653-1-let-it-rip-a-diffusion-tutorial Machine Learning, NLP and CV Mai Giménez en false https://programme.europython.eu/europython-2026/talk/ZPCDKE/ https://programme.europython.eu/europython-2026/talk/ZPCDKE/feedback/ S4B Tutorial 2026-07-14T13:45:00+02:00 13:45 01:30 This tutorial will introduce fundamentals of security research and CodeQL when looking for security vulnerabilities in software. We'll share how to look for vulnerabilities in code and how to use static analysis to help us find sources, sinks and vulnerabilities. Using an example of a vulnerability in an open source project that the speaker has found, CVE-2024-32022, we will walk through how we could detect it manually by reading code, learn how to write CodeQL, and by the end write a CodeQL query to find this vulnerability and its variants. europython-2026-90395-0-introduction-to-security-research-find-a-cve-with-codeql Testing, Quality Assurance, Security Sylwia Budzynska en false https://programme.europython.eu/europython-2026/talk/ZSRZPC/ https://programme.europython.eu/europython-2026/talk/ZSRZPC/feedback/ S4B Tutorial 2026-07-14T15:30:00+02:00 15:30 01:30 This tutorial will introduce fundamentals of security research and CodeQL when looking for security vulnerabilities in software. We'll share how to look for vulnerabilities in code and how to use static analysis to help us find sources, sinks and vulnerabilities. Using an example of a vulnerability in an open source project that the speaker has found, CVE-2024-32022, we will walk through how we could detect it manually by reading code, learn how to write CodeQL, and by the end write a CodeQL query to find this vulnerability and its variants. europython-2026-90395-1-introduction-to-security-research-find-a-cve-with-codeql Testing, Quality Assurance, Security Sylwia Budzynska en false https://programme.europython.eu/europython-2026/talk/ZSRZPC/ https://programme.europython.eu/europython-2026/talk/ZSRZPC/feedback/ S1 Announcements 2026-07-15T08:00:00+02:00 08:00 01:00 Welcome to EuroPython 2026! Please notice the registration will happen on the TBD. You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday! We hope to see you around! europython-2026-96933-wednesday-registration-welcome-tbd en false https://programme.europython.eu/europython-2026/talk/9V77RU/ https://programme.europython.eu/europython-2026/talk/9V77RU/feedback/ S1 Announcements 2026-07-15T09:00:00+02:00 09:00 00:30 Welcome to EuroPython 2026! Join us on the opening session, where we will kick-off the conference days, and tell you what's going to happen in the following days. You will have three days filled with Keynotes, talks, panels, and open spaces, lightning talks, and a weekend full of sprints and other events for people attending the conference. europython-2026-96935-conference-opening en false https://programme.europython.eu/europython-2026/talk/R7PTVB/ https://programme.europython.eu/europython-2026/talk/R7PTVB/feedback/ S1 Keynote 2026-07-15T09:30:00+02:00 09:30 00:45 This talk traces a meandering story of twenty years of invention, triumph and disaster, touching on theoretical physics, cloud computing, viral genetics, pandemic responses, and nearly dying in an NHS A&E queue. You'll pick up four generally applicable laws of complex systems, gain some superpowers for averting an apocalypse, and hopefully laugh a bit along the way. This isn't much of a technical talk and it is neither sanitised nor triumphant — expect sarcasm, most of all during the rough patches. My hope is that you'll leave seeing your own work differently, especially if it's quiet and unglamorous. Resilience is a property of systems, not their components, and it's the people who notice small changes and tend locally who make the biggest differences of all. europython-2026-100638-how-complex-systems-taught-me-to-fail Professional Development, Careers, Leadership Imogen Wright en false https://programme.europython.eu/europython-2026/talk/JZYBA3/ https://programme.europython.eu/europython-2026/talk/JZYBA3/feedback/ S1 Talk (long session) 2026-07-15T10:45:00+02:00 10:45 00:45 Free-threaded Python, the effort to remove the Global Interpreter Lock from CPython, is one of the biggest and most exciting changes to Python in many years. However, It can be hard to follow what that means, what effect it will have on you and your code, and how this isn't yet another Python 2 to 3 migration. This overview will explain what free-threading is, why it's a big deal, how it differs from other ways to deal with the GIL, and what the plan is for ensuring a smooth migration. We'll explain the basics of thread safety, data races, and concurrent designs, how those apply to Python code, and how this will and won't change when the GIL is disabled. And yes, we'll show some threads go _brrr_. Although we'll mention some complex, deeply technical problems, this is not a technical deep dive and any experience level is welcome. europython-2026-90914-free-threaded-python-past-present-and-future Python Core, Internals, Extensions Thomas Wouters en false https://programme.europython.eu/europython-2026/talk/Y8QAUA/ https://programme.europython.eu/europython-2026/talk/Y8QAUA/feedback/ S1 Talk 2026-07-15T11:40:00+02:00 11:40 00:30 Python 3.15's JIT is finally starting to see real speedups on benchmarks. Core to that is a revamped JIT optimizer. *What* the JIT selects to compile and *how* it optimizes code has seen significant improvements thanks to the work of many contributors. In this talk, I will cover in-depth how the Python JIT optimizes your Python code, and how this was an amazing community team effort spanning multiple continents. europython-2026-91364-inside-python-3-15-s-jit-optimizer Python Core, Internals, Extensions Ken Jin en false https://programme.europython.eu/europython-2026/talk/KRMBWS/ https://programme.europython.eu/europython-2026/talk/KRMBWS/feedback/ S1 Talk 2026-07-15T12:20:00+02:00 12:20 00:30 This talk is a follow-up to my EuroPython 2025 session on the foundations of the CPython JIT compiler. It looks at how the JIT has evolved since Python 3.14 and where it stands as Python 3.15 approaches release. We cover the transition of the JIT from an experimental feature towards a supported part of CPython, how it fits into the runtime today, and what that means in practice for users and distributors. The talk also explores how the JIT interacts with free-threaded builds, the current status of integration with external debuggers, and how these constraints shape real-world usage. Finally, we examine how the JIT performs today, where it already delivers substantial speedups, where it does not, and what realistic performance expectations look like for Python 3.15. europython-2026-90696-update-on-the-cpython-jit-what-to-expect-in-3-15 Python Core, Internals, Extensions Diego Russo en false https://programme.europython.eu/europython-2026/talk/W9NLXV/ https://programme.europython.eu/europython-2026/talk/W9NLXV/feedback/ S1 Talk 2026-07-15T13:50:00+02:00 13:50 00:30 AsyncIO was designed with the Global Interpreter Lock (GIL) in mind: the event loop runs all of your async in a single thread, regardless of the GIL presence. Projects like trio focused on better ergonomics, but with a noticeable disadvantage in performance. What if we can have both? In this talk we’ll explore an alternative approach to async code in Python, redesigning the whole thing from the ground up, looking at what it takes – spoiler: way less than you think – to have simpler interfaces and multi-threaded support from day zero in a single package: TonIO. europython-2026-90690-rethinking-asyncio-from-scratch-for-free-threaded-python Python Core, Internals, Extensions Giovanni Barillari en false https://programme.europython.eu/europython-2026/talk/US3W8J/ https://programme.europython.eu/europython-2026/talk/US3W8J/feedback/ S1 Talk 2026-07-15T14:30:00+02:00 14:30 00:30 Most developers interact with the CPython interpreter by writing code in the Python language and executing it with the bytecode interpreter. However, any native extensions and any code that runs alongside or embeds the interpreter needs to communicate with CPython via the CPython C API. This API corresponds to an application binary interface (ABI) that native code written in C, C++, Rust, Zig, or any other low-level programming language needs to use to directly interact with the CPython interpreter runtime. Understanding the ABI allows Python developers to make informed trade-offs when they distribute or depend on packages that contain native extensions. In this talk, I will explain what the CPython ABI is, how it differs from the CPython C API, and how it determines whether a package from PyPI is installable with a given installation of CPython. I will discuss how CPython's stable ABI and limited C API enable substantially reduced distribution overhead at the cost of some performance overhead. I'll show how maintainers of projects that distribute compiled code in binary wheels can choose to ship wheels using the stable ABI to trade off peak performance with ease of distribution and support for new platforms. I'll finish by explaining how the ABI is evolving to enable improvements like the free-threaded interpreter. I will share real-world experience of introducing the new free-threaded ABI to the community with the perspective available to a maintainer of open source projects that are core components of the Python ecosystem. Python 3.15 will enable a new stable ABI that allows distributing one extension per platform for any interpreter newer than Python 3.15. I'll describe work done by myself and others in the community to enable end-to-end testing of the next-generation stable ABI. europython-2026-90643-what-every-python-developer-should-know-about-the-cpython-abi Python Core, Internals, Extensions Nathan Goldbaum en false https://programme.europython.eu/europython-2026/talk/ENK9EF/ https://programme.europython.eu/europython-2026/talk/ENK9EF/feedback/ S1 Talk 2026-07-15T15:25:00+02:00 15:25 00:30 Python has become the most widely used language in scientific computing and data science due to its approachable syntax, vast ecosystem of libraries, and rapid prototyping capabilities. However, its interpreted nature often poses a performance bottleneck for computationally intensive tasks common in High Performance Computing (HPC) used in scientific and data work, such as large-scale simulations, complex data analysis, and machine learning model training. Enhancing Python's performance, therefore, is critical for scientific computing: it allows researchers and engineers to maintain the productivity and flexibility of the Python environment while achieving the necessary speed and scalability to tackle demanding, real-world HPC problems without needing to switch to lower-level languages entirely. In this talk, we will review the current state of Python in HPC, examine the role of key libraries like NumPy and Dask, and see how to use PyO3 to create robust Rust bindings for Python in a way that simplifies the process of building and distributing packages. We’ll explore how Rust brings specific advantages to HPC, including guaranteed memory safety without garbage collection, zero-cost abstractions, and true parallelism. Attendees will leave with a clear understanding of the 'why' and 'how' of leveraging Rust in their Python-based HPC workflows, positioning them to develop faster, safer, and more scalable computational code. europython-2026-91138-rust-for-high-performance-computing-hpc-in-python Jupyter and Scientific Python Cheuk Ting Ho en false https://programme.europython.eu/europython-2026/talk/WKBHZW/ https://programme.europython.eu/europython-2026/talk/WKBHZW/feedback/ S1 Talk 2026-07-15T16:05:00+02:00 16:05 00:30 September 2026, a month after Euro Python, the first wave of legal obligations for the EU Cyber Resilience Act (CRA) will wash over the software world. For us in the open-source community, CRA has been a source of major confusion, dilemma, and anxiety - 'Will my hobby project make me liable?' - 'Is my Python package "commercial activity"?' - 'Will PSF be liable for your code?' - 'Do I really need an SBOM for a Python library?' In this talk I, a lawyer, engineer, and FOSS alumni, will cut through the legal jargon to explain what the CRA actually is, why it exists, and how it changes the "manufacturer" relationship with open-source code. We will walk through the new legal roles—from Manufacturers to the newly defined "Stewards"—and provide a clear "To-Do and Not-To-Do" list for community maintainers. Whether you are a solo contributor or part of a major foundation, this session will help you navigate the 2026–2027 transition period with confidence. europython-2026-91611-demystifying-cra-for-the-community Ethics, Social Responsibility, Sustainability, Legal Anwesha Das en false https://programme.europython.eu/europython-2026/talk/Y3DGWB/ https://programme.europython.eu/europython-2026/talk/Y3DGWB/feedback/ S1 Keynote 2026-07-15T16:45:00+02:00 16:45 00:45 "TBD: Keynote Speaker" Details coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event. Our team is finalizing an exceptional speaker whose insights and vision will leave a lasting impression. Check back shortly for the full announcement, topic, and speaker biography. europython-2026-96939-keynote-2-placeholder en false https://programme.europython.eu/europython-2026/talk/PKMSSL/ https://programme.europython.eu/europython-2026/talk/PKMSSL/feedback/ S1 Announcements 2026-07-15T17:30:00+02:00 17:30 00:10 Join us for a special informative session as we celebrate EuroPython's 25th anniversary — a milestone worth marking together! We have some exciting surprises in store that you won't want to miss, so make sure to stick around after the keynote and be part of this memorable occasion. europython-2026-101788-europython-25th-anniversary en false https://programme.europython.eu/europython-2026/talk/G9QJBU/ https://programme.europython.eu/europython-2026/talk/G9QJBU/feedback/ S1 Announcements 2026-07-15T17:40:00+02:00 17:40 00:15 Join us for a fast, fun, and brain-twisting quiz all about Python, the tools, and the community. Test your knowledge, race against the clock, and compete with fellow EuroPython attendees for a shot at some awesome prizes. Whether you’re a seasoned developer or just love a good challenge, this showdown is your time to shine. europython-2026-97559-python-quiz en false https://programme.europython.eu/europython-2026/talk/FMNUSD/ https://programme.europython.eu/europython-2026/talk/FMNUSD/feedback/ S1 Lightning Talk 2026-07-15T17:55:00+02:00 17:55 00:45 Enjoy Wednesday's lightning talks! Short talks about everything by everyone. Lightning talks are 5 minute talks that anyone participating at the conference can submit. If that talk gets selected, you will have the chance to jump into the main stage and show us your project, your ideas, something you have learned, something you are proud of that's helping and contributing to our conference and community, or something else! Lightning talks last a maximum of 5 minutes. You can use less time, but not more. This time limit is strictly enforced! If you get accepted, you will be notified by email on the day of your talk by 1pm. Reply to the acceptance email by 3pm to confirm your spot. (If you don't, you lose your spot!) You can submit your lightning talk on this form: TBD Note that there's a limit of one submission per person. Community/conference announcement submissions are done through the same form before 1pm Thursday. europython-2026-97560-lightning-talks-wednesday en false https://programme.europython.eu/europython-2026/talk/PRFYJA/ https://programme.europython.eu/europython-2026/talk/PRFYJA/feedback/ S2 Talk (long session) 2026-07-15T10:45:00+02:00 10:45 00:45 The upcoming Python 3.15 keeps improving error messages, which will be the fourth out of the last five releases to establish this most recent tradition. Good errors help developers debug faster and keep beginners from giving up in frustration In this talk we go all the way back to 2008 and explore how error messages evolved from Python 3.0 to today. Along the way we will also go into what makes up a good error message and why they are often so hard to get right. We'll also touch on how academia and research let us down and why good errors remain an art more than an exact science. I will also talk about my personal experience and the ~~bad~~ _unfortunate_ error message I encountered during my first teaching job that fueled my passion for compiler and language development. Finally, I will also argue why you not only don't have to be a compiler engineer to contribute to python errors but why not being one might be an actual advantage. By the end, you will have learned what makes a good error message, how to spot a bad one and how to fix them. europython-2026-91718-how-cpythons-errors-keep-getting-better Python Core, Internals, Extensions Florian Freitag en false https://programme.europython.eu/europython-2026/talk/DWBGJ9/ https://programme.europython.eu/europython-2026/talk/DWBGJ9/feedback/ S2 Talk 2026-07-15T11:40:00+02:00 11:40 00:30 Programmers spend countless hours typing, yet we rarely question how keyboard design affects our comfort and productivity. Standard QWERTY layouts and one-size-fits-all hardware often contribute to strain and inefficiency. This talk explores how Python can help you design, build, and optimize your own custom keyboard; from analyzing your typing habits to generating the PCB. We start with a brief history of keyboard design and the limitations of QWERTY, then introduce alternative layouts (ortholinear, split, and more) and explain why they can reduce strain and improve speed. Next, we use Python to make data-driven decisions: we’ll look at scripts that analyze your codebases or IDE usage to find your most-used characters and symbols, so you can place keys where they matter most for your workflow and favorite languages. We then move on to PCB design with KidCad and GDSFactory, a Python-based tool for creating keyboard PCBs and exporting Gerber or GDS files for manufacturing. You’ll see how to arrange keys around your hand shape and generate production-ready files. After that, we cover basic assembly and programming your layout with open-source firmware. Finally, we discuss trade-offs: the benefits of a tailored setup (better posture, less finger travel, DIY satisfaction) it can also be a meaningful accessibility solution for users with special needs, limited mobility, or other conditions where standard keyboards become a uncomfortable or unusable. Some of the barriers (cost, time, learning a new layout), plus strategies for gradual adoption and practice tools. **What you will learn:** - Why keyboard layout and ergonomics matter for long-term comfort and productivity. - How to use Python to analyze your typing patterns and inform layout choices. - How to use KidCad or GDSFactory (Python) to design hardware and generate manufacturing files. - How to go from design to assembly and firmware, and how to ease the transition to a new layout. No prior experience with keyboard building or PCB design is required; just curiosity and a desire to create a custom typing experience. By the end, you’ll know how to question your current keyboard and how to start building your own with Python. europython-2026-91688-designing-and-building-custom-keyboards-with-python Python for Games, Art, Play and Expression Carlos A Aranibar en false https://programme.europython.eu/europython-2026/talk/CBA98V/ https://programme.europython.eu/europython-2026/talk/CBA98V/feedback/ S2 Talk 2026-07-15T12:20:00+02:00 12:20 00:30 <b>Graphs</b> offer a powerful tool for uncovering relationships and hidden patterns between entities. This presentation provides an introduction to <b>graph theory</b>, and demonstrates how graphs are applied across various business domains - from social network analysis and recommendation systems to fraud detection and supply chain optimization. Through an overview of core concepts and algorithmic approaches, the goal is to show how graphs can reveal underlying structures in complex systems. As a real-world case study, the presentation focuses on <b>Eurovision voting</b> - an area long suspected of regional bias and neighbourly favoritism. Using graph-based analysis and community detection techniques, we explore voting patterns between countries to better understand how geography, history, and politics influence the distribution of points. Through visualizations and data-driven insights, the talk demonstrates how graph theory uncovers hidden alliances and behavioral trends within the seemingly light-hearted spectacle of a music contest. europython-2026-89571-friendly-borders-graph-algorithms-reveal-eurovision-voting-patterns Data preparation and visualisation Domagoj Marić en false https://programme.europython.eu/europython-2026/talk/UPELCT/ https://programme.europython.eu/europython-2026/talk/UPELCT/feedback/ S2 Talk 2026-07-15T13:50:00+02:00 13:50 00:30 This talk shares my experience in my first ever role as a junior engineer after switching careers. I picked up a ticket involving tools and concepts I’d never used before (OpenTelemetry and Honeycomb), hoping to spend a day learning a bit about how we implement observability and monitoring of our Django app. Spoiler alert: it took three weeks of learning, debugging and asking for help to complete this work. I learned some valuable lessons along the way, not just technical stuff, but about how to problem-solve, collaborate effectively, and keep going in the face of *seemingly unending* challenges. Through this talk, I want junior engineers in the audience to know: - You can do difficult things, even if you think you lack the experience or knowledge required. If you’re willing to learn, and have a supportive team around you, you have everything you need. - Doing difficult things is daunting, but also incredibly rewarding. You often learn 10x more than you expected, and when you finally merge your work into main, it feels like winning the lottery. - Taking on hard things benefits the whole team—others might learn something new, or strengthen their own understanding by helping you out. - There’s a lot you can do to support yourself: reach out early, reach out often, and learn how to communicate problems clearly. - The value of your work cannot be measured by lines of code, it’s so much greater than that. This talk also offers a reminder to seniors, and leaders or managers, about how tough it can be to be new. Juniors don’t just lack experience, we don't know what we don't know and it's *really* easy (for others and ourselves!) to underestimate this. When things break or go wrong, we might not understand where or why, and even if we find a bug or an error, knowing how to fix it is another challenge altogether. I’ll share how my team’s support made all the difference, and offer some practical ideas for how others can support their junior colleagues, too. This isn’t a super technical talk. It’s more about the human experience of being a beginner, the value of persistence, why asking for help is a great thing to do, and the power of supportive teams; there's hopefully something useful and/or interesting in this for everyone. europython-2026-89608-why-doing-difficult-things-is-good-for-you-and-good-for-your-team Community Building, Education, Outreach Katie Bickford en false https://programme.europython.eu/europython-2026/talk/NWLBJC/ https://programme.europython.eu/europython-2026/talk/NWLBJC/feedback/ S2 Talk 2026-07-15T14:30:00+02:00 14:30 00:30 Are mathematics a reliable way to explain reality? Can we trust them? And more importantly: what role could Python play in such profound questions? Gödel’s Incompleteness Theorems are pillars of mathematics and computer science, revealing inherent limits in our ability to formalize truth and reason about the world. Their implications reach far beyond logic, touching philosophy, the foundations of computing, and the limits of machine reasoning. Despite their importance, understanding _why_ these results hold can feel inaccessible and abstract. In this talk, we tackle that difficulty directly. Python will be used not only as a programming language, but as a conceptual tool to understand Gödel’s First Incompleteness Theorem through algorithmic thinking. We will see how computational ideas make abstract concepts tangible, exploring the intellectual journey from Hilbert’s dream of a complete mathematics to the breakthroughs of Gödel, Church, and Turing. Through this lens, Python helps illuminate the boundaries of logic and computation, offering a new perspective on how mathematics works... and where its limits lie. europython-2026-91592-hacking-truth-python-and-the-limits-of-mathematics Community Building, Education, Outreach Miguel Ángel Fernández Gutiérrez en false https://programme.europython.eu/europython-2026/talk/8CDAWL/ https://programme.europython.eu/europython-2026/talk/8CDAWL/feedback/ S2 Talk 2026-07-15T15:25:00+02:00 15:25 00:30 Want to know what makes your data pipeline slow? How much memory does it use? In this talk, we'll guide you through the landscape of Python profilers – from classics like Scalene, py-spy and memray to newer tools like Tachyon and eBPF profiling – and show you how to choose the right one for your needs. We'll cover timing and memory profiling methodologies, compare tools across accuracy and overhead, walk through real usage examples, and explore continuous profiling. Whether you're optimizing a single script or debugging production systems, you'll leave with a practical framework for profiling smarter. europython-2026-91651-python-profiling-the-hitchhiker-s-guide-to-profiling Data Engineering and MLOps Jonathan Striebel en false https://programme.europython.eu/europython-2026/talk/CKXUGV/ https://programme.europython.eu/europython-2026/talk/CKXUGV/feedback/ S2 Talk 2026-07-15T16:05:00+02:00 16:05 00:30 For years, this real-time video system had no tests. Every change produced unpredictable side effects. Accuracy drifted. Production incidents and escalations followed. The only “verification” was manual inspection and hope. When I joined the project, this was the reality - and building a proper integration test suite became my first priority. In this talk, I’ll share how I designed and evolved the hardest integration test suite of my career using pytest - and kept it readable. The system processed live streams in production. It was non-deterministic. Individual detections were only 80–90% accurate. For testing, we replayed recorded scenarios to make system behavior observable and comparable across runs. But binary assertions were not enough. A single failed event did not mean the whole system was broken - but we needed a way to measure when it actually was. Instead of writing one massive test, I built a layered architecture: - dual parametrization - recording scope and event scope - orchestration in fixtures - assertions in tiny, single-purpose tests - statistics collection during execution - end-of-run aggregation that summarizes system accuracy The result was a suite that could detect regressions in model changes and produce reproducible evidence - HTML reports, structured dumps, and a summary statistics file. This talk explores how far pytest can be stretched beyond unit tests - into a framework for architecting complex integration systems. europython-2026-91588-the-hardest-test-suite-i-ever-built-a-pytest-case-study Testing, Quality Assurance, Security Grzegorz Kocjan en false https://programme.europython.eu/europython-2026/talk/TWBDVZ/ https://programme.europython.eu/europython-2026/talk/TWBDVZ/feedback/ S4 Talk (long session) 2026-07-15T10:45:00+02:00 10:45 00:45 Python systems rarely fail because of raw performance limits. They fail because the architecture does not scale with the team. As services grow, coordination overhead increases. Shared databases create implicit coupling. API contracts become political boundaries. Async workflows leak across domains. Meetings multiply to compensate for structural flaws. Instead of adding process, we should redesign architecture. This talk explores how Python system design directly determines team scalability. Using real-world backend systems built with FastAPI, asyncio, gRPC (grpcio), PostgreSQL, Redis, Docker, we will examine how architectural decisions shape organizational complexity. Topics include: • Domain boundaries in Python services and their impact on ownership • Database-per-service vs shared schemas • REST vs gRPC as team contracts • Monorepo vs polyrepo trade-offs in multi-service Python ecosystems • Contract testing and schema evolution • Observability as an interface between teams • Async workloads and cross-service backpressure • When microservices increase coordination cost instead of reducing it Rather than promoting a single architecture style, this session introduces a framework for evaluating whether a design reduces or amplifies team cognitive load. Attendees will leave with: • Criteria for defining service boundaries that align with ownership • Patterns for reducing cross-team friction through architectural design • Warning signs that architecture is becoming a coordination bottleneck • Practical techniques for evolving Python systems without multiplying process This talk is intended for experienced Python engineers, architects, and technical leaders responsible for systems that must scale both technically and organizationally. europython-2026-91517-scaling-python-systems-by-designing-team-aware-architecture Professional Development, Careers, Leadership Ivan Markeev en false https://programme.europython.eu/europython-2026/talk/QT97WA/ https://programme.europython.eu/europython-2026/talk/QT97WA/feedback/ S4 Sponsored 2026-07-15T12:20:00+02:00 12:20 00:30 When you write a Python library, you have a dilemma. Ship async-only? Ship blocking-only? Or write everything twice and watch both copies drift? [Synchronicity](https://github.com/modal-labs/synchronicity) removes this dilemma. Write your library once (in async) and get a blocking interface for free, while avoiding the boilerplate and limitations of `asyncio.run()` wrappers. We’ll talk through how to handle persistent connections, async generators, clean tracebacks, type hints and more. We've used it in production at Modal for years, and it's fully open source. We hope it can save you from writing your own library twice! europython-2026-100244-write-async-get-sync-for-free Tooling, Packaging, Developer Productivity Thom Lane en false https://programme.europython.eu/europython-2026/talk/D899EP/ https://programme.europython.eu/europython-2026/talk/D899EP/feedback/ S4 Talk 2026-07-15T13:50:00+02:00 13:50 00:30 Sometimes, one writes code to answer an important scientific question. On other occasions, code is developed with some economic interest in mind, legitimate or otherwise. And then there are situations where something else is going on. This work, which I call _June Gloom_, is just that: something else. Specifically, it is about producing pretty pictures, inspired by very real analog art and executed by using a somewhat abstract toy model for magnetism from statistical mechanics. In my presentation, I will show how we can use Monte Carlo techniques to perform physically accurate computer simulations. The results obtained from these simulations are then turned into both static as well as interactive visualizations using Matplotlib. europython-2026-91439-how-to-blend-python-physics-and-art-to-create-hopefully-pretty-pictures Python for Games, Art, Play and Expression Christian Leitold en false https://programme.europython.eu/europython-2026/talk/3HBWHB/ https://programme.europython.eu/europython-2026/talk/3HBWHB/feedback/ S4 Talk 2026-07-15T14:30:00+02:00 14:30 00:30 Have you ever merged a config file, applied an input that says "update only these fields", or handled an API payload, only to overwrite data because "missing", `None`, and "unset" were treated as the same thing? In real-world projects, "no value" has at least three meanings: - a missing key (the field is absent), - an explicit `None` (the value is present and intentionally null), - an unset input (the caller didn't specify the field, so you must not touch it). When we collapse these into `T | None` (a nullable type) or fall back to `dict[str, Any]`, type checking becomes noisy, branching becomes fragile, and refactors get risky. Every field nullable, every check defensive, every change scary. This is a practical talk about using typing to model and safely consume real-world data with `TypedDict` and `dataclasses`, not a typing tutorial or a framework pitch. We'll walk through one end-to-end example (payload -> normalization -> domain model -> safe updates) with before/after code and focus on patterns you can apply immediately: - Use `Required` / `NotRequired` to model missing keys instead of abusing `T | None`. - Use `T | None` only when `None` is a meaningful value. - Represent unset inputs with a sentinel pattern (starting from `UNSET = object()` and optionally evolving to `typing_extensions.Sentinel`) so partial updates don't silently overwrite data and the type checker can distinguish unset from `None`. - Keep extraction code honest with type aliases, `TypeIs`, and (optionally) small `match` cases for readability. After this session, you'll be able to define stricter data models, write safer extraction code, and make schema changes less painful, because your types will reflect what your data actually means. This talk is for intermediate Python developers who already use type hints in production. europython-2026-90791-beyond-optional-in-real-world-projects-missing-none-and-unset Python Core, Internals, Extensions Koudai Aono en false https://programme.europython.eu/europython-2026/talk/7VKQQM/ https://programme.europython.eu/europython-2026/talk/7VKQQM/feedback/ S4 Talk 2026-07-15T15:25:00+02:00 15:25 00:30 *Pitch* With DuckDB and DuckLake, managing and analyzing huge data sets is no longer limited to complex cloud infrastructure setups. You can literally run these tasks on your notebook now and at comparable speeds. This talk will show you how. *Description* **DuckDB** is an embedded relational analytics database (OLAP) which can be added to a Python project with a simple `uv add duckdb` or `pip install duckdb`. It is both fast and powerful for processing analytical data warehouse workloads, using the well-known PostgreSQL SQL dialect. Data can be stored in memory and persisted on disk. DuckDB is well integrated with Polars via zero copy Apache Arrow data structures, making it a great choice for complex data science and engineering tasks. **DuckLake** is a extension which comes with DuckDB to add data lake features, meaning that huge data sets can be managed using Parquet files stored on disk or in an object store such as S3. It uses a novel approach to data lakes in that the management structures are stored in a database (DuckDB), instead of complex file and directory structures, as many other data lake systems do. This provides great advantages for implementing smart features such as snapshots, schema evolution or time travel. Again, installation of the extension is just a simple `INSTALL ducklake` command away, making this a really easy way to configure your own personal "lake house" - the ideal combination of a data warehouse with a data lake. The talk will give a short introduction to the database terminology, explain what is novel about the DuckLake approach and then showcase a typical use case for lake houses: storing historical weather data and making this available for analytics to Python applications. Both DuckDB and DuckLake are MIT licensed. *Resources:* - [Python.org](https://www.python.org/) - [DuckDB – An in-process SQL OLAP database management system](https://duckdb.org/) - [DuckLake is an integrated data lake and catalog format – DuckLake](https://ducklake.select/) europython-2026-90763-ducklake-take-python-and-duckdb-for-a-swim-in-your-data-lake Data Engineering and MLOps Marc-André Lemburg en false https://programme.europython.eu/europython-2026/talk/H7KGU3/ https://programme.europython.eu/europython-2026/talk/H7KGU3/feedback/ S4 Talk 2026-07-15T16:05:00+02:00 16:05 00:30 Modern data systems rarely stay unchanged. Schemas evolve, search indices are rebuilt, and for some period of time, multiple versions of the same dataset need to be kept in sync. A typical example is a zero-downtime migration, where several versions of the same data must be synchronised in parallel while the system remains live. This creates a subtle but important challenge: how to keep each version consistent without duplicating extraction work or increasing database load. In this talk, I’ll describe a production ETL architecture built in Python that processes multiple data versions in parallel using a single streaming pipeline. The system synchronises data from PostgreSQL into OpenSearch, keeps each version independently consistent, and guarantees that no version ever moves backwards — while querying the database only once per batch. The talk is based on a real production system and explains the design decisions and tradeoffs behind it. The design is based on generator pipelines and functional composition using the functools module. Instead of relying on threads or async frameworks, the ETL flow is expressed as a sequence of small, composable functions: page extraction, DTO normalisation, version-aware filtering, transformation, bulk loading, and dead-letter handling. The reference implementation uses Django as the ORM layer and Celery for orchestration, but the core design is not framework-specific and can be applied equally with SQLAlchemy or raw SQL. I’ll show how this design makes it possible to: 1. Synchronise multiple versions efficiently without duplicate database queries 2. Process large datasets in a streaming, memory-efficient way 3. Build extensible pipelines from protocol-defined functional stages 4. Maintain a clear separation of concerns with strong typing and isolated tests 5. handle failures safely using bulk retries and dead-letter queues Attendees will leave with concrete patterns for building fast and maintainable ETL pipelines in Python, and with a clearer understanding of how generators and functional composition can be used to model complex data flows — borrowing ideas from Go-style concurrency while staying entirely within the Python ecosystem. While the examples focus on ETL pipelines, the patterns discussed apply to any Python system that processes large streams of data and needs to balance performance, correctness, and extensibility. Audience: Intermediate to advanced Python developers. Familiarity with generators and basic ETL concepts is helpful; interest in functional design patterns and backend data systems will be beneficial. europython-2026-91007-fast-multi-version-etl-pipelines-in-python-with-generators-and-functools Data Engineering and MLOps Nikita Smirnov en false https://programme.europython.eu/europython-2026/talk/JEN7WA/ https://programme.europython.eu/europython-2026/talk/JEN7WA/feedback/ S3A Talk (long session) 2026-07-15T10:45:00+02:00 10:45 00:45 Open source software (OSS) is today an integral part of software solutions and the software industry as a whole. However, it is often the case that not all parts of an organization are equally familiar with the OSS ecosystem and the specific licenses upon which it relies. Since this ecosystem is built on intellectual property, discussions about using OSS, patching existing OSS projects, or publishing one's own software as an OSS project inevitably involve conversations with the legal department at some point. In this talk, we will discuss some of the fundamentals of intellectual property, OSS licenses, how lawyers tend to think about software in general, and how to convince them that OSS is a good idea. europython-2026-90692-how-to-talk-with-your-legal-department-about-open-source Ethics, Social Responsibility, Sustainability, Legal Vladimir Slavov en false https://programme.europython.eu/europython-2026/talk/9EFAJS/ https://programme.europython.eu/europython-2026/talk/9EFAJS/feedback/ S3A Talk 2026-07-15T11:40:00+02:00 11:40 00:30 A few nights ago I was up to 2am obsessively crafting an LLM plan. (_"Just one more prompt!"_ - famous last words). Yet it still did something inexplicably stupid. 🫠 So yeah: LLMs are both genuinely useful and genuinely destabilising. Focusing on the first and ignoring the second is how people burn out. This talk is an honest account of what it feels like to be a developer right now, from someone inside it, and some thoughts on what might actually help. My thesis: we've been optimising for _model output_ when we need to be optimising for _human experience_. I'll share observations from my work, peers and colleagues. The peculiar fatigue of machine supervision: holding the intent in your head while the machine generates volumes of mostly-correct output that still needs your eyes, your judgment, and your taste. The way the satisfying part of the work shrank while the exhausting part grew. The isolation of pair-programming with a machine, and the loss of real human learning, interconnection and collaboration. And underneath all of it: uncertainty. About market conditions, about employability, about whether the skills we've spent years building will still matter. The second half is about what's been working for me, and what hasn't. On the human side: encouraging pairing and teamwork even when the tools push you toward isolation, sharing the pain openly, naming the uncomfortable thing. On the technical side: structuring your environment to collaborate with LLMs more deliberately — writing plans, configuring project-specific rules. Learning when to stop prompting and just write code. And critically: rebalancing the push and pull of information so that you're directing your attention, not feeling at the mercy of the model's output. More Star Trek, less Black Mirror. Leave with concrete strategies for recalibrating your workflow, challenges to discuss and the reassurance that if you're finding this hard, you're not broken. The feedback loop is. And we can start fixing that. europython-2026-91546-the-human-in-the-loop-is-tired Professional Development, Careers, Leadership Laura Summers en false https://programme.europython.eu/europython-2026/talk/HJ8KPY/ https://programme.europython.eu/europython-2026/talk/HJ8KPY/feedback/ S3A Talk 2026-07-15T12:20:00+02:00 12:20 00:30 As engineers grow in their careers, many of us try to support our teams by writing more code, reviewing every pull request, and stepping in to fix the hardest problems. It feels helpful and responsible. Over time though, this approach can unintentionally create too much dependency on one person. This talk explores the shift from being the person who solves everything to becoming someone who helps the whole team succeed. Drawing from lessons learned through experience(often the hard way :)) and from colleagues and mentors along the way, I will share practical shifts that make a difference: creating clearer technical direction, improving design conversations, sharing context early, mentoring thoughtfully and building systems that reduce reliance on any single “hero.” If you are a mid or senior engineer who is always busy but still feels that too much depends on you, this talk aims to offer useful ideas for your own journey. europython-2026-91169-from-code-hero-to-team-leader-learning-to-let-go Professional Development, Careers, Leadership Manivannan Selvaraj en false https://programme.europython.eu/europython-2026/talk/WHHAQK/ https://programme.europython.eu/europython-2026/talk/WHHAQK/feedback/ S3A Panel 2026-07-15T13:50:00+02:00 13:50 01:00 In this one-hour panel session, AI experts will explore the rapidly evolving impact of these technologies on our society. The discussion will address pressing questions across key domains being transformed by AI: privacy and regulation, environmental implications, economic and labor shifts, and the impact of AI on media and art. Beyond hearing insightful perspectives from our panelists, you'll have the opportunity to submit your own questions throughout the session. Whether you're an AI enthusiast, industry professional, or simply curious about how these technologies will shape our world, join us to find out more about this complex area and have your burning questions answered. europython-2026-101792-ai-discussion-panel en false https://programme.europython.eu/europython-2026/talk/N9HKQN/ https://programme.europython.eu/europython-2026/talk/N9HKQN/feedback/ S3A Talk 2026-07-15T15:25:00+02:00 15:25 00:30 APIs development start simple, feel fast, and ship quickly. Then the API grows: more endpoints, more traffic, more data, and suddenly performance becomes unpredictable. Latency creeps in, async code blocks without anyone noticing, and every new feature feels a little riskier to add. This talk is about building Python APIs that stay fast *as they evolve*. We’ll look at where performance issues really come from in real-world APIs: request lifecycle overhead, hidden blocking calls, dependency injection costs, serialization, and poorly scoped middleware. Instead of chasing micro-optimizations or benchmark numbers, we’ll focus on design decisions that make performance predictable. Using Litestar as a concrete example, you’ll see how explicit control over routing, dependencies, and async execution helps avoid common performance traps. We’ll walk through realistic API patterns and show how to structure handlers and dependencies so performance problems don’t slowly accumulate. You’ll leave with practical techniques you can apply immediately, whether you’re building a new API or maintaining one in production. Even if you don’t use Litestar today, the design principles in this talk will help you reason more clearly about performance in any Python API. europython-2026-89072-designing-performant-apis-with-litestar Web Development, Web APIs, Front-End Integration Julien CourtèsCody Fincher en false https://programme.europython.eu/europython-2026/talk/ZRWENU/ https://programme.europython.eu/europython-2026/talk/ZRWENU/feedback/ S3A Talk 2026-07-15T16:05:00+02:00 16:05 00:30 Say you've built a library whose main value is providing built-in integrations with a considerable number (say 60+) of different Python packages. That's cool, and your users are loving the out-of-the-box experience. (Being blissfully unaware of the lengths you had to go to in the background to make things work "seamlessly" helps.) Everything seems to be working fine, you get the odd bug report or feature request, the usual. Then one day you wake up and your otherwise fairly chill issue tracker is drowning in folks experiencing an issue with your library that breaks their app. Your first thought is, why is this coming up now, when your last release was two weeks ago? And then you realize: It's not your release that broke the library. All the third party code you're integrating with? It's become *your* code by extension. You need to react if something changes upstream and breaks your integration in unexpected ways. You can write your integrations so defensively that no one will ever want to read them again, but it's not enough: you can't anticipate every single change each of the 60+ packages will ever make. Let's assume having your users act as a release monitoring system by notifying you on your issue tracker is not what you want. How do you go about this? You'll want somehow to detect breakage early, so you can go fix things before your users are hit by them. And ideally you'd do it in a way that maintaining it is not a nightmare. This talk will take you through one such journey, from recognizing the problem, to various attempts at making it better, to eventually arriving at a solution that's good enough for now (tm). You might like this talk if you: - Have to deal with integrations in some shape or form - Are relying on third-party packages heavily - Don't like maintaining things by hand - Like to have that "this can be automated with a script" itch scratched - Are intrigued that there's a talk that has the word "bananas" in the title europython-2026-89563-how-to-maintain-60-integrations-and-not-go-bananas Testing, Quality Assurance, Security Ivana Kellyer en false https://programme.europython.eu/europython-2026/talk/H7DVRJ/ https://programme.europython.eu/europython-2026/talk/H7DVRJ/feedback/ S3B Talk (long session) 2026-07-15T10:45:00+02:00 10:45 00:45 In 2023, PyPI started supporting Trusted Publishers: A way to publish Python packages to PyPI without relying on insecure password and short-lived tokens. Three years later, this approach has become the default answer to package registries' security, as it found its way into NPM, crates.io, and RubyGems. But does it actually offer the benefits we hoped it would? Can you really trust the green checkmark, and if you can't, what's the point? In this talk, I want to look closely at what Trusted Publishers are, and what we _might_ think they are; who they do and do not protect. We'll explore the potential centralization problem of relying on Big Tech, US-based CI providers, leaving little room for smaller players like Codeberg and Sourcehut, as well as self-hosted Git forges and CI engines. But even when using GitHub, Trusted Publisher may be tricky to get right, exposing different backdoors for the attacker to exploit. I want to discuss the illusion of security Trusted Publishers may give the inexperienced PyPI user; that is, if they actually decide to look at the hidden details of the published artifacts. How can we safeguard our Python projects, and should it be us who safeguards it? I will propose some solutions to this issue, including how the package managers and the PyPI registry itself can help us in this task. Lastly, we'll reminisce about the past in search of answer. Maybe OpenPGP ‘Web of Trust’ wasn't such a bad idea after all? Can we regain our independence in deciding who we do and don't trust? europython-2026-91603-should-you-trust-trusted-publishing Testing, Quality Assurance, Security Nikita Karamov en false https://programme.europython.eu/europython-2026/talk/M8Q77Z/ https://programme.europython.eu/europython-2026/talk/M8Q77Z/feedback/ S3B Talk 2026-07-15T11:40:00+02:00 11:40 00:30 **Space Weather** doesn’t just produce beautiful auroras: it can silently disrupt navigation systems, radio links, and satellite-based technologies we rely on every day. Travelling Ionospheric Disturbances (TIDs) are wave-like structures in the ionosphere that affect GNSS accuracy and HF communications. From an ML perspective, forecasting TIDs is a challenging rare-event prediction problem involving imbalanced data and heterogeneous physical inputs. In this talk, I will present an operational machine learning approach developed within the T-FORS project to forecast TID occurrence over Europe. The model is built using **CatBoost** and integrates data from space- and ground-based observations. The talk focuses on **model design and evaluation choices**. In particular, I will show how **SHAP** can be used to debug model behaviour, validate feature relevance, and build trust in predictions in a high-risk operational context. Along the way, I’ll share practical engineering lessons on: - handling class imbalance, - incorporating domain knowledge into ML pipelines, - producing **uncertainty-aware outputs** via **Conformal Prediction**, and - running **interpretable models in real-time forecasting systems**. The talk is aimed at data scientists and ML practitioners interested in applied forecasting, interpretable models, uncertainty quantification and ML at the boundary between data and physics. --- **Talk outline** - 0-4: What is Space Weather and why should we care - 4-7: Framing TID forecasting as an ML problem - 7-10: Model design with CatBoost - 10-13: Explainability with SHAP - 13-18: Uncertainty quantification with Conformal Prediction - 18-22: Cost-sensitive learning and real-time operations - 22-25: Lessons learned - 25-30: Q&A europython-2026-90735-when-the-sun-breaks-your-gps-building-an-explainable-early-warning-system Machine Learning: Research & Applications Vincenzo Ventriglia en false https://programme.europython.eu/europython-2026/talk/VXDYGX/ https://programme.europython.eu/europython-2026/talk/VXDYGX/feedback/ S3B Talk 2026-07-15T12:20:00+02:00 12:20 00:30 The [website](https://hypothesis.works) of the Hypothesis project used to boldly assert: *"Normal 'automated' software testing is surprisingly manual. Every scenario the computer runs, someone had to write by hand. Hypothesis can fix this."* While it's debatable whether property-based testing should fully replace the manual parametrization of tests with different inputs and outputs, there's no doubt that Hypothesis is a powerful tool for uncovering bugs nobody would even have considered looking for. In fact, during its development, the authors of Hypothesis accidentally discovered countless bugs in CPython and libraries, thus coining the term *"The Curse of Hypothesis"*. The framework, although incredibly powerful, might seem overwhelming at first. In this talk, I will demonstrate how even simply throwing random strings at functions can reveal surprising bugs. From there, we'll progress towards generating more complex data, which will be less daunting than it initially appears. You'll also see how Hypothesis seamlessly integrates with various ecosystems and can be a valuable tool in any developer's toolkit. europython-2026-89705-property-based-testing-with-hypothesis Testing, Quality Assurance, Security Freya Bruhin en false https://programme.europython.eu/europython-2026/talk/NEH7RE/ https://programme.europython.eu/europython-2026/talk/NEH7RE/feedback/ S3B Talk 2026-07-15T13:50:00+02:00 13:50 00:30 # Python and HTTP/3: feel the difference in performance ## Abstract Building real-time Python applications, from live dashboards to multiplayer games, often feels like a battle against an invisible lag. While we focus on optimizing our async code, the underlying transport protocol often sabotages us: `TCP` guarantees ordering at the absolute cost of responsiveness. In this session, I will show that the standard choice of using Websocket over `HTTP/1.1` or `HTTP/2` can make the application perform horribly, due to the "head-of-line blocking" problem that is visible when the network is unstable. Then I will present how `HTTP/3` and `WebTransport` eliminate transport-layer bottlenecks and enable seamless connection migration for network switching users. The audience will experience the difference between protocols performance firsthand through a live three-round multiplayer snake game demo. ## Description ### The Problem Application performance is a complex challenge. Users often complain about lag, and regardless of how well we optimize our business logic, the issue persists. All too often, the blame is shifted to the client for having a "spotty network." However, even under ideal conditions, users experience disruptions simply by being mobile, due to switching between Wi-Fi access points or cellular towers. The core problem is that many developers are unaware of the limitations of `HTTP/1.1` and `HTTP/2`, or that implementing `HTTP/3` might be a solution. ### Why This is Interesting to the Python Community As Python applications become more real-time and data-intensive, traditional networking stacks are reaching their limits. There are important advances in technology that the audience should get familiar with, like `HTTP/3`, `QUIC`, and `WebTransport`. What is also important, is to be aware of how the Python ecosystem is still fragmented when it comes to supporting `HTTP/3`. Despite that, a solution is achievable, and by using a combination of `Starlette` and `aioquic` code across three generations of transport protocols, the audience will experience and learn how protocol choice dictates application reliability on imperfect networks. ### Key takeaways: - Witness an app suffering from transport-layer head-of-line blocking. - Understand the Python `HTTP/3` ecosystem, including `aioquic`, `Hypercorn`, and `Starlette`. - Deploy a `HTTP/3` server handling `WebTransport` datagrams for real-time data. - Learn how to use Linux traffic control (`tc`) to inject some chaos to the network - Play multiplayer Snake! europython-2026-91384-python-and-http-3-feel-the-difference-in-performance Web Development, Web APIs, Front-End Integration Daniel Vahla en false Game demo screenshot https://programme.europython.eu/europython-2026/talk/DRXC3E/ https://programme.europython.eu/europython-2026/talk/DRXC3E/feedback/ S3B Talk 2026-07-15T14:30:00+02:00 14:30 00:30 Conventions are one of Django’s greatest strengths. They simplify our day-to-day work, reduce cognitive load, and let teams move fast with confidence. By following well-established defaults, we spend less time debating structure and more time solving real problems. But every convention is also a decision - and every decision has trade-offs. Who decided these conventions? Why were they chosen? And what happens when your problem doesn’t quite fit the “Django way”? In this talk, we’ll explore Django’s conventions as both a feature and a constraint. We’ll look at where they shine, where they leak, and how experienced developers can respectfully bend (or break) them without fighting the framework. This is a talk for anyone who loves Django — especially when they disagree with it. europython-2026-90676-i-am-a-sucker-for-conventions-why-django-s-defaults-work-until-they-don-t Web Development, Web APIs, Front-End Integration David Vaz en false https://programme.europython.eu/europython-2026/talk/HVTSPC/ https://programme.europython.eu/europython-2026/talk/HVTSPC/feedback/ S3B Talk 2026-07-15T15:25:00+02:00 15:25 00:30 This talk is one part technology dance and one part walk through of Python environment best practices. In under 30 minutes, you'll see me load up some of the most gnarly environments and watch them fail. This isn't just another talk about dependency management. It's about the hidden cost of environment friction: the cognitive load, the lost spoons, the brilliant developers who almost quit tech because they felt "too stupid" to make pip work. It's about recognizing that setup barriers aren't just inconvenient—they're accessibility barriers that determine who gets to write Python. In this talk we'll cover: - Several environment failures (with dramatic audience participation): GPU-enabled errors, OS errors, mounted systems, CI/CD and virtual environments - The human side of technical frustration: spoon theory, burnout - Patterns about how environments break - What the Python community is doing to lower these barriers. Content note: This talk discusses mental health, burnout, and the emotional impact of technical barriers with care and intention. europython-2026-91599-how-many-spoons-does-your-environment-cost-broken-demos-human-element Tooling, Packaging, Developer Productivity Dawn Wages en false https://programme.europython.eu/europython-2026/talk/PCMBVT/ https://programme.europython.eu/europython-2026/talk/PCMBVT/feedback/ S3B Talk 2026-07-15T16:05:00+02:00 16:05 00:30 Most developers have to interact with databases at some point, and therefore need to know at least a little bit about them, but probably don't have much training or experience in that area. I've worked with databases for over 25 years because I love them so much, but I'm aware that most people don't feel the same way! As a Python developer, you probably just want the database to quietly do its thing in the background so you can concentrate on coding. That seems like a reasonable request. But the world of databases is changing. The traditional DBA role is becoming less common, and developers are increasingly expected to manage their own databases. So let's talk about what you actually need to know about databases. You should come away reassured that, although it helps to have a smattering of database knowledge, you don't need to be a database expert. We'll explore the minimum that you *do* need to know, and look at where you can find more information or help when you need it. I don't expect to turn everyone into a database enthusiast, but I hope I can share some of my love of databases with you along the way. europython-2026-91663-how-much-do-you-really-need-to-know-about-databases ~ None of these topics Karen Jex en false https://programme.europython.eu/europython-2026/talk/X3ENDU/ https://programme.europython.eu/europython-2026/talk/X3ENDU/feedback/ Poster Hall A Poster 2026-07-15T12:50:00+02:00 12:50 01:00 This poster will take you on a tour of the 20 functions available in the module `itertools`, showing you how they work, how they interact with each other, and how they relate to each other. By the time you're done reading the poster, you'll have an increased understanding of how to use the module `itertools` efficiently and effectively. europython-2026-88675-a-tour-of-the-module-itertools Python Core, Internals, Extensions Rodrigo Girão Serrão en false https://programme.europython.eu/europython-2026/talk/PRGGNW/ https://programme.europython.eu/europython-2026/talk/PRGGNW/feedback/ Poster Hall B Poster 2026-07-15T12:50:00+02:00 12:50 01:00 Most Django testing tutorials stop at "write a test, make it pass, refactor." But real-world Django applications have complex model relationships, permission systems, third-party API integrations, and asynchronous task chains that demand more sophisticated testing strategies. After delivering a hands-on TDD workshop at DjangoCon US 2023 and applying these patterns across multiple production Django codebases, I've identified a set of recurring testing patterns and anti-patterns that significantly impact both test reliability and developer productivity. This poster presents a visual field guide to practical TDD patterns in Django, organized as a decision-tree poster that developers can reference when writing tests for their own projects. **Section 1 — The Factory Pattern Taxonomy.** A visual decision tree for choosing the right `factory_boy` strategy based on your model structure. When to use `SubFactory` vs. `RelatedFactory` vs. `LazyAttribute` for foreign keys, how to handle circular relationships without creating test data explosions, and the `create` vs. `build` vs. `build_batch` decision that controls whether you hit the database. Annotated with `faker` provider selection for generating realistic test data that keeps test failure messages readable. **Section 2 — Testing Permission Layers Without Drowning in Fixtures.** Django apps often have three or more permission layers: model-level, view-level, and object-level (via packages like `django-guardian` or row-level security). This section shows a visual matrix for structuring permission tests: one axis for user roles, one for resources, and a clear pattern for generating all combinations using parameterized tests with `pytest.mark.parametrize` and factory traits. Instead of writing 30 separate test functions, you write one parameterized test with a role-resource matrix. **Section 3 — The Mock Boundary Diagram.** A flowchart showing where to place mocking boundaries in a Django request lifecycle. The poster illustrates the difference between mocking at the view level, the service layer, and the adapter/client level — and why mocking too deep creates brittle tests while mocking too shallow creates slow ones. Includes a decision rule: "Mock at the boundary where your code meets code you don't own." **Section 4 — Common Anti-Patterns and Fixes.** A visual rogues' gallery of the five most common Django testing anti-patterns with before/after code comparisons: test database leaks from missing `TransactionTestCase`, over-mocking that tests implementation instead of behavior, fixture files that nobody can maintain, test ordering dependencies, and the "God factory" that creates half the database for every test. Visitors will gain a practical decision framework for structuring Django tests, rather than just knowledge of individual testing tools. The patterns are tool-agnostic at their core (though examples use `pytest-django`, `factory_boy`, and `faker`) and apply to any Django project. europython-2026-91607-django-tdd-patterns-a-visual-field-guide Testing, Quality Assurance, Security Kuldeep Pisda en false https://programme.europython.eu/europython-2026/talk/LNVDY3/ https://programme.europython.eu/europython-2026/talk/LNVDY3/feedback/ Poster Hall C Poster 2026-07-15T12:50:00+02:00 12:50 01:00 IIoT Networks' performance is significantly impacted by packet losses in the network, which is the failure of data packets in reaching their intended destination within the network. Most of the transmission control protocol versions reduce the rate of transmission during the detection of packet losses, assuming network congestion and interference, thus resulting in operational disruption, reduced efficiency, data integrity failure and economic impact. However, not all packet losses are due to congestions and interference, some happen based on link issues from wireless which are seen as non-congestive packet losses as most transmission control protocol (TCP) modifications reduce the rate of transmission when these losses are detected while assuming network congestion, so TCP could not at present distinguish among these types of packet losses and reduces the rate of transmission irrespective of the types thus resulting in lower throughput for IIoT networks clients. In addressing this issue, a heuristic-rule-based machine learning model was used for packet loss identification, classification, and prediction to differentiate between the types of packet losses at the IIoT network hosts’ end. The result shows that Random Forest performs better based on the rule, giving a hopeful resolution to an enhanced IIoT network's performance. europython-2026-90066-heuristic-rule-based-model-for-packet-loss-inference-in-iiot-networks Machine Learning: Research & Applications Oladapo Kayode Abiodun en false https://programme.europython.eu/europython-2026/talk/33RGZA/ https://programme.europython.eu/europython-2026/talk/33RGZA/feedback/ S1 Announcements 2026-07-16T08:00:00+02:00 08:00 01:00 Welcome to EuroPython 2026! Please notice the registration will happen on the TBD. You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday! We hope to see you around! europython-2026-97550-thursday-registration-welcome-tbd en false https://programme.europython.eu/europython-2026/talk/QDCP3K/ https://programme.europython.eu/europython-2026/talk/QDCP3K/feedback/ S1 Announcements 2026-07-16T09:00:00+02:00 09:00 00:15 Welcome to the second day of conference! Yesterday was an amazing day, but for sure you don't remember all the things that were mentioned during the opening. Join us to get an update and few more announcements. Come by and find out what is going to happen today. europython-2026-97551-thursday-s-morning-announcement en false https://programme.europython.eu/europython-2026/talk/DSHNXM/ https://programme.europython.eu/europython-2026/talk/DSHNXM/feedback/ S1 Keynote 2026-07-16T09:20:00+02:00 09:20 00:45 Python now powers nearly half of all new AI repositories (State of the Octoverse Report 2025.) It is the most used language for Applied AI work, from training and inference to orchestration and deployment. Regardless of its popularity in the space, AI has caused a significant divide within the Python community. Many Pythonistas believe it should not be used at all, while others are excited about its potential to increase their output. As developers, we also find ourselves reluctantly at the frontier, being told our jobs are at risk, while simultaneously being pushed to use AI to make us more productive. In this talk we'll explore all of these themes and try to understand the 'right way' to do AI. europython-2026-100189-the-pursuit-of-purity-the-right-way-to-do-ai ~ None of these topics Marlene Mhangami en false https://programme.europython.eu/europython-2026/talk/PEJ9RY/ https://programme.europython.eu/europython-2026/talk/PEJ9RY/feedback/ S1 Panel 2026-07-16T10:05:00+02:00 10:05 00:25 The Python Steering Council is a 5-person elected committee that assumes a mandate to maintain the quality and stability of the Python language and CPython interpreter, improve the contributor experience, formalize and maintain a relationship between the Python core team and the PSF, establish decision making processes for Python Enhancement Proposals, seek consensus among contributors and the Python core team, and resolve decisions and disputes in decision making among the language. europython-2026-100641-python-steering-council-update Python Core, Internals, Extensions en false https://programme.europython.eu/europython-2026/talk/YUGHSW/ https://programme.europython.eu/europython-2026/talk/YUGHSW/feedback/ S1 Talk (long session) 2026-07-16T10:50:00+02:00 10:50 00:45 Should you use Kafka or RabbitMQ? Which Python library is the right fit? Is Celery still alive and kicking in 2026, or has Temporal taken over the world while we weren't watching? Perhaps we should all migrate to FastStream—or are the native background tasks in your web framework all you really need? There have never been so many possibilities when choosing how to queue and distribute work. This talk provides a comprehensive comparison of the modern Python ecosystem. We will explore where each tool shines, how they perform under pressure, and—crucially—when a specific tool is a poor match and should be avoided. Using two real-world case studies, we will showcase the capabilities of each library. You will be able to evaluate the developer experience and how debugging works for each solution. You’ll walk out with an ultimate decision chart, equipped to choose the perfect stack for your next project. europython-2026-91042-navigating-waters-of-background-jobs-and-queues-in-python-as-of-2026 Web Development, Web APIs, Front-End Integration Sebastian Buczyński en false https://programme.europython.eu/europython-2026/talk/TZHTEE/ https://programme.europython.eu/europython-2026/talk/TZHTEE/feedback/ S1 Talk 2026-07-16T11:45:00+02:00 11:45 00:30 From default args, to `**kwargs`, and everything in-between, Python's comprehensive argument system lends itself to some of the most effective code, through encouraging readability, reuse, and easy refactoring. But is that really true? Why, and why not? What could we learn from other languages? And what else could lie in their future? --- In this session, we'll give a rundown of Python's comprehensive function argument system and how its features allow for safety, conciseness, and expressiveness (whether you're calling or writing functions). We'll then give examples for where that system lacks, where it could bite you, and give suggestions for what more could be done on Python code to fix those limitations. europython-2026-90788-args-amazing-or-approaching Tooling, Packaging, Developer Productivity Evan Kohilas en false https://programme.europython.eu/europython-2026/talk/G9FDRY/ https://programme.europython.eu/europython-2026/talk/G9FDRY/feedback/ S1 Talk 2026-07-16T12:25:00+02:00 12:25 00:30 Python supports parallelism through multiple sub-interpreters. Parallelism though sub-interpreters avoid the restrictions of a single GIL, and isolating parallel processes from each other is safe from data-races. The downside is that subinterpreter isolation comes with a high cost: sending objects across sub-interpreters typically involves pickling and copying which has negative impact on performance with both CPU and memory overheads. This talk is about [PEP795](https://pep-previews--4468.org.readthedocs.build/pep-0795/) which adds immutability to Python, which permits sub-interpreters to transfer and share immutable objects directly by reference. We will present the design and rationale for immutability in Python, the API for creating and managing immutable state, decorators for communicating immutability in code, as well as opting out of immutability where necessary. We will also discuss our prototype implementation on-top of Python 3.15, and demonstrate how immutable sharing across sub-interpreters improves performance, and compare the speed of freezing (the act of making objects immutable) to pickling and unpickling. Attendees will learn: * About the semantics of immutability in Python, and what are the challenges of designing immutability to support sharing across sub-interpreters. * When immutability can improve performance and predictability in concurrent Python. * How freezing works for built-in types, user‑defined types and functions, and how it interacts with sub-interpreters. * Performance of pickling vs. immutable sharing, with numbers and failure modes. * Current limitations of immutability, risks, and what would need to land in CPython for this to be widely usable. Target audience: programmers interested in concurrent programming in Python. Note: This PEP is not yet accepted; the talk focuses on design, prototype results, and open questions. europython-2026-91116-immutability-fast-and-safe-sharing-of-data-across-subinterpreters Python Core, Internals, Extensions Fridtjof StoldtTobias Wrigstad en false https://programme.europython.eu/europython-2026/talk/GEJAQW/ https://programme.europython.eu/europython-2026/talk/GEJAQW/feedback/ S1 Talk 2026-07-16T13:05:00+02:00 13:05 00:30 Python dicts are everywhere! They back module namespaces, instance attributes, **kwargs, and of course actual dictionaries. But have you ever wondered how they work under the hood? And more importantly, what happens to them now that free-threaded Python is here? In this talk, we'll start by exploring the internals of CPython's dict implementation: how hashing works, the compact table layout that gives you insertion order, and how lookups, insertions, and deletions actually play out in memory. Then we'll see what had to change for free-threading: how reads remain fast without acquiring locks, what the per-object lock is and when it kicks in, and why making a dict thread-safe is harder than it sounds. Finally, we'll look at the ongoing effort to document CPython's thread-safety guarantees for built-in types and what the resulting documentation means for a Python developer writing concurrent code. The audience will leave with a deep understanding of how Python's most important data structure works, how it's been adapted for a free-threaded world, and what they can (or can't) safely do with dicts across threads. europython-2026-91444-python-dicts-past-present-and-free-threaded-future Python Core, Internals, Extensions Lysandros Nikolaou en false https://programme.europython.eu/europython-2026/talk/VKURLV/ https://programme.europython.eu/europython-2026/talk/VKURLV/feedback/ S1 Talk 2026-07-16T14:30:00+02:00 14:30 00:30 In July 2025, PyPI users received emails directing them to pypj.org—a near-perfect clone transparently proxying requests to pypi.org. Within hours, attackers compromised four accounts and uploaded malicious releases of the popular num2words package. This talk dissects the complete attack chain: how attackers harvested email addresses from public package metadata, built a transparent proxy that relayed TOTP codes in real-time, and why traditional 2FA failed while WebAuthn-based authentication stopped the attack cold. The session covers the incident response timeline, challenges getting malicious infrastructure taken down (including initial rejection of abuse reports), and defensive measures deployed afterward—including new email verification for TOTP logins from unrecognized devices. Attendees will learn exactly how modern phishing attacks work against package repositories, the critical difference between "phishable" and "phishing-resistant" 2FA, and practical steps to protect accounts and packages from the next campaign. The talk also examines the September 2025 follow-up campaign targeting pypi-mirror.org and patterns across these ongoing attacks. europython-2026-90769-anatomy-of-a-phishing-campaign Testing, Quality Assurance, Security Mike Fiedler en false https://programme.europython.eu/europython-2026/talk/NXNHSB/ https://programme.europython.eu/europython-2026/talk/NXNHSB/feedback/ S1 Talk 2026-07-16T15:10:00+02:00 15:10 00:30 The Python Packaging Index or PyPI, is used by over a million users. But what is behind the scenes of PyPI? PyPI is currently powered by Warehouse, a software built using Pyramid, a Python web framework. This talk explores Pyramid through the lens of a beginner’s mindset and will lead the audience through the ins and outs of this Python web framework, its utility, and why it still holds its own and stands strong (like a pyramid!) among other comparable web frameworks. europython-2026-90952-climbing-the-pyramid-behind-the-scenes-of-the-python-package-index Web Development, Web APIs, Front-End Integration Maria Ashna en false https://programme.europython.eu/europython-2026/talk/TAZHCD/ https://programme.europython.eu/europython-2026/talk/TAZHCD/feedback/ S1 Talk 2026-07-16T16:00:00+02:00 16:00 00:30 The CPython runtime is some of the most-used software in the world. Part of maintaining a secure software project like CPython is participating in coordinated vulnerability disclosure (CVD). This process allows security researchers and maintainers of projects to work together to fix vulnerabilities and alert the public, keeping all Python programmers and users safe. In this talk attendees will learn about how the Python language organizes its security team, how to balance security and open source contribution in coordinated vulnerability disclosure, and the latest in how open source projects can maintain a sustainable vulnerability disclosure program. Attendees that aren’t currently contributing to open source projects, but have an interest in their dependencies being secure, will learn ways they can contribute meaningfully to the security of open source projects they depend on. europython-2026-89990-learning-from-the-not-so-secret-python-security-cabal Testing, Quality Assurance, Security Seth Michael Larson en false https://programme.europython.eu/europython-2026/talk/9JALSN/ https://programme.europython.eu/europython-2026/talk/9JALSN/feedback/ S1 Keynote 2026-07-16T16:40:00+02:00 16:40 00:45 "TBD: Keynote Speaker" Details coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event. Our team is finalizing an exceptional speaker whose insights and vision will leave a lasting impression. Check back shortly for the full announcement, topic, and speaker biography. europython-2026-96941-keynote-4-placeholder en false https://programme.europython.eu/europython-2026/talk/BDUAKE/ https://programme.europython.eu/europython-2026/talk/BDUAKE/feedback/ S1 Lightning Talk 2026-07-16T17:25:00+02:00 17:25 00:45 Enjoy Thursday's lightning talks! A series of short community/conference announcements followed by short talks about everything by everyone. Lightning talks are 5 minute talks that anyone participating at the conference can submit. If that talk gets selected, you will have the chance to jump into the main stage and show us your project, your ideas, something you have learned, something you are proud of that's helping and contributing to our conference and community, or something else! Lightning talks last a maximum of 5 minutes. You can use less time, but not more. This time limit is strictly enforced! If you get accepted, you will be notified by email on the day of your talk by 1pm. Reply to the acceptance email by 3pm to confirm your spot. (If you don't, you lose your spot!) You can submit your lightning talk on this form: TBD Note that there's a limit of one submission per person. Community/conference announcement submissions are done through the same form before 1pm Thursday. europython-2026-97553-lightning-talks-thursday en false https://programme.europython.eu/europython-2026/talk/DJU8GK/ https://programme.europython.eu/europython-2026/talk/DJU8GK/feedback/ S2 Talk (long session) 2026-07-16T10:50:00+02:00 10:50 00:45 Some codebases let you ship a change in minutes. Others turn a one-line fix into weeks of investigation. The difference is often not skill, tooling, or even architecture—it’s cognitive load. In this talk, we’ll look at real examples from long-lived Python systems to understand how inheritance, deep nesting, excessive abstraction, microservices, and over-applied DRY silently increase the cost of change. You’ll learn practical heuristics to recognize high cognitive load early and concrete strategies to reduce it—so your team can move faster without rewriting everything. This is a pragmatic engineering talk for developers who work in real production code, not greenfield demos. europython-2026-91610-the-hidden-cost-of-complexity-reducing-cognitive-load-in-python Tooling, Packaging, Developer Productivity Jarosław Śmietanka en false https://programme.europython.eu/europython-2026/talk/UGM7F8/ https://programme.europython.eu/europython-2026/talk/UGM7F8/feedback/ S2 Talk 2026-07-16T11:45:00+02:00 11:45 00:30 Due to climate change, **large wildfires** continue affecting all continents of the Earth, leading to forest loss and exacerbating environmental impacts. Even more, current changing weather conditions associated with global warming will further increase fire danger to a global extent. Investigating these phenomena in a data-driven manner helps in decision making in pre-intervention and post-restoration following wildfire events. **Satellites** orbiting Earth can offer critical insights by capturing detailed images of the planet’s surface. Utilizing this data, environmental scientists perform detailed assessments to monitor an ecosystem’s loss and post-restoration progress. However, data from satellites arrive in the form of millions of raw pixels and turning them into analysis ready products is a **time-consuming** task full of **multi-step** and **error-prone** processes. This talk introduces an end-to-end Python workflow to automate the processing of **Earth Observation (EO) data**. The presentation walks through pixels to insights showcasing a real example and highlighting both the power of automation in the field of remote sensing and the importance of EO data in **climate change monitoring**. After the session, the audience will understand how utilizing open Python packages such as **Rasterio** and **NumPy** with openly distributed data from the [European Space Agency’s Sentinel-2 mission](https://dataspace.copernicus.eu/data-collections/copernicus-sentinel-missions/sentinel-2) can lead us quickly into crucial and spatially meaningful information. Although the demonstration focuses on wildfire events, the automated workflow is broadly applicable to other environmental fields such as land cover change detection, hydrological assessments and coastal studies. **No prior knowledge is required**! The **goal** is not to delve into complex mathematical equations, but to showcase the power of automation in remote sensing with Python. europython-2026-89197-from-pixels-to-insights-python-for-earth-observation Jupyter and Scientific Python ELENI TOKMAKTSI en false https://programme.europython.eu/europython-2026/talk/DWGSFA/ https://programme.europython.eu/europython-2026/talk/DWGSFA/feedback/ S2 Talk 2026-07-16T12:25:00+02:00 12:25 00:30 This talk explores how **Python games can run entirely in the browser using WebAssembly (WASM)** and how they can also be **written and modified directly in the browser using Python itself**. Rather than treating the browser as a mere deployment target, this talk presents it as the **primary learning environment**. Learners interact with a browser-embedded code editor where they write Python code that directly controls and modifies a game, which is also implemented in Python. This creates a zero-install, highly interactive learning experience where Python concepts are introduced through familiar game mechanics instead of traditional REPLs or slide-based instruction. The focus of this talk is **not on building a game engine**, but on how **educators and instructors** can leverage **WASM to safely run Python in the browser for teaching purposes**. The talk introduces a tool I built that enables instructors to design browser-based Python tutorials using common game concepts such as scenery, sprites, and swatches, making it easier to create engaging, game-driven learning content. The talk covers: - How Python can be executed in the browser using WebAssembly - A comparison of **Pyodide vs. pyscript**, highlighting their benefits and limitations in educational contexts - How browser-based execution changes assumptions around security, isolation, and infrastructure In the latter part of the talk, this approach is packaged as an **XBlock**, the modular unit used to build courses in **Open edX**. This demonstrates how WASM-based Python execution can be integrated into large-scale learning platforms and how it compares to traditional server-side execution models such as **CodeJail**, highlighting improvements in safety, reduced infrastructure complexity, and an improved learner experience. **WebAssembly enables a new class of interactive, game-based Python learning experiences** that run securely and entirely in the browser, without requiring local setup or server-side code execution. europython-2026-91463-python-games-in-the-browser-teaching-with-webassembly Community Building, Education, Outreach Farhaan Bukhsh en false https://programme.europython.eu/europython-2026/talk/LN7EF3/ https://programme.europython.eu/europython-2026/talk/LN7EF3/feedback/ S2 Talk 2026-07-16T13:05:00+02:00 13:05 00:30 Your smart home is a wireless network of connected devices which all talk to each other by sending messages into a central hub. If you control the hub's messaging queue, you can control and monitor the network and even create your own custom devices that end up visible in services like Apple or Google Home. In this talk I will show you what it takes to create such a custom device using an affordable ESP32 microcontroller running MicroPython. We'll briefly look at the capabilities of the ESP32 family and why it is a good choice for WiFi-enabled projects. We'll talk about the tooling that makes development a pleasure, from flashing firmware to interacting with the board using WebREPL, installing lightweight dependencies with mip, testing, logging, and more. We will also discuss the MQTT protocol, how our custom devices can send and receive messages, how to integrate third-party Zigbee devices, and how to use Home Assistant as a bridge between our MQTT server and Apple or Google Home. We'll see how to use the Mosquitto broker and client tools such as paho.mqtt and how Zigbee2MQTT allows remote sensors to join the same messaging layer. My goal is to give a practical overview of the hardware and software pieces involved: ESP32, MicroPython tooling, MQTT infrastructure, Zigbee integration, and Home Assistant bridging. If you are comfortable with Python and curious about embedded systems, this talk is for you. europython-2026-91351-building-a-smart-home-device-with-micropython IoT, Embedded Systems, Hardware Integration Michał Karzyński en false https://programme.europython.eu/europython-2026/talk/BMQP7J/ https://programme.europython.eu/europython-2026/talk/BMQP7J/feedback/ S2 Panel 2026-07-16T14:30:00+02:00 14:30 01:00 Python has been evolving very rapidly in the last few years, and this is because new ideas have been taking over the Core Development. New ideas require new people, a new background and lots of energy. This panel aims for the people to be aware of the changes that are coming in 3.15 and future versions, as well as ways people can contribute by testing features, fixing issues, or even sharing their own ideas. * Hosts: TBD * Panelists: * TBD europython-2026-101791-cpython-panel Python Core, Internals, Extensions en false https://programme.europython.eu/europython-2026/talk/GRCJRZ/ https://programme.europython.eu/europython-2026/talk/GRCJRZ/feedback/ S2 Talk 2026-07-16T16:00:00+02:00 16:00 00:30 Package manifests like `pyproject.toml` record source-level dependencies: _pandas_ depends on _numpy_'s code. The story is different for binary dependencies, which exist whenever compiled code, like C code, is called from Python. _numpy_ depends on _OpenBLAS_'s binaries, but this dependency relationship is not recorded anywhere. This makes _OpenBLAS_ a _[phantom](https://www.endorlabs.com/learn/dependency-resolution-in-python-beware-the-phantom-dependency) binary dependency_. Phantom dependencies are therefore hidden from programmers and researchers, which is bad for at least two reasons. First, security. If one of your binary dependencies has a vulnerability, this means your project is probably also vulnerable — but you won't reliably find out about this, since your dependency is invisible. Secondly, sustainability. If we can't keep track of our binary dependencies, we can't keep track of their maintainers either, which means we can't credit and [financially support](https://opensourcepledge.com/) them. This can lead to [maintainer burnout](https://opensourcepledge.com/blog/burnout-in-open-source-a-structural-problem-we-can-fix-together/), which has already created serious supply chain issues. Python is not only tremendously popular, but also valued for its ability to easily interface with compiled libraries. According to my research, around 20% of Python packages have binary dependencies. This means that the problem of phantom binary dependencies is widespread, and puts the public at risk of harm, eg if critical infrastructure like hospitals or transportation is compromised by exploiting the aforementioned weaknesses. I aim to describe how the problem of phantom binary dependencies can be fixed within the Python ecosystem, and demo some of my preliminary work. First, binary dependencies must be identified. Tools like _[auditwheel](https://github.com/pypa/auditwheel/)_ and _[elfdeps](https://github.com/python-wheel-build/elfdeps/)_ are able to identify a project's [required dynamic libraries](https://vlad.website/how-binary-dependencies-work/). If we create better APIs for these tools, and integrate them with package managers such as _pip_ and _uv_, we can give developers and researchers visibility into binary dependencies, dispelling the phantom. Beyond this, standards like [PEP 725](https://peps.python.org/pep-0725/), [PEP 770](https://peps.python.org/pep-0770/) and [PEP 804](https://peps.python.org/pep-0804/) specify how we might record binary dependency relationships in an easily accessible way. I'll explain how we can build on these standards to create tools that will allow users and researchers to explore binary dependencies and identify security issues by default. Lastly, I want to talk about the road towards the ultimate aim of having binary dependencies be managed not by Python package managers, but by system package managers, as they should be. This will require interoperation between package managers, and I'll explain how this might work. europython-2026-91516-binary-dependencies-identifying-the-hidden-packages-we-all-depend-on Tooling, Packaging, Developer Productivity Vlad-Stefan Harbuz en false https://programme.europython.eu/europython-2026/talk/UY9UAG/ https://programme.europython.eu/europython-2026/talk/UY9UAG/feedback/ S4 Talk (long session) 2026-07-16T10:50:00+02:00 10:50 00:45 This is the real story about the design, benchmark, tuning and operation of a 24x7 multi-tenant network monitoring platform, that started out at only 1 packet/second, but then with the power of Python it scaled to 1 million packet/second. It is like an high performance version of ICMP ping and mtr/traceroute, supports dualstack IP v4/v6, and runs 24x7 on a set of probing nodes distributed Worldwide. Each ICMP packet needs to be scheduled, crafted, sent, analyzed and stored for query in near-time. To make things harder, the probing platform has been designed and tuned to use the least amount of resources as CPU, memory and storage, in order to run on cheap burstable cloud instances. Python is used everywhere: packet scheduling, generate randomized ICMP packets, send them via RAW sockets, and match results from probing. Probing results are then pushed to ClickHouse in near-time, and visualized via Grafana. And rest assured that every packet counts. Some of the concept explored during the talk: - ICMP protocol, BGP protocol, routing table - ping, mtr/traceroute - RAW socket in Python, crafting ICMP packets - tcpdump, PCAP dump file - msgpack, zstd compression - object storage - Apache Parquet as optimized data storage format - near-time batch and streaming data workflow - performance profiling and tuning - Python vs PyPy performance comparison - monitoring of the monitor: probing node performance monitoring europython-2026-90755-from-one-to-1-million-packet-second-scaling-global-internet-monitoring DevOps, Cloud, Scalable Infrastructure Marco Grossi en false https://programme.europython.eu/europython-2026/talk/788XZA/ https://programme.europython.eu/europython-2026/talk/788XZA/feedback/ S4 Talk 2026-07-16T11:45:00+02:00 11:45 00:30 Deploying machine learning models should be predictable, repeatable, and auditable—not a leap of faith. This talk breaks the deployment lifecycle into clear, actionable steps and demonstrates pragmatic choices for containerization, serverless and platform-based deployments, monitoring, and scaling. It also introduces the Model Context Protocol MCP as a practical pattern for giving deployed models secure, auditable access to external data and tools. Attendees will leave with concrete patterns, a checklist to avoid common pitfalls, and reproducible workflows they can apply the next day to move models from experimentation into reliable production services. europython-2026-91619-no-more-it-works-on-my-notebook-from-notebook-to-production-ready-model DevOps, Cloud, Scalable Infrastructure Ariane Djeupang en false https://programme.europython.eu/europython-2026/talk/RC7ALD/ https://programme.europython.eu/europython-2026/talk/RC7ALD/feedback/ S4 Talk 2026-07-16T12:25:00+02:00 12:25 00:30 Production has a special talent for turning “seems fine” into “why is everything on fire?” — usually because we’re missing signals. A service restarts and never becomes ready, a background worker silently stops consuming tasks, or a database gets overloaded and latency creeps up until downstream services (or customers) notice it first. These situations aren’t unsolvable — they’re preventable with the right signals in place. I’ve seen how stressful this gets when a system is already in production, but there’s no clear guidance or shared “where to look first” playbook; so every incident starts with guesswork. Over time, we turned those lessons into a lightweight standard that replaces panic mode with a predictable investigation flow. In this talk, I’ll share a practical, vendor-agnostic observability checklist for a Python setup with three cooperating workloads: an HTTP API, an event-driven worker, and a scheduled daily job. Each workload fails differently, so each requires a different set of signals to stay observable. We’ll cover what “good enough” looks like for logging, metrics, tracing, and alerting: what to instrument first, what pitfalls to avoid, and how to design alerts that catch problems early without creating noise. You’ll leave with a concrete checklist and a phased rollout order you can apply to your own Python services — without rewriting your system or committing to a specific monitoring vendor. ## **Takeaways** - A baseline observability checklist every service should have: health/readiness, logging with consistent context, core metrics, and alert routing - Workload-specific signals: what to watch in APIs vs background workers vs scheduled jobs, and why one size doesn’t fit all - Structured logging that works in production: a minimal event schema + contextual fields that speed up debugging - Must-have alerts that prevent silent failures: service never becomes ready, worker stalls, scheduled job misses its run, sustained latency increase - Where tracing adds value: when it’s worth the effort, what “minimal viable tracing” looks like, and what’s optional at the beginning - A rollout sequence you can apply incrementally: what to do first, what to add later europython-2026-90882-stop-firefighting-practical-observability-for-python-apis-workers-jobs DevOps, Cloud, Scalable Infrastructure Daria Korsakova en false https://programme.europython.eu/europython-2026/talk/9MRVPM/ https://programme.europython.eu/europython-2026/talk/9MRVPM/feedback/ S4 Talk 2026-07-16T13:05:00+02:00 13:05 00:30 Artificial intelligence has become deeply embedded in modern Python development workflows. From generating backend services to refactoring production systems, large language models now influence how software is designed, implemented, and shipped. While these tools offer significant productivity gains, many teams are discovering a less visible cost: code is increasingly produced faster than architectural decisions can be reviewed, validated, and governed. In real production environments, particularly those built on distributed services, data pipelines, and cloud infrastructure, unstructured AI-driven development often leads to predictable outcomes. Teams encounter rising defect rates, fragile integrations, unclear system ownership, security regressions, and access control mistakes introduced by AI-generated code. Over time, these issues surface as service outages, compliance risks, lost clients, and escalating maintenance costs. The problem is not AI itself, but the absence of engineering structure around how it is used. This talk examines why unsupervised “vibe coding” fails at scale and how development teams can adopt a disciplined, AI-assisted development model that improves both velocity and reliability. Drawing from real-world backend systems, I will present practical techniques for embedding AI across the Software Development Life Cycle — including structured design inputs, architecture validation, automated reviews, testing strategies, and continuous quality controls. To ground the discussion in reality, the session includes a concrete production case study from a rapidly developed, AI-assisted Python system. Starting from access to a single project, I was able to traverse service boundaries and gain visibility into multiple cloud environments and internal repositories across both AWS and GCP. The root cause was not a single vulnerability, but a chain of small, AI-generated decisions: overly broad permissions, copied infrastructure patterns, missing ownership boundaries, and unreviewed assumptions propagated across services. The result was a system that appeared to move quickly, but ultimately required emergency remediation, delayed releases, and loss of trust. The talk concludes by addressing a common misconception: a 50% increase in coding speed does not translate into 50% faster product delivery. Without governance, the opposite is often true. The session is aimed at Python developers, technical leads, and architects responsible for production systems. Familiarity with Python backend development is recommended, but no prior experience with AI tooling is required. europython-2026-91376-the-hidden-cost-of-vibe-coding Community Building, Education, Outreach Sebastian Burzyński en false https://programme.europython.eu/europython-2026/talk/MJTZ7A/ https://programme.europython.eu/europython-2026/talk/MJTZ7A/feedback/ S4 Talk 2026-07-16T14:30:00+02:00 14:30 00:30 We deployed Python in serverless environments and quickly saw the performance limits. Serverless systems suffer from startup latency, memory overhead, and repeated object creation as their executions start almost from scratch. Those extra seconds made our user experience painfully slow—and we couldn’t afford it. We looked into the performance of our flight search engine, ran profilers, and applied optimizations. We found real gains when **tuning Python’s GC**, reducing **stop-the-world pauses**, and introducing an **asynchronous post-execution process** that runs after the handler returns. We reduced execution time from **1.2 seconds to 300 milliseconds—a 4× speedup** with just a few tweaks. Understanding **Python’s memory model** and its runtime behavior was essential, and it’s something we’ll dive into during the talk. What we share is based on **AWS Lambda**, but it can be applied to any short-lived Python system—whether serverless or containerized. Another big gain came from replacing `Pydantic` with `TypedDict` for faster parsing, using **Redis** strategically to distribute operations, and restructuring code to eliminate duplicated transformations. Our web API processes thousands of flight offers—deserialize, enrich, transform—and every millisecond counts. While covering optimization techniques, when they matter, and how we measured their impact, the main idea is that you will walk away with tactics that help your system stay fast while it grows. europython-2026-88756-python-on-serverless-strategies-for-peak-performance DevOps, Cloud, Scalable Infrastructure Alejandro Cabello Jiménez en false https://programme.europython.eu/europython-2026/talk/PPQ3KE/ https://programme.europython.eu/europython-2026/talk/PPQ3KE/feedback/ S4 Talk 2026-07-16T15:10:00+02:00 15:10 00:30 What holds open source together when the code is done? Recent research paints a worrying picture: 58% of open source maintainers have considered stepping back, and over two-thirds of OSS work is non-code labor: conflict mediation, mentoring, documentation, governance, and emotional labor.Most of it unpaid, invisible, and unrewarded. These pressures are disproportionately carried by community leads and underrepresented contributors. As open source scales across companies, foundations, and global teams, outdated governance models built to manage code is today being asked to manage humans, and they’re failing or buckling under the weight of human complexity. We continue to optimise for commits while ignoring emotional load, collaboration friction, and psychological safety, the very factors that determine sustainability. I’ve lived this tension as a Service Delivery Manager and community leader. I’ve helped build and sustain communities, but I’ve also reached the point of emotional exhaustion, questioning whether my unseen contributions mattered at all. This talk argues that ignoring emotional labor is no longer neutral , it is actively harmful. We’ll explore how modern governance approaches, supported by AI-driven tooling such as sentiment analysis, workload dashboards, and governance bots, can surface invisible work, distribute responsibility more fairly, and prevent burnout before it becomes exit.If open source is to survive its own success, we must start treating its human systems with the same rigor as its technical ones. europython-2026-91575-the-unseen-pull-request-the-crisis-we-don-t-measure Community Building, Education, Outreach Lokko Joyce Dzifa en false https://programme.europython.eu/europython-2026/talk/NS8QQA/ https://programme.europython.eu/europython-2026/talk/NS8QQA/feedback/ S3A Talk (long session) 2026-07-16T10:50:00+02:00 10:50 00:45 Scaling an application to a global audience often hits a bottleneck: the manual translation of thousands of strings. While machine translation exists, developers need a reliable way to integrate it into their codebases without breaking JSON structures or losing placeholders. In this talk, we will explore a streamlined workflow to optimize the localization (l10n) process using Python and the DeepL API. We will walk through a real-world journey of transforming a single-language platform into a multi-language product, focusing on: The Localization Workflow: Designing a pipeline that extracts, translates, and reintegrates content automatically. Structure Preservation: Strategies to handle nested JSON files and complex data structures, ensuring that keys and code logic remain untouched while values are translated. Variable & Context Integrity: How to protect placeholders and dynamic segments (like {count} or {date}) so they survive the translation process intact. Automated Batch Processing: Using Python scripts to iterate through entire project directories, enabling the translation of multiple files in a single execution. Attendees will learn how to build a robust localization engine that acts as a "first draft" generator, allowing developers to focus on validating quality rather than managing strings. europython-2026-91700-localization-made-easy-a-pythonic-approach-to-global-applications Web Development, Web APIs, Front-End Integration Mario García en false https://programme.europython.eu/europython-2026/talk/ETBPVR/ https://programme.europython.eu/europython-2026/talk/ETBPVR/feedback/ S3A Talk 2026-07-16T11:45:00+02:00 11:45 00:30 GPUs power almost every modern Python workload in machine learning, vision, and scientific computing. Yet most Python developers treat GPUs like “faster CPUs” and hope frameworks will handle performance automatically. That mental model is wrong and it is the main reason Python GPU code underperforms by orders of magnitude. This introductory talk builds the correct mental model for writing fast GPU code in Python. We will explore how modern GPUs are structured, why global memory dominates execution time, and how to determine whether a kernel is compute-bound or memory-bound using the roofline model. Through concrete examples, attendees will see why naive parallel kernels fail to scale and which hardware-aware patterns; tiling, data reuse, and kernel fusion actually lead to speedups. The session concludes with a practical look at how Python can express these ideas using Triton, showing how high-level code is compiled into PTX and how Python can approach near-CUDA performance when it respects hardware constraints. europython-2026-91576-an-introduction-to-writing-fast-gpu-code-in-python Machine Learning: Research & Applications Abhik Sarkar en false https://programme.europython.eu/europython-2026/talk/JQSQBB/ https://programme.europython.eu/europython-2026/talk/JQSQBB/feedback/ S3A Talk 2026-07-16T12:25:00+02:00 12:25 00:30 GPU programming can be scary, but doesn't need to be! Did you know you can access the full performance of CUDA purely in Python? With the full CUDA Python stack, you have a friendly interface to get you started with GPU acceleration. In this example-driven talk, we'll begin with a general discussion of the CUDA model and how to manage accelerator devices in Python with cuda.core. Next, we'll teach you how to create arrays and launch work with CuPy. Then, you'll learn how to customize parallel algorithms with cuda.compute and write your own kernels that leverage cooperative algorithms with cuda.coop, and integrate seamlessly with accelerated libraries such as cuBLAS and cuDNN. We'll look at a variety of parallel examples, from counting words, to implementing softmax and row-wise reductions. By the time the talk is over, you'll be ready to start accelerating your Python code with GPUs! europython-2026-91569-gpu-programming-in-pure-python ~ None of these topics Bryce Adelstein Lelbach en false https://programme.europython.eu/europython-2026/talk/JSLSHM/ https://programme.europython.eu/europython-2026/talk/JSLSHM/feedback/ S3A Talk 2026-07-16T13:05:00+02:00 13:05 00:30 In tech, it’s easy to get caught up in ego. Chasing the smartest solutions, writing the most complex code, or proving who’s the best in the room. But Python has a funny way of humbling us. Its simplicity reminds us that good code isn’t about showing off; it’s about making things clear, accessible, and collaborative. This talk is about what happens after that sting of humility. Python doesn’t just strip away ego, it builds communities that make you feel proud to belong. I’ll share stories from my journey with Black Python Devs and other Python groups, showing how people from all walks of life come together, support one another, and create space for growth. By the end, you’ll see that the real magic of Python isn’t just the language. It’s the people, the openness, and the sense of pride that comes from being part of something bigger than yourself. europython-2026-98198-python-stings-your-ego-finding-pride-in-community-not-just-code Community Building, Education, Outreach Emmanuel Ugwu en false https://programme.europython.eu/europython-2026/talk/FB93DB/ https://programme.europython.eu/europython-2026/talk/FB93DB/feedback/ S3A Talk 2026-07-16T14:30:00+02:00 14:30 00:30 Developing a single drug takes 12 years with only a 12% chance of success. AI is changing this dramatically: the first AI designed drug have reached human trials, Alphafold won a Nobel Prize and pharmaceutical companies have committed billions to AI partnerships. The best part? The Python ecosystem you already know is powering this revolution. This talk introduces AI drug discovery to Python developers with no biology or chemistry background required. We'll start with the key insight that makes this field accessible: molecules are data structures, proteins are strings, and drug target binding is just API matching. Through a demo, attendees will see how to represent and visualize molecules with RDKit, convert chemical structures into ML ready vectors, predict drug properties like toxicity and solubility using graph neural networks with DeepChem and predict 3D protein structures in seconds using the ESMFold API. europython-2026-91667-from-molecules-to-models-a-guide-to-ai-drug-discovery-with-python Machine Learning: Research & Applications Jenny Vega en false https://programme.europython.eu/europython-2026/talk/VNR377/ https://programme.europython.eu/europython-2026/talk/VNR377/feedback/ S3A Talk 2026-07-16T15:10:00+02:00 15:10 00:30 Nobody likes a slow application or a website. Not only can it frustrate your users, but it can also directly affect your business metrics, such as conversion rates. Without proper care, your application can easily slow down as your project grows. One of the most common sources of slowdowns is your database. Django ORM makes it easy to work with databases, but it also makes it easy to forget how to use it properly. In this talk, you will learn how to measure and diagnose database operations in your Django app, fix common issues, and leverage your database engine's features to unleash its full potential. We will cover topics such as N+1 queries, creating and using database views from Django, database indices and EXPLAINing queries (I’ll keep it easy to understand, I promise!). While the session focuses on Django apps, most of the topics also apply to SQLAlchemy and other libraries. After the talk, you will know how to diagnose database query performance and have a good understanding of how to fix common performance bottlenecks. You’ll need basic knowledge of the Django ORM or a similar tool like SQLAlchemy, as well as general database concepts. europython-2026-91115-faster-django-orm-queries-for-everybody Web Development, Web APIs, Front-End Integration Jan Smitka en false https://programme.europython.eu/europython-2026/talk/BFK3JK/ https://programme.europython.eu/europython-2026/talk/BFK3JK/feedback/ S3A Talk 2026-07-16T16:00:00+02:00 16:00 00:30 Pyodide is a CPython distribution for JavaScript runtimes. It powers browser-based CPython environments like PyScript, Jupyterlite, and Marimo. Pyodide uses the Emscripten compiler to compile CPython to JavaScript + WebAssembly. Since the fall of 2024, Emscripten has been a tier 3 supported platform of CPython. We will give demos showing how Pyodide is used in a variety of applications such as interactive notebooks, client side computing, safe code execution for AI, and edge computing. We will describe our work to standardize the Pyodide ecosystem: * to upstream most of the Pyodide runtime into CPython, and * to allow Pyodide-compatible packages to be uploaded to PyPI. We will also describe our long goals for the ecosystem. We will discuss recent progress in closing the large gap between the performance of the Python interpreter on WebAssembly and the performance on native platforms. europython-2026-91081-python-everywhere-the-state-of-python-on-webassembly Python Core, Internals, Extensions Hood ChathamGyeongjae Choi en false https://programme.europython.eu/europython-2026/talk/QHFXXA/ https://programme.europython.eu/europython-2026/talk/QHFXXA/feedback/ S3B Talk (long session) 2026-07-16T10:50:00+02:00 10:50 00:45 OpenAI's embedding API is the default for most Python RAG applications, but it creates real problems at scale: data privacy (every document leaves your network), cost (per-token pricing compounds fast), no customization (cannot fine-tune or swap models), and no quality validation. Most teams have never measured whether text-embedding-3-large actually works well for their domain. Open embedding models like BGE-M3, GTE-Qwen2, and E5 now match or beat OpenAI on MTEB benchmarks. The problem is not model quality anymore, it is infrastructure: running these models with proper batching, memory management, and quality assurance. This talk walks through a practical migration. We start from a typical LangChain app calling OpenAI, switch to self-hosted open models using SIE (an open-source inference server with an OpenAI-compatible endpoint), validate that retrieval quality is maintained using MTEB, and then go beyond what OpenAI offers by adding sparse embeddings for keyword, recall, and cross-encoder reranking for precision. The talk is aimed at Python developers who currently use OpenAI embeddings and models and want to understand their options. No prior experience with model serving is required. europython-2026-91383-self-hosted-small-models-from-openai-lock-in-to-open-models Machine Learning, NLP and CV Filip Makraduli en false https://programme.europython.eu/europython-2026/talk/CWBA3L/ https://programme.europython.eu/europython-2026/talk/CWBA3L/feedback/ S3B Talk 2026-07-16T11:45:00+02:00 11:45 00:30 Deploying a Python web app is deeply confusing for newcomers, but it doesn't have to be! In this talk, I'll provide an overview of the entire process, with visuals and code, to demystify it and share hard-won lessons along the way. We will start with a high-level overview of the architecture underpinning deployment: web servers vs. app servers, queues, security considerations, databases, caching, environment variables, and more. Then we will discuss Python-specific aspects, such as how WSGI (PEP 333) standardized the process across all frameworks. Finally, we will review a deployment checklist for Django, Flask, and FastAPI, highlighting where they overlap and where they differ. The goal of this talk is to explain how web deployments work under the hood, highlighting the Python-specific technical underpinnings that enable a knowledgeable developer to quickly deploy any Python web app, whether using FastAPI, Django, or Flask. europython-2026-89176-deploying-python-web-apps-in-2026 Web Development, Web APIs, Front-End Integration Will Vincent en false https://programme.europython.eu/europython-2026/talk/AGX8D9/ https://programme.europython.eu/europython-2026/talk/AGX8D9/feedback/ S3B Talk 2026-07-16T12:25:00+02:00 12:25 00:30 Your FastAPI + SQLAlchemy tests pass alone but fail together. Data leaks between tests, and cleanup becomes slower. Meanwhile, it seems effortless in Django. Why? This isn't a framework war - we'll dig into what Django actually does behind the scenes to keep the database clean between tests and why that approach isn’t straightforward to replicate in a typical SQLAlchemy setup. We'll explore common cleanup strategies like recreating schema, truncating, transaction wrapping or template databases and benchmark how they scale as your test suite grows. You'll leave with a clear understanding of why this problem exists and practical, benchmarked options to keep your test suite fast and data isolated. Aimed at intermediate Python developers comfortable with writing tests and familiar with basic database concepts like transactions. europython-2026-90910-django-s-magic-fastapi-s-reality-test-isolation-at-scale Web Development, Web APIs, Front-End Integration Maciej Sobczak en false https://programme.europython.eu/europython-2026/talk/YKWMBZ/ https://programme.europython.eu/europython-2026/talk/YKWMBZ/feedback/ S3B Sponsored 2026-07-16T13:05:00+02:00 13:05 00:30 Your team ships an AI feature and users love it. Then one viral post turns "normal load" into hundreds of LLM requests per second. LLM calls don't behave like traditional API requests. They're slow (sometimes seconds), expensive, rate-limited by providers, and a single provider outage can take your entire feature down. You can't just "add more servers." You need a routing layer that knows where to send traffic, when to back off, and how to fail without taking everything with it. In this talk, we'll walk through the LLM traffic routing architecture we built in Python at Manychat, where we serve AI-powered automation to thousands of Instagram and messaging accounts. Everything we'll show is running in production. We'll cover the core gateway patterns for multi-provider LLM traffic, implemented using LiteLLM Router as a reference design. By the end, you'll walk away with: - A weighted routing blueprint you can adapt to your own provider mix - Fallback and cooldown rules designed to survive real outages - Practical rate limiting (requests and tokens) with retry backoff - The monitoring baseline (latency, tokens, errors by provider, weight drift) to catch issues before they cascade - A checklist for rolling this out safely, incrementally europython-2026-91008-surviving-llm-traffic-spikes-routing-rate-limits-and-failover-in-python DevOps, Cloud, Scalable Infrastructure Sergi Porta en false https://programme.europython.eu/europython-2026/talk/E3GVVR/ https://programme.europython.eu/europython-2026/talk/E3GVVR/feedback/ S3B Talk 2026-07-16T14:30:00+02:00 14:30 00:30 Has this ever happened to you? You're happily coding a new feature in your Python project, and at some point, you make a hasty call: ``` self._thing.do_someting(rnicro_meters=10) ``` You've written unit tests for it, including an assertion line: ``` mock_do_someting.assret_called_once_with(rnicro_meters=10)` ``` The tests pass, the CI is green, the PR is reviewed and merged. But some time later, the service crashes because the real method does not have the `rnicro_meters` keyword argument in the first place. What happened? And more importantly, did you notice any of the mistakes above? This is a problem we've faced more than a few times over the past few years, and that's a few too many. Unit tests are crucial in any sort of Python development, from small libraries to large distributed systems. `unittest.mock` is used to isolate dependencies and mock external calls in order to keep the tests simple and focused. But mistakes can slip by (e.g.: attribute typos, wrong keyword arguments, wrong patch locations), just like the three mistakes above, leading to false positive tests and a false sense of confidence in our code quality. This can happen because `Mock` and `MagicMock` silently auto-creates attributes on the fly, even when those attributes do not exist on the real object. These issues become even more pronounced as dependencies change and projects evolve. In this session, we’ll look at why these false positives happen, and how to avoid them. Topics include: - Understand how `Mock` and `MagicMock` allow invalid attributes and calls. - Common pitfalls and anti-patterns with `Mock`, `MagicMock`, and `patch`. - Using `spec`, `spec_set`, and `autospec` to force mocks to match real objects. - Ensuring patched functions and methods have their signatures validated. - How to avoid patching the wrong import path. - Introducing guardrails in existing projects (e.g. OpenStack’s approach) without rewriting the entire test suite. europython-2026-91786-what-is-this-footgun-called-unittest-mock-and-how-to-avoid-misusing-it Testing, Quality Assurance, Security Claudiu Belu en false https://programme.europython.eu/europython-2026/talk/93XE3S/ https://programme.europython.eu/europython-2026/talk/93XE3S/feedback/ S3B Talk 2026-07-16T15:10:00+02:00 15:10 00:30 Coordinating a swarm of drones to autonomously allocate tasks, bid on them in real time, and execute multi-robot formations sounds like science fiction — but it is entirely possible with Python, a handful of threading primitives, and ROS2's MultiThreadedExecutor. This talk walks through the concrete implementation challenges of building a decentralised auction-based task allocation system for a swarm of four Crazyflie UAVs. The focus is on a problem that trips up almost every robotics engineer who graduates from tutorials to real deployments: what happens when your system has to wait for external, asynchronous events — bids from four robots, assignment confirmations, formation completion signals — without blocking the entire node and without introducing race conditions or deadlocks? We will explore how Python's threading.Event and Lock primitives were used alongside ROS2's MultiThreadedExecutor and ReentrantCallbackGroup to implement a synchronized bid-collation protocol, a global assignment barrier, and a concurrent multi-goal formation controller — all running in parallel on a single laptop while communicating with physical drones over radio. You will leave with a clear, transferable mental model for combining Python threading with ROS2 callback groups, practical patterns for synchronizing distributed asynchronous events in real-time systems, and an honest account of what breaks in the real world (and why). europython-2026-91687-flying-in-formation-with-python-threading-and-ros2-parallelism ~ None of these topics DEBORAH E DANJUMA en false https://programme.europython.eu/europython-2026/talk/SASJQU/ https://programme.europython.eu/europython-2026/talk/SASJQU/feedback/ S3B Talk 2026-07-16T16:00:00+02:00 16:00 00:30 Coding often looks boring or challenging at the beginning, but the more we code, the more it becomes interesting, and we hope to be better in it. From my background, schools don’t always teach the exciting ways for us to learn coding, which makes many teenagers of my age not realise how simple Python programming can assist them in real life and day-to-day activities. Also, the adults within the Python community don’t know that the future of Python programming depends on bringing new and young beginners like me into the community at an early stage, so this session discusses how teenagers can use their communication interests in learning Python. Learning Python at a young age can expose us to various skills and help us develop our reasoning, as teenagers face a lot of distractions today through social media chats. Showing how Python can be learned through simple chat interactions makes Python programming more accessible and friendly. As a teenager and beginner myself, I have an idea of how teenagers chat regularly on phones and applications, so chatting can also be a way of learning Python, so schools and communities like Python can discover this method to introduce Python to teenagers as a beginner. Python doesn’t need to be scary; it can feel like chatting with a friend who explains things step by step. By combining Python with conversational learning, we can remove fear, build confidence, and make coding a normal part of teenage life. This session will expose how teenagers can use simple conversation in WhatsApp to ask questions and learn Python as a chat. The audience will understand the tools and techniques for introducing Python to young people in a way that fits their communication style and how conversational learning makes Python more fun and less intimidating. europython-2026-91399-python-learning-that-fits-teen-life Community Building, Education, Outreach Oladapo Jesusemilore Jael en false https://programme.europython.eu/europython-2026/talk/3FW7UF/ https://programme.europython.eu/europython-2026/talk/3FW7UF/feedback/ Glass room Tutorial 2026-07-16T10:50:00+02:00 10:50 02:30 This will be a hands-on workshop during which we will build a digital musical instrument controlled by personalised gestures. We will make a standalone desktop application with a web UI which embeds an existing machine learning model for timbre transfer. We will look at an example of a meaningful control of the model for creative use in interactive, real-time sound generation. Finally, we will use interactive machine learning to define a personalised way of controlling the instrument based on a few examples provided on the fly. Workshop goals: - Demonstrate a practical example of creating a musical instrument with custom gesture control. - Walk you through a typical architecture of a real-time system with interactive control. - Show you how to run an existing machine learning model for timbre transfer on your computer and embed it in a desktop application. - Discuss ways for incorporating interactive methods for augmenting user interactions. europython-2026-101493-create-your-own-musical-instrument-with-custom-gesture-control Python for Games, Art, Play and Expression Anna Wszeborowska en false https://programme.europython.eu/europython-2026/talk/3VEJRA/ https://programme.europython.eu/europython-2026/talk/3VEJRA/feedback/ Glass room Coffee Break 2026-07-16T13:20:00+02:00 13:20 01:00 We’re excited to announce a range of events for underrepresented groups in computing this year! 🎉 Whether you’re new to PyLadies or a long-time supporter, we warmly welcome you to join us and be part of our supportive community. Join us for a special lunch event aimed at fostering community and empowerment in tech. Enjoy meaningful conversations and networking opportunities. Location: Red Carpet (Second Floor) Time: Thursday 16th of July at 13:15 europython-2026-101789-pyladies-lunch en false https://programme.europython.eu/europython-2026/talk/PXRCR9/ https://programme.europython.eu/europython-2026/talk/PXRCR9/feedback/ Glass room Conference Workshop 2026-07-16T14:30:00+02:00 14:30 02:00 Teams are getting leaner, context switching is constant, and expectations stay high even when clarity is low. Under that pressure, many of us start reacting instead of leading: stepping in too often, firefighting instead of thinking, and quietly carrying load that was never ours to hold. You do not need a title for any of this to apply. Leadership shows up in how you respond when things get tense, how you support the people around you, and where you choose to spend your finite energy. This workshop is a space to notice what pressure does to your leadership, and to practise doing something different. ## Designed for - Engineers and ICs who find themselves leading without a formal title - People who care about their teammates and want to stay effective over time - Anyone in a lean, fast-moving environment who keeps ending up as the one who absorbs the pressure - Folks who are often the only one like them in the room, and carry extra invisible load because of it No management experience required. ## What we will explore Leading yourself under pressure: how urgency and ambiguity shape your default responses. Learning to slow down enough to create space to think, and noticing when a question helps more than jumping in with an answer. Supporting others without taking over: helping a teammate without rescuing them or quietly absorbing their work. Framing problems as shared instead of solving them alone. Building trust when clarity is low. Staying strategic under pressure: understanding where your influence actually flows, with or without authority. Connecting day-to-day reality to the bigger picture, and choosing where to put your energy instead of trying to hold everything. ## What you will take away Clearer insight into how pressure shapes your leadership. Practical experience using questions and framing to grow agency in the people around you. A better sense of where to focus next: on yourself, the people around you, or the wider system. And one concrete move to try in the next two weeks. ## Format A two-hour interactive workshop. Short input bursts, hands-on exercises, solo reflection, and peer learning, using the group as a space to think together about real leadership challenges. europython-2026-101696-leading-under-pressure Professional Development, Careers, Leadership Tereza Iofciu en false https://programme.europython.eu/europython-2026/talk/CERV3F/ https://programme.europython.eu/europython-2026/talk/CERV3F/feedback/ Poster Hall A Poster 2026-07-16T13:15:00+02:00 13:15 01:00 Have you ever wondered how to write good unit tests? Do you know the best practices for unit testing? Or maybe you’re already using unit tests in your project and want to see how others approach them? If the answer to any of these questions is yes, this talk is for you. During the session, you’ll learn how to write proper unit tests, discover good testing practices, learn to distinguish mocks from stubs, see examples of using dependency injection to improve testability, and find out what pure functions are and why they’re easier to test. europython-2026-91425-how-we-write-unit-test-in-my-team-in-openchip Testing, Quality Assurance, Security Jan Koprowski en false https://programme.europython.eu/europython-2026/talk/9URK9U/ https://programme.europython.eu/europython-2026/talk/9URK9U/feedback/ Poster Hall B Poster 2026-07-16T13:15:00+02:00 13:15 01:00 When you write a Python library, you have a dilemma. Ship async-only? Ship blocking-only? Or write everything twice and watch both copies drift? [Synchronicity](https://github.com/modal-labs/synchronicity) removes this dilemma. Write your library once (in async) and get a blocking interface for free, while avoiding the boilerplate and limitations of `asyncio.run()` wrappers. We’ll talk through how to handle persistent connections, async generators, clean tracebacks, type hints and more. We've used it in production at Modal for years, and it's fully open source. We hope it can save you from writing your own library twice! europython-2026-100248-write-async-get-sync-for-free Tooling, Packaging, Developer Productivity Thom Lane en false https://programme.europython.eu/europython-2026/talk/SEJYRG/ https://programme.europython.eu/europython-2026/talk/SEJYRG/feedback/ Poster Hall C Poster 2026-07-16T13:15:00+02:00 13:15 01:00 The poster shows a [railroad diagram](https://en.wikipedia.org/wiki/Syntax_diagram) of the entire [Python grammar](https://docs.python.org/3/reference/grammar.html). It allows exploring subtle details of the language, like when parentheses are required around generator expressions, tuples or “walrus” assignment operations; what's the precedence of various operators; or what kinds of arguments are possible in function definitions and calls. europython-2026-91004-python-syntax-diagram Python Core, Internals, Extensions Petr Viktorin en false https://programme.europython.eu/europython-2026/talk/8HBEYS/ https://programme.europython.eu/europython-2026/talk/8HBEYS/feedback/ S1 Announcements 2026-07-17T08:00:00+02:00 08:00 00:45 Welcome to EuroPython 2026! Please notice the registration will happen on the TBD. You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday! Enjoy the conference! europython-2026-97554-friday-registration-welcome-tbd en false https://programme.europython.eu/europython-2026/talk/JGBFDF/ https://programme.europython.eu/europython-2026/talk/JGBFDF/feedback/ S1 Announcements 2026-07-17T08:45:00+02:00 08:45 00:15 Welcome to the third day of conference! Yesterday was an amazing day, but for sure you don't remember all the things that were mentioned during the opening. Join us to get an update and few more announcements. Come by and find out what is going to happen today. europython-2026-97555-friday-s-morning-announcement en false https://programme.europython.eu/europython-2026/talk/SXBNNA/ https://programme.europython.eu/europython-2026/talk/SXBNNA/feedback/ S1 Keynote 2026-07-17T09:00:00+02:00 09:00 00:45 The world of open source is undergoing numerous seismic changes, and Python is no exception. This keynote will focus on security: we'll extrapolate (and speculate) on the task of securing Python for the next decade of usage by open source maintainers, corporations, tinkerers, vibe coders, and everyone in between. We'll also cover how we expect attacker behaviors to shift, and how those shifts will require us to discard traditional assumptions as defenders. europython-2026-98027-securing-python-for-the-next-decade ~ None of these topics William Woodruff en false https://programme.europython.eu/europython-2026/talk/KH9EQN/ https://programme.europython.eu/europython-2026/talk/KH9EQN/feedback/ S1 Talk 2026-07-17T10:10:00+02:00 10:10 00:30 Have you ever needed to debug a live Python process but couldn't restart it? Didn't want to redeploy with debug flags or manage sidecar containers just to debug your application? In this talk, I'll show you why `sys.remote_exec()` is one of the coolest features of Python 3.14! I'll cover the basics of Python's new remote debugging capabilities and demonstrate how `sys.remote_exec()` can be combined with debugpy (an implementation of the Debug Adapter Protocol) to provide full IDE debugging experiences for live processes. I'll share what I learned building a tool that uses these primitives to attach debuggers to FastAPI applications running in local Kubernetes clusters. Beyond debugging, we'll explore other use cases for `sys.remote_exec()` and how you can apply the feature to solve problems in your own work! europython-2026-88905-the-coolest-feature-in-python-3-14-sys-remoteexec Python Core, Internals, Extensions Savannah Ostrowski en false https://programme.europython.eu/europython-2026/talk/KFQN3X/ https://programme.europython.eu/europython-2026/talk/KFQN3X/feedback/ S1 Talk 2026-07-17T11:05:00+02:00 11:05 00:30 Most Pythonistas handle Python objects every day, but sometimes, the bugs and performance surprises we encounter happen because we misunderstand how Python actually manages memory. Variables are not just containers(which I previously thought), objects are not copied by default, and references behave differently than what many developers expect — especially as the codebases we work with grow. In this talk, we will build an accurate mental model of how Python handles objects, references, and memory at runtime; we will look at what really happens when objects are created, passed to functions, mutated, and destroyed. We will also look at how reference counting works at a high level, why mutability matters, and how these fundamental concepts come up when we examine debugging and performance in our Python code. After this session, developers will be more confident about their understanding of Python behaviour, avoid common pitfalls, and better understand what the profilers and debuggers are really saying. europython-2026-91397-pointers-objects-and-references-how-python-manages-memory Python Core, Internals, Extensions Abigail Afi Gbadago en false https://programme.europython.eu/europython-2026/talk/ARRMQR/ https://programme.europython.eu/europython-2026/talk/ARRMQR/feedback/ S1 Talk 2026-07-17T11:45:00+02:00 11:45 00:30 Step 1: Fix a bug Step 2: ??? Step 3: Core developer Ok, it's not that simple but it's also not as mysterious as it might seem! About three years ago I fixed an obscure bug in the unittest module. Today, I'm a core developer. This talk is about what happened in between, and how you can start contributing too! Over the years, I got to work on many different areas of Python. I've fixed bugs in the parser, added import autocomplete to the REPL, worked on gettext tooling, and eventually found my way to the JIT compiler, all things I knew little about before diving in. Getting started contributing to Python can be intimidating, so I'll share some practical things I learned along the way such as: - How is the CPython project organized? - How do you find something to work on? (and why it doesn't have to be code!) - What happens after you submit a PR? - How do you navigate a 30 year old codebase without getting lost? If you've ever wanted to contribute to Python but weren't sure where to start, this talk is for you. europython-2026-90895-become-a-python-core-developer-in-3-easy-steps Python Core, Internals, Extensions Tomas Roun en false https://programme.europython.eu/europython-2026/talk/B7CMBD/ https://programme.europython.eu/europython-2026/talk/B7CMBD/feedback/ S1 Talk 2026-07-17T12:25:00+02:00 12:25 00:30 It’s common to hear complaints about Python being slow. In this talk, I will show how to make _some_ Python programs dramatically faster by using Python 3.14’s free threading and ahead-of-time compilation to C extensions using the mypyc compiler, while staying entirely in Python (and CPython). Free threading can deliver large speedups for CPU-bound code that can be adapted for parallel execution, while mypyc speeds up workloads that benefit from reduced interpreter overhead and that can use static typing. If each can give a 10x speedup in an ideal use case, can we get a “holy grail” 100x speedup by using both? I’ll introduce several small examples inspired by real-world workloads, measuring and explaining what happens when you apply free threading, mypyc, or both. In practice, relatively few programs are perfect fits for both techniques at once, but when they are, you can get substantial gains. Having both tools available gives you options for attacking a wide range of performance problems. Along the way, I’ll cover various bottlenecks you are likely to encounter while optimizing real-world workloads. These often limit performance scaling. I'll explain how to diagnose and improve allocation-heavy code and thread contention caused by reference counting, in particular. europython-2026-91593-speeding-up-python-with-free-threading-and-mypyc Python Core, Internals, Extensions Jukka Lehtosalo en false https://programme.europython.eu/europython-2026/talk/PWGSJQ/ https://programme.europython.eu/europython-2026/talk/PWGSJQ/feedback/ S1 Talk 2026-07-17T13:55:00+02:00 13:55 00:30 From CLI developers to maintainers of large applications, many Python developers have been bitten by the high overhead of eagerly loading imports. Long start-up times can make it prohibitively costly to run simple commands like --help, and the memory overhead from loading every imported module eagerly can trigger Out-Of-Memory errors in production. After the most discussed PEP thread in the history of discuss.python.org, with hundreds of messages and fierce debate, Python 3.15 finally brings Explicit Lazy Imports to the language. With a simple new keyword, you can now defer module loading until the moment you actually need it. This is one of the most requested performance features in Python's history, and finally it's here. This presentation will take you through how we got here and where we're going. We'll look at why existing workarounds never quite worked, and how an earlier proposal (PEP 690) tried to make all imports lazy by default but was rejected. Then PEP 810 emerged with a different approach: explicit, opt-in syntax that the community accepted. The heart of this talk is discovering how lazy imports actually work inside the interpreter. We'll trace through the bytecode, see how proxy objects stand in for unloaded modules, and watch the moment when your code first touches a lazy import and the real module snaps into place. You'll also learn about the future tooling that we are baking that will help you adopt this safely in your own projects. Whether you're a beginner curious about Python's future, someone looking to speed up your CLI tools, or you just want to understand what's happening under the hood, this talk will give you everything you need to start using lazy imports with confidence. europython-2026-92016-lazy-imports-and-the-art-of-interpreter-procrastination Python Core, Internals, Extensions Pablo Galindo Salgado en false https://programme.europython.eu/europython-2026/talk/RGBSS8/ https://programme.europython.eu/europython-2026/talk/RGBSS8/feedback/ S1 Talk 2026-07-17T14:35:00+02:00 14:35 00:30 Debugging and testing multithreaded code in Python is so challenging. How do you create reproducible tests of multithreaded code, when the order of execution changes from run to run? How do you achieve 100% coverage, when you ship code only called to handle rare, obscure race conditions? And if you think it's a problem now... just imagine how much worse it's going to become as adoption of "nogil" Python grows! Blanket is here to help. Come learn how Blanket gives you back control over the order of execution in multithreaded code, enabling you to write deterministic multithreaded tests. Restore blessed order and determinism to your unit test suite--use Blanket! europython-2026-91380-conquer-multithreaded-python-with-blanket Python Core, Internals, Extensions Larry Hastings en false https://programme.europython.eu/europython-2026/talk/QY7PFR/ https://programme.europython.eu/europython-2026/talk/QY7PFR/feedback/ S1 Talk 2026-07-17T15:30:00+02:00 15:30 00:30 Open source maintainers are drowning in a new kind of noise. "AI"-generated pull requests — superficial, poorly reasoned, and submitted without genuine understanding of the codebase — are consuming review bandwidth that was already scarce. These contributions range from cosmetic "improvements" that introduce subtle bugs to elaborate refactorings that no one asked for, all bearing telltale signs of LLM output: confident tone, plausible-looking code, and zero awareness of project conventions. This talk presents a practical, battle-tested framework for combating "AI" slop without discouraging legitimate contributors. Drawing from real experiences maintaining pip-tools, aiohttp, ansible-core, CherryPy, and other Python projects, I'll share concrete strategies that work today. First, we'll dissect the anatomy of "AI" slop PRs — what they look like, why they pass superficial review, and the hidden costs beyond wasted review time: CI compute waste, security risks from plausible-but-wrong code, and the demoralizing effect on genuine contributors who see low-effort submissions getting attention. Then I'll walk through a defense-in-depth approach being developed across my projects: updating `CONTRIBUTING.md` with explicit expectations about understanding the codebase before submitting changes; crafting repository-level LLM instruction files (like `AGENTS.md`/`CLAUDE.md`) that steer "AI" tools toward project-specific conventions; configuring PR templates to require evidence of human reasoning; and establishing community norms that set quality expectations without being hostile to newcomers. We'll also tackle the harder questions: Where is the line between "AI"-assisted (the human drives and understands the change) and "AI"-generated (the human clicks "submit" on LLM output)? How do we preserve the welcoming culture that makes open source special while defending against low-effort spam? What should platforms like GitHub improve for maintainers? You'll leave with a ready-to-adapt policy template and configuration files for your own projects. europython-2026-91752-defending-open-source-from-ai-slop-a-maintainer-s-practical-guide Ethics, Social Responsibility, Sustainability, Legal Sviatoslav Sydorenko (Святослав Сидоренко) en false https://programme.europython.eu/europython-2026/talk/ZHCNDY/ https://programme.europython.eu/europython-2026/talk/ZHCNDY/feedback/ S1 Keynote 2026-07-17T16:10:00+02:00 16:10 00:45 "TBD: Keynote Speaker" Details coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event. Our team is finalizing an exceptional speaker whose insights and vision will leave a lasting impression. Check back shortly for the full announcement, topic, and speaker biography. europython-2026-96943-keynote-6-placeholder en false https://programme.europython.eu/europython-2026/talk/8XMJGZ/ https://programme.europython.eu/europython-2026/talk/8XMJGZ/feedback/ S1 Lightning Talk 2026-07-17T16:55:00+02:00 16:55 00:30 Enjoy Friday's lightning talks! Short talks about everything by everyone. Lightning talks are 5 minute talks that anyone participating at the conference can submit. If that talk gets selected, you will have the chance to jump into the main stage and show us your project, your ideas, something you have learned, something you are proud of that's helping and contributing to our conference and community, or something else! Lightning talks last a maximum of 5 minutes. You can use less time, but not more. This time limit is strictly enforced! If you get accepted, you will be notified by email on the day of your talk by 1pm. Reply to the acceptance email by 3pm to confirm your spot. (If you don't, you lose your spot!) You can submit your lightning talk on this form: TBD Note that there's a limit of one submission per person. europython-2026-97556-lightning-talks-friday en false https://programme.europython.eu/europython-2026/talk/YUECR3/ https://programme.europython.eu/europython-2026/talk/YUECR3/feedback/ S1 Announcements 2026-07-17T17:25:00+02:00 17:25 00:30 What an amazing week! We had two tutorials days and three talks days filled with amazing topics, but more important, amazing people! Our community is thankful, and want to close the main conference days. Join us to get a nice summary of what was EuroPython 2026. europython-2026-97557-conference-closing en false https://programme.europython.eu/europython-2026/talk/UALU9S/ https://programme.europython.eu/europython-2026/talk/UALU9S/feedback/ S1 Announcements 2026-07-17T17:55:00+02:00 17:55 00:30 Do you know what is a sprint? The sprints are activities that will happen during the weekend on a different location. Do you know if you can join? and how can you join? Do you know all the projects that are participating? Let us answer these questions and a few more in the Sprint orientation. europython-2026-97558-sprint-orientation en false https://programme.europython.eu/europython-2026/talk/3QHVK3/ https://programme.europython.eu/europython-2026/talk/3QHVK3/feedback/ S2 Talk (long session) 2026-07-17T10:10:00+02:00 10:10 00:45 Deep learning is often taught through large frameworks and large models, which is great for getting real projects out of the door, but not always great for learning. This talk is about a different practice: building tiny, runnable versions of various modern architectures with minimal dependencies (mostly Python and NumPy) to learn about the ideas through application. We’ll get our feet wet by building a small Transformer end-to-end and learn about the model architecture that started the craze. Then we switch perspectives, and learn about other architectures, always staying small and nimble, focusing on applying the math and breathing life into formulas. We will look look at multi-scale modelling (in a simplified version of Renormalizing Generative Models), State Spaces, and other scary concepts, until they are not scary at all anymore. You’ll leave with a model for turning papers into little prototypes that stay true to ideas and the starting point for your own little lab to build models yourself. Prerequisites: a basic understanding of NumPy and a willingness to look at Greek letters. No deep learning framework knowledge required. europython-2026-90861-ai-architecture-katas-learning-by-building-small-models-in-plain-python Machine Learning: Research & Applications hellerve en false https://programme.europython.eu/europython-2026/talk/899VGG/ https://programme.europython.eu/europython-2026/talk/899VGG/feedback/ S2 Talk 2026-07-17T11:05:00+02:00 11:05 00:30 Music generation has gone from a research curiosity to something you can try in a browser. Commercial platforms and open source models can produce full songs from a text prompt. Between the hype and the technical papers, it’s hard to get a straight answer about what’s actually going on under the hood. **This talk is a clear, honest walkthrough of how music generation systems work, in simple language**, no deep machine learning knowledge needed. We start with the core challenge: how do you turn a continuous audio signal into something a generative model can work with? Neural audio codecs solve this by compressing waveforms into sequences of discrete tokens, and this idea is the foundation everything else builds on. From there, we look at the two main modeling strategies: token prediction and diffusion. We compare what each does well, where it struggles, and why the choice between them matters. On the practical side, we walk through the open source models and Python tools available today, and what you can build with them. Then we get into evaluation, one of the most important open problems in the field. Current metrics only tell part of the story, and there is no standard benchmark for comparing systems. This has real consequences for how research moves forward and how models get used. We close with a discussion that often gets skipped: how artists and musicians see these tools, what legal questions remain around training data and copyright, and why these conversations matter for the future of the field.​​​​​​​​​​​​​​​​ europython-2026-91520-how-music-generation-actually-works Python for Games, Art, Play and Expression Mateusz Modrzejewski en false https://programme.europython.eu/europython-2026/talk/7SSS93/ https://programme.europython.eu/europython-2026/talk/7SSS93/feedback/ S2 Talk 2026-07-17T11:45:00+02:00 11:45 00:30 The presentation will discuss practical applications of Python in technologies used in forensic science. In an era of growing cybercrime and digitalization of evidence, Python has become an essential tool for forensics specialists, offering powerful libraries for data analysis, process automation and processing complex information structures. Participants will gain insights into spanning multiple domains of forensic investigation, including: - mobile device analysis, - network traffic examination, - memory forensics, - automated report generation. We will analyze how Python libraries parse SQLite databases in messaging applications like WhatsApp and iMessage, also examine tools for analyzing iOS file formats including PLIST and XML structures and techniques for extracting data from disk images using pytsk3 or libewf. Network analysis will showcase Scapy for packet analysis and Dpkt for parsing capture files, demonstrating how Python analyzes Windows Event Logs and Linux syslog to reconstruct activity timelines. Memory forensics will be explored through the Volatility Framework for analyzing RAM dumps and recovering volatile data. We will discuss recovering deleted files, extracting metadata, and analyzing browser artifacts. Cryptographic analysis using hashlib will demonstrate integrity verification, encrypted file analysis, and cipher breaking techniques essential for maintaining chain of custody. Data visualization using Matplotlib, Seaborn, and NetworkX will show how to create compelling visual representations of timelines and connection networks. Automated report generation with ReportLab and python-docx streamlines professional expert report creation. The presentation emphasizes real-world applications with dusscussion about Python scripts processing realistic datasets, illustrating how multiple Python tools integrate into comprehensive investigation workflows, demonstrating the synergistic effects of combining different analytical approaches for actionable forensic intelligence. europython-2026-91711-python-in-the-service-of-justice-modern-analysis-tools-in-forensics Ethics, Social Responsibility, Sustainability, Legal Aleksander en false https://programme.europython.eu/europython-2026/talk/PQCHT3/ https://programme.europython.eu/europython-2026/talk/PQCHT3/feedback/ S2 Talk 2026-07-17T12:25:00+02:00 12:25 00:30 We’re living in weird times. The lines and connections that hold allies and trusted partners together are changing. New barriers to trade, to travel, to collaboration are affecting everything we do. Python is not immune to these shifts, but internationally stewarded open source is still the best choice if you are looking for software that does what it says it does and doesn’t do a lot of things that you don’t want it to do. Large open source projects are vetted by multiple stakeholders in different counties, using that software for different purposes and running on all different hardware around the world. Increasingly, large projects like Python come with a Software Bill of Materials and massive new patches coming from brand new contributors are looked at with a little more skepticism than they would’ve been a few years ago. This talk will discuss what’s changed about international collaboration and how Python and other community driven projects are looking at security and collaboration these days. europython-2026-90927-international-open-source-your-best-choice-in-interesting-times Ethics, Social Responsibility, Sustainability, Legal Deb Nicholson en false https://programme.europython.eu/europython-2026/talk/SQRYJA/ https://programme.europython.eu/europython-2026/talk/SQRYJA/feedback/ S2 Talk 2026-07-17T13:55:00+02:00 13:55 00:30 Managing complex authorization logic can be a nightmare. Without a framework to help you, it can soon end up in a mess of if-else statements and partial solutions that will only give you a headache. One day, I found myself in that exact situation. I decided to tackle the problem, and that's how I came across the concept of "policy-based authorization" or ABAC. While there are available libraries for this, I found them of little help for a large, legacy codebase that is monolithic at its core. In my talk, I will share my experience in thinking about this problem and how to use ABAC to implement a custom solution that fits your needs. I will outline the main components of my solution and show how it can be applied to Django views and FastAPI endpoints. europython-2026-91184-how-to-tackle-complex-authorization-logic-and-don-t-go-crazy Web Development, Web APIs, Front-End Integration Maria Lowas-Rzechonek en false https://programme.europython.eu/europython-2026/talk/PBTPJR/ https://programme.europython.eu/europython-2026/talk/PBTPJR/feedback/ S2 Talk 2026-07-17T14:35:00+02:00 14:35 00:30 How can you create open digital tools that run on both the Cloud and the Edge for small/medium farms across Greek vineyards, French cattle ranches, and Belgian potato fields? The OpenAgri project, funded by the EU Horizon program and now part of the Linux Foundation's AgStack, has developed reusable Python tools for this purpose. These building blocks, using Python Web frameworks such as Django and FastAPI, are already being tested in 14 real-world sustainability pilots across Europe. In this presentation, we will show how Python is helping farmers, from camera-based scouting in vineyards to UHF RFID cattle monitoring, UAV pest detection, IoT smart irrigation, and compost production monitoring. We will talk about what works across different countries, the challenges that arise when your "data centre is a barn", and what still needs improvement. Join us to hear farming stories from across Europe and learn practical lessons on deploying Python microservices on Edge devices to build a more democratised agritech landscape in Europe. europython-2026-91690-how-python-is-democratising-agritech-for-farmers-across-europe Ethics, Social Responsibility, Sustainability, Legal Felipe Arruda Pontes en false https://programme.europython.eu/europython-2026/talk/T7ATVM/ https://programme.europython.eu/europython-2026/talk/T7ATVM/feedback/ S2 Talk 2026-07-17T15:30:00+02:00 15:30 00:30 Here's a secret from someone who's been on every side of the hiring table — as a candidate who's passed 80%+ of technical processes (including Google and Meta), as a hiring manager who's interviewed hundreds of engineers, and as the former CTO of Codility, the platform that powers technical assessments at thousands of companies worldwide: the interview is not about solving the problem. Most candidates walk into coding interviews laser-focused on getting to the correct solution. They grind LeetCode, memorize algorithm patterns, and panic when they hit a wall. But here's what they miss — interviewers aren't scoring your answer. They're evaluating how you think, how you communicate, and how you handle uncertainty. The candidates who get offers aren't always the ones who solve the problem. They're the ones who make the interviewer want to work with them. In this talk, I'll pull back the curtain on what technical interviews — both coding and system design — actually measure. You'll learn why talking through a wrong approach can score higher than silently arriving at the right one, why system design interviews aren't looking for the "correct" architecture, and why the soft skills you think are secondary are actually the main event. Drawing from nearly 20 years of real-world experience on both sides of the table, I'll share a practical framework for approaching any technical interview with the right mindset. You'll walk away with concrete strategies you can apply at your next interview — not more algorithm flashcards, but a fundamentally different understanding of what the process is actually testing. europython-2026-91158-you-don-t-need-to-solve-it-what-actually-gets-you-hired-in-tech Professional Development, Careers, Leadership Wojtek Erbetowski en false https://programme.europython.eu/europython-2026/talk/BPJHWT/ https://programme.europython.eu/europython-2026/talk/BPJHWT/feedback/ S4 Talk 2026-07-17T10:10:00+02:00 10:10 00:30 Have you ever wondered how popular tools like pytest or tox are able to discover and use plugins? In this talk we will learn about entry-points in Python package metadata and how they enable plugin discovery. We will review how some popular projects are using this mechanism to create their plugin systems. After a walkthrough of the basics, we will explore how you can use this to create a plugin mechanism for your own project. We will explore possible hook implementations and their advantages and disadvantages. Finally we will learn how to make plugins discoverable on PyPi. europython-2026-91648-plugins-in-python-how-it-is-done Tooling, Packaging, Developer Productivity Grzegorz Bokota en false https://programme.europython.eu/europython-2026/talk/SGM9SV/ https://programme.europython.eu/europython-2026/talk/SGM9SV/feedback/ S4 Talk 2026-07-17T11:05:00+02:00 11:05 00:30 In software development, messy, outdated, or inefficient code is inevitable. We have to deal daily with old code that has not been touched for years, refactoring allows us to keep the code maintainable and easy to extend without altering its functionality, and it plays a crucial role in enhancing maintainability, readability, and performance. This session explores the how, when, and why of code refactoring with code smell examples, coupled with practical insights on performance profiling techniques, tools and how it affects Refactoring. Also exploring how testing is very crucial when it comes to Refactoring. Whether you're dealing with legacy code or looking to enhance your development workflows, this talk equips you with the tools and techniques to write cleaner, more efficient Python code. This session is inspired by Martin Fowler's seminal works on refactoring and Python-specific insights shared at EuroPython 2024. europython-2026-88895-refactor-optimize-and-test-crafting-cleaner-python-code ~ None of these topics Mohamed Elmaghraby en false https://programme.europython.eu/europython-2026/talk/TG7YMS/ https://programme.europython.eu/europython-2026/talk/TG7YMS/feedback/ S4 Sponsored 2026-07-17T11:45:00+02:00 11:45 00:30 Running Python natively on Windows on Arm requires more than a working interpreter. To have the best developer experience, it depends on compilers, packaging, binary wheels, CI infrastructure, and support from the wider library ecosystem. This talk provides a status update of the Python ecosystem on Windows on Arm in 2026, based on ongoing collaboration between the open-source community, Microsoft, and Arm. We will cover CPython support, packaging, wheels, tooling, and CI availability, with a focus on what developers can realistically use today. Using widely adopted libraries such as PyTorch as examples, we will show how native Arm support is being enabled and creating better capabilities across the ecosystem, what remaining challenges projects face when supporting Windows on Arm. The talk will also cover the developer and CI story enabled by native Arm runners and Windows 11 Arm images on GitHub Actions, and how this infrastructure lowers the barrier for projects to add and maintain Windows on Arm support. The goal is to give a snapshot of the current state, highlight the remaining gaps, and explain how contributors and maintainers can participate to the ongoing effort. europython-2026-98322-python-on-windows-on-arm-ecosystem-enablement-update Python Core, Internals, Extensions Diego RussoGleb Khmyznikov en false https://programme.europython.eu/europython-2026/talk/QXZMP8/ https://programme.europython.eu/europython-2026/talk/QXZMP8/feedback/ S4 Talk 2026-07-17T12:25:00+02:00 12:25 00:30 After months of maintaining the MCP Python SDK and reviewing many community contributions, I've seen some architectural hiccups in repeat. Developers struggle with questions that seem simple but have nuanced answers: When should one tool become three? When does a server need to split into two? How do you test an MCP server without spinning up a full client? When should you use resources or prompts instead? In this talk, we will explore my learnings and understand how to design tool boundaries that scale with your server's complexity, structure your codebase for long-term maintainability, and build a testing strategy for your MCP server that works. I'll share real examples from the wild, both the antipatterns to run away from and the implementations worth adopting. In 2026, the MCP Python SDK v2 will bring improved typing, a refined API, and better testing primitives. The architectural decisions you make today will determine whether that migration takes a day or a month. Whether you're maintaining an internal tool or publishing to the community, you'll leave with a clear framework for evaluating your own server's design and concrete next steps to improve it. europython-2026-91682-what-i-ve-learned-maintaining-the-mcp-python-sdk Machine Learning, NLP and CV Marcelo Trylesinski en false https://programme.europython.eu/europython-2026/talk/BJBKRM/ https://programme.europython.eu/europython-2026/talk/BJBKRM/feedback/ S4 Talk 2026-07-17T13:55:00+02:00 13:55 00:30 *but were too afraid to ask! `pandas`, the data wrangling workhorse, will celebrate its *18th year of existence* in 2026. You rely on it daily, but are you truly confident in your code? This session is dedicated to the unwritten rules and hidden mechanics that separate a confident user from one who constantly battles warnings and unexpected outputs. We will confront the infamous `SettingWithCopyWarning` that haunts chained operations, clarify the critical differences in *deep vs. shallow copies* and the true cost of using `inplace=True`. We’ll also demystify the complex handling of missing data (`NaN`s) and much more! Crucially, we will look to the future. `pandas` is engaged in a `DataFrame` library race with newer, high-performance libraries like `polars` and `duckdb`. The latest advancements—`pandas` 2.0 and the new and shiny 3.0, with features like *Copy-on-Write* and *Apache Arrow* integration—are the direct response, promising a future of dramatically improved speed, memory efficiency, and data types. Join me to master the crucial concepts of the past and prepare for the performance gains and new behaviors of the future, ensuring your skills stay ahead of the curve. Stop guessing and start mastering `pandas`! europython-2026-88818-everything-you-always-wanted-to-know-about-pandas Data Engineering and MLOps Francesco Lucantoni en false https://programme.europython.eu/europython-2026/talk/UGLF7Q/ https://programme.europython.eu/europython-2026/talk/UGLF7Q/feedback/ S4 Talk 2026-07-17T14:35:00+02:00 14:35 00:30 Have you ever built a feature perfectly, only to discover it solved the wrong problem? Or made architectural decisions that seemed right in isolation but fell apart when business needs changed? You were missing context. Discovery workshops give developers what tickets can't: the full picture. This talk explores how proper discovery phase work transforms developers from ticket executors into empowered problem solvers who make better decisions and have more fun doing it. Developers with discovery artifacts like Business Model Canvas summaries, entity relation diagrams, and mapped user segments write better code. They understand why revenue streams demand certain performance characteristics, how customer segments shape feature priorities, and how key partnerships affect API design. This talk walks through the discovery process from a developer perspective. You'll see what artifacts actually help us code, how business requirements map to technical architecture, and why understanding the problem space before touching code prevents costly rework. We'll cover epics, user stories, service architecture, and wireframes, but more importantly, how they connect to real business value. Discovery workshops reduce surprises, empower confident decisions, and accelerate your growth from developer to senior engineer by teaching you to think beyond tickets. Learn how to work smarter by knowing the WHY, not just the WHAT. europython-2026-90626-from-ticket-taker-to-problem-solver-discovery-for-senior-thinking Professional Development, Careers, Leadership Damian Wysocki en false https://programme.europython.eu/europython-2026/talk/NTZ7DG/ https://programme.europython.eu/europython-2026/talk/NTZ7DG/feedback/ S4 Talk 2026-07-17T15:30:00+02:00 15:30 00:30 As developers, our daily workflow is scattered across dozens of platforms: GitHub for PRs and issues, Jira or Linear for tasks, GitLab for CI/CD, and Todoist for personal focus. Constant "context switching" between browser tabs is a productivity killer. To solve this, I built **Monokl** - a unified terminal dashboard that aggregates these services into a single, high-performance interface. In this talk, we explore how to build complex, API-driven applications using **Textual**, the rapid application development framework for Python. We will dive into the real-world challenges of building Monokl, including: * **Async integration:** How to fetch data from multiple APIs (GitHub, Atlassian, GitLab, Linear) without freezing the UI. * **Component architecture:** Designing reusable widgets for task lists, progress bars, and status feeds. * **Reactive UI:** Using Textual’s reactive traits to ensure your dashboard updates not long after a PR is approved or a task is completed. * **The TUI advantage:** Why a terminal interface is often faster and more focused than a web-based aggregator. Attendees will walk away with a clear blueprint for building their own interactive terminal tools and a deep understanding of the Textual framework. ## **Learning Outcomes** * **Learning Textual:** Understand the core architecture of `App`, `Screen`, and `Widget`. * **Managing async data:** Learn patterns for integrating multiple external APIs/CLIs into a single event loop. * **Modern layouts:** How to use **TCSS** (Textual CSS) to create beautiful, responsive terminal layouts. * **State & reactivity:** How to use `@reactive` attributes to create a UI that stays in sync with background data. europython-2026-90871-modern-tui-with-textual-in-python-building-monokl Tooling, Packaging, Developer Productivity Piotr Grędowski en false https://programme.europython.eu/europython-2026/talk/LRVCYU/ https://programme.europython.eu/europython-2026/talk/LRVCYU/feedback/ S3A Talk (long session) 2026-07-17T10:10:00+02:00 10:10 00:45 *The hardships of building End-to-End Voice Assistants in the Wild* Robot Holmes is back in the mist-choked streets of MLington, but he isn’t working solo. Meet Zintia, an intern from the Voice Assistant district. She’s helpful, hyper-efficient, and incredibly annoying, providing Holmes with data before he can lift a finger. But Zintia has a secret. The longer she’s on the case, the more of her "dark side" emerges. She’s not just hearing the truth; she’s deciding which parts Holmes is allowed to hear. This is a story-driven, practical session for anyone tired of "Hello World" chatbots. We will move past the hype to look at what it actually take to make End-to-End Voice Assistants work in the real world. Our Investigation Includes: - The Gear: How to use E2E speech models like gpt-realtime and integrate them into a production voice interface using FreeSWITCH and Pipecat. - The Interrogation: Navigating the hardships of instruction-following, ensuring underlying LLMs stay on path through defined states and agentic flow. - The Double-Cross: Identifying and mitigating "hidden agendas" - the hallucinations and safety guardrails that can make a voice assistant turn on its user. Expect live demos, hard-won production lessons, a detective noir story and a blueprint for building voice agents that are fast, fluid, and (mostly) law-abiding. europython-2026-91650-robot-holmes-and-the-silenced-witness-a-noir-guide-to-real-time-voice-ai Machine Learning, NLP and CV Johannes Kolbe en false https://programme.europython.eu/europython-2026/talk/LFSJYL/ https://programme.europython.eu/europython-2026/talk/LFSJYL/feedback/ S3A Talk 2026-07-17T11:05:00+02:00 11:05 00:30 Do you maintain a Python library, REST API or any other user-facing interface? Breaking changes are frowned upon, but from a a certain project size, they become unavoidable. How do you make the breaking changes manageable? How should you version your package / API? Should you put an upper bound on your dependencies? We'll discuss deprecation, forward and backward compatibility, upgrade strategies and more, illustrated on real-world examples. Our main focus will be on API changes of Python libraries, but the principles are widely applicable. europython-2026-91308-breaking-changes-not-great-not-terrible Tooling, Packaging, Developer Productivity Jan Musílek en false https://programme.europython.eu/europython-2026/talk/FBQQXS/ https://programme.europython.eu/europython-2026/talk/FBQQXS/feedback/ S3A Sponsored 2026-07-17T11:45:00+02:00 11:45 01:00 Many of our sponsors are looking for people from a wide range of backgrounds and experience levels to join their teams. This session is a chance to hear directly from companies about what they are building, the kinds of people they epare looking for, and what it’s like to work with them. Throughout the session, sponsors will give short introductions, followed by time for questions and conversations. If something sparks your interest, you can continue chatting with the teams at their booths afterwards. We hope you, like many folks in past years, will discover new opportunities and make valuable connections through the conversations started here. europython-2026-100293-sponsor-highlight-recruitment-fair en false https://programme.europython.eu/europython-2026/talk/BMX7VR/ https://programme.europython.eu/europython-2026/talk/BMX7VR/feedback/ S3A Talk 2026-07-17T13:55:00+02:00 13:55 00:30 Python’s type system isn't just for static analysis anymore. With Annotated, our types can carry their own documentation, validation logic, and runtime instructions—effectively breaking the boundary between "checking code" and "executing it." This talk explores how Annotated acts as a universal metadata engine, allowing us to define semantic and branded types that attach rich instructions to our data without cluttering the core code. The real magic of Annotated lies in its ability to handle composition and layering in application design. We’ll look at how to build from the inside out, starting with core business logic in pure Python and then layering on metadata to bridge the gap to higher-level application layers. By enriching primitive types with the annotated-types standard, we can enable (almost) zero-config test data generation and property-based testing using Polyfactory and Hypothesis. From there, we can layer on SQLAlchemy metadata to handle persistence without letting the database schema influence our data model, or use Pydantic to provide specialized data validation and serialization metadata—all within the same type definition. We will also see how Annotated serves as a single source of truth for documentation. We’ll explore annotated-doc as an alternative approach to documentation compared to traditional Sphinx or NumPy/Google-style docstrings, showing how to leverage type hints to keep our descriptions directly attached to the data they define. The goal is to show how composition and layering allow your core logic to stay stable while your infrastructure evolves independently. You’ll get a whirlwind tour of how the modern Python stack—including Pydantic, SQLAlchemy, and FastAPI—has converged on Annotated as a primary or at least first-class configuration interface. You'll walk away with a practical framework for using these integrations to keep your software design clean, decoupled, and easy to maintain in everyday development. This talk is for anyone interested in modern Python typing and effective application design. We’ll focus on how to use Annotated to bind your favorite libraries together and apply these patterns to your daily work. If you're familiar with basic type hints, you're ready to go—we'll build the rest from the ground up! europython-2026-91227-powering-up-your-types-with-annotated Web Development, Web APIs, Front-End Integration Vladyslav Fedoriuk en false https://programme.europython.eu/europython-2026/talk/HEUFDT/ https://programme.europython.eu/europython-2026/talk/HEUFDT/feedback/ S3A Talk 2026-07-17T14:35:00+02:00 14:35 00:30 Pandas now natively supports PyArrow-backed data types. But what does that actually mean? If you've ever wondered how these two libraries relate to each other, whether they compete or complement each other, and what happens to your data when it moves between them, this talk is for you. As PyArrow maintainers, we took on the challenge of digging into the conversion code between PyArrow and Pandas, and we're here to share what we've learned. We'll show you what's really going on under the hood: how Arrow's columnar format differs from Pandas' block-based memory layout (including what a BlockManager actually is), when data can be shared without copying, and when a full copy is unavoidable. We'll also clarify what each library is designed for and how they work together rather than against each other. With pandas increasingly adopting PyArrow as a backend, understanding this relationship is becoming essential rather than optional. This talk is aimed at Python developers and data engineers who want to deepen their understanding of what's happening beneath the surface. europython-2026-91056-stop-guessing-start-understanding-how-arrow-and-pandas-exchange-data Data Engineering and MLOps Alenka FrimRaúl Cumplido Domínguez en false https://programme.europython.eu/europython-2026/talk/ZFJEUJ/ https://programme.europython.eu/europython-2026/talk/ZFJEUJ/feedback/ S3A Talk 2026-07-17T15:30:00+02:00 15:30 00:30 One of the most exciting recent developments in Python is the addition of Android and iOS as officially-supported platforms. This allows us to reach far more users on the devices where they spend the most time. What does this mean for you as a Python package maintainer? If your package is pure-Python, then it'll probably just work. But if it uses C, Cython, Rust, or any other native-compiled language, then you'll have to take some steps to make it available to these new platforms. The mobile support status of the most popular packages on PyPI can be seen at [beeware.org/mobile-wheels](https://beeware.org/mobile-wheels). Let's help push those numbers up! Come to this talk to learn about: - Why mobile platforms are important for the future of Python - How to build your package for Android and iOS using cibuildwheel - How to test your mobile builds – even if you don't have Android or iOS hardware - How to distribute mobile packages to your users - How to automate all of these things in your CI system At the sprints, there will also be an opportunity to put this into practice, by getting personal assistance from the BeeWare team in building your package for mobile. europython-2026-91665-supporting-android-and-ios-in-your-python-package Tooling, Packaging, Developer Productivity Malcolm Smith en false https://programme.europython.eu/europython-2026/talk/MP9ZRM/ https://programme.europython.eu/europython-2026/talk/MP9ZRM/feedback/ S3B Talk 2026-07-17T10:10:00+02:00 10:10 00:30 With the rise of foundation models and zero-shot segmentation, it sometimes feels like fine-tuning classic object detection models is outdated. But is it? There are over 90 000 different LEGO bricks produced in almost 200 colors, and a single photo can easily contain hundreds of bricks. This makes LEGO recognition a perfect stress test for both traditional object detectors and the latest generation of vision models. During this talk, I will walk you through a practical comparison of approaches to LEGO brick detection. I will start with the classic object detection pipeline: dataset creation, annotation, and training with models like NanoDet and RF-DETR. Then, I will put these detectors up against zero-shot approaches: SAM 3 (Segment Anything Model 3), and vision language models, both closed-source APIs like Gemini and open-source alternatives like Qwen-VL. Along the way, I will share the pitfalls, surprising results, and lessons learned, including cases where a fine-tuned lightweight detector still outperforms models orders of magnitude larger. europython-2026-91527-is-object-detection-dead-a-case-for-recognizing-lego-bricks Machine Learning, NLP and CV Piotr Rybak en false https://programme.europython.eu/europython-2026/talk/RB9TKP/ https://programme.europython.eu/europython-2026/talk/RB9TKP/feedback/ S3B Talk 2026-07-17T11:45:00+02:00 11:45 00:30 A multitude of Python libraries offer Just In Time (JIT) compilation capabilities for general purpose computations, such as JAX or Numba. But in certain cases these solutions might not be enough, thus we seek more specialized solutions that can include domain knowledge as well. Compilers for Domain Specific Languages (DSL) allow us to incorporate additional information during compilation, possibly tied to a specific domain, such as sparse arrays computing. In this talk I'm going to introduce [Finch](https://finch-tensor.org/) - language and a compiler for sparse and structured multidimensional arrays, which specializes its kernels for control flow and data structures. It supports common control flow (loops, if conditions, etc.) and a wide variety of data structures - dense, sparse list, triangles, coordinate, or symmetry. The ongoing effort to move Finch from the original Julia implementation to pure Python exposed us to new ways of using Python - as a language for implementing compilers. In this talk I will present some key aspects of Python language and ecosystem which played a central role in making us productive in the last months during this undertaking: - Defining IRs with dataclasses and utilizing Structural Pattern Matching for term rewriting, - Using [Lark](https://lark-parser.readthedocs.io/en/stable/) for parsing custom languages into large IR structures, - Expressing complex rewrite schemes with [rewrite-tools](https://pypi.org/project/rewrite-tools/). The audience will learn our approach to designing the structure of a compiler, together with a few technical decisions made along the way. I hope these insights will be useful for engineers and scientists coming from closely related fields and projects also involving compiling custom languages, such as probabilistic programming or hardware design. europython-2026-91354-building-your-dsl-compiler-in-python Machine Learning: Research & Applications Mateusz Sokół en false https://programme.europython.eu/europython-2026/talk/SCZ8ZK/ https://programme.europython.eu/europython-2026/talk/SCZ8ZK/feedback/ S3B Sponsored 2026-07-17T12:25:00+02:00 12:25 00:30 What if AI could help design 3D worlds without taking creative control away from humans? In this talk, I will present a hosted Blender agent that creates and edits 3D scenes from natural language. The agent runs Blender headlessly inside Docker, communicates with it through a TCP socket protocol, and exposes Python-powered tools for scene creation, object manipulation, materials, screenshots, rendering, and asset import. It is built with the Microsoft Agent Framework and Azure AI Foundry, using Python as the bridge between the LLM, Blender’s scripting API, cloud storage, and the hosted runtime. More than a technical demo, this talk explores a potential future pipeline for AI-assisted 3D creation: a workflow where artists, game designers, architects, and developers can iteratively generate, inspect, modify, and refine 3D environments while keeping human control at every stage. Instead of replacing creative tools, the agent becomes a programmable collaborator that can accelerate repetitive work, propose variations, and turn high-level intent into editable Blender scenes. Through live examples, we will discuss what this could mean for the future of video game world-building, virtual production, and 3D architecture: faster prototyping, more accessible scene creation, and new ways to move from idea to interactive environment. Attendees will leave with a practical architecture for building Python agents that operate real creative software, and a grounded view of both the opportunities and current limitations of human-in-the-loop AI for 3D design. europython-2026-98192-when-python-agents-meet-3d-automating-blender-from-natural-language Python for Games, Art, Play and Expression David Rousset en false https://programme.europython.eu/europython-2026/talk/7NWR9R/ https://programme.europython.eu/europython-2026/talk/7NWR9R/feedback/ S3B Talk 2026-07-17T13:55:00+02:00 13:55 00:30 Our litigation against Apple in front of the European Court of Justice, pushing for sustainable long term funding for Free Software in the EU and member states, "Public Money? Public Code!", Device Neutrality, Router Freedom, Free Your Android, assistance with licensing questions, a European coding competition for teenagers, and a tale of software, skateboards, and raspberry ice cream. These are some of the activities by the Free Software Foundation Europe (FSFE), which at this year's Europython celebrates its 25 anniversary in empowering users to control technology. How would the world like in our area in 2048, if the FSFE has been successful? This talk will give an overview of the FSFE's vision, invite participants to give feedback on the next decades of our journey, and invite everyone to join those who shaped our work for software freedom at the FSFE's anniversary party on Saturday. europython-2026-99531-a-vision-for-software-freedom-in-2048 ~ None of these topics Matthias Kirschner en false https://programme.europython.eu/europython-2026/talk/R3GBYA/ https://programme.europython.eu/europython-2026/talk/R3GBYA/feedback/ S3B Talk 2026-07-17T14:35:00+02:00 14:35 00:30 None is probably the most overloaded value in Python — and often the wrong one. Python quietly depends on sentinel values: None, NotImplemented, Ellipsis, dataclasses.MISSING. They aren’t just placeholders. They define semantics, coordinate object interactions, and influence API design in subtle but powerful ways. In this talk, we treat sentinel values as a deliberate design tool. We’ll uncover how NotImplemented enables double dispatch, why None frequently conflates “missing” with “empty,” and how sentinel patterns permeate the standard library. But the real tension appears in typing. Python’s type system still cannot properly express sentinel semantics. Optional, overload, and Literal only approximate the problem, and building a fully typed custom sentinel remains an open challenge. We’ll examine the deferred PEP 661, what it tried to solve, and what its absence means today. Expect practical patterns, real-world examples, and a sharper way to think about absence in Python. europython-2026-91781-the-problem-with-none-sentinel-values-and-the-semantics-of-absence Python Core, Internals, Extensions Florian Wilhelm en false https://programme.europython.eu/europython-2026/talk/AXAV7D/ https://programme.europython.eu/europython-2026/talk/AXAV7D/feedback/ Glass room Talk 2026-07-17T14:30:00+02:00 14:30 01:30 Open source communities don’t grow because people contribute. They grow because contributors help create the next contributors. This interactive workshop introduces the **POPCOM Framework** (Participation, Ownership, Purpose, Connection, Opportunity, and Mentorship), a practical approach for understanding how communities create future contributors, organisers, mentors, and leaders. Who this workshop is for: - Meetup organizers - Conference organizers - Open source maintainers - Community managers - Volunteer leaders Participants will evaluate their own communities, identify areas for improvement, and design concrete change that they can take back and apply. Each participant walks out with: - a practical assessment of their own community - a framework for identifying strengths and gaps - a concrete experiment to improve participation, retention, and leadership development _The Experience Is the Community_ is one module in OCL (Open Community Leadership). You can run this workshop yourself. Adapt the timing to your community. Free to use, adapt, and share with attribution. europython-2026-101536-the-experience-is-the-community ~ None of these topics Georgi Ker en false https://programme.europython.eu/europython-2026/talk/LSNR3C/ https://programme.europython.eu/europython-2026/talk/LSNR3C/feedback/ Poster Hall A Poster 2026-07-17T12:55:00+02:00 12:55 01:00 Maintaining CI/CD configurations across dozens of Python projects means copying the same `tox` invocations, Python version matrices, and error-handling logic into every repository. This poster presents five architectural patterns from the `reusable-tox.yml` project that eliminate this duplication by applying familiar software engineering principles to GitHub Actions workflows. Each pattern is illustrated with a before/after YAML comparison and a Python code analogy, making the design decisions immediately recognizable to Python developers: * *Singular inputs* — accepting one Python version per workflow call instead of JSON arrays. Like writing `def run(version: str)` instead of `def run(versions: list[str])` — simpler to reason about, test, and compose via caller-side matrix strategies. * *Caller-side matrix strategy* — separating "what to test" (the calling workflow's job) from "how to test" (the reusable workflow's job). The same Separation of Concerns you'd apply to Python modules. * *Three-phase execution* — splitting `tox` runs into environment preparation (`tox --notest`), main execution, and debug rerun on failure. Like Unix pipelines — each stage transforms data through a single responsibility, improving cacheability and error diagnosis. * *Composite action hooks* — providing extension points where projects inject custom setup logic without modifying shared infrastructure, discovered automatically via `hashFiles()`. The Dependency Injection pattern applied to CI/CD. * *Explicit over implicit* — refusing to auto-detect `tox` environments or infer configuration. Predictable and debuggable beats magical and surprising. The poster includes a "Which pattern solves your problem?" decision flowchart and a QR code linking to the open-source repository with ready-to-fork templates. Born from maintaining dozens of Python projects including aiohttp, CherryPy, and pip-tools, these patterns treat CI/CD with the same architectural rigor as application code. europython-2026-91749-reusable-tox-yml-five-patterns-to-eliminate-ci-cd-boilerplate Tooling, Packaging, Developer Productivity Sviatoslav Sydorenko (Святослав Сидоренко) en false https://programme.europython.eu/europython-2026/talk/BX77EE/ https://programme.europython.eu/europython-2026/talk/BX77EE/feedback/ Poster Hall B Poster 2026-07-17T12:55:00+02:00 12:55 01:00 Over the last year, LLM-based coding agents have matured to the point where they can autonomously navigate codebases, edit files, run tests, and iterate on solutions with minimal human input. Many Python teams have started applying these agents to machine learning projects, where the volume of repetitive experimental work makes automation appealing. However, coding execution and ML optimization are not the same problem. In software engineering, success is often local and binary: a feature works or it does not, a bug is reproduced or fixed. In ML, code correctness is only a prerequisite. Progress is determined by measured model behavior across repeated experiments, and that measurement only happens after training and evaluation are complete. This distinction creates a coordination gap. Coding agents can generate and modify training code, but without external structure they drift over long experiment horizons. Teams encounter recurring failure modes: multiple coupled changes in a single step make results unattributable, LLMs lose context and rediscover already tested hypothesis in slightly different wording, etc. This poster presents an architecture that addresses the gap by pairing coding agents with a deterministic (non-LLM) orchestrator. The orchestrator manages experimentation as a tree search. It starts from a reproducible baseline, samples hypothesis-driven modifications constrained to a single aspect per step, evaluates each modification through a fixed entrypoint that returns multiple metrics, and decides which branches to expand or prune based on statistical evidence. Each experiment runs in an isolated git worktree, so every branch has a clean file state, an independent diff, and a separate log. An anti-repetition memory tracks previously attempted hypotheses across the tree to prevent the agent from regenerating equivalent ideas. When stopping criteria are met, an integration stage combines winning branches and evaluates the result. This presentation is aimed at ML engineers and data scientists who have experimented with (or are considering) coding agents for their workflows. Attendees will learn how to utilize coding agents for ML tasks and structure experiments as an LLM-searchable trajectory with deterministic controls rather than a sequence of ad-hoc edits. europython-2026-90963-why-coding-agents-fail-at-ml-and-how-to-fix-it Machine Learning, NLP and CV Olha Poliuliakh en false https://programme.europython.eu/europython-2026/talk/GP39VP/ https://programme.europython.eu/europython-2026/talk/GP39VP/feedback/ Poster Hall C Poster 2026-07-17T12:55:00+02:00 12:55 01:00 **PyPartMC** is a Pythonic interface to *PartMC*. PartMC (Particle Monte Carlo) is a stochastic, particle-resolved atmospheric aerosol dynamics model, used for solving aerosol processes such as coagulation, nucleation, emission, and deposition. Both projects are free and open-source. One of the main aims of the PyPartMC project is streamlining user experience. To use PartMC, you have to: work with UNIX shell, provide Fortran and C libraries, and perform standard Fortran and C source code configuration, compilation and linking. All of that boils down to a single **pip** package manager call with PyPartMC. Depending on the OS, PyPartMC will install from a binary wheel or compile from a source wheel containing all the dependencies. PyPartMC can operate on **Linux**, **Windows** and **MacOS**, and has been tested to install correctly on **Google Colab** Jupyter notebook cloud platform. The API is also callable from C++, Julia, and MATLAB. PyPartMC ships with a collection of introductory notebook examples, that can help with learning the library's API. From the developers point of view, PyPartMC is an interesting challenge, due to its **multi-language** environment. A C++ API is built on top of the Fortran one, leveraging the C-Fortran API. The Python interface is then constructed with the help of **nanobind** library. **PyPartMC** is part of **open-atmos**, which is a multi-institutional community hub for projects in atmospheric sciences (https://github.com/open-atmos). The development of this package is a collaboration between AGH University of Krakow and University of Illinois Urbana-Champaign. In the poster, I will outline the package features and architecture, and also highlight the newly engineered components and CI workflows engineered in our team at AGH. europython-2026-91511-pypartmc-a-pythonic-interface-enhancing-fortran-based-simulation-package Jupyter and Scientific Python Gracjan Adamus en false PyPartMC logo https://programme.europython.eu/europython-2026/talk/U7AHP3/ https://programme.europython.eu/europython-2026/talk/U7AHP3/feedback/