Notice! Due to last minute complications, this talk will be given remotely.

The Global Interpreter Lock (GIL) has long been the single-core ceiling for CPU-bound Python. It throttles multi-core performance, complicates GPU data staging, reinforcement-learning pipelines, and pushes developers toward costly multiprocessing work-arounds. Removing it, however, is not as simple as flipping a switch: C-API extensions assume implicit serialization, and CPython’s own data structures are far from race-free.

We will cover:

• Free-threading mechanics – how fine-grained atomic operations and purpose-built critical-section macros replace the monolithic GIL without sacrificing safety;

• Memory-management rewrites – Biased Reference Counting (fast, non-atomic bumps for the thread that “owns” an object) and Deferred Reference Counting (batching updates from other threads) that together cut synchronization overhead dramatically;

• A new garbage collector – a stop-the-world pass that computes exact reference counts, drops generational heuristics, and pairs naturally with the new scheme;

• The allocator swap – why pymalloc gives way to mimalloc, delivering thread-safe, cache-friendly performance out of the box.

• Will see benchmarks

Attendees will leave with a clear picture of how free-threaded Python works, what it means for extension authors, and which workloads already see double-digit speed-ups. If you care about Python at scale—web servers, data pipelines, or reinforcement-learning loops—this session is your roadmap to a GIL-free future.