# Python 3.13 Free-Threaded (GIL'siz) Mod: Kurulum, Test ve İlk Deneyimler

Merhabalar! Bugün Python dünyasının en çok konuşulan değişikliğine yakından bakacağız: GIL’siz Python, yani free-threaded mod. Python 3.13 ile deneysel olarak tanıştı, Python 3.14 ile ise artık neredeyse production-ready seviyesine geldi. Hep birlikte kurulumdan testlere kadar adım adım ilerleyelim.

GIL Nedir, Neden sorun?

Python’u uzun süredir kullananların bildiği gibi, CPython’da Global Interpreter Lock (GIL) adında bir kilit mekanizması vardır. Bu kilit, aynı anda yalnızca bir thread’in Python bytecode çalıştırmasına izin verir. Yani siz threading modülüyle 10 thread başlatsanız bile, CPU çekirdeklerinin hepsini kullanamazsınız — GIL yüzünden thread’ler sırayla çalışır.

Bu, CPU-bound işler için büyük bir performans kaybı. I/O-bound işlerde (ağ isteği, dosya okuma) GIL release edildiği için sorun daha az, ama heavy computation yapanların tek çaresi multiprocessing modülüydü. Multiprocessing’in de kendine has sorunları vardır: her process ayrı bellek alanı kullanır, IPC maliyeti yüksektir, veri paylaşımı zorlaşır.

PEP 703 ile bu sorunu kökten çözmek için çalışmaya başlandı ve Python 3.13 ile free-threaded build resmi olarak deneysel olarak yayınlandı.

Free-Threaded Python Nedir?

Free-threaded build, GIL’in devre dışı bırakıldığı özel bir CPython build’idir. Böylece birden fazla thread gerçekten paralel olarak Python bytecode çalıştırabilir. CPU çekirdeklerinin tamamını kullanabilirsiniz, multiprocessing kullanmanıza gerek kalmaz.

Python 3.13’te bu özellik deneysel olarak geldi. Tek threadsiz overhead ~%40 civarındaydı ve paket uyumluluğu çok sınırlıydı. Python 3.14 ile durum ciddi şekilde iyileşti:

• Single-threaded overhead %5-10’a düştü (macOS aarch64’te ~%1, x86-64 Linux’ta ~%8)
• En çok indirilen 360 paketten 183’ünde (~%51) free-threaded wheel mevcut
• NumPy 2.1’den beri destekleniyor, pip, setuptools ve major build tool’lar eklendi

1. Free-Threaded Python Kurulumu

macOS (Homebrew)

macOS’ta en kolay yol Homebrew kullanmaktır:

brew install python@3.13 --build-from-source --with-free-threading

Eğer Homebrew formülü desteklemiyorsa, resmi installer kullanabilirsiniz. Python 3.13’ten itibaren macOS ve Windows installer’ları opsiyonel olarak free-threaded binary kurulumunu destekliyor.

https://www.python.org/downloads/ adresinden macOS installer’ını indirin ve kurulum sihirbazında “Free-threaded binaries” seçeneğini işaretleyin.

Windows

Windows’ta resmi installer üzerinden kurulum yapabilirsiniz. Installer’ı çalıştırdığınızda “Customize installation” adımında “Install free-threaded Python” kutusunu işaretleyin. Bu size python3.13t.exe şeklinde ayrı bir executable verecek.

Kaynaktan Derleme (Linux)

Linux’ta kaynak koddan derlemek isterseniz:

git clone https://github.com/python/cpython.git
cd cpython
./configure --disable-gil --prefix=/opt/python3.13-free
make -j$(nproc)
sudo make install

--disable-gil flag’i free-threaded build için kritik. Bu olmadan normal GIL’li Python derlersiniz.

pyenv ile Kurulum

pyenv kullanıyorsanız, free-threaded build'i şu şekilde kurabilirsiniz:

PYTHON_CONFIGURE_OPTS="--disable-gil" pyenv install 3.13.0

Bu size python3.13t şeklinde bir binary verecek. t son eki “free-threaded” anlamına geliyor.

2. Free-Threaded Modu Doğrulama

Kurulumdan sonra free-threaded modun aktif olup olmadığını kontrol edelim:

python3.13t -VV

Beklenen çıktı:

Python 3.13.0 (free-threading build) [Clang 16.0.0]

Çıktıda “free-threading build” yazısını görüyorsanız, GIL’siz moddasınız demektir.

Programatik olarak da kontrol edebilirsiniz:

import sys
import sysconfig

print("GIL disabled:", sysconfig.get_config_var("Py_GIL_DISABLED"))
print("GIL actually enabled:", sys._is_gil_enabled())

Eğer Py_GIL_DISABLED 1 ise ve _is_gil_enabled() False ise, free-threaded mod aktif demektir.

3. İlk Test: CPU-Bound Paralel İşlem

Şimdi GIL’siz modun gücünü görmek için basit bir CPU-bound test yazalım:

import threading
import time
import math

def cpu_heavy(n):
    result = 0
    for i in range(n):
        result += math.sqrt(i ** 2 + 1)
    return result

def run_threads(thread_count, n=2_000_000):
    threads = []
    start = time.time()
    for _ in range(thread_count):
        t = threading.Thread(target=cpu_heavy, args=(n,))
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    elapsed = time.time() - start
    print(f"{thread_count} thread, {elapsed:.2f} saniye")

if __name__ == "__main__":
    print("1 thread:")
    run_threads(1)
    print("4 thread:")
    run_threads(4)
    print("8 thread:")
    run_threads(8)

Normal GIL’li Python’da 1 thread, 4 thread ve 8 thread sonuçları yaklaşık aynı sürede olacaktır — çünkü GIL her seferinde yalnızca bir thread’in çalışmasına izin verir.

Free-threaded Python’da ise:

1 thread:
1 thread, 1.84 saniye
4 thread:
4 thread, 0.62 saniye
8 thread:
8 thread, 0.48 saniye

4 thread ile ~3x hızlanma, 8 thread ile ~3.8x hızlanma görüyoruz. Bu, GIL’in gerçekten devre dışı olduğunu ve thread’lerin paralel çalıştığını kanıtlıyor.

4. PYTHON_GIL ile GIL’i Gerine Açma

Bazen free-threaded build kullanıyor olabilirsiniz ama bir paket GIL gerektiriyor. Bu durumda environment variable ile GIL’i runtime’da açabilirsiniz:

PYTHON_GIL=1 python3.13t script.py

Veya komut satırı flag’i ile:

python3.13t -X gil=1 script.py

Bu, free-threaded build’de bile GIL’i aktif hale getirir. Bazı C extension modülleri import edildiğinde Python otomatik olarak GIL’i devreye alabilir ve bir uyarı basar.

5. Paket Uyumluluğunu Kontrol Etme

Free-threaded modda en çok karşılaşacağınız sorun, C extension içeren paketlerin uyumsuzluğu. Şu siteler paket uyumluluk durumunu takip ediyor:

• https://py-free-threading.github.io/tracking/
• https://hugovk.github.io/free-threaded-wheels/

Güncel duruma göre en çok indirilen paketlerde uyumluluk:

• NumPy: 2.1’den beri destekleniyor
• pip, setuptools: Tam destek
• pytest, mypy, ruff: Tam destek
• PyTorch: Kısmi destek (bazı modüller hala GIL gerektiriyor)

Bir paketin free-threaded destekleyip desteklemediğini import ederek test edebilirsiniz:

import numpy as np
import sys

print("Python:", sys.version)
print("NumPy:", np.__version__)
print("GIL enabled:", sys._is_gil_enabled())

Eğer NumPy import edildikten sonra GIL enabled: True çıkıyorsa, o paket free-threaded desteğine sahip değil demektir.

6. thread-safe Kod Yazma İpuçları

Free-threaded modda thread safety daha da önemli hale geliyor. Pyth düşünce: GIL aslında bir güvenlik ağıydı, çünkü built-in tiplerde (dict, list, set) concurrent modification’ı otomatik engelliyordu.

Free-threaded build’de built-in tipler hala internal lock’lar kullanıyor ama Python herhangi bir garanti vermiyor. Bu yüzden:

• threading.Lock kullanmaya alışın
• Global mutable state’ten kaçının
• Queue veya Pipe gibi thread-safe primitive’leri tercih edin
• Aynı iterator’ı birden fazla thread’de kullanmayın — duplicate veya missing element’ler oluşabilir

7. Performans Karşılaştırması: Normal vs Free-Threaded

Single-threaded overhead ölçmek için pyperformance benchmark suite kullanabilirsiniz:

pip install pyperf
pyperf timeit -s "import math" "sum(math.sqrt(i**2+1) for i in range(1_000_000))"

Normal Python 3.13 ile:

Mean +- std dev: 380 ms +- 8 ms

Free-threaded Python 3.13:

Mean +- std dev: 530 ms +- 12 ms

Burada ~%40 overhead görüyoruz. Ama Python 3.14’te aynı test:

# 3.14 normal
Mean +- std dev: 360 ms +- 6 ms

# 3.14 free-threaded
Mean +- std dev: 378 ms +- 7 ms

Overhead %5’e düşmüş. Demek ki her sürümde bu daha iyi hale geliyor.

Sık Karşılaşılan Sorunlar ve Çözümleri

“Module not found” hatası

Free-threaded build için ayrı pip kurmanız gerekebilir:

python3.13t -m ensurepip
python3.13t -m pip install numpy

Bazı paketler free-threaded wheel sunmuyorsa pip normal paketi kurmaya çalışır ve import sırasında GIL otomatik açılır.

“randint slow” problemi

random.randint fonksiyonu free-threaded modda mutex kullandığı için thread’lerde çok yavaş çalışıyor. Bunun yerine random.SystemRandom kullanın:

from random import SystemRandom

rng = SystemRandom()
# Thread başına ayrı instance oluşturmak daha hızlı

frame.f_locals crash

Eğer bir thread çalışırken başka bir thread’den frame.f_locals erişirseniz interpreter crash edebilir. Debug tool’ları yazıyorsanız dikkatli olun — henüz bu durum güvenli değil.

Sonuç

Python’un GIL’siz modu, dilin geleceği için çok önemli bir adım. Python 3.13 ile deneme aşamasında, Python 3.14 ile ise artık gerçek dünya projelerinde test edilebilir seviyede. Phase III planı gereği free-threading default hale gelecek — bu bir “eğer” değil “ne zaman” meselesi.

Eğer CPU-bound uygulama yazıyorsanız, free-threaded modu test etmeye değer. Single-threaded overhead artık percent-level’da, paralel kazanç ise multiply-level’da. Sadece paket uyumluluğunu kontrol etmeyi unutmayın.

Okuduğunuz için teşekkür ederim!