How to Install Python 3.8 on Ubuntu Linux

Python 3.8 reached end-of-life in October 2024 and no longer receives upstream security updates, yet many enterprise applications, automation scripts, and tested deployment pipelines still require this version for compatibility. Installing Python 3.8 on Ubuntu addresses these transitional needs while Ubuntu 22.04 ships Python 3.10 by default and Ubuntu 24.04 ships 3.12, meaning you must add the Deadsnakes PPA or compile from source to access this interpreter.

The installation process covers adding Python 3.8 via the community-maintained Deadsnakes PPA or compiling from source with OpenSSL 3 compatibility, bootstrapping PIP without breaking Ubuntu’s externally-managed environment protections, and managing multiple interpreters safely. Treat every Python 3.8 deployment as temporary: isolate workloads in virtual environments or containers and plan migrations to Python 3.10 or newer for continuing security updates.

Choose Your Python Version for Ubuntu

Compare Supported Python Releases

Each Python version on Ubuntu targets different support lifecycles and compatibility needs. Python 3.8 reached end-of-life in October 2024 and no longer receives upstream security updates, while 3.10, 3.11, 3.12, and 3.13 maintain active security support on their own timelines.

Python Version	Primary Focus	Best For	Trade-offs
Python 3.8	Legacy application support and EOL compatibility	Enterprise applications pinned to 3.8, legacy codebases requiring walrus operator/positional-only parameters, transitional deployments	End-of-life October 2024, no upstream security patches, ecosystem support declining rapidly, requires Deadsnakes PPA or source compilation
Python 3.10	Stable production runtime with security support	Production applications needing structural pattern matching, better error messages, multiple context managers, security-conscious deployments	End-of-life October 2026, some newer libraries dropping support, Ubuntu 22.04 default (24.04 ships 3.12)
Python 3.11	Performance improvements and error handling	Applications benefiting from 10-60% speed improvements, better exception groups, TOML support, fine-grained error locations	End-of-life October 2027, not Ubuntu default on any LTS, requires Deadsnakes PPA on 22.04/24.04
Python 3.12	Modern Python with comprehension inlining and f-string improvements	New projects, Ubuntu 24.04 LTS default, development workstations, applications using PEP 701 f-strings, improved debugger, per-interpreter GIL	End-of-life October 2028, some older libraries not yet compatible, Ubuntu 22.04 users need the Deadsnakes PPA
Python 3.13	Latest interpreter with free-threaded preview and typing refinements	Development that needs the newest features, concurrency benchmarking, forward-looking testing with support through October 2029	Not in Ubuntu repositories, depends on Deadsnakes PPA or source builds, community packages may trail initial releases
Python 3.14	Latest interpreter with continued free-threaded progress and ecosystem catch-up	Early adopters planning for support through October 2030, benchmarking the newest runtime, testing future compatibility	Not in Ubuntu repositories, relies on Deadsnakes PPA or source builds, some wheels lag early releases

Ubuntu 24.04 LTS ships Python 3.12 by default, making it the best choice for new projects that need support through October 2028. Jammy users can stay on Python 3.10 for a conservative, well-tested interpreter with extended security updates, while Python 3.11 is the sweet spot for CPU-heavy workloads that benefit from the 10-60% speed boost and improved exception groups. Choose Python 3.13 when you want the newest language features and free-threaded preview via PPA or source builds, or Python 3.14 for the longer support runway and latest interpreter updates. All options are readily available through Ubuntu repositories, Deadsnakes packages, or source builds without forcing major workflow changes.

Decide When to Keep Python 3.8

Only install Python 3.8 when a legacy application cannot immediately move forward. The interpreter reached end-of-life in October 2024, no longer receives upstream security patches, and modern frameworks such as Django 5.0 or NumPy 2.0 reject it outright.

Treat every Python 3.8 deployment as a transitional solution while you plan migrations to Python 3.10, 3.11, or 3.12 for continuing security updates and ecosystem compatibility.

Choose Your Python 3.8 Installation Method

Select the installation method that matches your deployment requirements. Most users should choose the Deadsnakes PPA for simplicity, while source compilation suits air-gapped environments or workloads requiring custom optimization flags.

Installation Option	Best For	Trade-offs
Deadsnakes PPA	Ubuntu 22.04 and 24.04 systems that need packaged Python 3.8 builds integrated with apt	Community-maintained packages with no guaranteed security updates; still must avoid replacing Ubuntu’s default python3
Compile from Source	Strict compliance or air-gapped environments that need custom patches, --enable-optimizations, or alternate prefixes such as /opt/python3.8	Takes longer to build, you manage updates yourself, requires build dependencies
Stick with Ubuntu’s Default Python 3.x	Users who only needed newer language features; follow the Python 3.12 on Ubuntu guide or similar if you actually want the distro-supported release	Does not give you Python 3.8; meant as the safest option for system scripts
Virtual environments or containers	Running multiple Python versions per project without touching system binaries; follow the Python virtual environment guide or use Docker when isolating entire stacks	Requires managing per-project environments, but keeps Ubuntu’s system Python untouched

Whichever method you pick, never replace the default /usr/bin/python3 interpreter. Ubuntu’s package manager, desktop tools, and cloud-init all depend on the version that ships with the distribution.

Understand Support and Compatibility Limits

• Ubuntu archives no longer ship python3.8: visiting https://packages.ubuntu.com/jammy/python3.8 or /noble/python3.8 returns “No such package.” Expect apt install python3.8 to fail on Ubuntu 22.04, 24.04, and future 26.04 unless you add a third-party source such as Deadsnakes or build from source.
• Deadsnakes PPA carries a “no guaranteed updates” disclaimer on Launchpad. Production users must monitor CVEs themselves and be ready to recompile or sandbox workloads until patched packages arrive.
• Ecosystem support has already moved on: Django 5.0 only supports Python 3.10-3.12, and NumPy 2.0 supports 3.9-3.12 (see the version comparison table above for details). Expect modern frameworks to reject python3.8 builds outright on 24.04/26.04, so gate new application updates carefully.

Python 3.8 reached upstream end-of-life on 7 October 2024, per the official lifecycle tracker. Install Python 3.8 only when a legacy application demands it, isolate that workload (venv, containers, snaps), and plan a migration to Ubuntu’s supported interpreter. Ubuntu 20.04 LTS was the last release that shipped Python 3.8 as the default, while 22.04 provides 3.10 and 24.04 already ships 3.12.

Python 3.8 Pre-Installation Steps

Update System Before Proceeding

Before installing Python 3.8, update your system’s package lists to ensure all dependencies resolve correctly and you receive the latest security patches. This step is particularly important when adding third-party repositories like Deadsnakes or compiling software from source, as build tools and libraries frequently receive compatibility updates.

Open a terminal (press Ctrl + Alt + T, similar to launching Windows Terminal) and run:

sudo apt update

After refreshing package lists, upgrade any installed packages to their latest versions. This step prevents conflicts between outdated system libraries and newly compiled software, particularly when building Python from source with --enable-optimizations.

Run the upgrade command:

sudo apt upgrade

Once your system is updated, select an installation method based on your deployment requirements. Most users should choose the Deadsnakes PPA for simplicity, while custom compilation suits air-gapped environments or workloads requiring specific optimization flags.

Install Python 3.8 from the Deadsnakes PPA

Import Python 3.8 PPA

For Ubuntu users, the easiest way to access the latest updates for Python and additional required packages is by importing the “deadsnakes” team Launchpad PPA. This will enable you to install and update Python 3.8 directly from your terminal. To import the PPA, run the following command:

The Launchpad package list confirms that Python 3.8.20 builds exist for Ubuntu 22.04 (Jammy) and 24.04 (Noble), so both LTS releases can install python3.8 directly from this PPA without manual compilation.

Launchpad also reiterates the Deadsnakes disclaimer: there is no guarantee of timely security fixes, so production teams must monitor CVEs and be ready to recompile or sandbox workloads if a vulnerability appears before patched packages land.

sudo add-apt-repository ppa:deadsnakes/ppa -y

Update Package List After Python 3.8 Import

After importing the PPA, you must update your package list to ensure your system recognizes the newly added repository. To do this, run the following command in your terminal:

sudo apt update

Install Python 3.8 via APT Command

With the PPA successfully imported and your package list updated, you’re ready to install Python 3.8. To do so, run the following command:

sudo apt install python3.8

Verify Python 3.8 Installation

After installation completes, verify Python 3.8 installed correctly by checking the version string:

python3.8 --version

This command should display output similar to:

Python 3.8.20

Next, verify that the SSL module compiled correctly (critical for OpenSSL 3 compatibility on Ubuntu 22.04 and newer):

python3.8 -c "import ssl, sqlite3, bz2; print('Core modules OK')"

If the ssl import fails with ModuleNotFoundError, you compiled an older Python 3.8.x release (pre-3.8.16) against Ubuntu’s OpenSSL 3. Download Python 3.8.20 and recompile using the steps above.

Install Additional Python Packages on Ubuntu (Optional)

If desired, you can also install the following extras:

Package	Why Install It
python3.8-dbg	Provides debugging symbols so you can trace crashes or attach gdb to Python processes
python3.8-dev	Installs headers for compiling native extensions such as uvloop or psycopg2
python3.8-venv	Enables the built-in venv module so you can isolate dependencies per project
python3.8-distutils	Provides the legacy Distutils packaging tools still used by some build scripts
python3.8-lib2to3	Installs the modernization tool used to port legacy Python 2 code
python3.8-gdbm	Adds GNU dbm bindings so your apps can use dbm.gnu databases
python3.8-tk	Ships Tk bindings (Tkinter) for GUI applications

Install optional modules individually as needed:

sudo apt install python3.8-dbg
sudo apt install python3.8-dev
sudo apt install python3.8-venv
sudo apt install python3.8-distutils
sudo apt install python3.8-lib2to3
sudo apt install python3.8-gdbm
sudo apt install python3.8-tk

Only install legacy components like python3.8-distutils or python3.8-lib2to3 when a project explicitly requires them; modern packaging tools favor pip, setuptools, and pyproject.toml-based builds.

Install whichever modules you need in a single apt command to save time:

sudo apt install python3.8-venv python3.8-dev python3.8-tk

Compile Python 3.8 from Source on Ubuntu

Download Python 3.8

Visit the official Python download page and copy the download link for the latest Python 3.8.x release. Use wget to download the archive directly to your system:

wget https://www.python.org/ftp/python/3.8.20/Python-3.8.20.tar.xz

Download links on python.org change regularly, so copy the latest Python 3.8.x URL before running wget and update the version fields in the following commands to match.

After downloading the Python archive, extract it using tar:

tar -xf Python-3.8.20.tar.xz

Install Required Packages for Python 3.8

Before compiling Python from source, install the build dependencies. The build-essential package provides GCC and core compilation tools, while the development libraries supply headers for SSL, compression, and database support:

sudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libsqlite3-dev libreadline-dev libffi-dev curl libbz2-dev pkg-config make -y

These package names exist on Ubuntu 22.04 LTS, 24.04 LTS, and will continue to exist on 26.04 because they pull from the standard Jammy/Noble “-dev” meta-packages. Install them before compiling so every header is available. For complex projects that require additional build systems beyond make, you may also want to install CMake, though Python’s build process does not require it.

Python 3.8.16+ is required on Ubuntu 22.04/24.04/26.04 because these releases only ship OpenSSL 3 (libssl3). Earlier 3.8.x builds expect OpenSSL 1.1.1 and will fail to build the ssl module. Always download the latest 3.8.x tarball before compiling.

Configure the Python Build Environment

Navigate to the extracted source directory:

cd Python-3.8.20/

Now, run the ./configure command with the --enable-optimizations and --enable-shared options:

./configure --enable-optimizations --enable-shared

The script will perform several checks to ensure that all necessary dependencies are present on your system. Running ./configure with --enable-optimizations will optimize the Python binary by running multiple tests. This can make the build process slower but will result in a faster and more efficient Python installation.

Compile Python 3.8

After configuring the build environment, compile Python using the make command. To significantly speed up compilation, use the -j flag to enable parallel builds across multiple CPU cores:

make -j $(nproc)

The $(nproc) command automatically detects your available CPU cores and runs that many parallel jobs. Alternatively, you can manually specify the number of cores, such as make -j 6 for systems where you want to reserve processing power for other tasks during compilation.

Install Python Binaries

After finishing the building process, install the Python binaries by running the following command: sudo make altinstall. Using the make altinstall command is recommended to avoid overwriting the default Python 3 binary system.

sudo make altinstall

After installation, update the dynamic linker cache so the system can locate the Python 3.8 shared library (libpython3.8.so) when running Python or importing extension modules. If you compiled with the default prefix (--prefix=/usr/local), run:

sudo ldconfig /usr/local/lib

When you compiled with a custom prefix (for example ./configure --prefix=/opt/python3.8), provide that path explicitly:

sudo ldconfig /opt/python3.8/lib

Verify Python 3.8 Installation

After configuring the dynamic linker, confirm the source-compiled Python 3.8 installation succeeded and the version matches your downloaded release:

python3.8 --version

Additionally, verify critical modules like SSL compiled correctly, as missing development headers during compilation cause silent module failures. Run this test to confirm OpenSSL 3 compatibility:

python3.8 -c "import ssl; print('SSL module OK'); print(ssl.OPENSSL_VERSION)"

Install PIP with Python 3.8

Install PIP via APT

When you installed Python 3.8 from the Deadsnakes PPA, installing PIP becomes straightforward using apt. However, the system python3-pip package only wires PIP to Ubuntu’s default interpreter (3.10 on Jammy, 3.12 on Noble), not to Python 3.8. For comprehensive coverage of PIP functionality and advanced usage, refer to the dedicated PIP on Ubuntu guide.

To install PIP specifically for Python 3.8, use one of the methods below instead:

Method 1: Bootstrap PIP with ensurepip

Python includes a bundled bootstrap module named ensurepip that installs the version of PIP packaged with the interpreter. This method is the simplest and works offline. Run the following to install (or refresh) PIP for Python 3.8:

python3.8 -m ensurepip --upgrade

This method avoids fetching an external script and works in minimal, offline, or restricted environments. After using ensurepip, upgrade to the latest release with python3.8 -m pip install --upgrade pip to pick up current security fixes.

Method 2: Download and Run get-pip.py

Alternatively, manually install PIP using the official bootstrap script provided by the Python Packaging Authority (PyPA). Download it using wget:

wget https://bootstrap.pypa.io/get-pip.py

This script is provided by the Python Packaging Authority (PyPA) and is used to install or upgrade PIP on your system.

Run the PIP Installation Script

After downloading the bootstrap script, execute it with Python 3.8 to install PIP specifically for this interpreter:

python3.8 get-pip.py

This will install PIP specifically for Python 3.8 on your system.

Ubuntu 23.04 and newer mark the system Python as “externally managed” (PEP 668). If you try to run python3.8 -m pip install <package> directly on 24.04 or 26.04, pip prints an error unless you work inside a virtual environment or pass --break-system-packages. The latter flag bypasses Ubuntu’s protections but risks dependency conflicts; the recommended approach is to create a virtual environment per project using python3.8 -m venv.

Upgrade PIP to the Latest Version

After installing PIP, upgrade it to the latest version to access recent bug fixes and features. Always specify the python3.8 interpreter explicitly to avoid accidentally upgrading Ubuntu’s system-wide PIP, which could break apt-managed packages:

python3.8 -m pip install --upgrade pip

You should see output similar to the following:

joshua@ubuntu-linux:~$ python3.8 -m pip install --upgrade pip
Defaulting to user installation because normal site-packages is not writeable
Requirement already satisfied: pip in ./.local/lib/python3.8/site-packages (22.3.1)

This output indicates that PIP has been upgraded to the latest version.

Verify the Installed PIP Version

Confirm PIP installed correctly and check which version is bound to your Python 3.8 interpreter:

python3.8 -m pip --version

This will display the current PIP version associated with your Python 3.8 installation.

Manage Multiple Python Versions Safely on Ubuntu

If you need multiple versions of Python installed on your system and want to control which interpreter launches when you run python, follow these guardrails to avoid breaking core Ubuntu tools.

Do Not Replace Ubuntu’s Default Python 3 Interpreter

Ubuntu binds thousands of packages (APT, software-properties-gtk, update-manager, cloud-init, Ansible controllers, etc.) to the specific /usr/bin/python3 version that shipped with your release. Replacing that binary or symlink with Python 3.8 causes modules compiled for the distro version to disappear, and everyday commands immediately fail.

Leave /usr/bin/python3 untouched. Install additional interpreters via the Deadsnakes PPA, make altinstall, or tools like pyenv so they register as /usr/bin/python3.8 or /opt/python3.8/bin/python3.8 instead of replacing the system Python.

For example, symlinking /usr/bin/python3 to Python 3.8 immediately breaks apt update because the apt_pkg module is compiled specifically for Ubuntu’s stock interpreter.

Traceback (most recent call last):
  File "/usr/bin/apt", line 27, in <module>
    import apt_pkg
ModuleNotFoundError: No module named 'apt_pkg'

This is why every command in this guide either references python3.8 directly or installs into isolated environments. Keep that habit when scripting.

Virtual Environments Are the Safest Approach

The safest approach for Python 3.8 workloads is creating per-project environments with python3.8 -m venv instead of modifying system-wide settings. This keeps Ubuntu’s stock Python untouched while giving every project the interpreter it requires, and avoids PEP 668 PIP restrictions entirely. Refer to the virtual environment guide or isolate entire workloads inside Docker containers for larger deployments.

Add Symbolic Links for Each Python Version

When you need to switch the python command between interpreters without manually editing symlinks, use update-alternatives to create a managed group. This approach references explicit binaries like /usr/bin/python3.8 while preserving /usr/bin/python3, allowing you to control which interpreter executes when you run python without a version suffix.

update-alternatives only manages the generic /usr/bin/python entry. It never alters /usr/bin/python3, which remains pinned to the distribution’s default interpreter. Any script that invokes python3 continues to use Ubuntu’s stock version regardless of which alternative you select for python.

Here’s an example (you can customize this or copy it):

sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.8 1
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.10 2
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.11 3
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.12 4

Remember that you don’t need to list all the Python versions you have installed – copying the entire command will create symbolic links for the versions on your system. Remove references to versions that are not installed to avoid errors.

List Available Python Versions

After registering all desired Python versions with update-alternatives, view the complete list and identify which version is currently active:

sudo update-alternatives --config python

This will display a list of installed Python versions with their respective selection numbers. An asterisk (*) beside the selection number will indicate the currently set default version.

Set a Different Python Version as the Default

To switch the default Python interpreter (for example, to Python 3.8), enter the selection number shown for python3.8 in your menu. The specific number varies depending on how many versions you registered.

After running the command to set Python 3.8 as the default version, the output should confirm the change:

update-alternatives: using /usr/bin/python3.8 to provide /usr/bin/python (python) in manual mode

Verify the Default Python Version

After switching to Python 3.8, confirm the change took effect by listing alternatives again. The asterisk (*) next to Python 3.8’s selection number indicates it is now the active default:

sudo update-alternatives --config python

This will confirm that the default Python version has been successfully switched to the desired version.

Troubleshooting Common Python 3.8 Installation Issues

OpenSSL Module Build Failures

When compiling Python 3.8 on Ubuntu 22.04 or newer, the build may complete successfully but the ssl module fails to load with import errors. Ubuntu 22.04+ ships OpenSSL 3.x, while Python 3.8.0 through 3.8.15 were designed for OpenSSL 1.1.1. Therefore, always download Python 3.8.16 or newer, which includes OpenSSL 3 compatibility patches.

Verify SSL module availability after installation:

python3.8 -c "import ssl; print(ssl.OPENSSL_VERSION)"

If this command fails with ModuleNotFoundError, you likely compiled an older Python 3.8 release against OpenSSL 3. Download Python 3.8.20 (the latest 3.8.x release) and recompile.

Missing Development Headers During Compilation

The configure script may report warnings about missing optional libraries when development headers are not installed. While Python will compile successfully, certain standard library modules like _ssl, _bz2, or _sqlite3 will be unavailable. Review the configure output carefully:

./configure --enable-optimizations --enable-shared 2>&1 | grep "disabled"

This command displays all disabled modules. Additionally, after running make, check for “Failed to build these modules” messages near the end of the compilation output. Install the corresponding -dev packages, then run ./configure and make again to rebuild with full module support.

Shared Library Linking Errors

When running python3.8 after source compilation, you may encounter an error stating error while loading shared libraries: libpython3.8.so.1.0: cannot open shared object file. This happens when the dynamic linker cannot locate the Python shared library because it was installed outside standard library paths.

First, verify the library exists:

find /usr/local -name "libpython3.8.so*"

Then update the linker cache with the correct path:

sudo ldconfig /usr/local/lib

Alternatively, add the library path to your environment permanently by creating a configuration file:

echo "/usr/local/lib" | sudo tee /etc/ld.so.conf.d/python3.8.conf
sudo ldconfig

PIP Externally-Managed Environment Errors

On Ubuntu 23.04 and newer, running python3.8 -m pip install package-name may fail with an “externally-managed-environment” error per PEP 668. Ubuntu marks the system Python as externally managed to prevent conflicts between apt-installed packages and pip-installed packages.

The recommended solution is creating a virtual environment for each project:

python3.8 -m venv myproject_env
source myproject_env/bin/activate
pip install package-name

Alternatively, use the --break-system-packages flag to bypass the restriction, though this approach risks dependency conflicts with apt packages and is not recommended for production systems:

python3.8 -m pip install --break-system-packages package-name

APT Breaking After Installing Python 3.8 PPA

If apt update or apt install fails with Python-related errors after adding the Deadsnakes PPA, ensure you did not accidentally replace Ubuntu’s system Python 3 interpreter. Check the /usr/bin/python3 symlink:

ls -la /usr/bin/python3

This should point to the Ubuntu default version (python3.12 on 24.04, python3.10 on 22.04), not python3.8. If it points to python3.8, restore the original symlink:

sudo ln -sf /usr/bin/python3.12 /usr/bin/python3

Replace 3.12 with your Ubuntu release’s default Python version. Additionally, always invoke Python 3.8 explicitly using python3.8 rather than modifying the python3 symlink.

Uninstalling Python 3.8 from Ubuntu

Remove Deadsnakes PPA Installation

To completely remove Python 3.8 installed from the Deadsnakes PPA, first remove all python3.8 packages:

sudo apt remove --purge python3.8 python3.8-minimal python3.8-dev python3.8-venv

Then remove the PPA repository to prevent future updates:

sudo add-apt-repository --remove ppa:deadsnakes/ppa
sudo apt update

Remove Source-Compiled Installation

For source-compiled Python 3.8 installed via make altinstall, manually remove the binaries and libraries. If you used the default prefix (/usr/local), remove these files:

Review paths carefully before running bulk rm -rf commands on production systems; avoid deleting similarly named custom scripts or data directories.

sudo rm -rf /usr/local/bin/python3.8*
sudo rm -rf /usr/local/bin/pip3.8*
sudo rm -rf /usr/local/lib/python3.8
sudo rm -rf /usr/local/lib/libpython3.8*
sudo rm -rf /usr/local/include/python3.8
sudo ldconfig

When you compiled with a custom prefix like --prefix=/opt/python3.8, simply remove that directory:

sudo rm -rf /opt/python3.8
sudo ldconfig

Remove update-alternatives Entries

If you configured update-alternatives for Python version switching, remove the python3.8 entry:

sudo update-alternatives --remove python /usr/bin/python3.8

Verify the removal completed successfully:

sudo update-alternatives --list python

Keep Python 3.8 Isolated as a Legacy Runtime

Python 3.8 has not been Ubuntu’s default interpreter since Ubuntu 20.04 LTS. Jammy ships Python 3.10 and Noble ships Python 3.12, so installing python3.8 today always introduces an extra runtime. Treat it like legacy tooling on Windows: leave the system binaries untouched and run legacy apps inside isolated virtual environments or containers.

Create a dedicated environment for every Python 3.8 workload, keep those configurations under version control with the project, and document the migration path in your deployment notes. This approach protects Ubuntu’s system interpreter, apt tooling, and future upgrades to newer Python releases while still supporting legacy applications.

Conclusion

Python 3.8 remains accessible on Ubuntu through the Deadsnakes PPA or source compilation despite reaching end-of-life in October 2024. Your system now runs Python 3.8 alongside Ubuntu’s default interpreter without disrupting system tools, package management, or distribution upgrades. Isolate every Python 3.8 workload in virtual environments or containers and prioritize migrations to Python 3.10 or newer for continuing security updates and framework compatibility.