Uploaded August 2026 | Updated September 2026, 2 weeks ago
[EuroPython 2026 - S1 on 2026-07-15]
🎤 *Rust for High Performance Computing (HPC) in Python by Cheuk Ting Ho*
🔗 https://ep2026.europython.eu/session/rust-for-high-performance-computing-hpc-in-python
📝 Abstract:
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.
---
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: creativecommons.org/licenses/by-nc-sa/4.0
[EuroPython 2026 - S1 on 2026-07-15]
🎤 *Rust for High Performance Computing (HPC) in Python by Cheuk Ting Ho*
🔗 https://ep2026.europython.eu/session/rust-for-high-performance-computing-hpc-in-python
📝 Abstract:
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.
---
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: creativecommons.org/licenses/by-nc-sa/4.0
![Refactor, Optimize, and Test: Crafting Cleaner Python Code - Mohamed Elmaghraby
[EuroPython 2026 - S4 on 2026-07-17]
🎤 *Refactor, Optimize, and Test: Crafting Cleaner Python Code by Mohamed Elmaghraby*
🔗 https://ep2026.europython.eu/session/refactor-optimize-and-test-crafting-cleaner-python-code
📝 Abstract:
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 youre 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 Fowlers seminal works on refactoring and Python-specific insights shared at EuroPython 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/ Refactor, Optimize, and Test: Crafting Cleaner Python Code - Mohamed Elmaghraby](https://i.ytimg.com/vi/SIq-ZnJ9D6k/mqdefault.jpg)
![SPy: high-level Python, low-level performance, no overhead - Antonio Cuni
[EuroPython 2026 - S3B on 2026-07-17]
🎤 *SPy: high-level Python, low-level performance, no overhead by Antonio Cuni*
🔗 https://ep2026.europython.eu/session/spy-high-level-python-low-level-performance-no-overhead
📝 Abstract:
SPy is a Python variant designed for compilation: well-specified, debuggable, and expressive. It consists of a low-level core which gives control and speed comparable to C, Rust and Go, and powerful metaprogramming features which make possible to build high-level zero-cost abstractions. The result is something which is statically typed and as fast as C, but with the feeling and ease of Python.
This talk is a deep dive into the SPy core ideas: in particular, we will explore the internals of the language, show how many builtins are implemented in SPy itself, what zero cost abstraction means in practice and some end-to-end example of how high-level Python code is compiled into a low-level fast executable.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ SPy: high-level Python, low-level performance, no overhead - Antonio Cuni](https://i.ytimg.com/vi/SJ8Ws8Xv9jA/mqdefault.jpg)
![Lazy imports and the art of interpreter procrastination - Pablo Galindo Salgado, Noah Kim
[EuroPython 2026 - S1 on 2026-07-17]
🎤 *Lazy imports and the art of interpreter procrastination by Pablo Galindo Salgado, Noah Kim*
🔗 https://ep2026.europython.eu/session/lazy-imports-and-the-art-of-interpreter-procrastination
📝 Abstract:
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 Pythons history, and finally its here.
This presentation will take you through how we got here and where were going. Well 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. Well 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. Youll also learn about the future tooling that we are baking that will help you adopt this safely in your own projects.
Whether youre a beginner curious about Pythons future, someone looking to speed up your CLI tools, or you just want to understand whats happening under the hood, this talk will give you everything you need to start using lazy imports with confidence.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Lazy imports and the art of interpreter procrastination - Pablo Galindo Salgado, Noah Kim](https://i.ytimg.com/vi/SavVPtsqUf0/mqdefault.jpg)
![When Python Agents Meet 3D: Automating Blender from Natural Language - David Rousset
[EuroPython 2026 - S3B on 2026-07-17]
🎤 *When Python Agents Meet 3D: Automating Blender from Natural Language by David Rousset*
🔗 https://ep2026.europython.eu/session/when-python-agents-meet-3d-automating-blender-from-natural-language
📝 Abstract:
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.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ When Python Agents Meet 3D: Automating Blender from Natural Language - David Rousset](https://i.ytimg.com/vi/Sg6XOnJ5n1c/mqdefault.jpg)

![DuckLake - Take Python and DuckDB for a swim in your data lake - Marc-André Lemburg
[EuroPython 2026 - S4 on 2026-07-15]
🎤 *DuckLake - Take Python and DuckDB for a swim in your data lake by Marc-André Lemburg*
🔗 https://ep2026.europython.eu/session/ducklake-take-python-and-duckdb-for-a-swim-in-your-data-lake
📝 Abstract:
_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/
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ DuckLake - Take Python and DuckDB for a swim in your data lake - Marc-André Lemburg](https://i.ytimg.com/vi/TB2P7pb6uR8/mqdefault.jpg)




![The Hidden Cost of Complexity: Reducing Cognitive Load in Python - Jarosław Śmietanka
[EuroPython 2026 - S2 on 2026-07-16]
🎤 *The Hidden Cost of Complexity: Reducing Cognitive Load in Python by Jarosław Śmietanka*
🔗 https://ep2026.europython.eu/session/the-hidden-cost-of-complexity-reducing-cognitive-load-in-python
📝 Abstract:
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.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ The Hidden Cost of Complexity: Reducing Cognitive Load in Python - Jarosław Śmietanka](https://i.ytimg.com/vi/W8yhFsA3s3w/mqdefault.jpg)