What's new in Python 3.14

Editors
Adam Turner and Hugo van Kemenade

* Anyone can add text to this document. Do not spend very much time on the wording of your changes, because your text will probably get rewritten to some degree.

* The maintainer will go through Misc/NEWS periodically and add changes; it's therefore more important to add your changes to Misc/NEWS than to this file.

* This is not a complete list of every single change; completeness is the purpose of Misc/NEWS. Some changes I consider too small or esoteric to include. If such a change is added to the text, I'll just remove it. (This is another reason you shouldn't spend too much time on writing your addition.)

* If you want to draw your new text to the attention of the maintainer, add 'XXX' to the beginning of the paragraph or section.

* It's OK to just add a fragmentary note about a change. For example: "XXX Describe the transmogrify() function added to the socket module." The maintainer will research the change and write the necessary text.

* You can comment out your additions if you like, but it's not necessary (especially when a final release is some months away).

* Credit the author of a patch or bugfix. Just the name is sufficient; the e-mail address isn't necessary.

• It's helpful to add the issue number as a comment:

XXX Describe the transmogrify() function added to the socket module. (Contributed by P.Y. Developer in 12345.)

This saves the maintainer the effort of going through the VCS log when researching a change.

This article explains the new features in Python 3.14, compared to 3.13. Python 3.14 was released on 7 October 2025. For full details, see the changelog <changelog>.

Summary -- Release highlights

Python 3.14 is a stable release of the Python programming language, with a mix of changes to the language, the implementation, and the standard library. The biggest changes include template string literals <whatsnew314-template-string-literals>, deferred evaluation of annotations <whatsnew314-deferred-annotations>, and support for subinterpreters <whatsnew314-multiple-interpreters> in the standard library.

The library changes include significantly improved capabilities for introspection in asyncio <whatsnew314-asyncio-introspection>, support for Zstandard <whatsnew314-zstandard> via a new compression.zstd module, syntax highlighting in the REPL, as well as the usual deprecations and removals, and improvements in user-friendliness and correctness.

This article doesn't attempt to provide a complete specification of all new features, but instead gives a convenient overview. For full details refer to the documentation, such as the Library Reference <library-index> and Language Reference <reference-index>. To understand the complete implementation and design rationale for a change, refer to the PEP for a particular new feature; but note that PEPs usually are not kept up-to-date once a feature has been fully implemented. See Porting to Python 3.14 for guidance on upgrading from earlier versions of Python.

---

Interpreter improvements:

• 649 and 749: Deferred evaluation of annotations <whatsnew314-deferred-annotations>
• 734: Multiple interpreters in the standard library <whatsnew314-multiple-interpreters>
• 750: Template strings <whatsnew314-template-string-literals>
• 758: Allow except and except* expressions without brackets <whatsnew314-bracketless-except>
• 765: Control flow in finally blocks <whatsnew314-finally-syntaxwarning>
• 768: Safe external debugger interface for CPython <whatsnew314-remote-debugging>
• A new type of interpreter <whatsnew314-tail-call-interpreter>
• Free-threaded mode improvements <whatsnew314-free-threaded-cpython>
• Improved error messages <whatsnew314-improved-error-messages>
• Incremental garbage collection <whatsnew314-incremental-gc>

Significant improvements in the standard library:

• 784: Zstandard support in the standard library <whatsnew314-zstandard>
• whatsnew314-asyncio-introspection
• whatsnew314-concurrent-warnings-control
• Syntax highlighting in the default interactive shell <whatsnew314-pyrepl-highlighting>, and color output in several standard library CLIs

C API improvements:

• 741: Python configuration C API <whatsnew314-capi-config>

Platform support:

• 776: Emscripten is now an officially supported platform <whatsnew314-build-changes>, at tier 3 <11#tier-3>.

Release changes:

• 779: Free-threaded Python is officially supported <whatsnew314-free-threaded-now-supported>
• 761: PGP signatures have been discontinued for official releases <whatsnew314-no-more-pgp>
• Windows and macOS binary releases now support the experimental just-in-time compiler <whatsnew314-jit-compiler>
• Binary releases for Android are now provided <whatsnew314-build-changes>

New features

649 & 749: Deferred evaluation of annotations

The annotations <annotation> on functions, classes, and modules are no longer evaluated eagerly. Instead, annotations are stored in special-purpose annotate functions <annotate function> and evaluated only when necessary (except if from __future__ import annotations is used).

This change is designed to improve performance and usability of annotations in Python in most circumstances. The runtime cost for defining annotations is minimized, but it remains possible to introspect annotations at runtime. It is no longer necessary to enclose annotations in strings if they contain forward references.

The new annotationlib module provides tools for inspecting deferred annotations. Annotations may be evaluated in the ~annotationlib.Format.VALUE format (which evaluates annotations to runtime values, similar to the behavior in earlier Python versions), the ~annotationlib.Format.FORWARDREF format (which replaces undefined names with special markers), and the ~annotationlib.Format.STRING format (which returns annotations as strings).

This example shows how these formats behave:

The porting <whatsnew314-porting-annotations> section contains guidance on changes that may be needed due to these changes, though in the majority of cases, code will continue working as-is.

(Contributed by Jelle Zijlstra in 749 and 119180; 649 was written by Larry Hastings.)

734: Multiple interpreters in the standard library

The CPython runtime supports running multiple copies of Python in the same process simultaneously and has done so for over 20 years. Each of these separate copies is called an 'interpreter'. However, the feature had been available only through the C-API <sub-interpreter-support>.

That limitation is removed in Python 3.14, with the new concurrent.interpreters module.

There are at least two notable reasons why using multiple interpreters has significant benefits:

• they support a new (to Python), human-friendly concurrency model
• true multi-core parallelism

For some use cases, concurrency in software improves efficiency and can simplify design, at a high level. At the same time, implementing and maintaining all but the simplest concurrency is often a struggle for the human brain. That especially applies to plain threads (for example, threading), where all memory is shared between all threads.

With multiple isolated interpreters, you can take advantage of a class of concurrency models, like Communicating Sequential Processes (CSP) or the actor model, that have found success in other programming languages, like Smalltalk, Erlang, Haskell, and Go. Think of multiple interpreters as threads but with opt-in sharing.

Regarding multi-core parallelism: as of Python 3.12, interpreters are now sufficiently isolated from one another to be used in parallel (see 684). This unlocks a variety of CPU-intensive use cases for Python that were limited by the GIL.

Using multiple interpreters is similar in many ways to multiprocessing, in that they both provide isolated logical "processes" that can run in parallel, with no sharing by default. However, when using multiple interpreters, an application will use fewer system resources and will operate more efficiently (since it stays within the same process). Think of multiple interpreters as having the isolation of processes with the efficiency of threads.

While the feature has been around for decades, multiple interpreters have not been used widely, due to low awareness and the lack of a standard library module. Consequently, they currently have several notable limitations, which are expected to improve significantly now that the feature is going mainstream.

Current limitations:

• starting each interpreter has not been optimized yet
• each interpreter uses more memory than necessary (work continues on extensive internal sharing between interpreters)
• there aren't many options yet for truly sharing objects or other data between interpreters (other than memoryview)
• many third-party extension modules on PyPI are not yet compatible with multiple interpreters (all standard library extension modules are compatible)
• the approach to writing applications that use multiple isolated interpreters is mostly unfamiliar to Python users, for now

The impact of these limitations will depend on future CPython improvements, how interpreters are used, and what the community solves through PyPI packages. Depending on the use case, the limitations may not have much impact, so try it out!

Furthermore, future CPython releases will reduce or eliminate overhead and provide utilities that are less appropriate on PyPI. In the meantime, most of the limitations can also be addressed through extension modules, meaning PyPI packages can fill any gap for 3.14, and even back to 3.12 where interpreters were finally properly isolated and stopped sharing the GIL. Likewise, libraries on PyPI are expected to emerge for high-level abstractions on top of interpreters.

Regarding extension modules, work is in progress to update some PyPI projects, as well as tools like Cython, pybind11, nanobind, and PyO3. The steps for isolating an extension module are found at isolating-extensions-howto. Isolating a module has a lot of overlap with what is required to support free-threading <whatsnew314-free-threaded-cpython>, so the ongoing work in the community in that area will help accelerate support for multiple interpreters.

Also added in 3.14: concurrent.futures.InterpreterPoolExecutor <whatsnew314-concurrent-futures-interp-pool>.

(Contributed by Eric Snow in 134939.)

750: Template string literals

Template strings are a new mechanism for custom string processing. They share the familiar syntax of f-strings but, unlike f-strings, return an object representing the static and interpolated parts of the string, instead of a simple str.

To write a t-string, use a 't' prefix instead of an 'f':

~string.templatelib.Template objects provide access to the static and interpolated (in curly braces) parts of a string before they are combined. Iterate over !Template instances to access their parts in order:

It's easy to write (or call) code to process !Template instances. For example, here's a function that renders static parts lowercase and ~string.templatelib.Interpolation instances uppercase:

from string.templatelib import Interpolation

def lower_upper(template):
    """Render static parts lowercase and interpolations uppercase."""
    parts = []
    for part in template:
        if isinstance(part, Interpolation):
            parts.append(str(part.value).upper())
        else:
            parts.append(part.lower())
    return ''.join(parts)

name = 'Wenslydale'
template = t'Mister {name}'
assert lower_upper(template) == 'mister WENSLYDALE'

Because !Template instances distinguish between static strings and interpolations at runtime, they can be useful for sanitising user input. Writing a !html function that escapes user input in HTML is an exercise left to the reader! Template processing code can provide improved flexibility. For instance, a more advanced !html function could accept a !dict of HTML attributes directly in the template:

attributes = {'src': 'limburger.jpg', 'alt': 'lovely cheese'}
template = t'<img {attributes}>'
assert html(template) == '<img src="limburger.jpg" alt="lovely cheese" />'

Of course, template processing code does not need to return a string-like result. An even more advanced !html could return a custom type representing a DOM-like structure.

With t-strings in place, developers can write systems that sanitise SQL, make safe shell operations, improve logging, tackle modern ideas in web development (HTML, CSS, and so on), and implement lightweight custom business DSLs.

(Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran, and Pablo Galindo Salgado in 132661.)

768: Safe external debugger interface

Python 3.14 introduces a zero-overhead debugging interface that allows debuggers and profilers to safely attach to running Python processes without stopping or restarting them. This is a significant enhancement to Python's debugging capabilities, meaning that unsafe alternatives are no longer required.

The new interface provides safe execution points for attaching debugger code without modifying the interpreter's normal execution path or adding any overhead at runtime. Due to this, tools can now inspect and interact with Python applications in real-time, which is a crucial capability for high-availability systems and production environments.

For convenience, this interface is implemented in the sys.remote_exec function. For example:

import os, sys
from tempfile import NamedTemporaryFile

with NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
    script_path = f.name
    f.write(f'import my_debugger; my_debugger.connect({os.getpid()})')

# Execute in process with PID 1234
print('Behold! An offering:')
sys.remote_exec(1234, script_path)

This function allows sending Python code to be executed in a target process at the next safe execution point. However, tool authors can also implement the protocol directly as described in the PEP, which details the underlying mechanisms used to safely attach to running processes.

The debugging interface has been carefully designed with security in mind and includes several mechanisms to control access:

• A PYTHON_DISABLE_REMOTE_DEBUG environment variable.
• A -X disable-remote-debug command-line option.
• A --without-remote-debug configure flag to completely disable the feature at build time.

(Contributed by Pablo Galindo Salgado, Matt Wozniski, and Ivona Stojanovic in 131591.)

A new type of interpreter

A new type of interpreter has been added to CPython. It uses tail calls between small C functions that implement individual Python opcodes, rather than one large C case statement. For certain newer compilers, this interpreter provides significantly better performance. Preliminary benchmarks suggest a geometric mean of 3-5% faster on the standard pyperformance benchmark suite, depending on platform and architecture. The baseline is Python 3.14 built with Clang 19, without this new interpreter.

This interpreter currently only works with Clang 19 and newer on x86-64 and AArch64 architectures. However, a future release of GCC is expected to support this as well.

This feature is opt-in for now. Enabling profile-guided optimization is highly recommended when using the new interpreter as it is the only configuration that has been tested and validated for improved performance. For further information, see --with-tail-call-interp.

[!NOTE] This is not to be confused with tail call optimization of Python functions, which is currently not implemented in CPython.

This new interpreter type is an internal implementation detail of the CPython interpreter. It doesn't change the visible behavior of Python programs at all. It can improve their performance, but doesn't change anything else.

(Contributed by Ken Jin in 128563, with ideas on how to implement this in CPython by Mark Shannon, Garrett Gu, Haoran Xu, and Josh Haberman.)

Free-threaded mode improvements

CPython's free-threaded mode (703), initially added in 3.13, has been significantly improved in Python 3.14. The implementation described in PEP 703 has been finished, including C API changes, and temporary workarounds in the interpreter were replaced with more permanent solutions. The specializing adaptive interpreter (659) is now enabled in free-threaded mode, which along with many other optimizations greatly improves its performance. The performance penalty on single-threaded code in free-threaded mode is now roughly 5-10%, depending on the platform and C compiler used.

From Python 3.14, when compiling extension modules for the free-threaded build of CPython on Windows, the preprocessor variable Py_GIL_DISABLED now needs to be specified by the build backend, as it will no longer be determined automatically by the C compiler. For a running interpreter, the setting that was used at compile time can be found using sysconfig.get_config_var.

The new -X context_aware_warnings <-X> flag controls if concurrent safe warnings control <whatsnew314-concurrent-warnings-control> is enabled. The flag defaults to true for the free-threaded build and false for the GIL-enabled build.

A new ~sys.flags.thread_inherit_context flag has been added, which if enabled means that threads created with threading.Thread start with a copy of the ~contextvars.Context() of the caller of ~threading.Thread.start. Most significantly, this makes the warning filtering context established by ~warnings.catch_warnings be "inherited" by threads (or asyncio tasks) started within that context. It also affects other modules that use context variables, such as the decimal context manager. This flag defaults to true for the free-threaded build and false for the GIL-enabled build.

(Contributed by Sam Gross, Matt Page, Neil Schemenauer, Thomas Wouters, Donghee Na, Kirill Podoprigora, Ken Jin, Itamar Oren, Brett Simmers, Dino Viehland, Nathan Goldbaum, Ralf Gommers, Lysandros Nikolaou, Kumar Aditya, Edgar Margffoy, and many others. Some of these contributors are employed by Meta, which has continued to provide significant engineering resources to support this project.)

Improved error messages

• The interpreter now provides helpful suggestions when it detects typos in Python keywords. When a word that closely resembles a Python keyword is encountered, the interpreter will suggest the correct keyword in the error message. This feature helps programmers quickly identify and fix common typing mistakes. For example:

  >>> whille True:
  ...     pass
  Traceback (most recent call last):
    File "<stdin>", line 1
      whille True:
      ^^^^^^
  SyntaxError: invalid syntax. Did you mean 'while'?
  

  While the feature focuses on the most common cases, some variations of misspellings may still result in regular syntax errors. (Contributed by Pablo Galindo in 132449.)

• elif statements that follow an else block now have a specific error message. (Contributed by Steele Farnsworth in 129902.)

  >>> if who == "me":
  ...     print("It's me!")
  ... else:
  ...     print("It's not me!")
  ... elif who is None:
  ...     print("Who is it?")
  File "<stdin>", line 5
    elif who is None:
    ^^^^
  SyntaxError: 'elif' block follows an 'else' block
  

• If a statement is passed to the if_expr after else, or one of pass, break, or continue is passed before if, then the error message highlights where the ~python-grammar:expression is required. (Contributed by Sergey Miryanov in 129515.)

  >>> x = 1 if True else pass
  Traceback (most recent call last):
    File "<string>", line 1
      x = 1 if True else pass
                         ^^^^
  SyntaxError: expected expression after 'else', but statement is given
  
  >>> x = continue if True else break
  Traceback (most recent call last):
    File "<string>", line 1
      x = continue if True else break
          ^^^^^^^^
  SyntaxError: expected expression before 'if', but statement is given
  

• When incorrectly closed strings are detected, the error message suggests that the string may be intended to be part of the string. (Contributed by Pablo Galindo in 88535.)

  >>> "The interesting object "The important object" is very important"
  Traceback (most recent call last):
  SyntaxError: invalid syntax. Is this intended to be part of the string?
  

• When strings have incompatible prefixes, the error now shows which prefixes are incompatible. (Contributed by Nikita Sobolev in 133197.)

  >>> ub'abc'
    File "<python-input-0>", line 1
      ub'abc'
      ^^
  SyntaxError: 'u' and 'b' prefixes are incompatible
  

• Improved error messages when using as with incompatible targets in:

  • Imports: import ... as ...
  • From imports: from ... import ... as ...
  • Except handlers: except ... as ...
  • Pattern-match cases: case ... as ...

  (Contributed by Nikita Sobolev in 123539, 123562, and 123440.)

• Improved error message when trying to add an instance of an unhashable type to a dict or set. (Contributed by CF Bolz-Tereick and Victor Stinner in 132828.)

  >>> s = set()
  >>> s.add({'pages': 12, 'grade': 'A'})
  Traceback (most recent call last):
    File "<python-input-1>", line 1, in <module>
      s.add({'pages': 12, 'grade': 'A'})
      ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  TypeError: cannot use 'dict' as a set element (unhashable type: 'dict')
  >>> d = {}
  >>> l = [1, 2, 3]
  >>> d[l] = 12
  Traceback (most recent call last):
    File "<python-input-4>", line 1, in <module>
      d[l] = 12
      ~^^^
  TypeError: cannot use 'list' as a dict key (unhashable type: 'list')
  

• Improved error message when an object supporting the synchronous context manager protocol is entered using async with instead of with, and vice versa for the asynchronous context manager protocol. (Contributed by Bénédikt Tran in 128398.)

784: Zstandard support in the standard library

The new compression package contains modules !compression.lzma, !compression.bz2, !compression.gzip and !compression.zlib which re-export the lzma, bz2, gzip and zlib modules respectively. The new import names under !compression are the preferred names for importing these compression modules from Python 3.14. However, the existing modules names have not been deprecated. Any deprecation or removal of the existing compression modules will occur no sooner than five years after the release of 3.14.

The new compression.zstd module provides compression and decompression APIs for the Zstandard format via bindings to Meta's zstd library. Zstandard is a widely adopted, highly efficient, and fast compression format. In addition to the APIs introduced in !compression.zstd, support for reading and writing Zstandard compressed archives has been added to the tarfile, zipfile, and shutil modules.

Here's an example of using the new module to compress some data:

from compression import zstd
import math

data = str(math.pi).encode() * 20
compressed = zstd.compress(data)
ratio = len(compressed) / len(data)
print(f"Achieved compression ratio of {ratio}")

As can be seen, the API is similar to the APIs of the !lzma and !bz2 modules.

(Contributed by Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner, and Rogdham in 132983.)

Asyncio introspection capabilities

Added a new command-line interface to inspect running Python processes using asynchronous tasks, available via python -m asyncio ps PID or python -m asyncio pstree PID.

The ps subcommand inspects the given process ID (PID) and displays information about currently running asyncio tasks. It outputs a task table: a flat listing of all tasks, their names, their coroutine stacks, and which tasks are awaiting them.

The pstree subcommand fetches the same information, but instead renders a visual async call tree, showing coroutine relationships in a hierarchical format. This command is particularly useful for debugging long-running or stuck asynchronous programs. It can help developers quickly identify where a program is blocked, what tasks are pending, and how coroutines are chained together.

For example given this code:

import asyncio

async def play_track(track):
    await asyncio.sleep(5)
    print(f'🎵 Finished: {track}')

async def play_album(name, tracks):
    async with asyncio.TaskGroup() as tg:
        for track in tracks:
            tg.create_task(play_track(track), name=track)

async def main():
    async with asyncio.TaskGroup() as tg:
        tg.create_task(
          play_album('Sundowning', ['TNDNBTG', 'Levitate']),
          name='Sundowning')
        tg.create_task(
          play_album('TMBTE', ['DYWTYLM', 'Aqua Regia']),
          name='TMBTE')

if __name__ == '__main__':
    asyncio.run(main())

Executing the new tool on the running process will yield a table like this:

python -m asyncio ps 12345

tid        task id              task name            coroutine stack                                    awaiter chain                                      awaiter name    awaiter id
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1935500    0x7fc930c18050       Task-1               TaskGroup._aexit -> TaskGroup.__aexit__ -> main                                                                       0x0
1935500    0x7fc930c18230       Sundowning           TaskGroup._aexit -> TaskGroup.__aexit__ -> album   TaskGroup._aexit -> TaskGroup.__aexit__ -> main    Task-1          0x7fc930c18050
1935500    0x7fc93173fa50       TMBTE                TaskGroup._aexit -> TaskGroup.__aexit__ -> album   TaskGroup._aexit -> TaskGroup.__aexit__ -> main    Task-1          0x7fc930c18050
1935500    0x7fc93173fdf0       TNDNBTG              sleep -> play                                      TaskGroup._aexit -> TaskGroup.__aexit__ -> album   Sundowning      0x7fc930c18230
1935500    0x7fc930d32510       Levitate             sleep -> play                                      TaskGroup._aexit -> TaskGroup.__aexit__ -> album   Sundowning      0x7fc930c18230
1935500    0x7fc930d32890       DYWTYLM              sleep -> play                                      TaskGroup._aexit -> TaskGroup.__aexit__ -> album   TMBTE           0x7fc93173fa50
1935500    0x7fc93161ec30       Aqua Regia           sleep -> play                                      TaskGroup._aexit -> TaskGroup.__aexit__ -> album   TMBTE           0x7fc93173fa50

or a tree like this:

python -m asyncio pstree 12345

└── (T) Task-1
    └──  main example.py:13
        └──  TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72
            └──  TaskGroup._aexit Lib/asyncio/taskgroups.py:121
                ├── (T) Sundowning
                │   └──  album example.py:8
                │       └──  TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72
                │           └──  TaskGroup._aexit Lib/asyncio/taskgroups.py:121
                │               ├── (T) TNDNBTG
                │               │   └──  play example.py:4
                │               │       └──  sleep Lib/asyncio/tasks.py:702
                │               └── (T) Levitate
                │                   └──  play example.py:4
                │                       └──  sleep Lib/asyncio/tasks.py:702
                └── (T) TMBTE
                    └──  album example.py:8
                        └──  TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72
                            └──  TaskGroup._aexit Lib/asyncio/taskgroups.py:121
                                ├── (T) DYWTYLM
                                │   └──  play example.py:4
                                │       └──  sleep Lib/asyncio/tasks.py:702
                                └── (T) Aqua Regia
                                    └──  play example.py:4
                                        └──  sleep Lib/asyncio/tasks.py:702

If a cycle is detected in the async await graph (which could indicate a programming issue), the tool raises an error and lists the cycle paths that prevent tree construction:

python -m asyncio pstree 12345

ERROR: await-graph contains cycles - cannot print a tree!

cycle: Task-2 → Task-3 → Task-2

(Contributed by Pablo Galindo, Łukasz Langa, Yury Selivanov, and Marta Gomez Macias in 91048.)

Concurrent safe warnings control

The warnings.catch_warnings context manager will now optionally use a context variable for warning filters. This is enabled by setting the ~sys.flags.context_aware_warnings flag, either with the -X command-line option or an environment variable. This gives predictable warnings control when using ~warnings.catch_warnings combined with multiple threads or asynchronous tasks. The flag defaults to true for the free-threaded build and false for the GIL-enabled build.

(Contributed by Neil Schemenauer and Kumar Aditya in 130010.)

Other language changes

• All Windows code pages are now supported as 'cpXXX' codecs on Windows. (Contributed by Serhiy Storchaka in 123803.)
• Implement mixed-mode arithmetic rules combining real and complex numbers as specified by the C standard since C99. (Contributed by Sergey B Kirpichev in 69639.)
• More syntax errors are now detected regardless of optimisation and the -O command-line option. This includes writes to __debug__, incorrect use of await, and asynchronous comprehensions outside asynchronous functions. For example, python -O -c 'assert (__debug__ := 1)' or python -O -c 'assert await 1' now produce SyntaxErrors. (Contributed by Irit Katriel and Jelle Zijlstra in 122245 & 121637.)
• When subclassing a pure C type, the C slots for the new type are no longer replaced with a wrapped version on class creation if they are not explicitly overridden in the subclass. (Contributed by Tomasz Pytel in 132284.)

Built-ins

• The bytes.fromhex and bytearray.fromhex methods now accept ASCII bytes and bytes-like objects <bytes-like object>. (Contributed by Daniel Pope in 129349.)
• Add class methods float.from_number and complex.from_number to convert a number to float or complex type correspondingly. They raise a TypeError if the argument is not a real number. (Contributed by Serhiy Storchaka in 84978.)
• Support underscore and comma as thousands separators in the fractional part for floating-point presentation types of the new-style string formatting (with format or f-strings). (Contributed by Sergey B Kirpichev in 87790.)
• The int function no longer delegates to ~object.__trunc__. Classes that want to support conversion to !int must implement either ~object.__int__ or ~object.__index__. (Contributed by Mark Dickinson in 119743.)
• The map function now has an optional keyword-only strict flag like zip to check that all the iterables are of equal length. (Contributed by Wannes Boeykens in 119793.)
• The memoryview type now supports subscription, making it a generic type. (Contributed by Brian Schubert in 126012.)
• Using NotImplemented in a boolean context will now raise a TypeError. This has raised a DeprecationWarning since Python 3.9. (Contributed by Jelle Zijlstra in 118767.)
• Three-argument pow now tries calling ~object.__rpow__ if necessary. Previously it was only called in two-argument !pow and the binary power operator. (Contributed by Serhiy Storchaka in 130104.)
• super objects are now copyable <copy> and pickleable <pickle>. (Contributed by Serhiy Storchaka in 125767.)

Command line and environment

• The import time flag can now track modules that are already loaded ('cached'), via the new -X importtime=2 <-X>. When such a module is imported, the self and cumulative times are replaced by the string cached.

  Values above 2 for -X importtime are now reserved for future use.

  (Contributed by Noah Kim and Adam Turner in 118655.)

• The command-line option -c now automatically dedents its code argument before execution. (Contributed by Jon Crall and Steven Sun in 103998.)

• !-J is no longer a reserved flag for Jython, and now has no special meaning. (Contributed by Adam Turner in 133336.)

PEP 758: Allow except and except* expressions without brackets

The except and except* <except_star> expressions now allow brackets to be omitted when there are multiple exception types and the as clause is not used. For example:

try:
    connect_to_server()
except TimeoutError, ConnectionRefusedError:
    print('The network has ceased to be!')

(Contributed by Pablo Galindo and Brett Cannon in 758 and 131831.)

PEP 765: Control flow in finally blocks

The compiler now emits a SyntaxWarning when a return, break, or continue statement have the effect of leaving a finally block. This change is specified in 765.

In situations where this change is inconvenient (such as those where the warnings are redundant due to code linting), the warning filter <warning-filter> can be used to turn off all syntax warnings by adding ignore::SyntaxWarning as a filter. This can be specified in combination with a filter that converts other warnings to errors (for example, passing -Werror -Wignore::SyntaxWarning as CLI options, or setting PYTHONWARNINGS=error,ignore::SyntaxWarning).

Note that applying such a filter at runtime using the warnings module will only suppress the warning in code that is compiled after the filter is adjusted. Code that is compiled prior to the filter adjustment (for example, when a module is imported) will still emit the syntax warning.

(Contributed by Irit Katriel in 130080.)

Garbage collection

From Python 3.14.5 onwards:

The garbage collector (GC) has changed in Python 3.14.5.

Python 3.14.0-3.14.4 shipped with a new incremental GC. However, due to a number of reports of significant memory pressure in production environments, it has been reverted back to the generational GC from 3.13. This is the GC now used in Python 3.14.5 and later.

Previously in Python 3.14.0-3.14.4:

The cycle garbage collector is now incremental. This means that maximum pause times are reduced by an order of magnitude or more for larger heaps.

There are now only two generations: young and old. When gc.collect is not called directly, the GC is invoked a little less frequently. When invoked, it collects the young generation and an increment of the old generation, instead of collecting one or more generations.

The behavior of !gc.collect changes slightly:

• gc.collect(1): Performs an increment of garbage collection, rather than collecting generation 1.
• Other calls to !gc.collect are unchanged.

(Contributed by Mark Shannon in 108362.)

Default interactive shell

New modules

• annotationlib: For introspecting annotations <annotation>. See PEP 749 <whatsnew314-deferred-annotations> for more details. (Contributed by Jelle Zijlstra in 119180.)
• compression (including compression.zstd): A package for compression-related modules, including a new module to support the Zstandard compression format. See PEP 784 <whatsnew314-zstandard> for more details. (Contributed by Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner, and Rogdham in 132983.)
• concurrent.interpreters: Support for multiple interpreters in the standard library. See PEP 734 <whatsnew314-multiple-interpreters> for more details. (Contributed by Eric Snow in 134939.)
• string.templatelib: Support for template string literals (t-strings). See PEP 750 <whatsnew314-template-string-literals> for more details. (Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran, and Pablo Galindo Salgado in 132661.)

Improved modules

argparse

• The default value of the program name <prog> for argparse.ArgumentParser now reflects the way the Python interpreter was instructed to find the __main__ module code. (Contributed by Serhiy Storchaka and Alyssa Coghlan in 66436.)
• Introduced the optional suggest_on_error parameter to argparse.ArgumentParser, enabling suggestions for argument choices and subparser names if mistyped by the user. (Contributed by Savannah Ostrowski in 124456.)
• Enable color for help text, which can be disabled with the optional color parameter to argparse.ArgumentParser. This can also be controlled by environment variables <using-on-controlling-color>. (Contributed by Hugo van Kemenade in 130645.)

ast

• Add ~ast.compare, a function for comparing two ASTs. (Contributed by Batuhan Taskaya and Jeremy Hylton in 60191.)
• Add support for copy.replace for AST nodes. (Contributed by Bénédikt Tran in 121141.)
• Docstrings are now removed from an optimized AST in optimization level 2. (Contributed by Irit Katriel in 123958.)
• The repr output for AST nodes now includes more information. (Contributed by Tomas Roun in 116022.)
• When called with an AST as input, the ~ast.parse function now always verifies that the root node type is appropriate. (Contributed by Irit Katriel in 130139.)
• Add new options to the command-line interface: --feature-version <ast --feature-version>, --optimize <ast --optimize>, and --show-empty <ast --show-empty>. (Contributed by Semyon Moroz in 133367.)

asyncio

• The function and methods named !create_task now take an arbitrary list of keyword arguments. All keyword arguments are passed to the ~asyncio.Task constructor or the custom task factory. (See ~asyncio.loop.set_task_factory for details.) The name and context keyword arguments are no longer special; the name should now be set using the name keyword argument of the factory, and context may be None.

  This affects the following function and methods: asyncio.create_task, asyncio.loop.create_task, asyncio.TaskGroup.create_task.

  (Contributed by Thomas Grainger in 128307.)

• There are two new utility functions for introspecting and printing a program's call graph: ~asyncio.capture_call_graph and ~asyncio.print_call_graph. See Asyncio introspection capabilities <whatsnew314-asyncio-introspection> for more details. (Contributed by Yury Selivanov, Pablo Galindo Salgado, and Łukasz Langa in 91048.)

calendar

concurrent.futures

configparser

• !configparser will no longer write config files it cannot read, to improve security. Attempting to ~configparser.ConfigParser.write keys containing delimiters or beginning with the section header pattern will raise an ~configparser.InvalidWriteError. (Contributed by Jacob Lincoln in 129270.)

contextvars

• Support the context manager protocol for ~contextvars.Token objects. (Contributed by Andrew Svetlov in 129889.)

ctypes

• The layout of bit fields <ctypes-bit-fields-in-structures-unions> in ~ctypes.Structure and ~ctypes.Union objects is now a closer match to platform defaults (GCC/Clang or MSVC). In particular, fields no longer overlap. (Contributed by Matthias Görgens in 97702.)
• The .Structure._layout_ class attribute can now be set to help match a non-default ABI. (Contributed by Petr Viktorin in 97702.)
• The class of ~ctypes.Structure/~ctypes.Union field descriptors is now available as ~ctypes.CField, and has new attributes to aid debugging and introspection. (Contributed by Petr Viktorin in 128715.)
• On Windows, the ~ctypes.COMError exception is now public. (Contributed by Jun Komoda in 126686.)
• On Windows, the ~ctypes.CopyComPointer function is now public. (Contributed by Jun Komoda in 127275.)
• Add ~ctypes.memoryview_at, a function to create a memoryview object that refers to the supplied pointer and length. This works like ctypes.string_at except it avoids a buffer copy, and is typically useful when implementing pure Python callback functions that are passed dynamically-sized buffers. (Contributed by Rian Hunter in 112018.)
• Complex types, ~ctypes.c_float_complex, ~ctypes.c_double_complex, and ~ctypes.c_longdouble_complex, are now available if both the compiler and the libffi library support complex C types. (Contributed by Sergey B Kirpichev in 61103.)
• Add ctypes.util.dllist for listing the shared libraries loaded by the current process. (Contributed by Brian Ward in 119349.)
• Move ctypes.POINTER types cache from a global internal cache (_pointer_type_cache) to the _CData.__pointer_type__ <ctypes._CData.__pointer_type__> attribute of the corresponding !ctypes types. This will stop the cache from growing without limits in some situations. (Contributed by Sergey Miryanov in 100926.)
• The ~ctypes.py_object type now supports subscription, making it a generic type. (Contributed by Brian Schubert in 132168.)
• !ctypes now supports free-threading builds <free threading>. (Contributed by Kumar Aditya and Peter Bierma in 127945.)

curses

• Add the ~curses.assume_default_colors function, a refinement of the ~curses.use_default_colors function which allows changing the color pair 0. (Contributed by Serhiy Storchaka in 133139.)

datetime

• Add the ~datetime.date.strptime method to the datetime.date and datetime.time classes. (Contributed by Wannes Boeykens in 41431.)

decimal

• Add .Decimal.from_number as an alternative constructor for ~decimal.Decimal. (Contributed by Serhiy Storchaka in 121798.)
• Expose ~decimal.IEEEContext to support creation of contexts corresponding to the IEEE 754 (2008) decimal interchange formats. (Contributed by Sergey B Kirpichev in 53032.)

difflib

• Comparison pages with highlighted changes generated by the ~difflib.HtmlDiff class now support 'dark mode'. (Contributed by Jiahao Li in 129939.)

dis

• Add support for rendering full source location information of instructions <dis.Instruction>, rather than only the line number. This feature is added to the following interfaces via the show_positions keyword argument:

  • dis.Bytecode
  • dis.dis
  • dis.distb
  • dis.disassemble

  This feature is also exposed via dis --show-positions. (Contributed by Bénédikt Tran in 123165.)

• Add the dis --specialized command-line option to show specialized bytecode. (Contributed by Bénédikt Tran in 127413.)

errno

• Add the ~errno.EHWPOISON error code constant. (Contributed by James Roy in 126585.)

faulthandler

• Add support for printing the C stack trace on systems that support it <c-stack-compatibility> via the new ~faulthandler.dump_c_stack function or via the c_stack argument in faulthandler.enable. (Contributed by Peter Bierma in 127604.)

fnmatch

• Add ~fnmatch.filterfalse, a function to reject names matching a given pattern. (Contributed by Bénédikt Tran in 74598.)

fractions

• A ~fractions.Fraction object may now be constructed from any object with the !as_integer_ratio method. (Contributed by Serhiy Storchaka in 82017.)
• Add .Fraction.from_number as an alternative constructor for ~fractions.Fraction. (Contributed by Serhiy Storchaka in 121797.)

functools

• Add the ~functools.Placeholder sentinel. This may be used with the ~functools.partial or ~functools.partialmethod functions to reserve a place for positional arguments in the returned partial object <partial-objects>. (Contributed by Dominykas Grigonis in 119127.)
• Allow the initial parameter of ~functools.reduce to be passed as a keyword argument. (Contributed by Sayandip Dutta in 125916.)

getopt

• Add support for options with optional arguments. (Contributed by Serhiy Storchaka in 126374.)
• Add support for returning intermixed options and non-option arguments in order. (Contributed by Serhiy Storchaka in 126390.)

getpass

• Support keyboard feedback in the ~getpass.getpass function via the keyword-only optional argument echo_char. Placeholder characters are rendered whenever a character is entered, and removed when a character is deleted. (Contributed by Semyon Moroz in 77065.)

graphlib

• Allow .TopologicalSorter.prepare to be called more than once as long as sorting has not started. (Contributed by Daniel Pope in 130914.)

heapq

• The !heapq module has improved support for working with max-heaps, via the following new functions:
  • ~heapq.heapify_max
  • ~heapq.heappush_max
  • ~heapq.heappop_max
  • ~heapq.heapreplace_max
  • ~heapq.heappushpop_max

hmac

• Add a built-in implementation for HMAC (2104) using formally verified code from the HACL* project. This implementation is used as a fallback when the OpenSSL implementation of HMAC is not available. (Contributed by Bénédikt Tran in 99108.)

http

• Directory lists and error pages generated by the http.server module allow the browser to apply its default dark mode. (Contributed by Yorik Hansen in 123430.)

• The http.server module now supports serving over HTTPS using the http.server.HTTPSServer class. This functionality is exposed by the command-line interface (python -m http.server) through the following options:

  • --tls-cert \<path\> <http.server --tls-cert>: Path to the TLS certificate file.
  • --tls-key \<path\> <http.server --tls-key>: Optional path to the private key file.
  • --tls-password-file \<path\> <http.server --tls-password-file>: Optional path to the password file for the private key.

  (Contributed by Semyon Moroz in 85162.)

imaplib

• Add .IMAP4.idle, implementing the IMAP4 IDLE command as defined in 2177. (Contributed by Forest in 55454.)

inspect

• ~inspect.signature takes a new argument annotation_format to control the annotationlib.Format used for representing annotations. (Contributed by Jelle Zijlstra in 101552.)
• .Signature.format takes a new argument unquote_annotations. If true, string annotations <annotation> are displayed without surrounding quotes. (Contributed by Jelle Zijlstra in 101552.)
• Add function ~inspect.ispackage to determine whether an object is a package or not. (Contributed by Zhikang Yan in 125634.)

io

• Reading text from a non-blocking stream with read may now raise a BlockingIOError if the operation cannot immediately return bytes. (Contributed by Giovanni Siragusa in 109523.)
• Add the ~io.Reader and ~io.Writer protocols as simpler alternatives to the pseudo-protocols typing.IO, typing.TextIO, and typing.BinaryIO. (Contributed by Sebastian Rittau in 127648.)

json

• Add exception notes for JSON serialization errors that allow identifying the source of the error. (Contributed by Serhiy Storchaka in 122163.)
• Allow using the json module as a script using the -m switch: python -m json. This is now preferred to python -m json.tool, which is soft deprecated. See the JSON command-line interface <json-commandline> documentation. (Contributed by Trey Hunner in 122873.)
• By default, the output of the JSON command-line interface <json-commandline> is highlighted in color. This can be controlled by environment variables <using-on-controlling-color>. (Contributed by Tomas Roun in 131952.)

linecache

• ~linecache.getline can now retrieve source code for frozen modules. (Contributed by Tian Gao in 131638.)

logging.handlers

• ~logging.handlers.QueueListener objects now support the context manager protocol. (Contributed by Charles Machalow in 132106.)
• QueueListener.start <logging.handlers.QueueListener.start> now raises a RuntimeError if the listener is already started. (Contributed by Charles Machalow in 132106.)

math

• Added more detailed error messages for domain errors in the module. (Contributed by Charlie Zhao and Sergey B Kirpichev in 101410.)

mimetypes

• Add a public command-line <mimetypes-cli> for the module, invoked via python -m mimetypes. (Contributed by Oleg Iarygin and Hugo van Kemenade in 93096.)

• Add several new MIME types based on RFCs and common usage:

  Microsoft and 8081 MIME types for fonts

  • Embedded OpenType: application/vnd.ms-fontobject
  • OpenType Layout (OTF) font/otf
  • TrueType: font/ttf
  • WOFF 1.0 font/woff
  • WOFF 2.0 font/woff2

  9559 MIME types for Matroska audiovisual data container structures

  • audio with no video: audio/matroska (.mka)
  • video: video/matroska (.mkv)
  • stereoscopic video: video/matroska-3d (.mk3d)

  Images with RFCs

  • 1494: CCITT Group 3 (.g3)
  • 3362: Real-time Facsimile, T.38 (.t38)
  • 3745: JPEG 2000 (.jp2), extension (.jpx) and compound (.jpm)
  • 3950: Tag Image File Format Fax eXtended, TIFF-FX (.tfx)
  • 4047: Flexible Image Transport System (.fits)
  • 7903: Enhanced Metafile (.emf) and Windows Metafile (.wmf)

  Other MIME type additions and changes

  • 2361: Change type for .avi to video/vnd.avi and for .wav to audio/vnd.wave
  • 4337: Add MPEG-4 audio/mp4 (.m4a)
  • 5334: Add Ogg media (.oga, .ogg and .ogx)
  • 6713: Add gzip application/gzip (.gz)
  • 9639: Add FLAC audio/flac (.flac)
  • 9512 application/yaml MIME type for YAML files (.yaml and .yml)
  • Add 7z application/x-7z-compressed (.7z)
  • Add Android Package application/vnd.android.package-archive (.apk) when not strict
  • Add deb application/x-debian-package (.deb)
  • Add glTF binary model/gltf-binary (.glb)
  • Add glTF JSON/ASCII model/gltf+json (.gltf)
  • Add M4V video/x-m4v (.m4v)
  • Add PHP application/x-httpd-php (.php)
  • Add RAR application/vnd.rar (.rar)
  • Add RPM application/x-rpm (.rpm)
  • Add STL model/stl (.stl)
  • Add Windows Media Video video/x-ms-wmv (.wmv)
  • De facto: Add WebM audio/webm (.weba)
  • ECMA-376: Add .docx, .pptx and .xlsx types
  • OASIS: Add OpenDocument .odg, .odp, .ods and .odt types
  • W3C: Add EPUB application/epub+zip (.epub)

  (Contributed by Sahil Prajapati and Hugo van Kemenade in 84852, by Sasha "Nelie" Chernykh and Hugo van Kemenade in 132056, and by Hugo van Kemenade in 89416, 85957, and 129965.)

multiprocessing

operator

• Add ~operator.is_none and ~operator.is_not_none as a pair of functions, such that operator.is_none(obj) is equivalent to obj is None and operator.is_not_none(obj) is equivalent to obj is not None. (Contributed by Raymond Hettinger and Nico Mexis in 115808.)

os

• Add the ~os.reload_environ function to update os.environ and os.environb with changes to the environment made by os.putenv, by os.unsetenv, or made outside Python in the same process. (Contributed by Victor Stinner in 120057.)
• Add the ~os.SCHED_DEADLINE and ~os.SCHED_NORMAL constants to the !os module. (Contributed by James Roy in 127688.)
• Add the ~os.readinto function to read into a buffer object <bufferobjects> from a file descriptor. (Contributed by Cody Maloney in 129205.)

os.path

• The strict parameter to ~os.path.realpath accepts a new value, ~os.path.ALLOW_MISSING. If used, errors other than FileNotFoundError will be re-raised; the resulting path can be missing but it will be free of symlinks. (Contributed by Petr Viktorin for 2025-4517.)

pathlib

• Add methods to pathlib.Path to recursively copy or move files and directories:

  • ~pathlib.Path.copy copies a file or directory tree to a destination.
  • ~pathlib.Path.copy_into copies into a destination directory.
  • ~pathlib.Path.move moves a file or directory tree to a destination.
  • ~pathlib.Path.move_into moves into a destination directory.

  (Contributed by Barney Gale in 73991.)

• Add the ~pathlib.Path.info attribute, which stores an object implementing the new pathlib.types.PathInfo protocol. The object supports querying the file type and internally caching ~os.stat results. Path objects generated by ~pathlib.Path.iterdir are initialized with file type information gleaned from scanning the parent directory. (Contributed by Barney Gale in 125413.)

pdb

• The pdb module now supports remote attaching to a running Python process using a new -p PID <pdb --pid> command-line option:

  python -m pdb -p 1234
  

  This will connect to the Python process with the given PID and allow you to debug it interactively. Notice that due to how the Python interpreter works attaching to a remote process that is blocked in a system call or waiting for I/O will only work once the next bytecode instruction is executed or when the process receives a signal.

  This feature uses PEP 768 <whatsnew314-remote-debugging> and the new sys.remote_exec function to attach to the remote process and send the PDB commands to it.

  (Contributed by Matt Wozniski and Pablo Galindo in 131591.)

• Hardcoded breakpoints (breakpoint and ~pdb.set_trace) now reuse the most recent ~pdb.Pdb instance that calls ~pdb.Pdb.set_trace, instead of creating a new one each time. As a result, all the instance specific data like display and commands are preserved across hardcoded breakpoints. (Contributed by Tian Gao in 121450.)

• Add a new argument mode to pdb.Pdb. Disable the restart command when pdb is in inline mode. (Contributed by Tian Gao in 123757.)

• A confirmation prompt will be shown when the user tries to quit pdb in inline mode. y, Y, <Enter> or EOF will confirm the quit and call sys.exit, instead of raising bdb.BdbQuit. (Contributed by Tian Gao in 124704.)

• Inline breakpoints like breakpoint or pdb.set_trace will always stop the program at calling frame, ignoring the skip pattern (if any). (Contributed by Tian Gao in 130493.)

• <tab> at the beginning of the line in pdb multi-line input will fill in a 4-space indentation now, instead of inserting a \t character. (Contributed by Tian Gao in 130471.)

• Auto-indent is introduced in pdb multi-line input. It will either keep the indentation of the last line or insert a 4-space indentation when it detects a new code block. (Contributed by Tian Gao in 133350.)

• $_asynctask is added to access the current asyncio task if applicable. (Contributed by Tian Gao in 124367.)

• pdb.set_trace_async is added to support debugging asyncio coroutines. await statements are supported with this function. (Contributed by Tian Gao in 132576.)

• Source code displayed in pdb will be syntax-highlighted. This feature can be controlled using the same methods as the default interactive shell, in addition to the newly added colorize argument of pdb.Pdb. (Contributed by Tian Gao and Łukasz Langa in 133355.)

pickle

• Set the default protocol version on the pickle module to 5. For more details, see pickle protocols <pickle-protocols>.
• Add exception notes for pickle serialization errors that allow identifying the source of the error. (Contributed by Serhiy Storchaka in 122213.)

platform

• Add ~platform.invalidate_caches, a function to invalidate cached results in the !platform module. (Contributed by Bénédikt Tran in 122549.)

pydoc

• Annotations <annotation> in help output are now usually displayed in a format closer to that in the original source. (Contributed by Jelle Zijlstra in 101552.)

re

• Support \z as a synonym for \Z in regular expressions <re>. It is interpreted unambiguously in many other regular expression engines, unlike \Z, which has subtly different behavior. (Contributed by Serhiy Storchaka in 133306.)
• \B in regular expression <re> now matches the empty input string, meaning that it is now always the opposite of \b. (Contributed by Serhiy Storchaka in 124130.)

socket

• Improve and fix support for Bluetooth sockets.
  • Fix support of Bluetooth sockets on NetBSD and DragonFly BSD. (Contributed by Serhiy Storchaka in 132429.)
  • Fix support for ~socket.BTPROTO_HCI on FreeBSD. (Contributed by Victor Stinner in 111178.)
  • Add support for ~socket.BTPROTO_SCO on FreeBSD. (Contributed by Serhiy Storchaka in 85302.)
  • Add support for cid and bdaddr_type in the address for ~socket.BTPROTO_L2CAP on FreeBSD. (Contributed by Serhiy Storchaka in 132429.)
  • Add support for channel in the address for ~socket.BTPROTO_HCI on Linux. (Contributed by Serhiy Storchaka in 70145.)
  • Accept an integer as the address for ~socket.BTPROTO_HCI on Linux. (Contributed by Serhiy Storchaka in 132099.)
  • Return cid in ~socket.socket.getsockname for ~socket.BTPROTO_L2CAP. (Contributed by Serhiy Storchaka in 132429.)
  • Add many new constants. (Contributed by Serhiy Storchaka in 132734.)

ssl

• Indicate through the ~ssl.HAS_PHA Boolean whether the !ssl module supports TLSv1.3 post-handshake client authentication (PHA). (Contributed by Will Childs-Klein in 128036.)

struct

• Support the float complex and double complex C types in the struct module (formatting characters 'F' and 'D' respectively). (Contributed by Sergey B Kirpichev in 121249.)

symtable

• Expose the following ~symtable.Symbol methods:

  • ~symtable.Symbol.is_comp_cell
  • ~symtable.Symbol.is_comp_iter
  • ~symtable.Symbol.is_free_class

  (Contributed by Bénédikt Tran in 120029.)

sys

• The previously undocumented special function sys.getobjects, which only exists in specialized builds of Python, may now return objects from other interpreters than the one it's called in. (Contributed by Eric Snow in 125286.)
• Add sys._is_immortal for determining if an object is immortal. (Contributed by Peter Bierma in 128509.)
• On FreeBSD, sys.platform no longer contains the major version number. It is always 'freebsd', instead of 'freebsd13' or 'freebsd14'. (Contributed by Michael Osipov in 129393.)
• Raise DeprecationWarning for sys._clear_type_cache. This function was deprecated in Python 3.13 but it didn't raise a runtime warning.
• Add sys.remote_exec to implement the new external debugger interface. See PEP 768 <whatsnew314-remote-debugging> for details. (Contributed by Pablo Galindo Salgado, Matt Wozniski, and Ivona Stojanovic in 131591.)
• Add the sys._jit namespace, containing utilities for introspecting just-in-time compilation. (Contributed by Brandt Bucher in 133231.)

sys.monitoring

• Add two new monitoring events, BRANCH_LEFT and BRANCH_RIGHT. These replace and deprecate the !BRANCH event. (Contributed by Mark Shannon in 122548.)
• Add sys.monitoring.clear_tool_id to unregister all events and callback functions associated with a tool identifier. sys.monitoring.free_tool_id now calls it before releasing the tool identifier, instead of leaving its events and callbacks registered. (Contributed by Tian Gao in 116750.)

sysconfig

• Add ABIFLAGS key to ~sysconfig.get_config_vars on Windows. (Contributed by Xuehai Pan in 131799.)

tarfile

• ~tarfile.data_filter now normalizes symbolic link targets in order to avoid path traversal attacks. (Contributed by Petr Viktorin in 127987 and 2025-4138.)
• ~tarfile.TarFile.extractall now skips fixing up directory attributes when a directory was removed or replaced by another kind of file. (Contributed by Petr Viktorin in 127987 and 2024-12718.)
• ~tarfile.TarFile.extract and ~tarfile.TarFile.extractall now (re-)apply the extraction filter when substituting a link (hard or symbolic) with a copy of another archive member, and when fixing up directory attributes. The former raises a new exception, ~tarfile.LinkFallbackError. (Contributed by Petr Viktorin for 2025-4330 and 2024-12718.)
• ~tarfile.TarFile.extract and ~tarfile.TarFile.extractall no longer extract rejected members when ~tarfile.TarFile.errorlevel is zero. (Contributed by Matt Prodani and Petr Viktorin in 112887 and 2025-4435.)

threading

• threading.Thread.start now sets the operating system thread name to threading.Thread.name. (Contributed by Victor Stinner in 59705.)

tkinter

• Make tkinter widget methods !after and !after_idle accept keyword arguments. (Contributed by Zhikang Yan in 126899.)
• Add ability to specify a name for !tkinter.OptionMenu and !tkinter.ttk.OptionMenu. (Contributed by Zhikang Yan in 130482.)

turtle

• Add context managers for turtle.fill, turtle.poly, and turtle.no_animation. (Contributed by Marie Roald and Yngve Mardal Moe in 126350.)

types

• types.UnionType is now an alias for typing.Union. See below <whatsnew314-typing-union> for more details. (Contributed by Jelle Zijlstra in 105499.)

typing

unicodedata

• The Unicode database has been updated to Unicode 16.0.0.

unittest

urllib

• Upgrade HTTP digest authentication algorithm for urllib.request by supporting SHA-256 digest authentication as specified in 7616. (Contributed by Calvin Bui in 128193.)

• Improve ergonomics and standards compliance when parsing and emitting file: URLs.

  In ~urllib.request.url2pathname:

  • Accept a complete URL when the new require_scheme argument is set to true.
  • Discard URL authority if it matches the local hostname.
  • Discard URL authority if it resolves to a local IP address when the new resolve_host argument is set to true.
  • Discard URL query and fragment components.
  • Raise ~urllib.error.URLError if a URL authority isn't local, except on Windows where we return a UNC path as before.

  In ~urllib.request.pathname2url:

  • Return a complete URL when the new add_scheme argument is set to true.
  • Include an empty URL authority when a path begins with a slash. For example, the path /etc/hosts is converted to the URL ///etc/hosts.

  On Windows, drive letters are no longer converted to uppercase, and : characters not following a drive letter no longer cause an OSError exception to be raised.

  (Contributed by Barney Gale in 125866.)

uuid

• Add support for UUID versions 6, 7, and 8 via ~uuid.uuid6, ~uuid.uuid7, and ~uuid.uuid8 respectively, as specified in 9562. (Contributed by Bénédikt Tran in 89083.)
• ~uuid.NIL and ~uuid.MAX are now available to represent the Nil and Max UUID formats as defined by 9562. (Contributed by Nick Pope in 128427.)
• Allow generating multiple UUIDs simultaneously on the command-line via python -m uuid --count <uuid --count>. (Contributed by Simon Legner in 131236.)

webbrowser

• Names in the BROWSER environment variable can now refer to already registered browsers for the webbrowser module, instead of always generating a new browser command.

  This makes it possible to set BROWSER to the value of one of the supported browsers on macOS.

zipfile

• Added ZipInfo._for_archive <zipfile.ZipInfo._for_archive>, a method to resolve suitable defaults for a ~zipfile.ZipInfo object as used by ZipFile.writestr <zipfile.ZipFile.writestr>. (Contributed by Bénédikt Tran in 123424.)
• .ZipFile.writestr now respects the SOURCE_DATE_EPOCH environment variable in order to better support reproducible builds. (Contributed by Jiahao Li in 91279.)

Optimizations

• The import time for several standard library modules has been improved, including annotationlib, ast, asyncio, base64, cmd, csv, gettext, importlib.util, locale, mimetypes, optparse, pickle, pprint, pstats, shlex, socket, string, subprocess, threading, tomllib, types, and zipfile.

  (Contributed by Adam Turner, Bénédikt Tran, Chris Markiewicz, Eli Schwartz, Hugo van Kemenade, Jelle Zijlstra, and others in 118761.)

• The interpreter now avoids some reference count modifications internally when it's safe to do so. This can lead to different values being returned from sys.getrefcount and Py_REFCNT compared to previous versions of Python. See below <whatsnew314-refcount> for details.

asyncio

• Standard benchmark results have improved by 10-20% following the implementation of a new per-thread doubly linked list for native tasks <asyncio.Task>, also reducing memory usage. This enables external introspection tools such as python -m asyncio pstree <whatsnew314-asyncio-introspection> to introspect the call graph of asyncio tasks running in all threads. (Contributed by Kumar Aditya in 107803.)
• The module now has first class support for free-threading builds <free threading>. This enables parallel execution of multiple event loops across different threads, scaling linearly with the number of threads. (Contributed by Kumar Aditya in 128002.)

base64

• ~base64.b16decode is now up to six times faster. (Contributed by Bénédikt Tran, Chris Markiewicz, and Adam Turner in 118761.)

bdb

• The basic debugger now has a sys.monitoring-based backend, which can be selected via the passing 'monitoring' to the ~bdb.Bdb class's new backend parameter. (Contributed by Tian Gao in 124533.)

difflib

• The ~difflib.IS_LINE_JUNK function is now up to twice as fast. (Contributed by Adam Turner and Semyon Moroz in 130167.)

gc

• From Python 3.14.5 onwards:

  Python 3.14.0-3.14.4 shipped with a new incremental garbage collector. However, due to a number of reports of significant memory pressure in production environments, it has been reverted back to the generational GC from 3.13. This is the GC now used in Python 3.14.5 and later.

• Previously in Python 3.14.0-3.14.4:

  The new incremental garbage collector <whatsnew314-incremental-gc> means that maximum pause times are reduced by an order of magnitude or more for larger heaps.

  Because of this optimization, the meaning of the results of ~gc.get_threshold and ~gc.set_threshold have changed, along with ~gc.get_count and ~gc.get_stats.

  • For backwards compatibility, ~gc.get_threshold continues to return a three-item tuple. The first value is the threshold for young collections, as before; the second value determines the rate at which the old collection is scanned (the default is 10, and higher values mean that the old collection is scanned more slowly). The third value is now meaningless and is always zero.
  • ~gc.set_threshold now ignores any items after the second.
  • ~gc.get_count and ~gc.get_stats continue to return the same format of results. The only difference is that instead of the results referring to the young, aging and old generations, the results refer to the young generation and the aging and collecting spaces of the old generation.

  In summary, code that attempted to manipulate the behavior of the cycle GC may not work exactly as intended, but it is very unlikely to be harmful. All other code will work just fine.

  (Contributed by Mark Shannon in 108362.)

io

• Opening and reading files now executes fewer system calls. Reading a small operating system cached file in full is up to 15% faster. (Contributed by Cody Maloney and Victor Stinner in 120754 and 90102.)

pathlib

• Path.read_bytes <pathlib.Path.read_bytes> now uses unbuffered mode to open files, which is between 9% and 17% faster to read in full. (Contributed by Cody Maloney in 120754.)

pdb

• pdb now supports two backends, based on either sys.settrace or sys.monitoring. Using the pdb CLI <pdb-cli> or breakpoint will always use the sys.monitoring backend. Explicitly instantiating pdb.Pdb and its derived classes will use the sys.settrace backend by default, which is configurable. (Contributed by Tian Gao in 124533.)

textwrap

• Optimize the ~textwrap.dedent function, improving performance by an average of 2.4x, with larger improvements for bigger inputs, and fix a bug with incomplete normalization of blank lines with whitespace characters other than space and tab.

uuid

• ~uuid.uuid3 and ~uuid.uuid5 are now both roughly 40% faster for 16-byte names and 20% faster for 1024-byte names. Performance for longer names remains unchanged. (Contributed by Bénédikt Tran in 128150.)
• ~uuid.uuid4 is now c. 30% faster. (Contributed by Bénédikt Tran in 128150.)

zlib

• On Windows, zlib-ng is now used as the implementation of the zlib module in the default binaries. There are no known incompatibilities between zlib-ng and the previously-used zlib implementation. This should result in better performance at all compression levels.

  It is worth noting that zlib.Z_BEST_SPEED (1) may result in significantly less compression than the previous implementation, whilst also significantly reducing the time taken to compress.

  (Contributed by Steve Dower in 91349.)

Removed

argparse

• Remove the type, choices, and metavar parameters of !BooleanOptionalAction. These have been deprecated since Python 3.12. (Contributed by Nikita Sobolev in 118805.)
• Calling ~argparse.ArgumentParser.add_argument_group on an argument group now raises a ValueError. Similarly, ~argparse.ArgumentParser.add_argument_group or ~argparse.ArgumentParser.add_mutually_exclusive_group on a mutually exclusive group now both raise ValueErrors. This 'nesting' was never supported, often failed to work correctly, and was unintentionally exposed through inheritance. This functionality has been deprecated since Python 3.11. (Contributed by Savannah Ostrowski in 127186.)

ast

• Remove the following classes, which have been deprecated aliases of ~ast.Constant since Python 3.8 and have emitted deprecation warnings since Python 3.12:

  • !Bytes
  • !Ellipsis
  • !NameConstant
  • !Num
  • !Str

  As a consequence of these removals, user-defined visit_Num, visit_Str, visit_Bytes, visit_NameConstant and visit_Ellipsis methods on custom ~ast.NodeVisitor subclasses will no longer be called when the !NodeVisitor subclass is visiting an AST. Define a visit_Constant method instead.

  (Contributed by Alex Waygood in 119562.)

• Remove the following deprecated properties on ast.Constant, which were present for compatibility with the now-removed AST classes:

  • !Constant.n
  • !Constant.s

  Use !Constant.value instead. (Contributed by Alex Waygood in 119562.)

asyncio

• Remove the following classes, methods, and functions, which have been deprecated since Python 3.12:

  • !AbstractChildWatcher
  • !FastChildWatcher
  • !MultiLoopChildWatcher
  • !PidfdChildWatcher
  • !SafeChildWatcher
  • !ThreadedChildWatcher
  • !AbstractEventLoopPolicy.get_child_watcher
  • !AbstractEventLoopPolicy.set_child_watcher
  • !get_child_watcher
  • !set_child_watcher

  (Contributed by Kumar Aditya in 120804.)

• asyncio.get_event_loop now raises a RuntimeError if there is no current event loop, and no longer implicitly creates an event loop.

  (Contributed by Kumar Aditya in 126353.)

  There's a few patterns that use asyncio.get_event_loop, most of them can be replaced with asyncio.run.

  If you're running an async function, simply use asyncio.run.

  Before:

  async def main():
      ...
  
  
  loop = asyncio.get_event_loop()
  try:
      loop.run_until_complete(main())
  finally:
      loop.close()
  

  After:

  async def main():
      ...
  
  asyncio.run(main())
  

  If you need to start something, for example, a server listening on a socket and then run forever, use asyncio.run and an asyncio.Event.

  Before:

  def start_server(loop): ...
  
  loop = asyncio.get_event_loop()
  try:
      start_server(loop)
      loop.run_forever()
  finally:
      loop.close()
  

  After:

  def start_server(loop): ...
  
  async def main():
      start_server(asyncio.get_running_loop())
      await asyncio.Event().wait()
  
  asyncio.run(main())
  

  If you need to run something in an event loop, then run some blocking code around it, use asyncio.Runner.

  Before:

  async def operation_one(): ...
  def blocking_code(): ...
  async def operation_two(): ...
  
  loop = asyncio.get_event_loop()
  try:
      loop.run_until_complete(operation_one())
      blocking_code()
      loop.run_until_complete(operation_two())
  finally:
      loop.close()
  

  After:

  async def operation_one(): ...
  def blocking_code(): ...
  async def operation_two(): ...
  
  with asyncio.Runner() as runner:
      runner.run(operation_one())
      blocking_code()
      runner.run(operation_two())
  

email

• Remove email.utils.localtime's isdst parameter, which was deprecated in and has been ignored since Python 3.12. (Contributed by Hugo van Kemenade in 118798.)

importlib.abc

• Remove deprecated importlib.abc classes:

  • !ResourceReader (use ~importlib.resources.abc.TraversableResources)
  • !Traversable (use ~importlib.resources.abc.Traversable)
  • !TraversableResources (use ~importlib.resources.abc.TraversableResources)

  (Contributed by Jason R. Coombs and Hugo van Kemenade in 93963.)

itertools

• Remove support for copy, deepcopy, and pickle operations from itertools iterators. These have emitted a DeprecationWarning since Python 3.12. (Contributed by Raymond Hettinger in 101588.)

pathlib

• Remove support for passing additional keyword arguments to ~pathlib.Path. In previous versions, any such arguments are ignored. (Contributed by Barney Gale in 74033.)
• Remove support for passing additional positional arguments to .PurePath.relative_to and ~pathlib.PurePath.is_relative_to. In previous versions, any such arguments are joined onto other. (Contributed by Barney Gale in 78707.)

pkgutil

• Remove the !get_loader and !find_loader functions, which have been deprecated since Python 3.12. (Contributed by Bénédikt Tran in 97850.)

pty

• Remove the !master_open and !slave_open functions, which have been deprecated since Python 3.12. Use pty.openpty instead. (Contributed by Nikita Sobolev in 118824.)

sqlite3

• Remove !version and !version_info from the sqlite3 module; use ~sqlite3.sqlite_version and ~sqlite3.sqlite_version_info for the actual version number of the runtime SQLite library. (Contributed by Hugo van Kemenade in 118924.)
• Using a sequence of parameters with named placeholders now raises a ~sqlite3.ProgrammingError, having been deprecated since Python 3.12. (Contributed by Erlend E. Aasland in 118928 and 101693.)

urllib

• Remove the !Quoter class from urllib.parse, which has been deprecated since Python 3.11. (Contributed by Nikita Sobolev in 118827.)

• Remove the !URLopener and !FancyURLopener classes from urllib.request, which have been deprecated since Python 3.3.

  myopener.open() can be replaced with ~urllib.request.urlopen. myopener.retrieve() can be replaced with ~urllib.request.urlretrieve. Customisations to the opener classes can be replaced by passing customized handlers to ~urllib.request.build_opener. (Contributed by Barney Gale in 84850.)

Deprecated

New deprecations

• Passing a complex number as the real or imag argument in the complex constructor is now deprecated; complex numbers should only be passed as a single positional argument. (Contributed by Serhiy Storchaka in 109218.)
• argparse:
  • Passing the undocumented keyword argument prefix_chars to the ~argparse.ArgumentParser.add_argument_group method is now deprecated. (Contributed by Savannah Ostrowski in 125563.)
  • Deprecated the argparse.FileType type converter. Anything relating to resource management should be handled downstream, after the arguments have been parsed. (Contributed by Serhiy Storchaka in 58032.)
• asyncio:

  • The !asyncio.iscoroutinefunction is now deprecated and will be removed in Python 3.16; use inspect.iscoroutinefunction instead. (Contributed by Jiahao Li and Kumar Aditya in 122875.)

  • The asyncio policy system is deprecated and will be removed in Python 3.16. In particular, the following classes and functions are deprecated:

    • !asyncio.AbstractEventLoopPolicy
    • !asyncio.DefaultEventLoopPolicy
    • !asyncio.WindowsSelectorEventLoopPolicy
    • !asyncio.WindowsProactorEventLoopPolicy
    • !asyncio.get_event_loop_policy
    • !asyncio.set_event_loop_policy

    Users should use asyncio.run or asyncio.Runner with the loop_factory argument to use the desired event loop implementation.

    For example, to use asyncio.SelectorEventLoop on Windows:

    import asyncio
    
    async def main():
        ...
    
    asyncio.run(main(), loop_factory=asyncio.SelectorEventLoop)
    

    (Contributed by Kumar Aditya in 127949.)

• codecs: The codecs.open function is now deprecated, and will be removed in a future version of Python. Use open instead. (Contributed by Inada Naoki in 133036.)
• ctypes:
  • On non-Windows platforms, setting .Structure._pack_ to use a MSVC-compatible default memory layout is now deprecated in favor of setting .Structure._layout_ to 'ms', and will be removed in Python 3.19. (Contributed by Petr Viktorin in 131747.)
  • Calling ctypes.POINTER on a string is now deprecated. Use incomplete types <ctypes-incomplete-types> for self-referential structures. Also, the internal ctypes._pointer_type_cache is deprecated. See ctypes.POINTER for updated implementation details. (Contributed by Sergey Myrianov in 100926.)
• functools: Calling the Python implementation of functools.reduce with function or sequence as keyword arguments is now deprecated; the parameters will be made positional-only in Python 3.16. (Contributed by Kirill Podoprigora in 121676.)
• logging: Support for custom logging handlers with the strm argument is now deprecated and scheduled for removal in Python 3.16. Define handlers with the stream argument instead. (Contributed by Mariusz Felisiak in 115032.)
• mimetypes: Valid extensions are either empty or must start with '.' for mimetypes.MimeTypes.add_type. Undotted extensions are deprecated and will raise a ValueError in Python 3.16. (Contributed by Hugo van Kemenade in 75223.)
• !nturl2path: This module is now deprecated. Call urllib.request.url2pathname and ~urllib.request.pathname2url instead. (Contributed by Barney Gale in 125866.)
• os: The os.popen and os.spawn* <os.spawnl> functions are now soft deprecated. They should no longer be used to write new code. The subprocess module is recommended instead. (Contributed by Victor Stinner in 120743.)
• pathlib: !pathlib.PurePath.as_uri is now deprecated and scheduled for removal in Python 3.19. Use pathlib.Path.as_uri instead. (Contributed by Barney Gale in 123599.)
• pdb: The undocumented pdb.Pdb.curframe_locals attribute is now a deprecated read-only property, which will be removed in a future version of Python. The low overhead dynamic frame locals access added in Python 3.13 by 667 means the frame locals cache reference previously stored in this attribute is no longer needed. Derived debuggers should access pdb.Pdb.curframe.f_locals directly in Python 3.13 and later versions. (Contributed by Tian Gao in 124369 and 125951.)
• symtable: Deprecate !symtable.Class.get_methods due to the lack of interest, scheduled for removal in Python 3.16. (Contributed by Bénédikt Tran in 119698.)
• tkinter: The !tkinter.Variable methods !trace_variable, !trace_vdelete and !trace_vinfo are now deprecated. Use !trace_add, !trace_remove and !trace_info instead. (Contributed by Serhiy Storchaka in 120220.)
• urllib.parse: Accepting objects with false values (like 0 and []) except empty strings, bytes-like objects and None in ~urllib.parse.parse_qsl and ~urllib.parse.parse_qs is now deprecated. (Contributed by Serhiy Storchaka in 116897.)

Pending removal in Python 3.15

• The import system:
  • Setting __cached__ on a module while failing to set __spec__.cached <importlib.machinery.ModuleSpec.cached> is deprecated. In Python 3.15, __cached__ will cease to be set or take into consideration by the import system or standard library. (97879)
• ctypes:
  • The undocumented !ctypes.SetPointerType function has been deprecated since Python 3.13.
• http.server:
  • The obsolete and rarely used !CGIHTTPRequestHandler has been deprecated since Python 3.13. No direct replacement exists. Anything is better than CGI to interface a web server with a request handler.
  • The !--cgi flag to the python -m http.server command-line interface has been deprecated since Python 3.13.
• importlib:
  • load_module() method: use exec_module() instead.
• pathlib:
  • !.PurePath.is_reserved has been deprecated since Python 3.13. Use os.path.isreserved to detect reserved paths on Windows.
• platform:
  • !platform.java_ver has been deprecated since Python 3.13. This function is only useful for Jython support, has a confusing API, and is largely untested.
• sysconfig:
  • The check_home argument of sysconfig.is_python_build has been deprecated since Python 3.12.
• threading:
  • ~threading.RLock will take no arguments in Python 3.15. Passing any arguments has been deprecated since Python 3.14, as the Python version does not permit any arguments, but the C version allows any number of positional or keyword arguments, ignoring every argument.
• types:
  • types.CodeType: Accessing !codeobject.co_lnotab was deprecated in 626 since 3.10 and was planned to be removed in 3.12, but it only got a proper DeprecationWarning in 3.12. May be removed in 3.15. (Contributed by Nikita Sobolev in 101866.)
• typing:
  • The undocumented keyword argument syntax for creating ~typing.NamedTuple classes (for example, Point = NamedTuple("Point", x=int, y=int)) has been deprecated since Python 3.13. Use the class-based syntax or the functional syntax instead.
  • When using the functional syntax of ~typing.TypedDicts, failing to pass a value to the fields parameter (TD = TypedDict("TD")) or passing None (TD = TypedDict("TD", None)) has been deprecated since Python 3.13. Use class TD(TypedDict): pass or TD = TypedDict("TD", {}) to create a TypedDict with zero field.
  • The !typing.no_type_check_decorator decorator function has been deprecated since Python 3.13. After eight years in the typing module, it has yet to be supported by any major type checker.
• !sre_compile, !sre_constants and !sre_parse modules.
• wave:
  • The getmark(), setmark() and getmarkers() methods of the ~wave.Wave_read and ~wave.Wave_write classes have been deprecated since Python 3.13.
• zipimport:
  • !zipimport.zipimporter.load_module has been deprecated since Python 3.10. Use ~zipimport.zipimporter.exec_module instead. (125746.)

Pending removal in Python 3.16

• The import system:
  • Setting ~module.__loader__ on a module while failing to set __spec__.loader <importlib.machinery.ModuleSpec.loader> is deprecated. In Python 3.16, !__loader__ will cease to be set or taken into consideration by the import system or the standard library.
  • Setting ~module.__package__ on a module while failing to set __spec__.parent <importlib.machinery.ModuleSpec.parent> is deprecated. In Python 3.16, !__package__ will cease to be taken into consideration by the import system or standard library. (97879)
• The bundled copy of libmpdec.
• array:
  • The 'u' format code (wchar_t) has been deprecated in documentation since Python 3.3 and at runtime since Python 3.13. Use the 'w' format code (Py_UCS4) for Unicode characters instead.
• asyncio:

  • !asyncio.iscoroutinefunction is deprecated and will be removed in Python 3.16; use inspect.iscoroutinefunction instead. (Contributed by Jiahao Li and Kumar Aditya in 122875.)

  • asyncio policy system is deprecated and will be removed in Python 3.16. In particular, the following classes and functions are deprecated:

    • !asyncio.AbstractEventLoopPolicy
    • !asyncio.DefaultEventLoopPolicy
    • !asyncio.WindowsSelectorEventLoopPolicy
    • !asyncio.WindowsProactorEventLoopPolicy
    • !asyncio.get_event_loop_policy
    • !asyncio.set_event_loop_policy

    Users should use asyncio.run or asyncio.Runner with loop_factory to use the desired event loop implementation.

    For example, to use asyncio.SelectorEventLoop on Windows:

    import asyncio
    
    async def main():
        ...
    
    asyncio.run(main(), loop_factory=asyncio.SelectorEventLoop)
    

    (Contributed by Kumar Aditya in 127949.)

• builtins:
  • Bitwise inversion on boolean types, ~True or ~False has been deprecated since Python 3.12, as it produces surprising and unintuitive results (-2 and -1). Use not x instead for the logical negation of a Boolean. In the rare case that you need the bitwise inversion of the underlying integer, convert to int explicitly (~int(x)).
• functools:
  • Calling the Python implementation of functools.reduce with function or sequence as keyword arguments has been deprecated since Python 3.14.
• logging:
  • Support for custom logging handlers with the strm argument is deprecated and scheduled for removal in Python 3.16. Define handlers with the stream argument instead. (Contributed by Mariusz Felisiak in 115032.)
• mimetypes:
  • Valid extensions start with a '.' or are empty for mimetypes.MimeTypes.add_type. Undotted extensions are deprecated and will raise a ValueError in Python 3.16. (Contributed by Hugo van Kemenade in 75223.)
• shutil:
  • The !ExecError exception has been deprecated since Python 3.14. It has not been used by any function in !shutil since Python 3.4, and is now an alias of RuntimeError.
• symtable:
  • The !symtable.Class.get_methods method has been deprecated since Python 3.14.
• sys:
  • The !_enablelegacywindowsfsencoding function has been deprecated since Python 3.13. Use the PYTHONLEGACYWINDOWSFSENCODING environment variable instead.
• sysconfig:
  • The !sysconfig.expand_makefile_vars function has been deprecated since Python 3.14. Use the vars argument of sysconfig.get_paths instead.
• tarfile:
  • The undocumented and unused !TarInfo.tarfile attribute has been deprecated since Python 3.13.

Pending removal in Python 3.17

• datetime:
  • ~datetime.datetime.strptime calls using a format string containing %e (day of month) without a year. This has been deprecated since Python 3.15. (Contributed by Stan Ulbrych in 70647.)
• collections.abc:

  • collections.abc.ByteString is scheduled for removal in Python 3.17.

    Use isinstance(obj, collections.abc.Buffer) to test if obj implements the buffer protocol <bufferobjects> at runtime. For use in type annotations, either use ~collections.abc.Buffer or a union that explicitly specifies the types your code supports (e.g., bytes | bytearray | memoryview).

    !ByteString was originally intended to be an abstract class that would serve as a supertype of both bytes and bytearray. However, since the ABC never had any methods, knowing that an object was an instance of !ByteString never actually told you anything useful about the object. Other common buffer types such as memoryview were also never understood as subtypes of !ByteString (either at runtime or by static type checkers).

    See PEP 688 <688#current-options> for more details. (Contributed by Shantanu Jain in 91896.)

• encodings:
  • Passing non-ascii encoding names to encodings.normalize_encoding is deprecated and scheduled for removal in Python 3.17. (Contributed by Stan Ulbrych in 136702.)
• profile:
  • The !profile module is deprecated and will be removed in Python 3.17. Use profiling.tracing instead, which provides a compatible API. See 799 for details. (Contributed by Pablo Galindo and László Kiss Kollár in 138122.)
• webbrowser:
  • !webbrowser.MacOSXOSAScript is deprecated in favour of !webbrowser.MacOS. (137586)
• typing:

  • Before Python 3.14, old-style unions were implemented using the private class typing._UnionGenericAlias. This class is no longer needed for the implementation, but it has been retained for backward compatibility, with removal scheduled for Python 3.17. Users should use documented introspection helpers like typing.get_origin and typing.get_args instead of relying on private implementation details.

  • typing.ByteString, deprecated since Python 3.9, is scheduled for removal in Python 3.17.

    Use isinstance(obj, collections.abc.Buffer) to test if obj implements the buffer protocol <bufferobjects> at runtime. For use in type annotations, either use ~collections.abc.Buffer or a union that explicitly specifies the types your code supports (e.g., bytes | bytearray | memoryview).

    !ByteString was originally intended to be an abstract class that would serve as a supertype of both bytes and bytearray. However, since the ABC never had any methods, knowing that an object was an instance of !ByteString never actually told you anything useful about the object. Other common buffer types such as memoryview were also never understood as subtypes of !ByteString (either at runtime or by static type checkers).

    See PEP 688 <688#current-options> for more details. (Contributed by Shantanu Jain in 91896.)

• tkinter:
  • The !tkinter.Variable methods !trace_variable, !trace (an alias of !trace_variable), !trace_vdelete and !trace_vinfo, deprecated since Python 3.14, are scheduled for removal in Python 3.17. Use !trace_add, !trace_remove and !trace_info instead. (Contributed by Serhiy Storchaka in 120220.)

Pending removal in Python 3.18

• No longer accept a boolean value when a file descriptor is expected. (Contributed by Serhiy Storchaka in 82626.)

• decimal:

  • The non-standard and undocumented ~decimal.Decimal format specifier 'N', which is only supported in the !decimal module's C implementation, has been deprecated since Python 3.13. (Contributed by Serhiy Storchaka in 89902.)

• Deprecations defined by 829:

  • import lines in {name}.pth files are silently ignored.

  (Contributed by Barry Warsaw in 148641.)

Pending removal in Python 3.19

• builtins:
  • Passing a complex number as the real or imag argument in the complex constructor is now deprecated; it should only be passed as a single positional argument. (Contributed by Serhiy Storchaka in 109218.)
• ctypes:
  • Implicitly switching to the MSVC-compatible struct layout by setting ~ctypes.Structure._pack_ but not ~ctypes.Structure._layout_ on non-Windows platforms.
• hashlib:

  • In hash function constructors such as ~hashlib.new or the direct hash-named constructors such as ~hashlib.md5 and ~hashlib.sha256, their optional initial data parameter could also be passed a keyword argument named data= or string= in various !hashlib implementations.

    Support for the string keyword argument name is now deprecated and slated for removal in Python 3.19.

    Before Python 3.13, the string keyword parameter was not correctly supported depending on the backend implementation of hash functions. Prefer passing the initial data as a positional argument for maximum backwards compatibility.

• http.cookies:
  • http.cookies.Morsel.js_output is deprecated and will be removed in Python 3.19.
  • http.cookies.BaseCookie.js_output is deprecated and will be removed in Python 3.19.
• imaplib:

  • Altering IMAP4.file <imaplib.IMAP4.file> is now deprecated and slated for removal in Python 3.19. This property is now unused and changing its value does not automatically close the current file.

    Before Python 3.14, this property was used to implement the corresponding read() and readline() methods for ~imaplib.IMAP4 but this is no longer the case since then.

• tkinter:
  • tkinter.filedialog.askopenfiles has been deprecated since Python 3.16. Iterate over the names returned by ~tkinter.filedialog.askopenfilenames and open them one by one instead. (Contributed by Serhiy Storchaka in 152638.)

Pending removal in Python 3.20

• Calling the __new__() method of struct.Struct without the format argument is deprecated and will be removed in Python 3.20. Calling ~object.__init__ method on initialized ~struct.Struct objects is deprecated and will be removed in Python 3.20.

  (Contributed by Sergey B Kirpichev and Serhiy Storchaka in 143715.)

• The __version__, version and VERSION attributes have been deprecated in these standard library modules and will be removed in Python 3.20. Use sys.version_info instead.

  • argparse
  • csv
  • ctypes
  • !ctypes.macholib
  • decimal (use decimal.SPEC_VERSION instead)
  • http.server
  • imaplib
  • ipaddress
  • json
  • logging (__date__ also deprecated)
  • optparse
  • pickle
  • platform
  • re
  • socketserver
  • tabnanny
  • tarfile
  • tkinter.font
  • tkinter.ttk
  • wsgiref.simple_server
  • xml.etree.ElementTree
  • !xml.sax.expatreader
  • xml.sax.handler
  • zlib

  (Contributed by Hugo van Kemenade and Stan Ulbrych in 76007.)

• The __author__, __credits__, __copyright__ and __date__ attributes have been deprecated in these standard library modules and will be removed in Python 3.20. Attribution is preserved in the source code and the version control history.

  • bz2
  • concurrent.futures
  • inspect
  • io
  • json
  • logging
  • optparse
  • platform
  • pydoc
  • tarfile
  • tkinter.ttk
  • tokenize
  • uuid

  (Contributed by Stan Ulbrych in 159240.)

• Deprecations defined by 829:

  • Warnings are produced for import lines found in {name}.pth files.
  • {name}.pth files are no longer decoded in the locale encoding by default. They MUST be encoded in utf-8-sig.

  (Contributed by Barry Warsaw in 148641.)

• ast:

  • Creating instances of abstract AST nodes (such as ast.AST or !ast.expr) is deprecated and will raise an error in Python 3.20.

• typing:

  • It is deprecated to call isinstance and issubclass checks on protocol classes that were not explicitly decorated with !runtime_checkable but that inherit from a runtime-checkable protocol class. This will raise a TypeError in Python 3.20.

    (Contributed by Bartosz Sławecki in 132604.)

Pending removal in Python 3.21

• abc

  • Soft-deprecated since Python 3.3 abc.abstractclassmethod, abc.abstractstaticmethod, and abc.abstractproperty now raise a DeprecationWarning. These classes will be removed in Python 3.21, instead use abc.abstractmethod with classmethod, staticmethod, and property respectively.

• ast:

  • Classes slice, Index, ExtSlice, Suite, Param, AugLoad and AugStore, will be removed in Python 3.21. These types are not generated by the parser or accepted by the code generator.
  • The dims property of ast.Tuple will be removed in Python 3.21. Use the ast.Tuple.elts property instead.

• functools:

  • Using a return annotation to infer the dispatch type for functools.singledispatch or functools.singledispatchmethod is deprecated since Python 3.16 and will raise TypeError in Python 3.21. Annotate the dispatch parameter or pass the dispatch type explicitly instead. (Contributed by Bartosz Sławecki in 143465.)

• struct:

  • Soft-deprecated since Python 3.15, using 'F' and 'D' type codes are now deprecated. These codes will be removed in Python 3.21. Use instead two-letter forms 'Zf' and 'Zd'.

• tempfile:

  • tempfile._TemporaryFileWrapper will be removed in Python 3.21. Use the public tempfile.TemporaryFileWrapper instead.

Pending removal in future versions

The following APIs will be removed in the future, although there is currently no date scheduled for their removal.

• argparse:
  • Nesting argument groups and nesting mutually exclusive groups are deprecated.
  • Passing the undocumented keyword argument prefix_chars to ~argparse.ArgumentParser.add_argument_group is now deprecated.
  • The argparse.FileType type converter is deprecated.
• builtins:
  • Generators: throw(type, exc, tb) and athrow(type, exc, tb) signature is deprecated: use throw(exc) and athrow(exc) instead, the single argument signature.
  • Currently Python accepts numeric literals immediately followed by keywords, for example 0in x, 1or x, 0if 1else 2. It allows confusing and ambiguous expressions like [0x1for x in y] (which can be interpreted as [0x1 for x in y] or [0x1f or x in y]). A syntax warning is raised if the numeric literal is immediately followed by one of keywords and, else, for, if, in, is and or. In a future release it will be changed to a syntax error. (87999)
  • Support for __index__() and __int__() method returning non-int type: these methods will be required to return an instance of a strict subclass of int.
  • Support for __float__() method returning a strict subclass of float: these methods will be required to return an instance of float.
  • Support for __complex__() method returning a strict subclass of complex: these methods will be required to return an instance of complex.
• calendar: calendar.January and calendar.February constants are deprecated and replaced by calendar.JANUARY and calendar.FEBRUARY. (Contributed by Prince Roshan in 103636.)
• codecs: use open instead of codecs.open. (133038)
• !codeobject.co_lnotab: use the codeobject.co_lines method instead.
• datetime:
  • ~datetime.datetime.utcnow: use datetime.datetime.now(tz=datetime.UTC).
  • ~datetime.datetime.utcfromtimestamp: use datetime.datetime.fromtimestamp(timestamp, tz=datetime.UTC).
• gettext: Plural value must be an integer.
• importlib:
  • ~importlib.util.cache_from_source debug_override parameter is deprecated: use the optimization parameter instead.
• importlib.metadata:
  • EntryPoints tuple interface.
  • Implicit None on return values.
• logging: the warn() method has been deprecated since Python 3.3, use ~logging.warning instead.
• mailbox: Use of StringIO input and text mode is deprecated, use BytesIO and binary mode instead.
• os: Calling os.register_at_fork in a multi-threaded process.
• os.path: os.path.commonprefix is deprecated, use os.path.commonpath for path prefixes. The os.path.commonprefix function is being deprecated due to having a misleading name and module. The function is not safe to use for path prefixes despite being included in a module about path manipulation, meaning it is easy to accidentally introduce path traversal vulnerabilities into Python programs by using this function.
• !pydoc.ErrorDuringImport: A tuple value for exc_info parameter is deprecated, use an exception instance.
• re: More strict rules are now applied for numerical group references and group names in regular expressions. Only sequence of ASCII digits is now accepted as a numerical reference. The group name in bytes patterns and replacement strings can now only contain ASCII letters and digits and underscore. (Contributed by Serhiy Storchaka in 91760.)
• shutil: ~shutil.rmtree's onerror parameter is deprecated in Python 3.12; use the onexc parameter instead.
• ssl options and protocols:
  • ssl.SSLContext without protocol argument is deprecated.
  • ssl.SSLContext: ~ssl.SSLContext.set_npn_protocols and !selected_npn_protocol are deprecated: use ALPN instead.
  • ssl.OP_NO_SSL* options
  • ssl.OP_NO_TLS* options
  • ssl.PROTOCOL_SSLv3
  • ssl.PROTOCOL_TLS
  • ssl.PROTOCOL_TLSv1
  • ssl.PROTOCOL_TLSv1_1
  • ssl.PROTOCOL_TLSv1_2
  • ssl.TLSVersion.SSLv3
  • ssl.TLSVersion.TLSv1
  • ssl.TLSVersion.TLSv1_1
• threading methods:
  • !threading.Condition.notifyAll: use ~threading.Condition.notify_all.
  • !threading.Event.isSet: use ~threading.Event.is_set.
  • !threading.Thread.isDaemon, threading.Thread.setDaemon: use threading.Thread.daemon attribute.
  • !threading.Thread.getName, threading.Thread.setName: use threading.Thread.name attribute.
  • !threading.currentThread: use threading.current_thread.
  • !threading.activeCount: use threading.active_count.
• typing.Text (92332).
• The internal class typing._UnionGenericAlias is no longer used to implement typing.Union. To preserve compatibility with users using this private class, a compatibility shim will be provided until at least Python 3.17. (Contributed by Jelle Zijlstra in 105499.)
• unittest.IsolatedAsyncioTestCase: it is deprecated to return a value that is not None from a test case.
• urllib.parse deprecated functions: ~urllib.parse.urlparse instead
  • splitattr()
  • splithost()
  • splitnport()
  • splitpasswd()
  • splitport()
  • splitquery()
  • splittag()
  • splittype()
  • splituser()
  • splitvalue()
  • to_bytes()
• wsgiref: SimpleHandler.stdout.write() should not do partial writes.
• xml.etree.ElementTree: Testing the truth value of an ~xml.etree.ElementTree.Element is deprecated. In a future release it will always return True. Prefer explicit len(elem) or elem is not None tests instead.
• sys._clear_type_cache is deprecated: use sys._clear_internal_caches instead.

CPython bytecode changes

• Replaced the opcode !BINARY_SUBSCR by the BINARY_OP opcode with the NB_SUBSCR oparg. (Contributed by Irit Katriel in 100239.)
• Add the BUILD_INTERPOLATION and BUILD_TEMPLATE opcodes to construct new ~string.templatelib.Interpolation and ~string.templatelib.Template instances, respectively. (Contributed by Lysandros Nikolaou and others in 132661; see also PEP 750: Template strings <whatsnew314-template-string-literals>).
• Remove the !BUILD_CONST_KEY_MAP opcode. Use BUILD_MAP instead. (Contributed by Mark Shannon in 122160.)
• Replace the !LOAD_ASSERTION_ERROR opcode with LOAD_COMMON_CONSTANT and add support for loading NotImplementedError.
• Add the LOAD_FAST_BORROW and LOAD_FAST_BORROW_LOAD_FAST_BORROW opcodes to reduce reference counting overhead when the interpreter can prove that the reference in the frame outlives the reference loaded onto the stack. (Contributed by Matt Page in 130704.)
• Add the LOAD_SMALL_INT opcode, which pushes a small integer equal to the oparg to the stack. The !RETURN_CONST opcode is removed as it is no longer used. (Contributed by Mark Shannon in 125837.)
• Add the new LOAD_SPECIAL instruction. Generate code for with and async with statements using the new instruction. Removed the !BEFORE_WITH and !BEFORE_ASYNC_WITH instructions. (Contributed by Mark Shannon in 120507.)
• Add the POP_ITER opcode to support 'virtual' iterators. (Contributed by Mark Shannon in 132554.)

Pseudo-instructions

• Add the !ANNOTATIONS_PLACEHOLDER pseudo instruction to support partially executed module-level annotations with deferred evaluation of annotations <whatsnew314-deferred-annotations>. (Contributed by Jelle Zijlstra in 130907.)
• Add the !BINARY_OP_EXTEND pseudo instruction, which executes a pair of functions (guard and specialization functions) accessed from the inline cache. (Contributed by Irit Katriel in 100239.)
• Add three specializations for CALL_KW; !CALL_KW_PY for calls to Python functions, !CALL_KW_BOUND_METHOD for calls to bound methods, and !CALL_KW_NON_PY for all other calls. (Contributed by Mark Shannon in 118093.)
• Add the JUMP_IF_TRUE and JUMP_IF_FALSE pseudo instructions, conditional jumps which do not impact the stack. Replaced by the sequence COPY 1, TO_BOOL, POP_JUMP_IF_TRUE/FALSE. (Contributed by Irit Katriel in 124285.)
• Add the !LOAD_CONST_MORTAL pseudo instruction. (Contributed by Mark Shannon in 128685.)
• Add the !LOAD_CONST_IMMORTAL pseudo instruction, which does the same as !LOAD_CONST, but is more efficient for immortal objects. (Contributed by Mark Shannon in 125837.)
• Add the NOT_TAKEN pseudo instruction, used by sys.monitoring to record branch events (such as BRANCH_LEFT). (Contributed by Mark Shannon in 122548.)

C API changes

Python configuration C API

Add a PyInitConfig C API <pyinitconfig_api> to configure the Python initialization without relying on C structures and the ability to make ABI-compatible changes in the future.

Complete the 587 PyConfig C API <pyconfig_api> by adding PyInitConfig_AddModule which can be used to add a built-in extension module; a feature previously referred to as the "inittab".

Add PyConfig_Get and PyConfig_Set functions to get and set the current runtime configuration.

587 'Python Initialization Configuration' unified all the ways to configure Python's initialization. This PEP also unifies the configuration of Python's preinitialization and initialization in a single API. Moreover, this PEP only provides a single choice to embed Python, instead of having two 'Python' and 'Isolated' choices (PEP 587), to further simplify the API.

The lower level PEP 587 PyConfig API remains available for use cases with an intentionally higher level of coupling to CPython implementation details (such as emulating the full functionality of CPython's CLI, including its configuration mechanisms).

(Contributed by Victor Stinner in 107954.)

New features in the C API

• Add Py_PACK_VERSION and Py_PACK_FULL_VERSION, two new macros for bit-packing Python version numbers. This is useful for comparisons with Py_Version or PY_VERSION_HEX. (Contributed by Petr Viktorin in 128629.)

• Add PyBytes_Join(sep, iterable) <PyBytes_Join> function, similar to sep.join(iterable) in Python. (Contributed by Victor Stinner in 121645.)

• Add functions to manipulate the configuration of the current runtime Python interpreter (PEP 741: Python configuration C API <whatsnew314-capi-config>):

  • PyConfig_Get
  • PyConfig_GetInt
  • PyConfig_Set
  • PyConfig_Names

  (Contributed by Victor Stinner in 107954.)

• Add functions to configure Python initialization (PEP 741: Python configuration C API <whatsnew314-capi-config>):

  • Py_InitializeFromInitConfig
  • PyInitConfig_AddModule
  • PyInitConfig_Create
  • PyInitConfig_Free
  • PyInitConfig_FreeStrList
  • PyInitConfig_GetError
  • PyInitConfig_GetExitCode
  • PyInitConfig_GetInt
  • PyInitConfig_GetStr
  • PyInitConfig_GetStrList
  • PyInitConfig_HasOption
  • PyInitConfig_SetInt
  • PyInitConfig_SetStr
  • PyInitConfig_SetStrList

  (Contributed by Victor Stinner in 107954.)

• Add Py_fopen function to open a file. This works similarly to the standard C !fopen function, instead accepting a Python object for the path parameter and setting an exception on error. The corresponding new Py_fclose function should be used to close a file. (Contributed by Victor Stinner in 127350.)

• Add Py_HashBuffer to compute and return the hash value of a buffer. (Contributed by Antoine Pitrou and Victor Stinner in 122854.)

• Add PyImport_ImportModuleAttr and PyImport_ImportModuleAttrString helper functions to import a module and get an attribute of the module. (Contributed by Victor Stinner in 128911.)

• Add PyIter_NextItem to replace PyIter_Next, which has an ambiguous return value. (Contributed by Irit Katriel and Erlend Aasland in 105201.)

• Add PyLong_GetSign function to get the sign of int objects. (Contributed by Sergey B Kirpichev in 116560.)

• Add PyLong_IsPositive, PyLong_IsNegative and PyLong_IsZero for checking if PyLongObject is positive, negative, or zero, respectively. (Contributed by James Roy and Sergey B Kirpichev in 126061.)

• Add new functions to convert C <stdint.h> numbers to/from Python int objects:

  • PyLong_AsInt32
  • PyLong_AsInt64
  • PyLong_AsUInt32
  • PyLong_AsUInt64
  • PyLong_FromInt32
  • PyLong_FromInt64
  • PyLong_FromUInt32
  • PyLong_FromUInt64

  (Contributed by Victor Stinner in 120389.)

• Add a new import and export API for Python int objects (757):

  • PyLong_GetNativeLayout
  • PyLong_Export
  • PyLong_FreeExport
  • PyLongWriter_Create
  • PyLongWriter_Finish
  • PyLongWriter_Discard

  (Contributed by Sergey B Kirpichev and Victor Stinner in 102471.)

• Add PyMonitoring_FireBranchLeftEvent and PyMonitoring_FireBranchRightEvent for generating BRANCH_LEFT and BRANCH_RIGHT events, respectively. (Contributed by Mark Shannon in 122548.)

• Add PyType_Freeze function to make a type immutable. (Contributed by Victor Stinner in 121654.)

• Add PyType_GetBaseByToken and Py_tp_token slot for easier superclass identification, which attempts to resolve the type checking issue mentioned in PEP 630 <630#type-checking>. (Contributed in 124153.)

• Add a new PyUnicode_Equal function to test if two strings are equal. The function is also added to the Limited C API. (Contributed by Victor Stinner in 124502.)

• Add a new PyUnicodeWriter API to create a Python str object, with the following functions:

  • PyUnicodeWriter_Create
  • PyUnicodeWriter_DecodeUTF8Stateful
  • PyUnicodeWriter_Discard
  • PyUnicodeWriter_Finish
  • PyUnicodeWriter_Format
  • PyUnicodeWriter_WriteASCII
  • PyUnicodeWriter_WriteChar
  • PyUnicodeWriter_WriteRepr
  • PyUnicodeWriter_WriteStr
  • PyUnicodeWriter_WriteSubstring
  • PyUnicodeWriter_WriteUCS4
  • PyUnicodeWriter_WriteUTF8
  • PyUnicodeWriter_WriteWideChar

  (Contributed by Victor Stinner in 119182.)

• The k and K formats in PyArg_ParseTuple and similar functions now use ~object.__index__ if available, like all other integer formats. (Contributed by Serhiy Storchaka in 112068.)

• Add support for a new p format unit in Py_BuildValue that produces a Python bool object from a C integer. (Contributed by Pablo Galindo in 45325.)

• Add PyUnstable_IsImmortal for determining if an object is immortal, for debugging purposes. (Contributed by Peter Bierma in 128509.)

• Add PyUnstable_Object_EnableDeferredRefcount for enabling deferred reference counting, as outlined in 703.

• Add PyUnstable_Object_IsUniquelyReferenced as a replacement for Py_REFCNT(op) == 1 on free threaded <free threading> builds. (Contributed by Peter Bierma in 133140.)

• Add PyUnstable_Object_IsUniqueReferencedTemporary to determine if an object is a unique temporary object on the interpreter's operand stack. This can be used in some cases as a replacement for checking if Py_REFCNT is 1 for Python objects passed as arguments to C API functions. (Contributed by Sam Gross in 133164.)

Limited C API changes

• In the limited C API version 3.14 and newer, Py_TYPE and Py_REFCNT are now implemented as an opaque function call to hide implementation details. (Contributed by Victor Stinner in 120600 and 124127.)
• Remove the PySequence_Fast_GET_SIZE, PySequence_Fast_GET_ITEM, and PySequence_Fast_ITEMS macros from the limited C API, since they have always been broken in the limited C API. (Contributed by Victor Stinner in 91417.)

Removed C APIs

• Creating immutable types <Py_TPFLAGS_IMMUTABLETYPE> with mutable bases was deprecated in Python 3.12, and now raises a TypeError. (Contributed by Nikita Sobolev in 119775.)
• Remove PyDictObject.ma_version_tag member, which was deprecated in Python 3.12. Use the PyDict_AddWatcher API instead. (Contributed by Sam Gross in 124296.)
• Remove the private _Py_InitializeMain() function. It was a provisional API added to Python 3.8 by 587. (Contributed by Victor Stinner in 129033.)
• Remove the undocumented APIs !Py_C_RECURSION_LIMIT and !PyThreadState.c_recursion_remaining. These were added in 3.13 and have been removed without deprecation. Use Py_EnterRecursiveCall to guard against runaway recursion in C code. (Removed by Petr Viktorin in 133079, see also 130396.)

Deprecated C APIs

• The !Py_HUGE_VAL macro is now soft deprecated. Use !INFINITY instead. (Contributed by Sergey B Kirpichev in 120026.)
• The !Py_IS_NAN, !Py_IS_INFINITY, and !Py_IS_FINITE macros are now soft deprecated. Use !isnan, !isinf and !isfinite instead, available from math.h since C99. (Contributed by Sergey B Kirpichev in 119613.)
• Non-tuple sequences are now deprecated as argument for the (items) format unit in PyArg_ParseTuple and other argument parsing <arg-parsing> functions if items contains format units which store a borrowed buffer <c-arg-borrowed-buffer> or a borrowed reference. (Contributed by Serhiy Storchaka in 50333.)
• The _PyMonitoring_FireBranchEvent function is now deprecated and should be replaced with calls to PyMonitoring_FireBranchLeftEvent and PyMonitoring_FireBranchRightEvent.
• The previously undocumented function PySequence_In is now soft deprecated. Use PySequence_Contains instead. (Contributed by Yuki Kobayashi in 127896.)

Pending removal in Python 3.15

• The !PyImport_ImportModuleNoBlock: Use PyImport_ImportModule instead.

• !PyWeakref_GetObject and !PyWeakref_GET_OBJECT: Use PyWeakref_GetRef instead. The pythoncapi-compat project can be used to get PyWeakref_GetRef on Python 3.12 and older.

• !PyUnicode_AsDecodedObject: Use PyCodec_Decode instead.

• !PyUnicode_AsDecodedUnicode: Use PyCodec_Decode instead; Note that some codecs (for example, "base64") may return a type other than str, such as bytes.

• !PyUnicode_AsEncodedObject: Use PyCodec_Encode instead.

• !PyUnicode_AsEncodedUnicode: Use PyCodec_Encode instead; Note that some codecs (for example, "base64") may return a type other than bytes, such as str.

• Python initialization functions, deprecated in Python 3.13:

  • !Py_GetPath: Use PyConfig_Get("module_search_paths") <PyConfig_Get> (sys.path) instead.
  • !Py_GetPrefix: Use PyConfig_Get("base_prefix") <PyConfig_Get> (sys.base_prefix) instead. Use PyConfig_Get("prefix") <PyConfig_Get> (sys.prefix) if virtual environments <venv-def> need to be handled.
  • !Py_GetExecPrefix: Use PyConfig_Get("base_exec_prefix") <PyConfig_Get> (sys.base_exec_prefix) instead. Use PyConfig_Get("exec_prefix") <PyConfig_Get> (sys.exec_prefix) if virtual environments <venv-def> need to be handled.
  • !Py_GetProgramFullPath: Use PyConfig_Get("executable") <PyConfig_Get> (sys.executable) instead.
  • !Py_GetProgramName: Use PyConfig_Get("executable") <PyConfig_Get> (sys.executable) instead.
  • !Py_GetPythonHome: Use PyConfig_Get("home") <PyConfig_Get> or the PYTHONHOME environment variable instead.

  The pythoncapi-compat project can be used to get PyConfig_Get on Python 3.13 and older.

Pending removal in Python 3.16

• Functions to configure Python's initialization, deprecated in Python 3.11:

  • !PySys_SetArgvEx(): Set PyConfig.argv instead.
  • !PySys_SetArgv(): Set PyConfig.argv instead.
  • !Py_SetProgramName(): Set PyConfig.program_name instead.
  • !Py_SetPythonHome(): Set PyConfig.home instead.

  The Py_InitializeFromConfig API should be used with PyConfig instead.

• Global configuration variables:

  • !Py_DebugFlag: Use PyConfig.parser_debug or PyConfig_Get("parser_debug") <PyConfig_Get> instead.
  • !Py_VerboseFlag: Use PyConfig.verbose or PyConfig_Get("verbose") <PyConfig_Get> instead.
  • !Py_QuietFlag: Use PyConfig.quiet or PyConfig_Get("quiet") <PyConfig_Get> instead.
  • !Py_InteractiveFlag: Use PyConfig.interactive or PyConfig_Get("interactive") <PyConfig_Get> instead.
  • !Py_InspectFlag: Use PyConfig.inspect or PyConfig_Get("inspect") <PyConfig_Get> instead.
  • !Py_OptimizeFlag: Use PyConfig.optimization_level or PyConfig_Get("optimization_level") <PyConfig_Get> instead.
  • !Py_NoSiteFlag: Use PyConfig.site_import or PyConfig_Get("site_import") <PyConfig_Get> instead.
  • !Py_BytesWarningFlag: Use PyConfig.bytes_warning or PyConfig_Get("bytes_warning") <PyConfig_Get> instead.
  • !Py_FrozenFlag: Use PyConfig.pathconfig_warnings or PyConfig_Get("pathconfig_warnings") <PyConfig_Get> instead.
  • !Py_IgnoreEnvironmentFlag: Use PyConfig.use_environment or PyConfig_Get("use_environment") <PyConfig_Get> instead.
  • !Py_DontWriteBytecodeFlag: Use PyConfig.write_bytecode or PyConfig_Get("write_bytecode") <PyConfig_Get> instead.
  • !Py_NoUserSiteDirectory: Use PyConfig.user_site_directory or PyConfig_Get("user_site_directory") <PyConfig_Get> instead.
  • !Py_UnbufferedStdioFlag: Use PyConfig.buffered_stdio or PyConfig_Get("buffered_stdio") <PyConfig_Get> instead.
  • !Py_HashRandomizationFlag: Use PyConfig.use_hash_seed and PyConfig.hash_seed or PyConfig_Get("hash_seed") <PyConfig_Get> instead.
  • !Py_IsolatedFlag: Use PyConfig.isolated or PyConfig_Get("isolated") <PyConfig_Get> instead.
  • !Py_LegacyWindowsFSEncodingFlag: Use PyPreConfig.legacy_windows_fs_encoding or PyConfig_Get("legacy_windows_fs_encoding") <PyConfig_Get> instead.
  • !Py_LegacyWindowsStdioFlag: Use PyConfig.legacy_windows_stdio or PyConfig_Get("legacy_windows_stdio") <PyConfig_Get> instead.
  • !Py_FileSystemDefaultEncoding, !Py_HasFileSystemDefaultEncoding: Use PyConfig.filesystem_encoding or PyConfig_Get("filesystem_encoding") <PyConfig_Get> instead.
  • !Py_FileSystemDefaultEncodeErrors: Use PyConfig.filesystem_errors or PyConfig_Get("filesystem_errors") <PyConfig_Get> instead.
  • !Py_UTF8Mode: Use PyPreConfig.utf8_mode or PyConfig_Get("utf8_mode") <PyConfig_Get> instead. (see Py_PreInitialize)

  The Py_InitializeFromConfig API should be used with PyConfig to set these options. Or PyConfig_Get can be used to get these options at runtime.

• Py_UNICODE which was deprecated by 393.

Pending removal in Python 3.18

• The following private functions are deprecated and planned for removal in Python 3.18:

  • !_PyBytes_Join: use PyBytes_Join.
  • !_PyDict_GetItemStringWithError: use PyDict_GetItemStringRef.
  • !_PyDict_Pop(): use PyDict_Pop.
  • !_PyLong_Sign(): use PyLong_GetSign.
  • !_PyLong_FromDigits and !_PyLong_New: use PyLongWriter_Create.
  • !_PyThreadState_UncheckedGet: use PyThreadState_GetUnchecked.
  • !_PyUnicode_AsString: use PyUnicode_AsUTF8.
  • !_PyUnicodeWriter_Init: replace _PyUnicodeWriter_Init(&writer) with writer = PyUnicodeWriter_Create(0) <PyUnicodeWriter_Create>.
  • !_PyUnicodeWriter_Finish: replace _PyUnicodeWriter_Finish(&writer) with PyUnicodeWriter_Finish(writer) <PyUnicodeWriter_Finish>.
  • !_PyUnicodeWriter_Dealloc: replace _PyUnicodeWriter_Dealloc(&writer) with PyUnicodeWriter_Discard(writer) <PyUnicodeWriter_Discard>.
  • !_PyUnicodeWriter_WriteChar: replace _PyUnicodeWriter_WriteChar(&writer, ch) with PyUnicodeWriter_WriteChar(writer, ch) <PyUnicodeWriter_WriteChar>.
  • !_PyUnicodeWriter_WriteStr: replace _PyUnicodeWriter_WriteStr(&writer, str) with PyUnicodeWriter_WriteStr(writer, str) <PyUnicodeWriter_WriteStr>.
  • !_PyUnicodeWriter_WriteSubstring: replace _PyUnicodeWriter_WriteSubstring(&writer, str, start, end) with PyUnicodeWriter_WriteSubstring(writer, str, start, end) <PyUnicodeWriter_WriteSubstring>.
  • !_PyUnicodeWriter_WriteASCIIString: replace _PyUnicodeWriter_WriteASCIIString(&writer, str, size) with PyUnicodeWriter_WriteASCII(writer, str, size) <PyUnicodeWriter_WriteASCII>.
  • !_PyUnicodeWriter_WriteLatin1String: replace _PyUnicodeWriter_WriteLatin1String(&writer, str, size) by decoding the string with PyUnicode_DecodeLatin1, writing the result with PyUnicodeWriter_WriteStr, and releasing the result with Py_DECREF.
  • !_PyUnicodeWriter_Prepare: (no replacement).
  • !_PyUnicodeWriter_PrepareKind: (no replacement).
  • !_Py_HashPointer: use Py_HashPointer.
  • !_Py_fopen_obj: use Py_fopen.
  • PyGen_New: (no replacement).
  • PyGen_NewWithQualName: (no replacement).
  • PyCoro_New: (no replacement).
  • PyAsyncGen_New: (no replacement).

  The pythoncapi-compat project can be used to get these new public functions on Python 3.13 and older. (Contributed by Victor Stinner in 128863.)

Pending removal in future versions

The following APIs are deprecated and will be removed, although there is currently no date scheduled for their removal.

• Py_TPFLAGS_HAVE_FINALIZE: Unneeded since Python 3.8.
• PyErr_Fetch: Use PyErr_GetRaisedException instead.
• PyErr_NormalizeException: Use PyErr_GetRaisedException instead.
• PyErr_Restore: Use PyErr_SetRaisedException instead.
• PyOS_AfterFork: Use PyOS_AfterFork_Child instead.
• PySlice_GetIndicesEx: Use PySlice_Unpack and PySlice_AdjustIndices instead.
• PyUnicode_READY: Unneeded since Python 3.12
• !PyErr_Display: Use PyErr_DisplayException instead.
• !_PyErr_ChainExceptions: Use !_PyErr_ChainExceptions1 instead.
• !PyBytesObject.ob_shash member: call PyObject_Hash instead.
• Thread Local Storage (TLS) API:
  • PyThread_create_key: Use PyThread_tss_alloc instead.
  • PyThread_delete_key: Use PyThread_tss_free instead.
  • PyThread_set_key_value: Use PyThread_tss_set instead.
  • PyThread_get_key_value: Use PyThread_tss_get instead.
  • PyThread_delete_key_value: Use PyThread_tss_delete instead.
  • PyThread_ReInitTLS: Unneeded since Python 3.7.

Build changes

• 776: Emscripten is now an officially supported platform at tier 3 <11#tier-3>. As a part of this effort, more than 25 bugs in Emscripten libc were fixed. Emscripten now includes support for ctypes, termios, and fcntl, as well as experimental support for the new default interactive shell <tut-interactive>. (Contributed by R. Hood Chatham in 127146, 127683, and 136931.)
• Official Android binary releases are now provided on python.org.
• GNU Autoconf 2.72 is now required to generate configure. (Contributed by Erlend Aasland in 115765.)
• wasm32-unknown-emscripten is now a 11 tier 3 platform. (Contributed by R. Hood Chatham in 127146, 127683, and 136931.)
• #pragma-based linking with python3*.lib can now be switched off with Py_NO_LINK_LIB. (Contributed by Jean-Christophe Fillion-Robin in 82909.)
• CPython now enables a set of recommended compiler options by default for improved security. Use the --disable-safety configure option to disable them, or the --enable-slower-safety option for a larger set of compiler options, albeit with a performance cost.
• The WITH_FREELISTS macro and --without-freelists configure option have been removed.
• The new configure option --with-tail-call-interp may be used to enable the experimental tail call interpreter. See whatsnew314-tail-call-interpreter for further details.
• To disable the new remote debugging support, use the --without-remote-debug configure option. This may be useful for security reasons.
• iOS and macOS apps can now be configured to redirect stdout and stderr content to the system log. (Contributed by Russell Keith-Magee in 127592.)
• The iOS testbed is now able to stream test output while the test is running. The testbed can also be used to run the test suite of projects other than CPython itself. (Contributed by Russell Keith-Magee in 127592.)

build-details.json

Installations of Python now contain a new file, build-details.json. This is a static JSON document containing build details for CPython, to allow for introspection without needing to run code. This is helpful for use-cases such as Python launchers, cross-compilation, and so on.

build-details.json must be installed in the platform-independent standard library directory. This corresponds to the 'stdlib' <installation_paths> sysconfig installation path, which can be found by running sysconfig.get_path('stdlib').

Discontinuation of PGP signatures

PGP (Pretty Good Privacy) signatures will not be provided for releases of Python 3.14 or future versions. To verify CPython artifacts, users must use Sigstore verification materials. Releases have been signed using Sigstore since Python 3.11.

This change in release process was specified in 761.

Free-threaded Python is officially supported

The free-threaded build of Python is now supported and no longer experimental. This is the start of phase II where free-threaded Python is officially supported but still optional.

The free-threading team are confident that the project is on the right path, and appreciate the continued dedication from everyone working to make free-threading ready for broader adoption across the Python community.

With these recommendations and the acceptance of this PEP, the Python developer community should broadly advertise that free-threading is a supported Python build option now and into the future, and that it will not be removed without a proper deprecation schedule.

Any decision to transition to phase III, with free-threading as the default or sole build of Python is still undecided, and dependent on many factors both within CPython itself and the community. This decision is for the future.

Binary releases for the experimental just-in-time compiler

The official macOS and Windows release binaries now include an experimental just-in-time (JIT) compiler. Although it is not recommended for production use, it can be tested by setting PYTHON_JIT=1 <PYTHON_JIT> as an environment variable. Downstream source builds and redistributors can use the --enable-experimental-jit=yes-off configuration option for similar behavior.

The JIT is at an early stage and still in active development. As such, the typical performance impact of enabling it can range from 10% slower to 20% faster, depending on workload. To aid in testing and evaluation, a set of introspection functions has been provided in the sys._jit namespace. sys._jit.is_available can be used to determine if the current executable supports JIT compilation, while sys._jit.is_enabled can be used to tell if JIT compilation has been enabled for the current process.

Currently, the most significant missing functionality is that native debuggers and profilers like gdb and perf are unable to unwind through JIT frames (Python debuggers and profilers, like pdb or profile, continue to work without modification). Free-threaded builds do not support JIT compilation.

Please report any bugs or major performance regressions that you encounter!

Porting to Python 3.14

This section lists previously described changes and other bugfixes that may require changes to your code.

Changes in the Python API

• On Unix platforms other than macOS, forkserver is now the default start method <multiprocessing-start-methods> for multiprocessing and ~concurrent.futures.ProcessPoolExecutor, instead of fork.

  See (1) <whatsnew314-concurrent-futures-start-method> and (2) <whatsnew314-multiprocessing-start-method> for details.

  If you encounter NameErrors or pickling errors coming out of multiprocessing or concurrent.futures, see the forkserver restrictions <multiprocessing-programming-forkserver>.

  This change does not affect Windows or macOS, where 'spawn' <multiprocessing-start-method-spawn> remains the default start method.

• functools.partial is now a method descriptor. Wrap it in staticmethod if you want to preserve the old behavior. (Contributed by Serhiy Storchaka and Dominykas Grigonis in 121027.)

• The garbage collector is now incremental <whatsnew314-incremental-gc>, which means that the behavior of gc.collect changes slightly:

  • gc.collect(1): Performs an increment of garbage collection, rather than collecting generation 1.
  • Other calls to !gc.collect are unchanged.

• The locale.nl_langinfo function now temporarily sets the LC_CTYPE locale in some cases. This temporary change affects other threads. (Contributed by Serhiy Storchaka in 69998.)

• pickle.dump and pickle.dumps now raise ~pickle.PicklingError for some failures that previously raised AttributeError, ImportError, ValueError, UnicodeEncodeError or !PicklingError, depending on the implementation (for example, pickling a local object, or an object whose module cannot be imported). The original exception is chained to the !PicklingError. Code that caught these exceptions should also catch !PicklingError. (Contributed by Serhiy Storchaka in 122311.)

• types.UnionType is now an alias for typing.Union, causing changes in some behaviors. See above <whatsnew314-typing-union> for more details. (Contributed by Jelle Zijlstra in 105499.)

• The runtime behavior of annotations has changed in various ways; see above <whatsnew314-deferred-annotations> for details. While most code that interacts with annotations should continue to work, some undocumented details may behave differently.

• As part of making the mimetypes CLI public, it now exits with 1 on failure instead of 0 and 2 on incorrect command-line parameters instead of 1. Error messages are now printed to stderr.

• The \B pattern in regular expression now matches the empty string when given as the entire pattern, which may cause behavioural changes.

• On FreeBSD, sys.platform no longer contains the major version number.

Changes in annotations (649 and 749)

This section contains guidance on changes that may be needed to annotations or Python code that interacts with or introspects annotations, due to the changes related to deferred evaluation of annotations <whatsnew314-deferred-annotations>.

In the majority of cases, working code from older versions of Python will not require any changes.

Implications for annotated code

If you define annotations in your code (for example, for use with a static type checker), then this change probably does not affect you: you can keep writing annotations the same way you did with previous versions of Python.

You will likely be able to remove quoted strings in annotations, which are frequently used for forward references. Similarly, if you use from __future__ import annotations to avoid having to write strings in annotations, you may well be able to remove that import once you support only Python 3.14 and newer. However, if you rely on third-party libraries that read annotations, those libraries may need changes to support unquoted annotations before they work as expected.

Implications for readers of __annotations__

If your code reads the ~object.__annotations__ attribute on objects, you may want to make changes in order to support code that relies on deferred evaluation of annotations. For example, you may want to use annotationlib.get_annotations with the ~annotationlib.Format.FORWARDREF format, as the dataclasses module now does.

The external typing_extensions package provides partial backports of some of the functionality of the annotationlib module, such as the ~annotationlib.Format enum and the ~annotationlib.get_annotations function. These can be used to write cross-version code that takes advantage of the new behavior in Python 3.14.

Related changes

The changes in Python 3.14 are designed to rework how !__annotations__ works at runtime while minimizing breakage to code that contains annotations in source code and to code that reads !__annotations__. However, if you rely on undocumented details of the annotation behavior or on private functions in the standard library, there are many ways in which your code may not work in Python 3.14. To safeguard your code against future changes, only use the documented functionality of the annotationlib module.

In particular, do not read annotations directly from the namespace dictionary attribute of type objects. Use annotationlib.get_annotate_from_class_namespace during class construction and annotationlib.get_annotations afterwards.

In previous releases, it was sometimes possible to access class annotations from an instance of an annotated class. This behavior was undocumented and accidental, and will no longer work in Python 3.14.

from __future__ import annotations

In Python 3.7, 563 introduced the from __future__ import annotations future statement <future>, which turns all annotations into strings.

However, this statement is now deprecated and it is expected to be removed in a future version of Python. This removal will not happen until after Python 3.13 reaches its end of life in 2029, being the last version of Python without support for deferred evaluation of annotations.

In Python 3.14, the behavior of code using from __future__ import annotations is unchanged.

Changes in the C API

• Py_Finalize now deletes all interned strings. This is backwards incompatible to any C extension that holds onto an interned string after a call to Py_Finalize and is then reused after a call to Py_Initialize. Any issues arising from this behavior will normally result in crashes during the execution of the subsequent call to Py_Initialize from accessing uninitialized memory. To fix, use an address sanitizer to identify any use-after-free coming from an interned string and deallocate it during module shutdown. (Contributed by Eddie Elizondo in 113601.)
• The Unicode Exception Objects <unicodeexceptions> C API now raises a TypeError if its exception argument is not a UnicodeError object. (Contributed by Bénédikt Tran in 127691.)

Notable changes in 3.14.5

gc

• The incremental garbage collector shipped in Python 3.14.0-3.14.4 has been reverted back to the generational garbage collector from 3.13, due to a number of reports of significant memory pressure in production environments. See whatsnew314-incremental-gc for details.