Python 3.13 does not remove the Global Interpreter Lock (GIL) from every CPython installation. It adds an optional, experimental free-threaded build that can run Python threads in parallel across available CPU cores. That can help some CPU-bound threaded programs, but it does not guarantee a speedup—and a C extension that is not marked as compatible can turn the GIL back on at runtime.
What changes when the GIL is disabled?
In a conventional CPython build, the GIL allows only one thread at a time to execute Python code. Python 3.13’s free-threaded build can disable that global lock, so multiple Python threads can execute in parallel on available CPU cores. PEP 703 describes the GIL as preventing multiple threads from executing Python code at the same time: PEP 703 – Making the Global Interpreter Lock Optional in CPython.
As an Amazon Associate I earn from qualifying purchases.
This is a different interpreter build, not a switch that transforms an ordinary Python installation into a universally lock-free interpreter. The implementation changes how CPython manages reference counts, memory, and thread safety; the practical result is more opportunity for parallel execution, along with performance and compatibility trade-offs.
Recommended Free Tools
Is free-threading the default in Python 3.13?
No. The standard GIL-enabled build remains the default. Free-threading is an experimental option in Python 3.13, and the GIL can still be enabled in a process that uses a free-threaded-capable build. The Python 3.13 documentation cautions: “The free-threaded mode is experimental and work is ongoing to improve it: expect some bugs and a substantial single-threaded performance hit.” See Python experimental support for free threading.
#1 Best Overall
Official macOS and Windows installers optionally include free-threaded binaries. The executable is commonly named python3.13t on macOS or Linux and python3.13t.exe on Windows. When building CPython from source, the documented configuration option is --disable-gil. The free-threaded executable is separate from the usual interpreter.
How to check whether your process is actually running without the GIL
Check both build capability and runtime state. A free-threaded build can support disabling the GIL while the GIL remains enabled in the current process.
-
Check whether the interpreter build supports free-threading:
Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.python3.13t -c 'import sysconfig; print(sysconfig.get_config_var("Py_GIL_DISABLED"))'A true value indicates a build configured for free-threading.
-
Check whether the GIL is disabled in the running process:
python3.13t -c 'import sys; print(sys._is_gil_enabled())'This reports the GIL’s current state. Run it in the same process, after the imports that matter; checking a separate, clean interpreter does not establish the state of your application.
-
Confirm the interpreter identity if needed. Python documents
python -VVandsys.versionas ways to identify a free-threaded build, but those identify the build rather than proving that the GIL is currently disabled.Recommended: Fix Windows Errors and Clear Junk Files in Minutes - Free Scan →Recommended: Crashes or Glitches? A Free Driver Scan Usually Finds the Culprit →Recommended: PC Feels Slow? A Free Scan Shows What's Dragging Windows Down →Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.
The GIL can be enabled with the PYTHON_GIL environment variable or the -X gil command-line option. Importing an unmarked C API extension may also enable it and print a warning. That is why the runtime check matters even when the executable has the free-threaded designation.
Will a threaded program become faster?
Only if the workload and program can use parallel execution effectively. Free-threading can benefit CPU-bound work structured across threads, but it is not an automatic speedup for every program. The result depends on the workload, hardware, synchronization costs, and whether all important dependencies allow the GIL to remain disabled.
There is a meaningful single-thread trade-off in Python 3.13. The Python Software Foundation’s Python 3.13 documentation, updated October 1, 2026, reports about 40% overhead for single-threaded execution on the pyperformance suite compared with the default GIL-enabled build. This is a result for that benchmark suite, not a prediction for every application. The documentation attributes the largest impact to the specializing adaptive interpreter being disabled in the free-threaded build. Programs spending most of their time in C extensions or doing I/O see less impact, according to the same documentation.
The documentation describes reducing overhead to 10% or less in a future release as an aim, not as a measured Python 3.13 result or a guarantee. For your own decision, measure the actual workload and compare single-thread performance, multi-thread scaling on the target hardware, runtime GIL state after dependencies load, and memory use.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →What happens to C extensions and packages?
C API extensions need to be built for the free-threaded interpreter and explicitly signal that they support running with the GIL disabled. If an extension is not marked as compatible, importing it may turn the GIL back on and emit a warning. A package installing successfully is therefore not proof that the application is still running without the GIL.
For installing packages with C extensions in the free-threaded build, Python 3.13’s “What’s New” documentation specifies pip 24.1 or newer. Check the current documentation for each dependency and verify the runtime GIL state after importing your application’s dependencies. Compatibility can vary by package version and build; do not assume that support for a package in one configuration establishes support in another.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Does free-threaded Python make shared data automatically safe?
No. Free-threaded CPython uses internal locks in built-in containers such as dict, list, and set to protect against some concurrent operations. That implementation detail is not a broad guarantee about the outcome of concurrent modifications. Python’s threading documentation covers the primitives available for coordinating threads; use an explicit threading.Lock or another suitable synchronization primitive when multiple threads access shared mutable state.
Python 3.13’s free-threaded documentation also identifies specific cautions:
-
Sharing one iterator object across threads is generally unsafe. Threads can see duplicate or missing elements, and the interpreter may crash.
-
Accessing a frame object from another thread can crash the program. The documentation says
sys._current_frames()is generally unsafe in a free-threaded build. -
Some objects are immortalized to reduce reference-count contention. Applications that create many such objects may use more memory.
These are specific limitations, not evidence that all existing Python programs will fail. They are reasons to review shared-state assumptions and test concurrency behavior rather than treating the absence of the GIL as a promise of automatic safety.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →When should you try the Python 3.13 free-threaded build?
It is most relevant when you have a CPU-bound workload that can be divided among threads, can test on the actual hardware, and can verify that the full dependency stack keeps the GIL disabled. It is a less compelling choice when the application depends on single-thread performance, relies on extensions without confirmed free-threaded support, or shares mutable data without explicit synchronization.
Compare the two builds against the same representative workload. Record single-thread performance, throughput with the intended thread count, memory use, and the result of sys._is_gil_enabled() after application imports. If the GIL turns back on or the workload does not scale, the free-threaded build may not deliver the intended benefit.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
