Web Development · Backend
Python 3.10 End of Life: Upgrade to 3.14, Not 3.15
Python 3.10 reached end of life on October 1, 2026. Move to 3.14, which gets bugfixes until 2030. What breaks between 3.10 and 3.14, and how to find it fast.
Abhishek Gupta
10 min read
Sponsored
Python 3.10 hit end of life on October 1, 2026. Its last release, 3.10.22, shipped that day alongside patch releases for every newer branch, and there won’t be another. If a service of yours still runs on 3.10, upgrade it to Python 3.14. Not 3.13, and not the brand-new 3.15.
That advice runs against two instincts. One says “go to the newest version so you don’t have to do this again soon.” The other says “take the smallest step, 3.11, and be done.” Both cost you more than the middle path. Everything below comes from the Python devguide’s version table and the official “What’s New” pages for 3.11 through 3.14, linked at the end.
Python 3.10 end of life: what actually changes
Nothing breaks today. Your 3.10 interpreter runs the same code it ran in September. What’s gone is the maintenance. The 3.10.22 release page is blunt about it: this is the final release, and “the 3.10 series will receive no further security updates.” A CPython vulnerability disclosed in 2027 will get a fix in 3.11 and newer, and 3.10 will keep it.
The second effect is slower and more annoying. The packages you install are dropping 3.10 one by one, so a 3.10 service gradually gets pinned to older versions of everything:
- NumPy 2.3 supports Python 3.11 to 3.13 (3.14 support followed), so a 3.10 project is stuck on the 2.2 line.
- PyTorch 2.15, released October 28, 2026, ships no cp310 wheels. The PyTorch team’s notice says 2.14 is the last release with them.
- Django 6.0 supports Python 3.12, 3.13 and 3.14 only. If you’re planning the Django 6.0 to 6.1 upgrade, the Python upgrade has to come first.
- Heroku deprecated 3.10 a year ago and removes it from the Python buildpack on January 6, 2027. Running apps keep running, but you can’t build or deploy them on 3.10 after that date.
Security scanners will start flagging 3.10 base images too, and if you sell to companies with vendor security reviews, the question comes up on the next questionnaire.
Upgrade Python 3.10 to 3.14, 3.13 or 3.15?
Upgrade to 3.14. It’s the oldest Python release still in full bugfix support, it has a year of patch releases behind it, and it gets fixes until October 2030. That’s four more years of runway than you have now, on a release the ecosystem has already caught up with.
| Version | Released | Status (Nov 2026) | End of life | Verdict |
|---|---|---|---|---|
| 3.10 | Oct 4, 2021 | End of life | Oct 1, 2026 | Leave it |
| 3.11 | Oct 24, 2022 | Security only | Oct 2027 | You’d do this again next year |
| 3.12 | Oct 2, 2023 | Security only | Oct 2028 | Fine if a dependency blocks 3.13+ |
| 3.13 | Oct 7, 2024 | Security only | Oct 2029 | Fallback if 3.14 is blocked |
| 3.14 | Oct 7, 2025 | Bugfix | Oct 2030 | Default target |
| 3.15 | Oct 9, 2026 | Bugfix | Oct 2031 | Test it, don’t ship it yet |

The 3.13 row is the one people misread. It still has three years of life, but in the devguide’s terms it’s now a “security” branch: only security fixes go in, releases are source-only, and python.org stops publishing binary installers for it. Your Docker images build from source anyway, so that matters less on servers. It matters more for every developer laptop on Windows or macOS that installs Python from python.org, and it means ordinary bugs you hit in 3.13 won’t get fixed there. You’d be moving onto a branch that’s already winding down.
Why not 3.15, then? It came out on October 9, five weeks ago. Two reasons to wait. First, compiled dependencies take time to publish cp315 wheels, and a missing wheel turns pip install into a source build that fails on a slim container image. Second, 3.15 changes behavior you’d have to test on top of everything else in this guide: it makes UTF-8 the default encoding for open(), and it adds lazy imports. Take 3.14 now and plan 3.15 as a separate, smaller hop in 2027.
There’s also a reason to want 3.14 beyond the support dates. Python 3.11 alone made CPython faster: the 3.11 release notes report a 1.25x average speedup over 3.10 on the standard pyperformance benchmark suite, with 10-60% depending on workload. A 3.10 service picks that up for free in this upgrade.
How to upgrade from Python 3.10 to 3.14, step by step
- Find every place 3.10 is pinned.
- Add 3.14 to CI next to 3.10 and get the test suite running.
- Fix removed modules and APIs (the table in the next section).
- Fix behavior changes that tests catch only if you exercise them: asyncio event loops, multiprocessing start method, annotations.
- Upgrade dependencies that don’t support 3.14, then flip the default.
Step 1 sounds trivial and usually isn’t. The version lives in more places than pyproject.toml:
# Every place a Python version is pinned, outside virtualenvs and node_modules
grep -rnE "python(_version)?[\"' =:>]*3\.10|python:3\.10|py310|3\.10\.[0-9]+" \
--include=Dockerfile* --include=*.toml --include=*.cfg --include=*.yml \
--include=*.yaml --include=*.txt --include=.python-version \
--exclude-dir=.venv --exclude-dir=node_modules .
That covers Dockerfiles, pyproject.toml (requires-python, plus tool settings like target-version = "py310"), GitHub Actions matrices, runtime.txt, .python-version and tox.ini. Lambda functions and other managed runtimes keep their version in infrastructure code, so search your Terraform or CDK repo too.
For step 2, if your team uses uv, getting a 3.14 test run takes two commands and doesn’t touch the system Python:
uv python install 3.14
uv run --python 3.14 --with-requirements requirements-dev.txt pytest -x
Then update the project metadata and your linter’s target in one change, so ruff starts suggesting the newer idioms (datetime.UTC, PEP 604 unions everywhere, and so on):
[project]
requires-python = ">=3.14"
[tool.ruff]
target-version = "py314"
What breaks between Python 3.10 and 3.14
Four releases of removals land at once. Most were deprecated for years, which is exactly why they’re easy to miss: the warnings were there, and nobody was reading them.
| Removed in | What’s gone | Use instead |
|---|---|---|
| 3.11 | @asyncio.coroutine, binhex, inspect.getargspec() | async def, nothing, inspect.signature() |
| 3.12 | distutils | setuptools or packaging |
| 3.12 | imp, asyncore, asynchat, smtpd | importlib, asyncio, aiosmtpd (third party) |
| 3.12 | unittest aliases: assertEquals, assertRegexpMatches, failUnless and friends | assertEqual, assertRegex, assertTrue |
| 3.12 | ssl.wrap_socket(), configparser.SafeConfigParser, ConfigParser.readfp() | SSLContext.wrap_socket(), ConfigParser, read_file() |
| 3.13 | cgi, cgitb, crypt, imghdr, telnetlib, pipes, uu and 12 more PEP 594 modules | Third-party replacements, shlex.quote for pipes.quote |
| 3.13 | lib2to3 and the 2to3 tool, typing.io, typing.re | Nothing, plain typing |
| 3.14 | ast.Num, ast.Str and the other old node classes | ast.Constant |
| 3.14 | pkgutil.find_loader(), get_loader(), sqlite3.version, urllib.request.URLopener | importlib.util.find_spec(), sqlite3.sqlite_version, urlopen() |
A grep finds most of these in your own code in seconds:
grep -rnE "^\s*(import|from) (distutils|imp|asyncore|asynchat|smtpd|cgi|cgitb|crypt|imghdr|telnetlib|pipes|uu|nntplib|lib2to3)\b" \
--include=*.py --exclude-dir=.venv .
grep -rnE "assertEquals|assertNotEquals|assertRegexpMatches|failUnless|SafeConfigParser|readfp\(|ssl\.wrap_socket|getargspec|asyncio\.coroutine|get_event_loop\(" \
--include=*.py --exclude-dir=.venv .
Your own code is the easy part. The import errors that hurt come from an old pinned dependency that still does from distutils.version import LooseVersion, and the only fix is upgrading that package. Two more 3.12 changes hide in the same place. Virtual environments created with venv no longer come with setuptools preinstalled, so anything that imports pkg_resources fails until you install setuptools explicitly (or better, switch to importlib.metadata and importlib.resources). And invalid escape sequences such as "\d" in a non-raw string now raise SyntaxWarning instead of a silent DeprecationWarning, which shows up in logs the first time each module compiles. Ruff’s W605 rule finds them.
asyncio.get_event_loop() now raises
This is the 3.14 change most likely to take down a service at startup. On 3.10, calling asyncio.get_event_loop() with no running loop quietly created one. On 3.14 it raises RuntimeError instead. Older scripts, management commands and test fixtures written before asyncio.run() was common all use the old pattern:
import asyncio
# Python 3.10: works. Python 3.14: RuntimeError, no current event loop
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
# Works on both
asyncio.run(main())
# If you need to call into async code several times from sync code
with asyncio.Runner() as runner:
runner.run(warm_cache())
runner.run(main())
If you hit odd behavior elsewhere in async code after the upgrade, the asyncio production pitfalls guide covers the loop-lifecycle mistakes that this change tends to expose.
multiprocessing stopped forking on Linux
On Linux, 3.14 changed the default start method for multiprocessing and ProcessPoolExecutor from fork to forkserver. Windows and macOS already used spawn, so a codebase developed on a Mac and deployed to Linux has been running two different models the whole time. Now Linux joins the stricter side: worker functions and their arguments must be picklable, and module-level state the parent set up after import (a loaded model, an open connection pool) isn’t inherited by the workers anymore.
The right fix is to make the worker self-contained: pass what it needs as arguments, or load it in a pool initializer. If you need time, you can ask for the old behavior explicitly while you refactor:
import multiprocessing
from concurrent.futures import ProcessPoolExecutor
ctx = multiprocessing.get_context("fork") # temporary: restores 3.10 behavior on Linux
with ProcessPoolExecutor(max_workers=4, mp_context=ctx) as pool:
results = list(pool.map(score_document, documents))
Treat that as a stopgap. The 3.14 notes explain why the default moved: fork is unsafe in a process that has started threads, which modern Python services nearly always have.
Annotations are evaluated lazily
Python 3.14 implements PEP 649: annotations on functions, classes and modules aren’t evaluated when the definition runs, only when something asks for them. Forward references no longer need quotes. For most application code this changes nothing, but libraries that read __annotations__ directly at class-creation time can behave differently. Tests catch these quickly, provided your dependencies are current.
The big one to check is Pydantic. The FastAPI migration guide states that Pydantic v1, including the pydantic.v1 compatibility module inside Pydantic 2, isn’t supported on Python 3.14. If your models are still on v1, the Pydantic v2 guide is a prerequisite for this upgrade, not a follow-up. Also grep your installed packages for pydantic.v1 imports, because a dependency can pull v1 in without you writing it.
Two smaller 3.14 notes. A return, break or continue that leaves a finally block now produces a SyntaxWarning (PEP 765), which is almost always a bug worth fixing. And start on a current 3.14 patch release: the incremental garbage collector in 3.14.0 through 3.14.4 was reverted to the 3.13 design in 3.14.5 after reports of memory pressure.
Roll it out one service at a time
Run 3.10 and 3.14 side by side in CI until the 3.14 job is green, then flip the default and drop 3.10 from the matrix. Deploy the 3.14 image to one service, watch memory and worker behavior for a few days (the multiprocessing change shows up there before it shows up in errors), then move the rest. Teams handling other end-of-life deadlines this autumn are working the same way: the .NET 8 end-of-support guide and the PostgreSQL 14 end-of-life guide make the same call, the mature supported release over the newest one.
If you’re still deciding which 3.14 features are worth adopting once you’re there, the Python 3.14 features rundown covers that. For the upgrade itself, the order is simple: dependencies that block 3.14 first, then the grep list above, then asyncio and multiprocessing, then ship. The services still on 3.10 in January are the ones Heroku will refuse to build, so put the CI job in this week.
Frequently asked questions
- Will my Python 3.10 app stop working now that 3.10 is end of life?
- No. The interpreter keeps running exactly as before. What stops is maintenance: no security patches, no bugfixes, no new releases. Platform support also falls away over time, for example Heroku removes 3.10 from its Python buildpack on January 6, 2027, after which 3.10 apps can't be rebuilt or redeployed.
- Can I jump straight from Python 3.10 to 3.14?
- Yes. There's no need to stop at 3.11, 3.12 or 3.13 along the way. You do need to read what was removed in each of those releases, because every removal between 3.10 and 3.14 applies to you in the single hop.
- Is Python 3.14 stable enough for production?
- It has been out since October 7, 2025 and has had a year of patch releases. One real correction happened along the way: the incremental garbage collector that shipped in 3.14.0 was reverted to the 3.13-style collector in 3.14.5 after memory pressure reports, so start on a current 3.14 patch release rather than an early one.
Sources
- Status of Python versions (Python Developer's Guide)
- Python 3.10.22 release page
- What's New in Python 3.11
- What's New in Python 3.12
- What's New in Python 3.13
- What's New in Python 3.14
- NumPy 2.3.0 release notes
- PyTorch: Python 3.10 support removed in 2.15
- Django 6.0 release notes
- Heroku: Python 3.10 support is deprecated
- FastAPI: Migrate from Pydantic v1 to Pydantic v2
Sponsored
More from this category
More from Web Development
Sponsored
Discussion
Join the conversation.
Comments are powered by GitHub Discussions. Sign in with your GitHub account to leave a comment.
Sponsored