November 6, 2023 - This includes Interpreter objects that represent the underlying interpreters. The module will also provide a basic Queue class for communication between interpreters. Finally, we will add a new concurrent.futures.InterpreterPoolExecutor based on the interpreters module.

January 30, 2026 - The InterpreterPoolExecutor class uses a pool of interpreters to execute calls asynchronously. It is a ThreadPoolExecutor subclass, which means each worker is running in its own thread.

July 13, 2025 - import concurrent.futures from concurrent.futures import InterpreterPoolExecutor, ThreadPoolExecutor def fib(n): if n < 2: return n return fib(n-1) + fib(n-2) with InterpreterPoolExecutor(max_workers=5) as executor: futures = {executor.submit(fib, n): n for n in range(10)} for future in concurrent.futures.as_completed(futures): n = futures[future] data = future.result() print(f"fib({n}): {data}")

Python 3.14 adds a new module and APIs for creating sub-interpreters. (e.g. InterpreterPoolExecutor) Significant work has gone into CPython to make the Interpreter state a thread-local, meaning it’s possible to run multiple “Pythons” in the same process.

December 29, 2025 - Python 3.14 introduced InterpreterPoolExecutor. How is it different from ProcessPoolExecutor? Here are the ways they are similar: Both can utilize multiple CPU cores Both use pickle to share obje...

July 25, 2025 - Multiple interpreters: concurrent.interpreters (plus InterpreterPoolExecutor) gives you “process-like isolation, thread-ish cost.” Prototype an actor-style worker or a CPU-bound pool.

July 9, 2025 - from concurrent.futures import InterpreterPoolExecutor def w(): import time time.sleep(100) executor1 = InterpreterPoolExecutor() executor1.submit(w) executor1.submit(w) executor2 = InterpreterPoolExecutor() executor2.submit(w) executor2.submit(w) executor1.shutdown() executor2.shutdown()

August 28, 2025 - To make subinterpreters easy to use, the standard library now offers an InterpreterPoolExecutor in concurrent.futures. It works just like ThreadPoolExecutor or ProcessPoolExecutor. You submit callables, and you get back results.

May 6, 2025 - gh-133485: Use interpreters.Interpreter in InterpreterPoolExecutor #133957 · [3.14] gh-133485: Use interpreters.Interpreter in InterpreterPoolExecutor (gh-133957) #135695 · Reactions are currently unavailable · ericsnowcurrently ·

September 29, 2025 - from concurrent.futures import InterpreterPoolExecutor def heavy_calc(n): total = 0 for i in range(n): total += (i * i) % 7 return total if __name__ == "__main__": tasks = [50_000_000, 60_000_000, 70_000_000, 80_000_000] with InterpreterPoolExecutor() as executor: futures = [ executor.submit(heavy_calc, size) for size in tasks ] results = [f.result() for f in futures] print(results)

December 30, 2025 - import numpy as np from operator import pos as identity # pickle-able "identity" function from concurrent.futures import InterpreterPoolExecutor, ProcessPoolExecutor arr = np.array(range(10)) with InterpreterPoolExecutor() as executor: result = executor.submit(identity, arr).result() # ^-- raises NotShareableError: args not shareable assert np.all(arr == result)

December 27, 2025 - Python 3.14's new InterpreterPoolExecutor offers a lightweight alternative to ProcessPoolExecutor by using sub-interpreters instead of separate processes. This results in faster startup times and reduced memory overhead for parallel CPU-bound tasks.

July 7, 2025 - Bug report Bug description: When the _interpreters module which under the hood to implement InterpreterPoolExecutor does not exist, import concurrent.futures.InterpreterPoolExecutor will result Non...

November 12, 2024 - """ # Unlike all other executors, the InterpreterPoolExecutor does not # automatically inherit the parent process's sys.path. This is a # workaround to ensure that the worker has the same sys.path as the # parent process or tests will fail.

This is an implementation of InterpreterPoolExecutor that builds on ThreadPoolExecutor. This assumes that we're okay adding the executor separately from PEP 734. That PEP is about adding a new...

October 23, 2024 - from concurrent.futures.interpreter import InterpreterPoolExecutor with InterpreterPoolExecutor() as executor: future = executor.submit(lambda x: 10) result = future.result() print(result)

July 14, 2025 - import concurrent.futures from concurrent.futures import InterpreterPoolExecutor, ThreadPoolExecutor def fib(n): if n < 2: return n return fib(n-1) + fib(n-2) with InterpreterPoolExecutor(max_workers=5) as executor: futures = {executor.submit(fib, n): n for n in range(10)} for future in concurrent.futures.as_completed(futures): n = futures[future] data = future.result() print(f"fib({n}): {data}")

November 28, 2023 - This includes Interpreter objects that represent the underlying interpreters. The module will also provide a basic Queue class for communication between interpreters. Finally, we will add a new concurrent.futures.InterpreterPoolExecutor based on the interpreters module.

September 27, 2024 - Feature or enhancement Proposal: While we wait on PEP 734, there's nothing blocking us from adding a new executor for multiple interpreters. Doing so would allow people to start trying them out. (I wish I had thought of this for 3.13!) M...

October 7, 2025 - import concurrent.futures import random import statistics def pi(trials: int) -> float: Ncirc = 0 for _ in range(trials): x = random.uniform(-1, 1) y = random.uniform(-1, 1) if x * x + y * y <= 1: Ncirc += 1 return 4.0 * (Ncirc / trials) def pi_in_threads(threads: int, trials: int) -> float: if threads == 0: return pi(trials) with InterpreterPoolExecutor(max_workers=threads) as executor: return statistics.mean(executor.map(pi, [trials // threads] * threads))