← Back to all briefings
Developer 6 min read Published Updated Credibility 86/100

October 1, 2025

Python 3.9 reached end-of-life in October 2025. No more security patches. If you are running production workloads on 3.9, you are accumulating risk. Python 3.10, 3.11, and 3.12 are your supported options. The good news: each newer version has performance improvements that make upgrading worthwhile beyond just security.

Kodi C.

Editor & Research Lead

Editorially reviewed for factual accuracy

Developer pillar illustration for Zeph Tech briefings
Developer enablement and platform engineering briefings

Executive summary. Python 3.9 is nearing its end‑of‑life (EOL) milestone. According to the official Python version status, the 3.9 branch is now in security‑fix mode and will be retired on . After this date, no new binaries or source releases will be provided and the core team will cease issuing security patches, leaving teams that still depend on Python 3.9 exposed to unpatched vulnerabilities and unsupported packages. this analysis explains the Python release lifecycle, reviews what Python 3.9 introduced, highlights improvements available in newer releases (3.10–3.12), and provides a migration roadmap and governance considerations to help teams decommission Python 3.9 safely.

Python release lifecycle and EOL schedule

CPython’s release policy requires that each major version receives new features for about 18 months (for versions 3.13 and later) followed by several years of security‑only support, for a total support window of around five years. The Python 3.9 series debuted on 5 October 2020 and reached security‑only status in October 2023; it is scheduled to become fully unsupported on 31 October 2025.

Once EOL occurs, the core development team will not backport bug or security fixes, leaving downstream distributions and projects responsible for maintaining their own forks. Many third‑party libraries have already dropped 3.9 support, and cloud providers will follow suit by deprecating runtime images and managed functions. Teams that have not yet begun migrating should treat Python 3.9’s retirement as an urgent engineering and governance priority.

What Python 3.9 introduced

Python 3.9 delivered several language and standard‑library improvements compared with 3.8. New dictionary union ( | ) and update ( |= ) operators (PEP 584) allow for more concise merging of key–value pairs. Built‑in generics for common collections (PEP 585) remove the need to import typing aliases when annotating lists, sets or dictionaries. The str.removeprefix() and str.removesuffix() methods (PEP 616) simplify string cleaning tasks. Under the hood, CPython adopted a new PEG parser (PEP 617) that enables future grammar innovations. Python 3.9 also added the zoneinfo module for IANA time‑zone data, the graphlib module for topological sorting, and optimized several built‑ins and the garbage collector.

Why upgrade: improvements in Python 3.10–3.12

Staying on Python 3.9 means missing out on performance gains, expressive syntax and developer ergonomics delivered in subsequent releases. Key improvements include:

  • Structural pattern matching (Python 3.10). PEP 634 introduced match/case statements that allow declarative decomposition of complex data structures. This feature enables expressive domain‑specific languages and simplifies state‑machine logic. Python 3.10 also improved error messages and debugging line numbers and added the Union operator (|) for type hints (PEP 604) and Parameter Specification Variables (PEP 612) for callable signatures.
  • Performance and exception handling (Python 3.11). CPython 3.11 delivers a 10–60 percent speed‑up for many workloads and implements zero‑cost exception handling using Exception Groups and the except* syntax (PEP 654). It also includes the tomllib module for parsing TOML configuration files (PEP 680), fine‑grained error locations in tracebacks (PEP 657), and new typing primitives such as Self and variadic generics.
  • Language evolution (Python 3.12). The latest release at the time of writing introduces an improved type‑parameter syntax and a dedicated type statement for defining generic classes (PEP 695), simplified f‑string grammar that supports comments and multiline expressions (PEP 701), optional per‑interpreter Global Interpreter Lock (GIL) to pave the way for true parallelism (PEP 684), and a low‑impact monitoring API for profilers and debuggers (PEP 669). Python 3.12 also removes the legacy distutils module and improves security by formally verifying hash setups.

These improvements make code more expressive, easier to maintain and debug, and faster. They also reflect patterns that ecosystem maintainers embrace: many popular libraries now require Python 3.10 or later, and continuous integration services default to modern interpreters. Delaying migration therefore increases technical debt and risk.

Risks of staying on Python 3.9

Running an unsupported interpreter exposes teams to several categories of risk:

  • Security exposure. After the EOL date, vulnerabilities discovered in CPython or the standard library will not be patched by the core team. Threat actors now target stale runtimes because they know those environments lack fixes. Without vendor‑supplied patches, defenders must maintain their own forks—an unsustainable proposition for most teams.
  • Dependency abandonment. The Python ecosystem moves quickly. Frameworks such as Django 5.0 and FastAPI 0.110 have already dropped support for 3.9, and package maintainers cite limited resources to backport features. Using unsupported Python versions may prevent you from upgrading dependencies, leaving known bugs unfixed.
  • Compatibility and tooling gaps. Many prebuilt wheels and container images will disappear from package indexes and registries once 3.9 support ends. Tooling (IDEs, linters, CI pipelines) may remove integration testing on 3.9, causing hidden regressions. Cloud providers like AWS Lambda and Google Cloud Functions typically deprecate runtimes a few months after upstream EOL, forcing last‑minute migrations.

Migration roadmap

To mitigate these risks, teams should set up a structured migration plan:

  1. Inventory and assessment. Use package‑management tools, configuration management databases and code searches to identify applications, scripts and services running on Python 3.9. Document dependencies, deployment environments and criticality.
  2. Choose target versions. Determine whether Python 3.10, 3.11 or 3.12 best fits your needs. Consider performance requirements, library compatibility, platform support and upcoming EOL timelines (for example, 3.10 EOL in 2026, 3.11 EOL in 2027).
  3. Upgrade dependencies. Before switching interpreters, update your frameworks and libraries to versions that support your target Python release. Pay special attention to compiled extensions and C‑extensions; rebuild them against the new Python headers.
  4. Test and validate. Run unit tests, integration tests and performance benchmarks under the new interpreter. Look for subtle behavior changes (for example, stricter type hint evaluation, different dictionary ordering for equal keys, modifications to garbage collection thresholds). Use tools like pyenv or containers to manage side‑by‑side interpreters.
  5. Deploy gradually. Use canary deployments, blue/green releases or feature flags to introduce the new runtime in production. Monitor error rates, latency, resource consumption and customer feedback.
  6. Retire Python 3.9 assets. Once migration is complete, remove Python 3.9 from build pipelines, images and developer workstations. Update documentation and runtime policies to reflect supported versions.

Governance and compliance alignment

Sunsetting Python 3.9 is not merely a technical exercise; it involves governance and regulatory considerations:

  • Security policies. Teams subject to SOC 2, ISO/IEC 27001 or PCI DSS must show that they maintain supported software. Document your migration plan and risk assessments as part of your security program.
  • Vendor management. Ask software vendors and SaaS providers about their Python runtime roadmaps and contractual obligations. Include clauses requiring timely upgrades and transparency regarding third‑party dependencies.
  • Training and communication. Provide developers with training on new language features, such as pattern matching and f‑string improvements, to ensure code quality. Communicate migration timelines to product managers and customers, highlighting any deprecations or behavior changes.

Our analysis

The retirement of Python 3.9 represents a natural step in CPython’s evolution. We believes teams should view this transition as an opportunity to modernize their codebases, adopt good practices (static typing, structured logging, asynchronous programming), and integrate supply‑chain security frameworks like the OpenSSF Scorecard. Aligning runtime upgrades with broader platform engineering initiatives—container standardization, dependency management automation, continuous compliance—will yield long‑term benefits. We will continue to monitor Python’s release cycle and guide on migrations, performance tuning, and secure development patterns.

We publishes runtime lifecycle briefings to help engineering leaders anticipate end‑of‑life events, reduce technical debt and align platform roadmaps with industry standards.

You may also find useful

Hand-picked articles on adjacent topics.

Continue in the Developer pillar

Return to the hub for curated research and deep-dive guides.

Visit pillar hub

Latest guides

  • Secure Software Supply Chain Tooling Guide

    Engineer developer platforms that deliver verifiable provenance, SBOM distribution, vendor assurance, and runtime integrity aligned with SLSA v1.0, NIST SP 800-204D, and CISA SBOM…

  • Developer Enablement & Platform Operations Guide

    Plan AI-assisted development, secure SDLC controls, and runtime upgrades using our research on GitHub Copilot, GitHub Advanced Security, and major language lifecycles.

  • Continuous Compliance CI/CD Guide

    Implement CI/CD pipelines that satisfy NIST SP 800-218, OMB M-24-04 secure software attestations, FedRAMP continuous monitoring, and CISA Secure-by-Design guidance while preserving…

Documentation

  1. Status of Python versions — Python Developer Guide
  2. What’s New in Python 3.9 — Python docs
  3. What’s New in Python 3.10–3.12 — Python docs
  • Python
  • Runtime lifecycle
  • Programming languages
Back to curated briefings

Comments

Community

We publish only high-quality, respectful contributions. Every submission is reviewed for clarity, sourcing, and safety before it appears here.

    Share your perspective

    Submissions showing "Awaiting moderation" are in review. Spam, low-effort posts, or unverifiable claims will be rejected. We verify submissions with the email you provide, and we never publish or sell that address.

    Verification

    Complete the CAPTCHA to submit.