Python 3.14, released on 7 October 2025, dropped the “experimental” label from the free-threaded build. That sounds like the GIL is gone. It is not. The standard build still has a global interpreter lock, and the free-threaded build is a separate, optional interpreter that is now officially supported. Understanding which PEP did what keeps you from either overselling it or ignoring it.

Two PEPs, two jobs

PEP 703, “Making the Global Interpreter Lock Optional in CPython,” is the engineering proposal. It described a build mode, enabled with the --disable-gil configure option, in which threads can run Python bytecode in parallel on multiple cores. That build first shipped in Python 3.13 as an explicitly experimental option.

PEP 779, “Criteria for supported status for free-threaded Python,” is the governance step. It is marked Final and targets 3.14. It was written by Thomas Wouters, Matt Page and Sam Gross, and its purpose is to define when the build can move from experimental to supported. It splits the road into three phases:

  • Phase I: the build exists but is experimental (Python 3.13).
  • Phase II: officially supported, but still optional (Python 3.14).
  • Phase III: free-threading becomes the default build. The PEP sets no criteria for this; a future PEP would decide it based on community support and demonstrated benefit.

So 3.14 is Phase II. Support means the core team commits to maintaining the build and keeping its APIs stable, not that it replaces the default.

What the criteria were

PEP 779 listed performance, memory, API and documentation criteria:

  • Performance: a target of no more than 15% slower than the GIL build on pyperformance, with the gap at the time of writing about 10%, and about 3% on macOS.
  • Memory: a target of no more than 20% higher memory use, with the gap at the time roughly 15 to 20%.
  • APIs: proven, stable APIs, with future changes following the PEP 387 backward-compatibility policy.
  • Documentation: better introductory material on free-threaded internals.

One caveat. The Steering Council accepted the PEP with its own list of Phase II requirements, and discussion of that acceptance describes tighter expectations than the PEP text, including a Stable ABI for free-threading targeted for 3.15. We read the acceptance only through the discussion thread, so check the Steering Council’s message itself if the exact numbers matter to you.

The 3.14 release notes report the outcome on speed: the specializing adaptive interpreter now runs in free-threaded mode, and the single-threaded penalty is roughly 5 to 10% depending on platform and compiler. The free-threading HOWTO gives a narrower range, an average of about 1% on macOS aarch64 and up to 8% on x86-64 Linux. Those are different measurements, so benchmark your own workload.

What changes for you

Nothing, until you opt in

Your default python is unchanged. The free-threaded build is installed separately: the python.org installers for macOS and Windows optionally include it, and other platforms use a community install guide or a source build. You can confirm which you have:

import sys, sysconfig

# 1 on a free-threaded build, 0 or None otherwise
print(sysconfig.get_config_var("Py_GIL_DISABLED"))

# False means the GIL is actually off in this process
print(sys._is_gil_enabled())

These calls come from the official free-threading documentation; we did not run them on a free-threaded build for this article.

The GIL can come back on

Two details matter. A free-threaded build can be told to run with the GIL via PYTHON_GIL=1 or -X gil=1. More importantly, importing a C extension that is not marked free-threading-compatible re-enables the GIL and prints a warning. Extensions are the main reason the lock returns, so your dependency tree decides whether you get parallelism. The community trackers at py-free-threading.github.io and hugovk.github.io/free-threaded-wheels list package support.

Memory behaves differently

Per the HOWTO, free-threaded builds use mimalloc instead of pymalloc, make some objects larger (for example None is 32 bytes rather than 16 on AMD64), and free some structures later through deferred reclamation. If a service is memory-constrained, measure it.

Thread-safety is still your job

Built-in dict, list and set use internal locks, so they behave much as under the GIL at the Python level. The documentation still recommends explicit threading.Lock or other primitives rather than relying on those internals, and warns that sharing one iterator across threads is generally unsafe. Code that was only accidentally safe because of the GIL, such as unsynchronized read-modify-write on shared state, is where you will find bugs first.

What “supported” commits the project to

The phrase has concrete consequences for library authors. Because the build is now Phase II, new experimental CPython projects are expected to be compatible with it, and API or ABI-breaking changes need agreement from the C API Working Group, according to the discussion of the Steering Council’s acceptance. Extension authors can therefore invest in free-threaded wheels without expecting the ground to shift under them, although the Stable ABI for free-threading is still to come, with 3.15 named as the target. On Windows there is also a small build change: the 3.14 notes say the build backend must now specify Py_GIL_DISABLED explicitly rather than the compiler inferring it.

For application teams, the practical effect is a clearer signal. Maintainers of popular libraries now have an official reason to publish free-threaded builds and fix thread-safety bugs, and the community trackers will show how quickly that happens in your own dependency tree.

Whether to try it

Free-threading pays off for CPU-bound work that can be split across threads in one process, and where processes are costly because of shared in-memory data. For I/O-bound services, asyncio and the standard build remain simpler. For single-threaded scripts, you pay a small speed cost for nothing.

A sensible path: install the free-threaded interpreter alongside your normal one, run your test suite under it with -X gil=0 to see which dependencies force the GIL back on, then benchmark a real parallel workload before changing any deployment. Support status means the build is a reasonable thing to evaluate now. It does not mean you should migrate.