Starting with Python 3.13, we’re getting access to an experimental free-threading build that removes Python’s Global Interpreter Lock (GIL). This isn’t just another performance tweak - it’s a fundamental shift in how Python handles concurrency, as outlined in PEP 703 (Making the Global Interpreter Lock Optional in CPython).

The GIL has long been one of Python’s most significant limitations, preventing true parallel execution of Python code. While we can try to work around it using multiprocessing, these workarounds often place constraints and memory penalties we can’t look away. The impact goes beyond just performance - it affects how we design libraries, structure our applications, and express concurrent operations.

Drawing from real-world example, and demonstrations, this talk will try to answer:

• How can we try out the free threading python build, and run parallel code.
• What changes when we remove the GIL. We gain speed, but what do we lose?
• The experimental stage we are in. Is it a new sharp knife in our toolbox, or toy to play around on weekends?
• Shared memory is much faster than message passing. Our code should fly now, right?
• Should we ditch multiprocessing then?
• Don’t we have numpy, and a bunch of ML/AI libraries already running in parallel and even on GPUs? Why should I care about this?
• How can existing libraries and codebases leverage these new capabilities?
• What the future may hold for Python concurrency, and what is already on the way with 3.14