Python 3.13 without GIL: Real-World Threading Finally Works

Tested Python 3.13's optional GIL. Shared results showing real multithreading gains, install steps, and when it outperforms multiprocessing.

May 23, 2025

Abhimanyu Saharan

Python 3.13 introduces the most significant concurrency improvement in CPython's history: the ability to disable the Global Interpreter Lock (GIL). Thanks to , Python can now execute native threads in parallel — not just in theory, but in practice.

Loading…

Mode	GIL Enabled	GIL Disabled	Performance Impact
Single-threaded	4.83s	4.80s	~identical
Multi-threaded	4.57s	2.32s	>2× faster without GIL
Multi-processing	2.51s	2.65s	Comparable

PYTHON_GIL=0 ./python3.13/bin/python3 script1.py
Python Version: 3.13.0 experimental free-threading build
GIL is currently disabled
Function 'single_threaded_task' took 4.8051 seconds to execute.
Function 'multi_threaded_task' took 2.3236 seconds to execute.
Function 'multi_processing_task' took 2.6521 seconds to execute.

PYTHON_GIL=1 ./python3.13/bin/python3 script1.py
Python Version: 3.13.0 experimental free-threading build
GIL is currently active
Function 'single_threaded_task' took 4.8303 seconds to execute.
Function 'multi_threaded_task' took 4.5740 seconds to execute.
Function 'multi_processing_task' took 2.5155 seconds to execute.

script1.py

import sys
import sysconfig
import math
import time
from threading import Thread
from multiprocessing import Process

def time_taken(func):
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"Function '{func.__name__}' took {end - start:.4f} seconds to execute.")
        return result
    return wrapper

def compute_intensive_task(num):
    return math.factorial(num)

@time_taken
def single_threaded_task(nums):
    for num in nums:
        compute_intensive_task(num)

@time_taken
def multi_threaded_task(nums):
    threads = []
    for num in nums:
        t = Thread(target=compute_intensive_task, args=(num,))
        threads.append(t)
        t.start()
    for t in threads:
        t.join()

@time_taken
def multi_processing_task(nums):
    processes = []
    for num in nums:
        p = Process(target=compute_intensive_task, args=(num,))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()

def main():
    print(f"Python Version: {sys.version}")
    gil_enabled = sys._is_gil_enabled()
    print("GIL is currently", "active" if gil_enabled else "disabled")

    nums = [300001] * 6

    single_threaded_task(nums)
    multi_threaded_task(nums)
    multi_processing_task(nums)

if __name__ == "__main__":
    main()