Python 3.15 Is Here: Lazy Imports, frozendict, and the New JIT

Python 3.15 introduces several changes that affect how developers start applications, manage configuration data, and evaluate runtime performance. The stable release arrived on October 9, 2026, bringing explicit lazy imports, a built-in frozendict type, and significant improvements to the experimental Just-in-Time (JIT) compiler.

These features address different development problems. Lazy imports can reduce the work performed during application startup. frozendict provides an immutable mapping for data that should not change after creation. The upgraded JIT offers another path for improving execution speed, although actual results depend on the workload and platform.

For developers maintaining APIs, command-line utilities, data-processing applications, or Python libraries, the important question is not simply what is new. It is which features solve real problems and how to adopt them without introducing compatibility issues.

What's New in Python 3.15?

Python 3.15 includes improvements to the language, interpreter, and standard library.

These features are not interchangeable performance optimizations. Lazy imports target initialization, frozendict addresses data immutability, and the JIT targets execution. Each should be evaluated against the specific problem an application has.

1. Explicit Lazy Imports Can Improve Startup Time

Python normally executes an imported module's top-level code when the module is imported. This includes loading dependencies, initializing objects, and executing other statements.

In a large application, the resulting dependency tree can become expensive to initialize. The problem is particularly noticeable in command-line tools that import many libraries but use only a small subset for a particular command.

Python 3.15 introduces explicit lazy imports through the lazy soft keyword.

How Lazy Imports Work

Consider a utility that supports several operations, including displaying a simple help message and processing JSON data.

With a regular import, Python loads the imported module immediately:

import json

def show_help():
    print("Usage: app [command]")

def parse_data(text):
    return json.loads(text)

If the program only displays help, it may not need the JSON module at all.

Python 3.15 allows the import to be declared lazily:

lazy import json

def show_help():
    print("Usage: app [command]")

def parse_data(text):
    return json.loads(text)

The actual module loading is deferred until the imported name is first accessed. In this example, calling show_help() does not require the application to load json, while calling parse_data() triggers the import when needed.

The syntax is available in Python 3.15 and later. Earlier Python versions cannot parse the lazy import statement.

When Should Developers Use Lazy Imports?

Lazy imports are worth evaluating when:

• A command-line application starts frequently but uses only a small part of its dependency tree.

• An application supports multiple optional integrations.

• A development tool has expensive modules used only for specific commands.

• A service imports substantial functionality that is not needed during initialization.

However, lazy imports do not make the underlying module execute faster. They defer the cost. If the module is eventually used, its loading and initialization work still needs to happen.

This means the first operation that accesses a lazy import may take longer than it did with an eager import.

Limitations to Understand

The lazy keyword is supported only in permitted module-level import statements. It cannot be used indiscriminately inside functions, class bodies, or exception-handling blocks.

It also cannot be used for star imports or __future__ imports.

Developers should test lazy imports carefully when module initialization has side effects, registers plugins, configures logging, or establishes global state. Deferring those actions can change when the application observes them.

2. Python 3.15 Adds a Built-In frozendict

Python dictionaries are mutable. After creating a dictionary, any code holding a reference to it can modify its contents.

That behavior is useful for ordinary application state, but it can be problematic when a mapping represents configuration, fixed metadata, or a value that must remain stable.

Python 3.15 introduces frozendict, a built-in immutable mapping type.

Creating an Immutable Mapping

The following example illustrates its basic usage:

settings = frozendict(
    timeout=30,
    retries=3,
    environment="production"
)

print(settings["timeout"])
print(settings)

Attempting to change the mapping raises a TypeError:

settings["timeout"] = 60

This makes the mapping useful when an application needs to prevent accidental changes to its top-level key-value associations.

Using frozendict for Configuration

Consider a service that receives a set of operational settings. The application should allow components to read the settings without allowing them to replace or remove entries.

DEFAULT_SETTINGS = frozendict({
    "timeout": 30,
    "max_retries": 3,
    "debug": False
})

def get_timeout(settings):
    return settings["timeout"]

print(get_timeout(DEFAULT_SETTINGS))

The mapping cannot be modified after creation. This can make configuration ownership easier to reason about, particularly when settings are shared across multiple components.

There is an important limitation: immutability is shallow. If a value inside the mapping is itself a mutable list or dictionary, that nested object can still change.

For example:

settings = frozendict({
    "allowed_hosts": ["api.example.com"]
})

settings["allowed_hosts"].append("internal.example.com")

The example demonstrates that the mapping is immutable while its list value remains mutable. Applications requiring deeply immutable configuration must also control the mutability of nested values.

Important Differences From dict