November 17, 2023 - class SubinterpreterWorker(threading.Thread): def __init__(self, number: int, config: Config, sockets: Sockets): self.worker_number = number self.interp = interpreters.create() self.channel = channels.create() self.config = config # TODO copy other parameters from config self.sockets = sockets super().__init__(target=self.run, daemon=True) def run(self): # Convert insecure sockets to a tuple of tuples because the Sockets type cannot be shared insecure_sockets = [] for s in self.sockets.insecure_sockets: insecure_sockets.append((int(s.family), int(s.type), s.proto, s.fileno())) interpreters.run

May 3, 2024 - In this tutorial, you'll preview one of the upcoming features of Python 3.12 and a proposed change to Python 3.13, addressing how subinterpreters work in the CPython program. The changes are described in PEP 684 and PEP 554.

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

The module is primarily meant to provide a basic API for managing interpreters (AKA “subinterpreters”) and running things in them.

See the Examples section for concrete usage and use cases. 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...

September 23, 2023 - On the other hand, each subinterpreter in Python has its own separate memory space, which can help to avoid these issues. However, this also means that sharing data between subinterpreters can be more complex. For example, subinterpreters can use the interpreters module to share data via channels, while threads can use the threading to share data via locks, queues, or other synchronization primitives.

August 5, 2025 - My solution for concurrency is almost always async, I've even made a similar case in Free Threaded Python With Asyncio. I am fully aware of how many people in the community dislike async. Unfortunately this is an opinion that could divide the community and is definitely a topic for another day. To marry subinterpreters with asyncio I created the package aiointerpreters. Here's a very basic example:

November 6, 2023 - In the case that code somewhere else may catch it, it is helpful to identify that the exception came from a subinterpreter (i.e. a “remote” source), rather than from the current interpreter. That’s why Interpreter.exec() raises ExecutionFailed and why it is a plain Exception, rather than a copy or proxy with a class that matches the original exception. For example, an uncaught ValueError from a subinterpreter would never get caught in a later try: ...

September 26, 2023 - That seems to suggest that accessing non-python resources is not actually possible, but correct me if I'm wrong. ... I haven't seen an example of this. According to the notes in extrainterpreters, for example, it says that ctypes is not importable with subinterpreters.

February 3, 2024 - Guests Anthony Shaw: @tonybaloney@fosstodon.org Eric Snow: @ericsnowcurrently@mastodon.social PEP 684 – A Per-Interpreter GIL: peps.python.org PEP 734 – Multiple Interpreters in the Stdlib: peps.python.org Running Python Parallel Applications with Sub Interpreters: fosstodon.org pytest subinterpreters: fosstodon.org Long-Term Vision for a Parallel Python Programming Model?: fosstodon.org Hypercorn Server: github.com msgspec: jcristharif.com Dill package: pypi.org Watch this episode on YouTube: youtube.com Episode #447 deep-dive: talkpython.fm/447 Episode transcripts: talkpython.fm ---== Don't be a stranger ==--- YouTube: youtube.com/@talkpython Bluesky: @talkpython.fm Mastodon: @talkpython@fosstodon.org X.com: @talkpython Michael on Bluesky: @mkennedy.codes Michael on Mastodon: @mkennedy@fosstodon.org Michael on X.com: @mkennedy

An example showing how to use sub interpreters and threads in Python - .dockerignore

An example project of how to use subinterpreters in the lastest version of the Python C API without threads - Sleemanmunk/python_subinterpreters_example

May 13, 2020 - Eric Snow's PEP 554 ("Multiple Interpreters in the Stdlib") would expose the existing subinterpreter support from the C API in the standard library. That would allow Python programs to use multiple separate interpreters; the PEP also proposes to add a way to share some data types between the instances.

3 weeks ago - Because sub-interpreters (and the main interpreter) are part of the same process, the insulation between them isn’t perfect — for example, using low-level file operations like os.close() they can (accidentally or maliciously) affect each other’s open files.

Still, at the eve of Python 3.14, I am issuing an small update so that the API as avaliable up to Python 3.13 is imported from the right place, and the structures in this project work. Just import "extrainterpreters" and use the Interpreter class as a wrapper to the subinterpreter represented by a single integer handle created by the new interpreters module:

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 me…

January 8, 2020 - As explained above, another example is gilstate that should also be moved to PyInterpreterState, but that's a complex change that should be well prepared to not break anything. Implementing subinterpreters also requires to cleanup various parts of Python internals.

Subinterpreters are only supported on Python 3.13 or later

October 3, 2025 - Hi - I thought that with the first class support for subinterpreters finally in the stdlib, my extrainterpreters pet project would be rendered all but obsolete. Nonetheless, I made a new release this week, changing just (and just) the importing names so that it could function with Python 3.14.