June 7, 2025 - The Global Interpreter Lock (GIL) has long limited Python’s concurrency — until now. Python 3.13 is breaking boundaries with subinterpreters and the nogil prototype.

May 14, 2024 - I’m testing the subinterpreters interface because I’ll likely be taking advantage of it to improve scaling of this library across multiple threads. Subinterpreters are attractive because: I need more flexible shared memory than multiprocessing can provide.

May 3, 2024 - The proposed changes in PEP 554, which should come into effect for Python 3.13, are likely more interesting to the average Python developer, especially since they allow you to access this feature from Python. However, they’re really the fundamental building blocks for allowing more user-friendly access to subinterpreters.

November 17, 2023 - In Python 3.12 and ongoing in Python 3.13, the Python standard library extensions written in C are being tested and any global shared state is being moved to a new API that puts that state within either the module, or in the interpreter state.

Python 3.12 introduced a new parallel execution model called "sub interpreters" that uses a per-interpreter GIL to unlock a new way of writing parallel code that's faster than multiprocessing. Python 3.13 introduces another new parallel execution model called "free-threading" (previously called ...

August 20, 2024 - The quick conclusion that can be drawn is that "subinterpreters are really like multiprocessing with less overhead and shared memory", he said. Moving on to the free-threading interpreter (which is the preferred term for the no-GIL version), he noted that Python 3.13 beta 1, which had been ...

We plan three parallelizable pieces of work for 3.13: ... Enabling subinterpreters from Python code (PEP 554).

March 14, 2024 - That means that the GIL will still be on by default in Python 3.13 while they test the GIL-less version and find all the bugs the change causes. Hopefully, by 3.14 or so, they will know all the bugs and have them fixed to some degree or another. A related enhancement are subinterpreters, which Eric Snow has worked on for quite some time.

I have experience with using threads in Python, but I came to know that a concept of subinterpreters will be introduced in Python 3.13.

May 11, 2024 - Hopefully there'll be progress on the datetime module fully supporting subinterpreters and the new free-threading builds; it's pretty hard to take advantage of those features if it means you can't deal with times or dates.

Python 3.12 introduced a new parallel execution model called "sub interpreters" that uses a per-interpreter GIL to unlock a new way of writing parallel code that's faster than multiprocessing.

While approved, the PEP is not in its final form, and as of Python 3.13 the interpreters module suggested there is made available as _interpreters. (And before that, in Python 3.13, it is available as _xxsubinterpreters. With the implementation of PEP 684 before Python 3.12, using subinterpreters became a lot more interesting, because each subinterpreter now has an independent GIL.

Effects of the EXPERIMENTAL_ISOLATED_SUBINTERPRETERS macro: Good things! Per-interpreter GIL!!! Use a TSS to get the current Python thread state (‘tstate’)

Along with exposing the existing (in CPython) multiple interpreter support, the module will also support a basic mechanism for passing data between interpreters. That involves setting “shareable” objects in the __main__ module of a target subinterpreter. Some such objects, like os.pipe(), may be used to communicate further.

August 22, 2025 - Python 3.13 breaks circular imports through single-phase extension modules using non-isolated subinterpreters#138045

Subinterpreters are only supported on Python 3.13 or later

February 23, 2026 - PEP 684 introduces a per-interpreter GIL, so that sub-interpreters may now be created with a unique GIL per interpreter. This allows Python programs to take full advantage of multiple CPU cores.

A new per-Interpreter GIL in Python 3.12 helps to facilitate true parallelism by opening up sub interpreters to run Python codes at the same time. In addition, it is going to be easier to use these features in Python 3.13 by having support for sub interpreters in the Stdlib.

August 28, 2025 - For a deeper dive into the backstory, see Python 3.12: Subinterpreters. The Global Interpreter Lock (GIL) ensures that only one thread can execute Python bytecode at a time. While this design has simplified CPython’s memory management for decades, it has also been a fundamental bottleneck for CPU-bound multithreaded applications. Overcoming this limitation has been a major goal for the Python community, and Python 3.14 delivers a significant step forward. In Python 3.13...

June 9, 2024 - Python 3.12 introduced a new parallel execution model called "sub interpreters" that uses a per-interpreter GIL to unlock a new way of writing parallel code that's faster than multiprocessing.