Python 3.10 Is End of Life: How to Upgrade, and to Which Version

MicroPyramid 18 min read

Python 3.10 Is End of Life: How to Upgrade, and to Which Version

Short answer: Python 3.10 is end of life (it stopped getting fixes on October 1, 2026), so upgrade to Python 3.14: it has security support until October 2030, it is the only candidate still getting regular bug-fix releases, Django 5.2 LTS supports it, and the main web and data libraries ship wheels for it. Pick 3.13 only if a dependency you cannot replace has no 3.14 wheel yet. Move straight from 3.10, with the tests running on both versions and warnings treated as errors until the switch.

Going straight to 3.14 means the changes of four releases arrive at once, so the path below puts the checks first and keeps a way back. Dates and versions come from python.org, Django's documentation and PyPI, checked on November 17, 2026, and we ran every code example on the Python versions named beside it. For the other 2026 and 2027 deadlines, see our end-of-life guide, or paste your own requirements and Dockerfiles into our end-of-life checker.

When did Python 3.10 reach end of life, and how long are newer versions supported?

Python 3.10 reached end of life on October 1, 2026, the day 3.10.22, its final release, came out. Each newer version gets security fixes for five years from its first release.

Python First released Status on November 17, 2026 Last regular bug-fix release Security fixes until
3.10 October 4, 2021 End of life 3.10.11, April 2023 October 1, 2026 (ended)
3.11 October 24, 2022 Security fixes only 3.11.9, April 2024 October 2027
3.12 October 2, 2023 Security fixes only 3.12.10, April 2025 October 2028
3.13 October 7, 2024 Security fixes only 3.13.16, October 2026 October 2029
3.14 October 7, 2025 Bug fixes and security fixes Planned for October 2027 October 2030
3.15 October 9, 2026 Bug fixes and security fixes Planned for October 2028 October 2031

Sources: the Python versions page and the release schedules in PEPs 619, 664, 693, 719, 745 and 790. Latest releases at the time of writing: 3.12.16, 3.13.18, 3.14.10 and 3.15.2 (python.org/downloads).

  • "Security fixes only" means source-only releases. In that phase python.org stops publishing installers. The official Docker images and uv's Python builds still package each release, so this matters most for Windows and macOS installers.
  • The platforms have moved on too. The official Docker images dropped Python 3.10 on October 1, 2026, so python:3.10 tags get no more rebuilds. AWS Lambda deprecated the python3.10 runtime on October 31, 2026, and blocks creating functions on it from July 29, 2027 and updating them from August 31, 2027.

Which version should we upgrade to: Python 3.12, 3.13 or 3.14?

Python 3.14, for most teams. It keeps you supported longest, it is the only one of the three still getting bug fixes, and Django 5.2 LTS and every 6.x release up to 6.2 LTS support it.

Python 3.12 Python 3.13 Python 3.14
Security fixes until October 2028 October 2029 October 2030
Regular bug-fix releases Ended April 2025 Ended October 2026 Until October 2027
Django 5.2 LTS Yes Yes Yes, from 5.2.8
Django 6.0, 6.1 and 6.2 LTS Yes Yes Yes
AWS Lambda runtime deprecation October 31, 2028 June 30, 2029 June 30, 2029
Removals on top of 3.12 None (the baseline) 19 legacy modules such as cgi and imghdr, plus lib2to3 3.13's, plus new defaults in multiprocessing and asyncio
Linux wheels in our PyPI check (below) Yes Yes Yes, except TensorFlow's stable release

Sources: the Python versions page, Django's Python version FAQ, AWS's Lambda runtimes, and PyPI (next section).

Why 3.14:

  • Runway. Every upgrade costs time, so take the version supported longest. 3.14 moves the next forced Python upgrade from 2028 to 2030, and it still gets bug fixes, not just security fixes, until October 2027.
  • Django. Django 6.0, 6.1 and 6.2 LTS all need Python 3.12 or newer and support 3.14, so the next Django LTS will not force another Python move.
  • Libraries are ready, and the extra work is modest. 3.14 has been out for over a year and the main packages ship wheels for it. The modules 3.13 removed are legacy ones such as cgi and telnetlib, the 3.14 changes mainly hit scripts and data pipelines, and one test run finds them all.

When 3.13 is the better choice: when a dependency you cannot replace has no 3.14 wheel. TensorFlow is the example today: its latest stable release, 2.21.0, ships wheels for Python 3.10 to 3.13, and 3.14 wheels exist only in the 2.22 release candidates.

When 3.12 makes sense: only as a stop on the way. Django 4.2 supports Python up to 3.12, so an app still on Django 4.2 moves Python to 3.12, then Django to 5.2 (see upgrading Django 4.2 to 5.2), then Python to 3.14.

Why not 3.15? It came out on October 9, 2026. Django 5.2 does not support it, and PyYAML, h5py, zstandard and confluent-kafka had no 3.15 wheels when we checked. Revisit it in 2027.

Are our libraries ready for Python 3.14?

Most likely, yes. We checked the latest release of 69 widely used packages on PyPI on November 17, 2026, looking for Linux x86_64 wheels:

  • Ship wheels that install on 3.14: NumPy, pandas, SciPy, scikit-learn, PyTorch, pyarrow, Pillow, lxml, cryptography, both psycopg drivers, asyncpg, pydantic-core, orjson, uvloop, grpcio and SQLAlchemy, among others. Pure-Python packages such as Django, FastAPI, Flask and Celery need no per-version wheel.
  • No 3.14 wheel in a stable release: TensorFlow (see above).
  • Source only on Linux, on every Python version: mysqlclient and python-ldap, which need a compiler and system libraries in your build image anyway.

Packages are also leaving 3.10 behind. The latest NumPy, SciPy and Django releases need Python 3.12 or newer, and the latest pandas, Pillow, SQLAlchemy, scikit-learn, PyTorch and FastAPI releases need 3.11 or newer. On 3.10, pip quietly installs older releases instead, so their fixes stop reaching you.

To check your own list, resolve your requirements for 3.14 with wheels only; anything that fails is a package to upgrade, replace or build yourself. Keep --prerelease disallow: without it, uv picked a TensorFlow release candidate in our test rather than report the gap.

# Resolve your requirements for Python 3.14 on Linux, using wheels only.
# Packages without a 3.14 wheel make it fail, and uv names them.
uv pip compile requirements.in \
  --python-version 3.14 \
  --python-platform x86_64-manylinux_2_28 \
  --only-binary :all: \
  --prerelease disallow \
  -o requirements-py314.txt

# Without uv: a throwaway 3.14 virtual environment and pip
python3.14 -m venv /tmp/py314-check
/tmp/py314-check/bin/python -m pip install --only-binary=:all: -r requirements.txt

What breaks when you upgrade from Python 3.10 to 3.14?

Unlike Django, Python does not need to be taken one release at a time, but the changes of 3.11, 3.12, 3.13 and 3.14 all land together. The table lists the ones most likely to reach application code; the full lists are in each release's "What's New" page: 3.11, 3.12, 3.13 and 3.14.

Release What changed Use instead
3.11 @asyncio.coroutine and inspect.getargspec() removed async def; inspect.signature()
3.11 Inline regex flags such as (?i) raise re.error unless they open the pattern Move the flag to the start, or pass re.IGNORECASE
3.11 random.sample() no longer accepts a set A sequence, for example sorted(items)
3.12 distutils removed; new virtual environments no longer include setuptools, so pkg_resources is missing packaging, importlib.metadata, importlib.resources
3.12 imp, asynchat, asyncore and smtpd removed importlib, asyncio, the aiosmtpd package
3.12 Old unittest aliases removed: assertEquals, assertRegexpMatches, assertRaisesRegexp, failUnless and others The current names; Ruff and pyupgrade rename them
3.12 ssl.wrap_socket() and configparser.SafeConfigParser removed SSLContext.wrap_socket(), ConfigParser
3.12 Invalid escapes such as "\d" now raise SyntaxWarning; datetime.utcnow() is deprecated Raw strings; datetime.now(timezone.utc)
3.13 19 legacy modules removed (PEP 594), including cgi, cgitb, crypt, imghdr, mailcap, pipes, telnetlib, uu and audioop email.message; filetype or puremagic; bcrypt or argon2-cffi; shlex.quote(); subprocess
3.14 On Linux, multiprocessing and ProcessPoolExecutor start workers with forkserver, not fork Pass state to workers explicitly
3.14 asyncio.get_event_loop() raises RuntimeError when there is no current event loop asyncio.run() or asyncio.Runner
3.14 tarfile extracts with the data filter by default, rejecting absolute paths and links that leave the target Pass filter= explicitly for archives you fully trust
3.14 urllib.request.URLopener and pkgutil.find_loader() removed urlopen(), importlib.util.find_spec()

An old pinned version of a dependency can import a removed module too, and the error then appears when your app imports it. The examples below show five of these failures, each run on 3.10 and on the newer versions named in it.

Removed in 3.12: distutils, pkg_resources and old test aliases

distutils is gone in 3.12, and python -m venv no longer installs setuptools, so pkg_resources goes missing with it. Installing setuptools brings back a distutils shim but not pkg_resources, which setuptools removed in version 82.0.0 in February 2026. Settings files that read booleans with strtobool are a typical case.

# Before: runs on Python 3.10.22; on 3.12.16 and 3.14.10, in a fresh venv:
# ModuleNotFoundError: No module named 'distutils'
import os
from distutils.util import strtobool

DEBUG = bool(strtobool(os.environ.get("DEBUG", "false")))

# ModuleNotFoundError: No module named 'pkg_resources'
import pkg_resources

APP_VERSION = pkg_resources.get_distribution("billing").version


# After: standard library only, runs on 3.10.22, 3.12.16 and 3.14.10
import os
from importlib.metadata import version


def env_bool(name, default="false"):
    value = os.environ.get(name, default).strip().lower()
    if value in {"y", "yes", "t", "true", "on", "1"}:
        return True
    if value in {"n", "no", "f", "false", "off", "0"}:
        return False
    raise ValueError(f"{name} must be true or false, not {value!r}")


DEBUG = env_bool("DEBUG")
APP_VERSION = version("billing")
# Before: passes on Python 3.10.22 with a DeprecationWarning; on 3.12.16 and 3.14.10:
# AttributeError: 'InvoiceTotalTests' object has no attribute 'assertEquals'
import unittest


def invoice_total(lines):
    return sum(qty * price for qty, price in lines)


class InvoiceTotalTests(unittest.TestCase):
    def test_total(self):
        self.assertEquals(invoice_total([(2, 5), (1, 3)]), 13)


# After: Ruff (rule UP005) or pyupgrade renames it for you
#         self.assertEqual(invoice_total([(2, 5), (1, 3)]), 13)

Removed in 3.13: cgi and the other dead batteries

Python 3.13 removed the 19 modules that PEP 594 deprecated in 3.11. cgi.parse_header(), used to split headers such as Content-Type, is a typical case in web code. What's New in 3.13 gives a replacement for each module, and lists standard-* copies on PyPI (for example standard-cgi) as a stopgap.

# Before: runs on Python 3.10.22, warns on 3.12.16; on 3.13.18 and 3.14.10:
# ModuleNotFoundError: No module named 'cgi'
import cgi

value, params = cgi.parse_header('text/csv; charset="utf-8"')


# After: the email package, as the 3.13 release notes suggest.
# Runs on 3.10.22, 3.12.16, 3.13.18 and 3.14.10.
from email.message import EmailMessage

msg = EmailMessage()
msg["content-type"] = 'text/csv; charset="utf-8"'
value, params = msg.get_content_type(), dict(msg["content-type"].params)
# value == "text/csv", params == {"charset": "utf-8"}

Changed in 3.14: event loops and process pools

Two changed defaults in 3.14 hit scripts, workers and data pipelines rather than web views.

  • asyncio.get_event_loop() no longer creates a loop. When no event loop is set, it now raises RuntimeError, after warning in 3.12 and 3.13. Use asyncio.run(), or asyncio.Runner when blocking code sits between async calls.
  • Process pools start workers differently on Linux. multiprocessing and ProcessPoolExecutor now use forkserver instead of fork, so workers no longer inherit the parent's memory: anything the parent sets at run time is missing in them, and everything sent to them must be picklable. set_start_method("fork") restores the old behaviour, but the docs call forking a process with threads problematic, so treat it as a stopgap. macOS and Windows already used spawn and do not change.
import asyncio


async def fetch_orders():
    await asyncio.sleep(0.1)
    return ["order-1", "order-2"]


# Before: runs on Python 3.10.22, warns on 3.12.16 and 3.13.18; on 3.14.10:
# RuntimeError: There is no current event loop in thread 'MainThread'.
loop = asyncio.get_event_loop()
orders = loop.run_until_complete(fetch_orders())

# After: runs on 3.10.22, 3.12.16, 3.13.18 and 3.14.10
orders = asyncio.run(fetch_orders())
# Before: prints [7.9, 15.8, 23.7] on Python 3.10.22 and 3.13.18; on 3.14.10
# (Linux) the workers never see the rate: KeyError: 'rate'
import multiprocessing as mp

SETTINGS = {}


def convert(amount):
    return round(amount * SETTINGS["rate"], 2)


if __name__ == "__main__":
    SETTINGS["rate"] = 0.79  # loaded at startup, for example from a config file
    with mp.Pool(2) as pool:
        print(pool.map(convert, [10, 20, 30]))


# After: hand the value to each worker. Prints [7.9, 15.8, 23.7] on all three.
import multiprocessing as mp

SETTINGS = {}


def init_worker(rate):
    # Runs once in each worker process, whatever the start method
    SETTINGS["rate"] = rate


def convert(amount):
    return round(amount * SETTINGS["rate"], 2)


if __name__ == "__main__":
    rate = 0.79  # loaded at startup, for example from a config file
    with mp.Pool(2, initializer=init_worker, initargs=(rate,)) as pool:
        print(pool.map(convert, [10, 20, 30]))

How do we find these problems in our own code?

Search first, then let the test suite find the rest, with warnings turned into errors.

  1. Search for imports of removed modules. The git grep below finds most of them in one pass; it misses forms such as import os, cgi, so the tests still matter.
  2. Run the tests on 3.10 with warnings as errors. Many removals already warn on 3.10: in our tests, assertEquals, inline regex flags, random.sample() on a set and invalid escapes all did. Fixing them there is low risk, because nothing else changes.
  3. Run them again on 3.14, still with warnings as errors. New deprecations such as datetime.utcnow() appear there. Python hides most deprecation warnings by default, so without this step they stay silent until the next removal.
  4. Triage third-party warnings. A warning raised inside a package is usually fixed in a newer release. Upgrade it, or ignore that one warning with a note, so new warnings still fail the run.
  5. Reach the code the tests miss. Management commands, scheduled jobs and data scripts often import modules no test touches. For Django, manage.py check imports your apps and URL configuration.
# Imports of modules removed in 3.12 and 3.13, plus pkg_resources
git grep -n -E '^[[:space:]]*(import|from)[[:space:]]+(aifc|asynchat|asyncore|audioop|cgi|cgitb|chunk|crypt|distutils|imghdr|imp|lib2to3|mailcap|msilib|nis|nntplib|ossaudiodev|pipes|pkg_resources|smtpd|sndhdr|spwd|sunau|telnetlib|uu|xdrlib)([[:space:].,]|$)' -- '*.py'

# Django: deprecation warnings become errors
python -W error::DeprecationWarning manage.py check
python -W error::DeprecationWarning manage.py test

# pytest: every warning becomes an error (or set filterwarnings, below)
python -m pytest -W error
# pyproject.toml
[project]
# Keep ">=3.10" while CI runs both versions; raise it to ">=3.14" after the switch
requires-python = ">=3.10"

[tool.pytest.ini_options]
# Every warning fails the test run
filterwarnings = [
    "error",
    # A third-party warning you have triaged and logged, one line each:
    "ignore::DeprecationWarning:somepackage.*",
]

[tool.ruff.lint]
# Ruff reads the minimum Python version from requires-python
extend-select = ["UP", "DTZ", "W605"]

Which tools do the mechanical rewrites?

A few command-line tools do most of the repetitive work. Review their changes like any other pull request.

  • Ruff (0.17.6 at the time of writing) carries pyupgrade's rewrites as its UP rules: UP005 renames the old unittest aliases, and W605 turns invalid escapes into raw strings. DTZ003 and DTZ004 flag utcnow() and utcfromtimestamp() but leave the fix to you, because the replacement is timezone-aware: isoformat() gains +00:00, and < or > against a naive datetime raises TypeError. Ruff takes its target version from requires-python.
  • pyupgrade (3.22.0) rewrites syntax for a minimum version, such as --py314-plus. It needs Python 3.11 or newer to run.
  • uv (0.13.9) installs and pins Python versions, locks dependencies, runs the wheel check above, and runs Ruff and pyupgrade without installing them (uvx).
  • tox (4.67.15) or nox (2026.10.20) run the suite under 3.10 and 3.14 on a laptop. In tox, that is env_list = py310, py314.
  • django-upgrade if Django is moving too; our Django 4.2 to 5.2 guide covers it.

Order matters. While 3.10 is in production, rewrite only for 3.10: in our test, Ruff's 3.14 rewrite changed timezone.utc to datetime.UTC, which only exists from 3.11, and the 3.10 test run failed with ImportError.

# While 3.10 is still live: rewrites that still run on 3.10
uvx ruff@0.17.6 check --select UP,W605 --target-version py310 --fix .

# After the switch, once 3.10 is gone for good: rewrites for 3.14
uvx ruff@0.17.6 check --select UP --target-version py314 --fix .
git ls-files -z -- '*.py' | xargs -0r uvx pyupgrade@3.22.0 --py314-plus
# noxfile.py: run the suite on both versions with `nox`
import nox

nox.options.default_venv_backend = "uv|virtualenv"


@nox.session(python=["3.10", "3.14"])
def tests(session):
    session.install("-e", ".", "pytest")
    session.run("pytest")

What is the step-by-step path from Python 3.10 to 3.14?

  1. List everywhere Python runs: Dockerfiles, CI configuration, .python-version files, requires-python, Lambda runtimes, servers using the operating system's Python, cron and ETL machines. Production counts, not a developer laptop.
  2. Get clean on 3.10. Move to 3.10.22, the final release, and fix every warning your own code raises with warnings as errors.
  3. Check every dependency with the wheel check above, decide what to do about each blocker, and upgrade the packages that need a newer release while still on 3.10.
  4. Add 3.14 to CI beside 3.10, so every pull request runs on both until the switch.
  5. Build a 3.14 image, changing only Python. If your current image is on Debian bookworm (check /etc/os-release), use python:3.14-slim-bookworm first and move to trixie separately.
  6. Regenerate the lock file for 3.14 and commit it.
  7. Get the suite green on 3.14 with warnings as errors, then run staging on the new image: workers, scheduled jobs, management commands, data pipelines and file uploads, with response times compared against production.
  8. Release, then tidy up. Ship web servers and workers together and watch the error tracker. Once you decide to stay, drop 3.10 from CI, raise requires-python to >=3.14 and run the 3.14 rewrites.
# Before
# FROM python:3.10-slim

# After: name the Python version and the Debian release, so neither changes by surprise
FROM python:3.14-slim-trixie

WORKDIR /app
COPY requirements.txt .
RUN python -m pip install --no-cache-dir -r requirements.txt
COPY . .

# Fail the build if any file no longer compiles cleanly on the new Python
RUN python -W error -m compileall -q .
# .github/workflows/tests.yml
name: tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        # Keep 3.10 only until the switch; then drop it and raise requires-python
        python-version: ["3.10", "3.14"]
    steps:
      - uses: actions/checkout@v7.0.1
      - uses: astral-sh/setup-uv@v10.4.0
        with:
          python-version: ${{ matrix.python-version }}
      - run: uv sync --locked
      - run: uv run pytest -W error::DeprecationWarning
# uv projects: after raising requires-python to ">=3.14" in pyproject.toml
uv python pin 3.14      # writes .python-version
uv lock                 # re-resolves for 3.14 and drops backports such as tomli
uv sync --locked
uv run pytest -W error::DeprecationWarning

# pip-tools: compile the lock file under 3.14
uvx --python 3.14 --from pip-tools pip-compile requirements.in -o requirements.txt

How do we roll back if the upgrade goes wrong?

A Python upgrade does not migrate your data, so going back is mostly a redeploy, as long as you keep it that simple.

  • Ship the Python change on its own, with no Django upgrade, Debian move or unrelated package upgrades, so going back changes one thing.
  • Keep the code running on both versions until you are sure: 3.10 stays in CI, requires-python stays at >=3.10, and the 3.14-only rewrites wait.
  • Keep the last 3.10 image and lock file, tagged, and know the command that redeploys them. On AWS Lambda, point an alias at a published version, so going back means moving the alias.
  • Move web servers and workers together, in both directions.
  • Agree in advance what sends you back, such as a rise in errors or a failed scheduled job, and who makes the call.

What drives the effort of a Python upgrade?

The size of the codebase matters less than these:

  • Test coverage. With good tests, most of the upgrade is mechanical. Without them, every change is checked by hand.
  • Third-party packages. One with no 3.14 wheel, an abandoned one, or an old pin that imports a removed module can take more work than Python's own changes.
  • Compiled and concurrent code. Your own C or Cython extensions, and scripts built on multiprocessing or asyncio.get_event_loop(), need working through by hand.
  • How many places Python runs. Every image, server, Lambda function and CI pipeline is a separate change.
  • What else is due. If Django is still on 4.2 or the database is near its own deadline (for example RDS PostgreSQL 14 on February 28, 2027), plan the order of the upgrades together.

How we approach it at MicroPyramid

We start with an assessment, then run the upgrade as a fixed project that we finish and hand back to your team.

The Upgrade Assessment is a dependency and end-of-life audit of everything you run, and an upgrade path with the risks called out: which packages block 3.14, where the tests are thin, and the order to move Python, Django and the database in. If another team built the app, we start with a Takeover Assessment instead: we get it building and deploying from a clean checkout and hand you a written risk list and plan.

The upgrade is then a fixed project: missing tests added, warnings fixed on 3.10, blockers replaced, CI running both versions, the 3.14 image rehearsed on staging, and a release with a way back. We hand it back with notes on what changed. To keep it on supported versions afterwards, our software maintenance is a monthly retainer that runs month to month with 30 days' notice.

Still on Python 3.10? Tell us what you run and we will show you what the path to 3.14 looks like for your app.

Frequently Asked Questions

When did Python 3.10 reach end of life?

On October 1, 2026. Python 3.10.22, released that day, is the final release, and the 3.10 branch takes no further fixes. Python 3.11 follows in October 2027 and 3.12 in October 2028.

Which Python version should we upgrade to from 3.10?

Python 3.14 for most teams: security support until October 2030, bug fixes until October 2027, support in Django 5.2 LTS and later, and wheels from the main libraries. Choose 3.13 only if a dependency you cannot replace, such as TensorFlow's current stable release, has no 3.14 wheel.

Can we upgrade straight from Python 3.10 to 3.14?

Yes. Python does not require stopping at 3.11, 3.12 and 3.13, but their removals all arrive together, so read each "What's New" page. Fix deprecation warnings on 3.10 first, then run the tests on 3.14 with warnings as errors.

Does Django 5.2 support Python 3.14?

Yes, from Django 5.2.8. Django 5.2 LTS supports Python 3.10 to 3.14 and is supported until April 2028. Django 6.0, 6.1 and 6.2 LTS need Python 3.12 or newer and all support 3.14.

What breaks when moving from Python 3.10 to 3.14?

The changes most likely to reach application code are imports of removed modules (distutils, imp, cgi, imghdr, telnetlib and others), pkg_resources missing from new virtual environments, old unittest aliases such as assertEquals, asyncio.get_event_loop() with no event loop set, and process pools on Linux that relied on fork.

Why not upgrade to Python 3.15?

It came out on October 9, 2026. Django 5.2 LTS does not support it, Django 6.1 added it only in 6.1.3, and some common packages had no 3.15 wheels when we checked. It becomes a reasonable target in 2027.

What happens if we stay on Python 3.10?

The Python project will not fix new vulnerabilities in it, the official Docker images no longer rebuild it, and AWS Lambda blocks updates to python3.10 functions from August 31, 2027. The latest NumPy and Django releases already need Python 3.12 or newer. If your 3.10 comes from a Linux distribution, its support policy decides how long it gets patches.

Share this article
Facebook X LinkedIn
Related servicePython Development Services

Start with a discovery call.

  1. TODAY Send a short message Tell us what you run and where it hurts.
  2. WITHIN ONE WORKING DAY We reply From the engineers you would work with, to set up a free 30-minute call.
  3. ON THE CALL Your first step A fixed-scope sprint or audit. Monthly maintenance after it only if you want it.
Talk to an engineer
Email
hello@micropyramid.com
Offices
Plano --:--Hyderabad --:--Sharjah --:--
You own
All code & IP, from day one

We reply within one working day