Python Free-Threaded Build: Threads in Parallel?

Yes, with a free-threaded build of Python (3.13+), threads can run in parallel on multiple CPU cores. This is a major change from the standard CPython build, where the Global Interpreter Lock (GIL) prevents true parallel execution of Python threads. This article explains what a free-threaded build is, how it works, how to get one, and what it means for your code.

What is the GIL and Why Does It Matter?

The Global Interpreter Lock (GIL) is a mutex in CPython that prevents multiple threads from executing Python bytecode simultaneously. It simplifies memory management (reference counting) and makes C extensions easier to write, but it also means that CPU-bound Python threads cannot run in parallel—they take turns, which can actually make them slower than a single thread due to context switching overhead. For I/O-bound tasks, threads still help because they release the GIL while waiting for I/O.

What is a Free-Threaded Build?

A free-threaded build is a CPython configuration compiled with the --disable-gil option. This removes the GIL, allowing multiple threads to execute Python bytecode simultaneously on different cores. It is an experimental feature introduced in Python 3.13, and it is designed to enable true parallelism for CPU-bound workloads without resorting to multiprocessing or external libraries.

How to Get a Free-Threaded Build

You can obtain a free-threaded build in a few ways:

Build from source: Download the CPython source and compile with --disable-gil (requires a C compiler and build tools).
Use a pre-built binary: Some distributions (e.g., the official Python.org Windows installer) offer a free-threaded variant labeled as “experimental.”
Use package managers: Some Linux package managers (e.g., conda-forge) provide free-threaded builds.

After installation, you can verify the build by checking sys._is_gil_enabled()—it returns False for free-threaded builds.

How to Enable Parallelism in Your Code

Simply using a free-threaded build does not automatically make your code faster. You still need to write code that can run in parallel. The threading module works as usual, but now threads can actually run concurrently. For CPU-bound tasks, you might see speedups if your code is thread-safe and avoids excessive locking. Example:

import threading

def work(n):
    # CPU-bound task
    return sum(i * i for i in range(n))

threads = []
for _ in range(4):
    t = threading.Thread(target=work, args=(10**6,))
    threads.append(t)
    t.start()
for t in threads:
    t.join()

In a free-threaded build, these four threads can run on four cores simultaneously (if available), potentially speeding up the total time.

Performance Gains and Limitations

The theoretical maximum speedup is limited by the number of CPU cores and the fraction of code that can be parallelized (Amdahl’s Law). For example, if 80% of your code is parallelizable and you have 4 cores, the maximum speedup is about 2.5x. In practice, overhead from thread synchronization and memory contention will reduce gains. Also, free-threaded builds are experimental: some C extensions may be incompatible or slower due to additional locking in the interpreter.

Common Problems and Misconceptions

One common misconception is that free-threaded builds are automatically faster for all programs. In reality, single-threaded programs may run slightly slower due to extra checks. Another issue is thread safety: without the GIL, shared mutable data requires explicit locks (e.g., threading.Lock) to avoid race conditions. Also, not all third-party libraries are free-threaded-ready; some may crash or behave unpredictably.

Alternatives to Free-Threaded Builds

If you cannot use a free-threaded build, there are alternatives for parallel execution:

multiprocessing: Spawns separate processes, each with its own GIL, allowing true parallelism. Overhead is higher due to inter-process communication.
asyncio: For I/O-bound tasks, async/await can achieve concurrency without threads.
C extensions / NumPy: Many CPU-heavy operations in libraries like NumPy release the GIL internally, so they already run in parallel.
JIT compilers: PyPy or Numba can speed up CPU-bound loops without threads.

Safety and Stability Considerations

Free-threaded builds are experimental and not recommended for production without thorough testing. The Python documentation warns that the GIL removal is a work in progress; memory management and C API changes may cause crashes. Always benchmark your specific workload and run extensive tests. Also, be aware that some debugging tools and profilers may not work correctly.

Frequently Asked Questions

Will my existing Python code run faster with a free-threaded build?

Not automatically. Only if your code is multi-threaded and CPU-bound, and you have multiple cores, you might see a speedup. Single-threaded code may be slightly slower.

Can I use third-party libraries like NumPy with a free-threaded build?

Many libraries are being adapted, but not all are compatible. Check the library’s documentation for free-threaded support. NumPy is working on it, but you may need to build from source.

How do I check if my Python is free-threaded?

Run import sys; print(sys._is_gil_enabled()). If it prints False, you have a free-threaded build.

Is the free-threaded build the same as PyPy or Jython?

No. PyPy and Jython are separate implementations of Python. The free-threaded build is still CPython, just compiled without the GIL.

Can I switch between standard and free-threaded builds easily?

You can install both side by side as separate Python executables. Just be careful about package installations—use virtual environments to keep dependencies separate.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.

More cards in this drawer

The whole Numbers and Powers drawer →