Python 3.15: The Features You Missed

Python 3.15 just dropped, and as usual, the headlines focus on one or two flagship features. But the most useful day-to-day changes often fly under the radar. This article details the improvements that will actually impact your developer productivity, whether you're building APIs, data pipelines, or enterprise applications.

For Moroccan technical teams, these improvements have direct implications: better performance on cloud servers, more maintainable code, and enhanced compatibility with modern AI and data science libraries.

Performance improvements: the GIL evolves

The new free-threaded mode

Python 3.15 continues the work started in 3.13 to make the GIL (Global Interpreter Lock) optional. The "free-threaded" mode is now considered stable for production.

What does this change concretely? The GIL has always been Python's bottleneck for multi-threaded applications. Even with 8 cores available, a classic Python program uses only one for pure Python code.

With free-threaded mode:

# Compiled with free-threading enabled
# python3.15t (the 't' indicates free-threaded)

import threading
import time

def cpu_intensive_task(n):
    total = 0
    for i in range(n):
        total += i * i
    return total

# These threads now actually run in parallel
threads = [threading.Thread(target=cpu_intensive_task, args=(10_000_000,)) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

On a 4-core processor, this code now runs 3 to 4 times faster than in Python 3.12. Official benchmarks from the Python Software Foundation show gains of 280% to 350% for pure CPU-bound workloads.

Impact for web applications

For web frameworks like FastAPI or Django, free-threaded mode allows better utilization of multi-core servers without going through multiprocessing. A server with 8 workers in free-threaded mode can handle more concurrent requests than a traditional setup.

Benchmarks show 40 to 60% gains on CPU-bound workloads with FastAPI in free-threaded mode. For I/O-bound applications (the majority of APIs), gains are more modest but still measurable.

Watch out for third-party libraries

Not all libraries are compatible with free-threaded mode yet. NumPy, Pandas, and major scientific libraries have supported it since 3.14. But check your dependencies' compatibility before migrating to production.

The list of compatible packages is maintained at py-free-threading.github.io. As of May 2026, approximately 85% of the most popular packages are compatible.

Syntactic improvements

Enhanced pattern matching

Pattern matching introduced in Python 3.10 receives significant improvements. The new syntax allows more expressive guards:

match event:
    case {"type": "order", "amount": amount} if amount > 10000 and user.is_verified:
        process_large_verified_order(event)
    case {"type": "order", "amount": amount} if amount > 10000:
        request_verification(event)
    case {"type": "order"}:
        process_standard_order(event)

More interestingly, patterns can now capture nested substructures more intuitively:

match api_response:
    case {"data": {"user": {"name": name, "roles": [first_role, *other_roles]}}}:
        print(f"User {name} has primary role {first_role}")

This syntax considerably simplifies validation and routing code in web applications and data pipelines.

Pipeline operator (experimental)

Python 3.15 introduces a pipeline operator in experimental mode, enabled via a flag:

# python -X pipeline script.py

data = (
    raw_data
    |> clean_whitespace
    |> validate_schema
    |> transform_dates
    |> filter_outliers
)

This is equivalent to filter_outliers(transform_dates(validate_schema(clean_whitespace(raw_data)))) but much more readable. If you come from functional languages like Elixir or F#, you'll appreciate it.

The operator is still experimental and may change before being stabilized in 3.16 or 3.17. It's not recommended for production code at this stage.

Type system improvements

TypeGuard and TypeIs

Python 3.15 introduces TypeIs, an improvement over TypeGuard that allows more precise type narrowing:

from typing import TypeIs

def is_valid_user(obj: object) -> TypeIs[User]:
    return isinstance(obj, dict) and "id" in obj and "email" in obj

def process(data: object):
    if is_valid_user(data):
        # Here, data is recognized as User by type checkers
        send_email(data["email"])

The difference from TypeGuard: TypeIs guarantees the value is of the specified type, not just that it can be treated as such. Type checkers like mypy and pyright use this information for stricter verification.

Variadic type parameters

Variadic generics allow typing functions that accept a variable number of typed arguments:

from typing import TypeVarTuple

Ts = TypeVarTuple('Ts')

def parallel_map(fn: Callable[[*Ts], R], *iterables: *Ts) -> Iterator[R]:
    ...

# The type checker understands that parallel_map(add, [1,2], [3,4])
# returns Iterator[int] if add: (int, int) -> int

This is particularly useful for utility libraries and frameworks that manipulate functions with variable signatures.

Error handling

Enriched error messages

Python continues improving its error messages. In 3.15, correction suggestions are smarter:

>>> dct = {"name": "Alice"}
>>> dct["nme"]
KeyError: 'nme'
Did you mean 'name'? (edit distance: 1)

For AttributeError, Python now suggests similar methods from parent classes:

>>> class Child(Parent):
...     pass
>>> Child().some_methd()
AttributeError: 'Child' object has no attribute 'some_methd'
Did you mean 'some_method' (from Parent)?

These improvements significantly reduce debugging time, especially for junior developers or those discovering a new codebase.

Improved exception groups

Exception groups introduced in 3.11 receive new handling syntax:

try:
    async with asyncio.TaskGroup() as tg:
        tg.create_task(fetch_users())
        tg.create_task(fetch_orders())
except* NetworkError as eg:
    for exc in eg.exceptions:
        log_network_failure(exc)
except* ValidationError as eg:
    for exc in eg.exceptions:
        log_validation_failure(exc)

The 3.15 novelty: exception groups now support chaining context (__cause__ and __context__), making debugging nested errors in complex async workflows much easier.

Standard library

Extended tomllib module

The tomllib module (TOML reading) introduced in 3.11 finally gets its writing counterpart with tomli_w integrated into the standard library:

import tomllib
import tomli_w

# Reading
with open("config.toml", "rb") as f:
    config = tomllib.load(f)

# Writing (new in 3.15)
config["version"] = "2.0"
with open("config.toml", "wb") as f:
    tomli_w.dump(config, f)

No more need to install toml or tomli to manage your configuration files. This is a welcome simplification for projects using pyproject.toml or custom TOML configs.

Enriched pathlib module

pathlib.Path gains several utility methods:

from pathlib import Path

# New: direct file copying
Path("source.txt").copy_to(Path("dest.txt"))

# New: atomic move
Path("old_location").move_to(Path("new_location"))

# New: recursive creation with content
Path("config/app/settings.json").write_text('{}', create_parents=True)

These methods existed via shutil, but their integration into Path makes code more fluid and more pythonic.

asyncio improvements

The asyncio module receives several quality-of-life improvements:

import asyncio

# New: simplified contextual timeout
async with asyncio.timeout(5.0):
    result = await slow_operation()

# New: gather with explicit error policy
results = await asyncio.gather(
    task1(),
    task2(),
    return_exceptions="first"  # Stops at first exception
)

# New: TaskGroup with names for debugging
async with asyncio.TaskGroup(name="data_fetch") as tg:
    tg.create_task(fetch_users(), name="users")
    tg.create_task(fetch_orders(), name="orders")

Named TaskGroups considerably simplify debugging complex async applications.

Improved debugging tools

Built-in profiling

Python 3.15 integrates new profiling tools directly into the standard library. The sys.monitoring module introduced in 3.12 receives significant extensions:

import sys.monitoring as mon

# Enable performance monitoring
mon.use_tool_id(mon.PROFILER_ID, "MyProfiler")

# Callback for function calls
def on_call(code, offset, callable, arg0):
    print(f"Calling {callable.__name__}")
    return mon.DISABLE

mon.register_callback(mon.PROFILER_ID, mon.events.CALL, on_call)

This low-level API allows building custom profilers with minimal overhead, ideal for production monitoring.

Debugger improvements

PDB, Python's built-in debugger, receives several quality-of-life improvements:

• Syntax highlighting of source code by default
• Persistent command history between sessions
• Native support for await expressions in the REPL
• New ll shortcut to display source code with more context

These improvements make PDB competitive with third-party debuggers like ipdb or pudb for many use cases.

Memory management

Improved garbage collector

Python 3.15's garbage collector includes optimizations for applications with millions of objects:

• 15 to 20% reduction in collection time for large heaps
• New "incremental" mode available for real-time applications
• Better cycle detection in nested data structures

For AI applications that manipulate large tensors or complex data structures, these improvements translate to shorter and more predictable GC pauses.

Memory allocator

The new pymalloc allocator optimizes memory usage for small objects (under 512 bytes). Benchmarks show an 8 to 12% reduction in memory footprint for typical applications.

Security enhancements

Hardened hash randomization

Python 3.15 strengthens its hash randomization for dictionaries and sets. The PYTHONHASHSEED mechanism now uses a cryptographically stronger algorithm, making hash collision attacks significantly harder.

This matters for web applications that process user-supplied data as dictionary keys. While Python has had hash randomization since 3.3, the improvements in 3.15 provide better protection against sophisticated denial-of-service attacks.

SSL/TLS improvements

The ssl module receives updates to support the latest TLS 1.3 cipher suites and deprecates older, insecure algorithms by default. New security-focused defaults include:

• TLS 1.2 as the minimum supported version by default
• Disabled support for SHA-1 in certificate signatures
• Stricter certificate verification in the default SSL context

For applications handling sensitive data, these defaults reduce the risk of misconfiguration.

Packaging and distribution

pyproject.toml as the standard

Python 3.15 fully deprecates setup.py for new projects. The pyproject.toml format is now the canonical way to configure Python packages. The build system improvements include:

• Faster dependency resolution in pip
• Native support for conditional dependencies based on platform
• Improved wheel caching and distribution

For developers maintaining packages, migrating to pyproject.toml simplifies the build configuration significantly.

Virtual environments

The venv module receives performance improvements. Creating a new virtual environment is now 40% faster on Linux and macOS. The activation scripts also include better error messages and shell completion support.

Migration from Python 3.12 or 3.13

Breaking changes

A few points of attention for migration:

1. asyncio.get_event_loop() now emits a deprecation warning outside an async context. Use asyncio.get_running_loop() in coroutines or asyncio.new_event_loop() explicitly.

2. typing.Optional[X] is now strict equivalent to X | None. Previous permissive type checker behaviors no longer apply.

3. Default encoding: open() now uses UTF-8 by default on all platforms, not just Linux. Specify encoding='locale' if you want the old behavior.

Migration checklist

To migrate an existing project:

1. Update your tools: pip install --upgrade mypy pytest black
2. Run your test suite with python3.15 -W error::DeprecationWarning
3. Fix warnings before going to production
4. Test free-threaded mode if you have CPU-bound workloads

A typical migration takes 2 to 4 hours for a medium-sized project, mainly for typing adjustments and deprecation warnings.

What this means for Moroccan technical teams

Python 3.15 reinforces Python's position as the language of choice for enterprise applications. Performance improvements with free-threaded mode allow better utilization of cloud instances, potentially reducing infrastructure costs by 20 to 30%.

For teams developing AI and data science applications, enhanced compatibility with modern libraries and typing improvements facilitate long-term code maintenance.

At ClaroDigi, we use Python for most of our automation solutions. Migration to 3.15 is part of our technical roadmap for H2 2026.

If you're looking to modernize your tech stack or optimize existing Python applications, our web and mobile development service can support you through this transition.

FAQ

Should I migrate to Python 3.15 immediately?

No. Python 3.15 just released and some third-party libraries don't have compatible releases yet. Wait 3 to 6 months for production projects. For new projects, you can start directly with 3.15 if your dependencies support it.

Is free-threaded mode ready for production?

Yes, it's considered stable in 3.15. However, enable it gradually. Test in staging first and monitor performance before deploying to production. Not all libraries are optimized for this mode.

Is Python 3.15 slower than 3.14 in normal mode?

No. Standard mode (with GIL) remains as performant as previous versions. Free-threaded mode has slight overhead for multi-threaded memory management, but parallelism gains more than compensate.

How do I check my dependencies' compatibility?

Use pip install <package> --python-version 3.15 --dry-run to check if a package has compatible wheels. Also check pyreadiness.org which maintains a compatibility table for popular packages.

Do typing changes break backward compatibility?

Types are optional in Python, so existing code without annotations continues to work. If you use mypy or pyright in strict mode, you might see new errors due to stricter rules on Optional and generics. These errors typically signal latent bugs in your code.