What's new in Python 3.14, and what it means for data work

Python 3.14 was released in October 2025, and is the current stable version of Python as of this writing. With Python 3.15 scheduled for October 2026, it is a good moment to review what 3.14 changed and whether it is time to upgrade your data projects.

Free-threaded Python is officially supported

For decades, the Global Interpreter Lock (GIL) meant a single Python process could only run Python code on one CPU core at a time. Python 3.13 introduced an experimental build without the GIL; in 3.14 the free-threaded build moved to officially supported status (PEP 779). It is still a separate, optional build rather than the default.

What it means for data work: CPU-heavy pure-Python code can finally use several cores with ordinary threads. Libraries such as NumPy and pandas already release the GIL for much of their heavy lifting, so the biggest gains are in custom Python loops and parsing code. Check that your key libraries publish free-threaded wheels before switching.

Template strings: t-strings

PEP 750 adds template strings, written with a t prefix. They look like f-strings, but instead of producing a string immediately they produce a Template object that code can inspect and process safely.

name = "Robert'); DROP TABLE students;--"
query = t"SELECT * FROM students WHERE name = {name}"
# query is a string.templatelib.Template, not a str.
# A library can turn it into a safe, parameterised SQL statement
# instead of pasting the value straight into the query text.

What it means for data work: expect database and templating libraries to adopt t-strings for safer SQL and HTML generation, reducing injection risks without clunky syntax.

Deferred evaluation of annotations

Type annotations are no longer evaluated when a function or class is defined; they are evaluated only when something asks for them (PEP 649 and PEP 749). Forward references now simply work, and importing heavily typed modules can be faster.

class Node:
    def add_child(self, child: Node) -> None:   # no quotes or __future__ import needed
        ...

Multiple interpreters in the standard library

The new concurrent.interpreters module (PEP 734) exposes isolated interpreters within one process, and concurrent.futures.InterpreterPoolExecutor makes them easy to use for parallel work, with lower overhead than separate processes.

Zstandard compression built in

A new compression package includes compression.zstd (PEP 784). Zstandard offers an excellent balance of speed and compression ratio, and is widely used in data formats such as Parquet.

from compression import zstd

raw = open("events.json", "rb").read()
packed = zstd.compress(raw)
assert zstd.decompress(packed) == raw

Smaller quality-of-life improvements

• Multiple exception types can be caught without brackets when there is no as clause: except TimeoutError, ConnectionError: (PEP 758).
• return, break and continue inside a finally block now raise a warning (PEP 765), catching a classic source of swallowed errors.
• The interactive shell gains syntax highlighting, and error messages continue to get more helpful.
• pathlib.Path gains copy() and move() methods.

Should you upgrade?

• New projects: yes, as long as your key libraries support 3.14. Tools like uv make trying a new version trivial: uv python install 3.14.
• Existing pipelines: upgrade in a branch, run your tests, and pin the version once it passes.
• Free-threading: treat it as an experiment for CPU-bound workloads, not a default.

Version support moves quickly. Always check the official "What's New" page on python.org and your libraries' release notes before upgrading production code.

Written by Alessandro Ecclesie Agazzi, freelance analytics engineer in London. Updated 30 September 2026.