Python 3.14 shipped Wednesday and the free-threaded build, which removes the global interpreter lock, is now what python.org offers as the default installer on Windows and macOS. That is a bigger change than any syntax addition in the past decade. The GIL has shaped how Python programs are written since 1992, forcing anyone who needed parallelism into multiprocessing, subinterpreters, or a rewrite in another language. Single-threaded performance in the free-threaded build now costs about 4 percent against the locked build, down from 40 percent when the work started in 2023. That number is what made the default switch defensible, and it took three years of specializing adaptive interpreter work to get there.
What changed to close the performance gap
Removing the GIL means every object's reference count becomes contended, and naive atomic increments on shared counters destroy performance. The implementation uses biased reference counting, where an object's owning thread updates a local count without atomics and other threads use a shared count, with a merge when ownership transfers. Most objects in a typical program are touched by one thread, so most reference counting stays cheap.
export async function handler(request: Request): Promise<Response> { const started = Date.now(); const upstream = await fetch(request); const headers = new Headers(upstream.headers); headers.set("x-skarvonix-ms", String(Date.now() - started)); return new Response(upstream.body, { status: upstream.status, headers, });}The second piece is deferred reference counting for objects that are effectively immortal, including small integers, interned strings, type objects, and module globals. Those get a flag that skips counting entirely. The third is a rewritten memory allocator with per-thread arenas that avoids a global lock on allocation. Together those three changes took the overhead from unusable to marginal. The remaining 4 percent comes mostly from lost optimizations in the interpreter loop that assumed exclusive access.
What actually gets faster
CPU-bound parallel work is the obvious win. A numerical simulation using threads instead of processes on a 16 core machine scaled to 13.2 times single-threaded throughput in the core team's benchmark, against 1.0 on the locked build where threads serialize. Anything that previously used multiprocessing gains from dropping the serialization cost of moving data between processes, which for large arrays was often the dominant expense.
Web serving is more nuanced. Most Python web workloads are input-output bound and already scale acceptably with the GIL because threads release it during blocking calls. The gain there comes from removing the multiple-process deployment pattern, which means one process holding one copy of loaded modules and caches rather than eight. A Django application in testing dropped from 3.2 gigabytes resident across eight workers to 780 megabytes in a single threaded process, which matters enormously for container density and cost.
The story is rarely the launch. It is what breaks, what ships, and who owns the mess at 2 a.m.
The extension ecosystem
C extensions are where free-threading breaks, because extension code written since 1992 assumed the GIL provided mutual exclusion for free. An extension that mutates a shared structure without its own lock is now a data race. The core team introduced an opt-in mechanism: extensions declare support through a module slot, and loading an extension that has not declared it causes the interpreter to re-enable the GIL for the whole process with a warning.
Coverage is better than skeptics expected. NumPy, pandas, PyTorch, Pillow, lxml, cryptography, psycopg, and SQLAlchemy's C accelerators all declare support as of their current releases. The long tail is where trouble lives, particularly older scientific packages with a single maintainer and Fortran underneath. PyPI now displays a free-threading compatibility indicator, and the current figure is that about 71 percent of the top 500 packages by download support it, up from 34 percent a year ago.
The new problems this creates
Python programmers have never had to think seriously about data races, because the GIL made most operations on built-in types atomic in practice. Appending to a list from two threads was safe. It still is, because the implementation added internal locking for built-in containers, a decision that cost some performance and prevented an enormous amount of broken code. But compound operations were never atomic and now fail more visibly, and code that got away with a check-then-act pattern will start producing wrong results under load.
The core team is direct about this in the documentation, and the recommendation is to use the same discipline any threaded language requires: locks around invariants spanning multiple operations, immutable data where possible, and queues for handing work between threads. That is a cultural change for a community that mostly avoided threads. Expect a year of blog posts about subtle bugs and a corresponding growth in the market for race detection tooling.
Migration advice
The safe path is to install 3.14 free-threaded, run your test suite, and check whether the interpreter re-enabled the GIL because of an extension. If it did, you have the old behavior and lost nothing. If it did not, your pure Python code is running without the lock and any latent race is now live. Running tests under load with repeated iterations catches most of what will bite, and the threading module gained a debug mode that reports lock-free access to objects shared across threads.
For libraries the work is larger. Any package shipping C extensions needs an audit of module-level state, static variables, and any cached objects, plus its own locking where shared mutation exists. The core team published a porting guide that is genuinely good, and several major projects have written up their experience. The consensus estimate from maintainers who have done it is two to six weeks for a medium-size extension, which is why the long tail will take years.
Skarvonix will keep following this beat with reporting grounded in how systems behave outside the launch keynote.
- Open Source
