Python 3.15 Is Out: Release Date and What's New

Python 3.15.0 is officially out. The Python core team released the final build on Friday, October 9, 2026, eight days later than originally planned, after a last-minute third release candidate was needed to land fixes for the new lazy-import system. The release brings explicit lazy imports, a built-in frozendict type, a built-in sentinel type, a brand-new sampling profiler nicknamed "Tachyon," and a new C API for building bytes objects, among dozens of smaller changes across the standard library.

Below is a rundown of what shipped, why the release slipped by more than a week, and how the changes affect day-to-day Python development, drawn from the official What's New in Python 3.15 document, the governing PEPs, and python.org's own release pages.

When was Python 3.15 released, and why was it late?

Python 3.15.0 was released on October 9, 2026, confirmed on python.org's own 3.15.0 download page and in the official What's New document. That date was not the original plan. PEP 790, the PEP that governs the 3.15 release schedule, had targeted October 1, 2026, for the final build, following two release candidates issued in August and September.

On October 1, release manager Hugo van Kemenade posted on the official Python discussion forum that the team had found "last-minute lazy-import release blockers" it wanted fixed before calling the release final, and that testing those fixes properly would take more time. Rather than ship 3.15.0 that day, the team cut a third release candidate, 3.15.0rc3, on October 2, explicitly marked as not for production use, and pushed the final build to October 9. The actual schedule, now recorded in PEP 790, lists candidate 3 on 2026-10-02 and the final release eight days later.

It is a reminder that even late-stage release candidates can surface real blockers — in this case tied to one of the release's biggest new language features, rather than a routine packaging issue.

PEP 810: explicit lazy imports

The feature that caused the delay is also the one generating the most attention: explicit lazy imports, specified in PEP 810. Python 3.15 adds a lazy soft keyword that defers loading and executing a module until the imported name is actually used:

lazy import json
lazy from pathlib import Path

print("Starting up...")        # json and pathlib are not fully loaded yet
data = json.loads('{"key": "value"}')   # json loads here, on first use

The name is bound immediately as a proxy object; the real module import happens transparently the first time the name is touched. According to the PEP's own motivation section, this targets a well-known pain point for command-line tools and large applications, where importing dozens of rarely used modules at startup can make something as simple as --help take seconds to print. The PEP cites startup-time reductions of 50 to 70 percent in some real-world cases, plus memory savings, when imports that are not always needed are marked lazy.

Laziness is opt-in and local: it only applies to imports explicitly marked with lazy, is restricted to module scope (it can't be used inside functions, classes, or try blocks), and doesn't cascade into the modules being imported. It can also be enabled globally for a whole run via the -X lazy_imports flag or the PYTHON_LAZY_IMPORTS environment variable, which is useful for testing whether an existing codebase tolerates deferred imports without code changes.

New builtins: frozendict and sentinel

Two long-requested additions land directly in the builtins module rather than in a library import. PEP 814 adds frozendict, an immutable, hashable mapping that preserves insertion order and implements the collections.abc.Mapping protocol — but, notably, is not a subclass of dict:

a = frozendict(x=1, y=2)
b = frozendict(y=2, x=1)
hash(a) == hash(b)   # True
a == b               # True
a['z'] = 3            # TypeError

PEP 661 adds sentinel, a built-in way to create unique placeholder objects such as "value was not provided," long faked with patterns like object() or module-level singletons. Built-in sentinels have a readable repr, survive copying and pickling (when importable by name), and work with the | operator in type annotations. Both PEPs carry a Final status with resolution dates in early-to-mid 2026 and explicitly target Python 3.15, which the shipped What's New document confirms.

PEP 799: the Tachyon sampling profiler

Python 3.15 also ships a reorganized profiling standard-library package, specified by PEP 799. It splits profiling into two submodules: profiling.tracing, which is simply the relocated, familiar deterministic profiler (cProfile remains available as an alias), and the new profiling.sampling, a statistical sampling profiler internally code-named "Tachyon."

Tachyon can attach to an already-running Python process by PID, or launch and profile a script or module directly, without restarting the process or modifying its code. Per the PEP and the official What's New document, it supports:

• Wall-clock, CPU-time, GIL-holding, and exception-time sampling modes
• Sampling rates up to 1,000,000 Hz
• Async-aware and opcode-level profiling options
• Output as pstats, collapsed stacks, Firefox Profiler (Gecko) format, interactive flame graphs, heatmaps, or a live terminal UI

Because it works by sampling rather than instrumenting every call, Tachyon is designed to add minimal overhead, making it realistic to run against production workloads in a way the older deterministic profiler generally wasn't.

C API, build, and performance changes

PEP 782 adds a new PyBytesWriter C API for extension authors building bytes objects from C, and soft-deprecates older patterns like calling PyBytes_FromStringAndSize(NULL, size) and then resizing, which treated nominally immutable bytes objects as mutable buffers. Those older functions keep working with no deprecation warnings for now.

Alongside it, the official What's New document lists continued stable-ABI work for free-threaded builds, frame pointers enabled by default to improve native profiling and stack unwinding, and further tuning of the experimental JIT introduced in earlier 3.1x releases. Windows 64-bit binaries also move to a tail-calling interpreter design. None of this changes everyday Python syntax, but it matters for anyone building C extensions or running free-threaded (no-GIL) builds.

Other notable changes

A handful of smaller but widely applicable changes round out the release, per the official What's New document:

• UTF-8 as the default text encoding (finishing the rollout of PEP 686): file and stream I/O without an explicit encoding argument now defaults to UTF-8 rather than a locale-dependent encoding; the old behavior can be restored with PYTHONUTF8=0 or -X utf8=0.
• Unpacking inside comprehensions: syntax like [*L for L in lists] and {**d for d in dicts} is now valid, including inside generator and async generator expressions.
• Clearer error messages: the interpreter now suggests Python equivalents for common mistakes carried over from other languages, such as hinting .append() when code calls .push() on a list.
• Deprecations: the old pure-Python profile module is deprecated in favor of profiling.tracing or cProfile, with removal planned for Python 3.17, and several long-deprecated APIs across modules including ast, ctypes, datetime, platform, and typing were removed outright in this release.

Python 3.15 vs. Python 3.14: what actually changed

Python 3.14, released in October 2025, was largely about the experimental JIT compiler, free-threading moving toward mainstream support, and template strings. Python 3.15 is a different kind of release: most of its headline work is about reducing the cost of using Python rather than adding new syntax for everyday application code. Lazy imports target startup latency, Tachyon targets profiling overhead, and frozendict/sentinel promote patterns that were previously hand-rolled or imported from third-party packages into the language itself. The JIT and free-threaded build work continue incrementally rather than landing as a single new headline feature, which is consistent with how the core team has signaled it plans to mature both efforts across several releases rather than one.

In practical terms, code written for 3.14 should keep running on 3.15 without changes; the new features are opt-in, and the removals are of APIs that had already been deprecated for one or more prior releases. The exception teams should actually check for is the UTF-8 default-encoding change, since it affects any code that relied on inheriting the platform's locale encoding rather than passing encoding= explicitly.

Who should care about this release

Lazy imports and the Tachyon profiler are the two changes most likely to show up in everyday work. Teams running large Django or FastAPI-style applications, or CLI tools built with libraries like Click or Typer, stand to see the clearest startup-time wins from adopting lazy import selectively on heavy, rarely-used dependencies. Anyone who has reached for cProfile and found its overhead too high for a production-like workload now has a lower-overhead alternative in Tachyon without installing a third-party sampling profiler. If your team already relies on CI/CD pipelines to gate dependency and interpreter upgrades, as covered in Pandromeda's explainer on how CI/CD pipelines work, a new minor Python version is a natural candidate to run through a staging pipeline before promoting it to production images.

C extension authors and anyone shipping free-threaded builds should read the PyBytesWriter and stable-ABI notes before their next release cycle, since soft-deprecated patterns still work today but are candidates for future removal.

What's next: should you upgrade now?

Python 3.15.0 is a final, stable release, not a preview, so it's safe to start testing in earnest. As with any new minor version, the usual cautious path still applies: update CI matrices to include 3.15 alongside 3.13 and 3.14, run your test suite, and pay particular attention to any profile-module usage, reliance on now-removed deprecated APIs, and any code that depends on locale-based text encoding defaults rather than explicit encoding= arguments, since UTF-8 is now the implicit default. Teams managing their own infrastructure as code, including those evaluating Terraform versus OpenTofu for provisioning build and CI runners, will want to make sure base images used for Python builds are updated deliberately rather than picking up 3.15 by accident on a floating tag.

For most projects, there's no urgency to adopt lazy imports or the new builtins immediately — they're additive, not required — but the startup-time case for lazy imports in CLI-heavy codebases is strong enough that it's worth profiling with Tachyon before deciding where to apply it. A reasonable rollout sequence: pin a staging environment to 3.15, run the existing test suite and linters, then selectively mark a handful of genuinely heavy, rarely-used imports as lazy in startup-sensitive paths, measuring before and after with Tachyon's wall-clock mode rather than guessing which imports are expensive.

As with other dependency and tooling upgrades, it's worth tracking this the same way engineering teams already track changes to package managers and bundlers — the recent default-off change to npm's install scripts, covered in Pandromeda's look at npm v12, is a good example of a minor-version change that quietly affects CI behavior if nobody reads the release notes first. Full details on Python 3.15, including every removal and deprecation, are in the official What's New in Python 3.15 document and its linked changelog.

Support timeline

Python's standard support policy applies to 3.15 as it has to every recent minor release: roughly two years of full bugfix support followed by a longer security-only tail before end of life, with exact dates maintained on python.org's status of Python versions page. Teams planning multi-year upgrade cycles should treat 3.15.0's October 9, 2026 ship date as the starting point for that clock, not the date they personally adopt it.

Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Felix MoreauAll Software & Guides coverage