Uploaded June 2026 | Updated September 2026, 2 weeks ago
Our Platinum Sponsor of EuroPython 2026, Microsoft, is bringing talks, demos, and conversations on Python, AI, cloud-native development, agentic systems, and the latest innovations across the Microsoft developer ecosystem.
Join them in Kraków from 15-17 July, catch their sessions, and stop by the Microsoft booth to say hello!
Microsoft @ EuroPython: https://ep2026.europython.eu/sponsor/microsoft
Join us: https://europython.eu
Our Platinum Sponsor of EuroPython 2026, Microsoft, is bringing talks, demos, and conversations on Python, AI, cloud-native development, agentic systems, and the latest innovations across the Microsoft developer ecosystem.
Join them in Kraków from 15-17 July, catch their sessions, and stop by the Microsoft booth to say hello!
Microsoft @ EuroPython: https://ep2026.europython.eu/sponsor/microsoft
Join us: https://europython.eu

![How to tackle complex authorization logic (and dont go crazy) - Maria Lowas-Rzechonek
[EuroPython 2026 - S2 on 2026-07-17]
🎤 *How to tackle complex authorization logic (and dont go crazy) by Maria Lowas-Rzechonek*
🔗 https://ep2026.europython.eu/session/how-to-tackle-complex-authorization-logic-and-don-t-go-crazy
📝 Abstract:
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 thats 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.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ How to tackle complex authorization logic (and dont go crazy) - Maria Lowas-Rzechonek](https://i.ytimg.com/vi/f9nB1spVrMM/mqdefault.jpg)
![A vision for software freedom in 2048 - Matthias Kirschner
[EuroPython 2026 - S3B on 2026-07-17]
🎤 *A vision for software freedom in 2048 by Matthias Kirschner*
🔗 https://ep2026.europython.eu/session/a-vision-for-software-freedom-in-2048
📝 Abstract:
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 years 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 FSFEs 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 FSFEs anniversary party on Saturday.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ A vision for software freedom in 2048 - Matthias Kirschner](https://i.ytimg.com/vi/g6xiSY50zDM/mqdefault.jpg)
![Localization Made Easy: A Pythonic Approach to Global Applications - Mario García
[EuroPython 2026 - S3A on 2026-07-17]
🎤 *Localization Made Easy: A Pythonic Approach to Global Applications by Mario García*
🔗 https://ep2026.europython.eu/session/localization-made-easy-a-pythonic-approach-to-global-applications
📝 Abstract:
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.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Localization Made Easy: A Pythonic Approach to Global Applications - Mario García](https://i.ytimg.com/vi/gNmcEctBawI/mqdefault.jpg)
![EuroPython 2026 - Sponsor Highlight & Recruitment Fair
[EuroPython 2026 - S3A on 2026-07-17]
🎤 *Sponsor Highlight & Recruitment Fair*
🔗 https://ep2026.europython.eu/session/sponsor-highlight-recruitment-fair
📝 Abstract:
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.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ EuroPython 2026 - Sponsor Highlight & Recruitment Fair](https://i.ytimg.com/vi/gj-0Ml_coU4/mqdefault.jpg)


![AI Slop to AI Gold: Building Codebases That Last - Dan Jones
[EuroPython 2026 - S4 on 2026-07-16]
🎤 *AI Slop to AI Gold: Building Codebases That Last by Dan Jones*
🔗 https://ep2026.europython.eu/session/ai-slop-to-ai-gold-building-codebases-that-last
📝 Abstract:
AI can generate Python faster than ever before. It can also generate an astonishing amount of code that nobody wants to maintain.
Thats not a new problem.
Every generation of software tooling has made writing code cheaper while increasing the cost of poor engineering. AI is simply the latest example.
Some Python features and architectural patterns dont just catch bugs - they make them difficult to write in the first place. Those ideas werent designed for AI, but they may be exactly what AI needs.
AI hasnt changed what good software engineering looks like. Its made good software engineering impossible to ignore.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ AI Slop to AI Gold: Building Codebases That Last - Dan Jones](https://i.ytimg.com/vi/ik6Uy28TEVs/mqdefault.jpg)

![Fast and Furious: 26’s Tooling Stack for a Streamlined Developer Experience - Nacho Llorca
[EuroPython 2026 - S4 on 2026-07-17]
🎤 *Fast and Furious: 26’s Tooling Stack for a Streamlined Developer Experience by Nacho Llorca*
🔗 https://ep2026.europython.eu/session/fast-and-furious-26s-tooling-stack-for-a-streamlined-developer-experience
📝 Abstract:
Cohesive, automated quality checks are first-order necessities — especially as LLMs take on more code-writing responsibilities. But developer experience is just as critical: if type checking takes five minutes, developers either lose their flow or feel tempted to skip it. If linting isn’t enforced, reviewer fatigue skyrockets. Blink, and Copilot might commit an API key to your repo — and the list goes on.
The tooling pioneers we know and love (`black`, `mypy`, and others) paved the way, but a new generation of faster, more reliable tools — yup, rewritten in Rust — is here to guardrail and simplify development. This talk presents a setup for Python development, contrasting the available options.
*What you will learn:*
- *The dependency management wars:* Why `uv` has emerged as the gold standard over Poetry or Hatch.
- *One tool to rule them all:* How to use `just` as a command runner to unify your local and CI environments.
- *You shall not pass:* Setting up `ruff` for linting, `pyrefly` (or `ty`) for type hints, and `complexipy` for cyclomatic complexity to keep your codebase cohesive and maintainable. Using `prek` (instead of `pre-commit`) to enforce the standards , including Conventional Commits message syntax and secret detection with `gitleaks`. Replicating pre-commit checks (and test coverage!) with every push in your CI pipeline.
- *Release the troll:* Implementing `semantic-release` to automate versioning and PyPI publishing.
A configurable Copier template will be provided to explore different setups using these frameworks.
*Prerequisites:* Familiarity with Python development and basic CI/CD concepts. No Rust knowledge required (though a high tolerance for Rust-related puns is encouraged).
*Inspiration:* This talk is inspired by Florian Wilhelm’s _Streamlining Python Development: A Guide to a Modern Project Setup_ from PyConDE 2024.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Fast and Furious: 26’s Tooling Stack for a Streamlined Developer Experience - Nacho Llorca](https://i.ytimg.com/vi/jg1ZaqcK7ds/mqdefault.jpg)
![Python and HTTP/3: feel the difference in performance - Daniel Vahla
[EuroPython 2026 - S3B on 2026-07-15]
🎤 *Python and HTTP/3: feel the difference in performance by Daniel Vahla*
🔗 https://ep2026.europython.eu/session/python-and-http-3-feel-the-difference-in-performance
📝 Abstract:
# 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!
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Python and HTTP/3: feel the difference in performance - Daniel Vahla](https://i.ytimg.com/vi/jvbCworTC8A/mqdefault.jpg)