How to Install Docker on Linux Mint 22 and 21

Docker on Linux Mint is easiest to maintain when Docker Engine and Docker Desktop are treated as different products. Docker Engine installs from Docker’s Ubuntu APT repository and works across current Ubuntu-based Mint releases, while Docker Desktop is a larger VM-backed GUI package that Docker documents for Ubuntu 26.04 and 24.04 on x86-64 systems.

For most Mint users, install Docker Engine first because it provides the daemon, Docker CLI, Compose plugin, Buildx plugin, and APT-managed updates. Add Docker Desktop only on Linux Mint 22.x amd64 when you specifically need the dashboard, Desktop-managed contexts, Kubernetes toggle, or GUI workflow.

Install Docker on Linux Mint

Choose Docker Engine or Docker Desktop

Use one Docker APT repository setup for both paths. Docker Engine installs directly from that repository. Docker Desktop installs from Docker’s current Linux DEB, but the package still depends on Docker’s repository for the CLI package.

Path	Source	Best For	Update Behavior
Docker Engine	Docker’s Ubuntu APT repository	Compose projects, terminal workflows, local services, CI-like testing, and normal Linux container work	APT updates Docker Engine, Docker CLI, Compose, Buildx, and containerd
Docker Desktop	Docker Desktop Linux DEB	GUI dashboard, Desktop extensions, local Kubernetes, and Desktop-managed contexts on Mint 22.x amd64	Use update-docker-desktop to download the newest DEB, verify Docker’s checksum, and install it with APT

Docker notes that Ubuntu-derivative installs such as Linux Mint are not officially supported for Docker Engine, although they may work. Docker Desktop’s supported Linux platform list names Ubuntu, Debian, Fedora, and RHEL, not Linux Mint. Keep Desktop to Mint 22.x amd64 unless Docker expands its supported Ubuntu-base requirements.

Check Linux Mint Release and Architecture

Confirm the Mint release, Ubuntu base codename, and CPU architecture before adding Docker’s repository. Docker’s Ubuntu repository uses noble for Mint 22.x and jammy for Mint 21.x; Mint codenames such as zena and virginia are not Docker repository suites.

. /etc/os-release
printf 'Linux Mint: %s\n' "${PRETTY_NAME:-unknown}"
printf 'Ubuntu base: %s\n' "${UBUNTU_CODENAME:-unknown}"
printf 'Architecture: %s\n' "$(dpkg --print-architecture)"

Linux Mint Release	Ubuntu Base	Docker Repository Suite	Desktop Path
Linux Mint 22.x	Ubuntu 24.04 LTS	noble	Docker Desktop can be attempted on amd64 systems that meet KVM and desktop requirements
Linux Mint 21.x	Ubuntu 22.04 LTS	jammy	Use Docker Engine; Docker Desktop’s current Ubuntu requirements no longer include 22.04

Remove Conflicting Docker Packages

Docker’s upstream packages conflict with older distro-packaged Docker names such as docker.io, docker-compose, containerd, and runc. List installed conflicts first, then remove only the package names found on your system.

mapfile -t conflicting_packages < <(dpkg-query -W -f='${binary:Package}\n' \
  docker.io docker-doc docker-compose docker-compose-v2 docker-buildx podman-docker containerd runc \
  2>/dev/null || true)

if [ "${#conflicting_packages[@]}" -gt 0 ]; then
  printf '%s\n' "${conflicting_packages[@]}"
  sudo apt remove "${conflicting_packages[@]}"
else
  printf 'No conflicting Docker packages are installed.\n'
fi

Package removal does not delete Docker images, containers, volumes, or daemon configuration by itself. Keep the data cleanup steps near the end for systems that need a full reset.

Add Docker’s APT Repository on Linux Mint

Add Docker’s signing key and a DEB822 source file that uses the Ubuntu base codename from /etc/os-release. The guarded subshell stops before writing the source file on unsupported Mint bases.

These commands use sudo for package and repository changes. If your account cannot use sudo yet, configure administrator access with the Linux Mint sudoers guide before changing APT sources.

(
set -e

. /etc/os-release
docker_suite="${UBUNTU_CODENAME:-}"
arch="$(dpkg --print-architecture)"

case "${ID:-}:${docker_suite}:${arch}" in
  linuxmint:noble:amd64|linuxmint:jammy:amd64) ;;
  *)
    printf 'This Docker APT setup supports Ubuntu-based Linux Mint 22.x or 21.x on amd64.\n' >&2
    printf 'Detected: %s, Ubuntu base: %s, architecture: %s\n' "${PRETTY_NAME:-unknown}" "${docker_suite:-unknown}" "$arch" >&2
    exit 1
    ;;
esac

sudo apt update
sudo apt install ca-certificates curl

sudo install -m 0755 -d /etc/apt/keyrings
key_tmp="$(mktemp)"
trap 'rm -f "$key_tmp"' EXIT
curl -fsSLo "$key_tmp" https://download.docker.com/linux/ubuntu/gpg
sudo install -m 0644 "$key_tmp" /etc/apt/keyrings/docker.asc

printf '%s\n' \
  'Types: deb' \
  'URIs: https://download.docker.com/linux/ubuntu' \
  "Suites: ${docker_suite}" \
  'Components: stable' \
  "Architectures: ${arch}" \
  'Signed-By: /etc/apt/keyrings/docker.asc' | sudo tee /etc/apt/sources.list.d/docker.sources >/dev/null

sudo apt update
)

Check that APT sees Docker’s repository before installing packages. The version number changes over time, but the candidate suffix should match the Mint base suite, such as ~ubuntu.24.04~noble or ~ubuntu.22.04~jammy.

apt-cache policy docker-ce docker-compose-plugin

docker-ce:
  Candidate: 5:29.5.2-1~ubuntu.24.04~noble
docker-compose-plugin:
  Candidate: 5.1.4-1~ubuntu.24.04~noble

Install Docker Engine Packages

Install Docker Engine, the Docker CLI, containerd, Buildx, and the Compose plugin from Docker’s repository:

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

APT may also install supporting packages such as docker-ce-rootless-extras, pigz, and Git libraries on a clean Mint system. Leave dependency packages in place unless APT later marks them as safe to autoremove.

Verify Docker Engine on Linux Mint

Confirm the CLI, Compose plugin, Buildx plugin, and service state:

docker --version
docker compose version
docker buildx version
systemctl is-active docker.service containerd.service
systemctl is-enabled docker.service containerd.service

Docker version 29.5.2, build 79eb04c
Docker Compose version v5.1.4
github.com/docker/buildx v0.34.1
active
active
enabled
enabled

Run Docker’s test image through the root-owned daemon socket. This first pull confirms the service can download an image and run a container:

sudo docker run --rm hello-world

Hello from Docker!

Run Docker Without sudo on Linux Mint

Docker creates a docker group for non-root CLI access. Membership in this group grants control over the Docker daemon, which is effectively administrator-level access on the host, so add only trusted local users.

sudo usermod -aG docker "$USER"

Open a new login session after changing group membership. To refresh only the current terminal, start a temporary shell with the new group and verify that Docker works without sudo:

newgrp docker
docker run --rm hello-world

Install Docker Desktop on Linux Mint 22.x

Docker Desktop on Mint should be a deliberate choice, not the default install path. It runs a separate VM, creates the desktop-linux context, stores Desktop images and containers separately from Docker Engine, and can conflict with Engine containers when both try to publish the same host port.

Docker’s Ubuntu Desktop instructions currently require an x86-64 system with Ubuntu 26.04 LTS or 24.04 LTS. On Linux Mint, that maps the practical Desktop path to Mint 22.x on amd64. Mint 21.x users should stay with Docker Engine unless Docker publishes a compatible Desktop requirement again.

Check Docker Desktop Requirements

Docker Desktop needs hardware virtualization, KVM access, systemd, QEMU, and a graphical desktop session. Docker lists GNOME, KDE, and MATE as supported desktop environments; Cinnamon and Xfce may work, but Docker does not name them in the supported environment list.

dpkg --print-architecture
grep -Ec '(vmx|svm)' /proc/cpuinfo
ls -l /dev/kvm

amd64
8
crw-rw----+ 1 root kvm 10, 232 May 27 10:00 /dev/kvm

A zero from the CPU check usually means virtualization is disabled in firmware or unavailable inside the current VM. If /dev/kvm belongs to the kvm group and your user is not a member, add the user and log out of the desktop session before launching Docker Desktop.

if getent group kvm >/dev/null && ! id -nG "$USER" | tr ' ' '\n' | grep -qx kvm; then
  sudo usermod -aG kvm "$USER"
  printf 'Log out and back in before starting Docker Desktop.\n'
fi

Install gnome-terminal on non-GNOME Mint editions so Docker Desktop can open terminal windows from the dashboard:

sudo apt install gnome-terminal

Create Docker Desktop Update Helper

Create one root-owned helper named update-docker-desktop. The helper refuses unsupported Mint releases, downloads Docker’s current Linux DEB and checksum file, verifies the checksum, installs or updates the package with APT, and checks the real launcher, icon, and user service paths shipped by the package.

helper_path=/usr/local/bin/update-docker-desktop

if [ -e "$helper_path" ] && ! sudo grep -q '^# Managed Docker Desktop updater for Linux Mint$' "$helper_path" 2>/dev/null; then
  printf 'Refusing to replace existing unmarked helper: %s\n' "$helper_path" >&2
  false
else
  sudo install -m 0755 -d /usr/local/bin
  sudo tee "$helper_path" >/dev/null <<'BASH'
#!/usr/bin/env bash
# Managed Docker Desktop updater for Linux Mint
set -euo pipefail

desktop_url="https://desktop.docker.com/linux/main/amd64/docker-desktop-amd64.deb"
checksum_url="https://desktop.docker.com/linux/main/amd64/checksums.txt"

for cmd in apt-cache apt-get awk basename curl dpkg dpkg-query grep id install sha256sum sudo tee; do
  if ! command -v "$cmd" >/dev/null 2>&1; then
    printf 'Missing required command: %s\n' "$cmd" >&2
    exit 1
  fi
done

if [ "$(id -u)" -eq 0 ]; then
  printf 'Run update-docker-desktop as your normal sudo-capable user, not as root.\n' >&2
  exit 1
fi

if [ ! -r /etc/os-release ]; then
  printf 'Cannot read /etc/os-release.\n' >&2
  exit 1
fi

# shellcheck source=/dev/null
. /etc/os-release

arch="$(dpkg --print-architecture)"
if [ "${ID:-}" != "linuxmint" ] || [ "${UBUNTU_CODENAME:-}" != "noble" ] || [ "$arch" != "amd64" ]; then
  printf 'This Docker Desktop helper supports Linux Mint 22.x on amd64.\n' >&2
  printf 'Detected: %s, Ubuntu base: %s, architecture: %s\n' "${PRETTY_NAME:-unknown}" "${UBUNTU_CODENAME:-unknown}" "$arch" >&2
  exit 1
fi

docker_cli_policy="$(apt-cache policy docker-ce-cli)"
case "$docker_cli_policy" in
  *download.docker.com/linux/ubuntu*) ;;
  *)
    printf 'Docker APT repository is not available yet. Add Docker'\''s repository before installing Docker Desktop.\n' >&2
    exit 1
    ;;
esac

cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/docker-desktop-updater"
deb_path="$cache_dir/docker-desktop-amd64.deb"
checksum_path="$cache_dir/checksums.txt"
checksum_entry="$cache_dir/docker-desktop-amd64.sha256"

install -m 0755 -d "$cache_dir"

printf 'Downloading Docker Desktop package...\n'
curl -fL --retry 3 -o "$deb_path" "$desktop_url"
curl -fsSL --retry 3 -o "$checksum_path" "$checksum_url"

awk '$2 == "*docker-desktop-amd64.deb" {print; found=1} END {exit found ? 0 : 1}' "$checksum_path" > "$checksum_entry"

(
  cd "$cache_dir"
  sha256sum -c "$(basename "$checksum_entry")"
)

before_version="$(dpkg-query -W -f='${Version}' docker-desktop 2>/dev/null || true)"

sudo apt-get update
sudo apt-get install "$deb_path"

after_version="$(dpkg-query -W -f='${Version}' docker-desktop 2>/dev/null || true)"
if [ -z "$after_version" ]; then
  printf 'Docker Desktop package is not installed after the APT transaction.\n' >&2
  exit 1
fi

if [ -n "$before_version" ] && [ "$before_version" = "$after_version" ]; then
  printf 'Docker Desktop is already installed at version %s.\n' "$after_version"
else
  printf 'Docker Desktop package version: %s\n' "$after_version"
fi

desktop_file="/usr/share/applications/docker-desktop.desktop"
if [ ! -r "$desktop_file" ]; then
  printf 'Missing expected desktop file: %s\n' "$desktop_file" >&2
  exit 1
fi

desktop_exec="$(awk -F= '$1 == "Exec" {print $2; exit}' "$desktop_file")"
desktop_exec_path="${desktop_exec%% *}"
desktop_icon="$(awk -F= '$1 == "Icon" {print $2; exit}' "$desktop_file")"

for path in "$desktop_file" "$desktop_exec_path" "$desktop_icon" /usr/lib/systemd/user/docker-desktop.service; do
  if [ -e "$path" ]; then
    printf 'OK: %s\n' "$path"
  else
    printf 'Missing expected Docker Desktop path: %s\n' "$path" >&2
    exit 1
  fi
done
BASH

  sudo chmod 0755 "$helper_path"
  command -v update-docker-desktop
fi

/usr/local/bin/update-docker-desktop

Install or Update Docker Desktop

Use the same helper for the first Docker Desktop install and later upgrades. It downloads the moving current package from Docker, verifies the matching moving checksum file, then lets APT resolve package dependencies such as docker-ce-cli, qemu-system-x86, pass, and uidmap.

update-docker-desktop

Relevant output includes the checksum result and the package-owned desktop paths:

docker-desktop-amd64.deb: OK
Docker Desktop package version: 4.75.0-227598
OK: /usr/share/applications/docker-desktop.desktop
OK: /opt/docker-desktop/bin/docker-desktop
OK: /opt/docker-desktop/share/icon.original.png
OK: /usr/lib/systemd/user/docker-desktop.service

A later run reports that the package is already current, then repeats the same path checks:

Docker Desktop is already installed at version 4.75.0-227598
OK: /usr/share/applications/docker-desktop.desktop
OK: /opt/docker-desktop/bin/docker-desktop
OK: /opt/docker-desktop/share/icon.original.png
OK: /usr/lib/systemd/user/docker-desktop.service

The Docker Desktop package installs the application under /opt/docker-desktop. Its desktop launcher uses Exec=/opt/docker-desktop/bin/docker-desktop and Icon=/opt/docker-desktop/share/icon.original.png, so avoid older icon symlink workarounds unless the helper reports a missing path after the package installs.

Launch Docker Desktop

Start Docker Desktop from the Linux Mint application menu. The first launch shows Docker’s subscription terms, and Docker Desktop will not run until those terms are accepted.

The terminal start path uses the user service installed by the package:

systemctl --user start docker-desktop

Enable Docker Desktop for future logins only if you want the Desktop VM to start when your user session starts:

systemctl --user enable docker-desktop

Switch Docker Contexts

Docker Desktop creates a separate desktop-linux context. Containers, images, and volumes from Docker Engine under /var/lib/docker do not automatically appear inside Docker Desktop’s VM-backed environment.

docker context ls

NAME              DESCRIPTION                               DOCKER ENDPOINT
default           Current DOCKER_HOST based configuration   unix:///var/run/docker.sock
desktop-linux *   Docker Desktop                            unix:///home/user/.docker/desktop/docker.sock

Use the Engine context for the normal Linux Mint Docker service:

docker context use default

Use the Desktop context for containers running in Docker Desktop’s VM:

docker context use desktop-linux

Use Docker and Compose on Linux Mint

Run a Local Test Container

Bind development containers to loopback unless you deliberately want LAN access. This Nginx test publishes the container only on 127.0.0.1 and gives the web server a moment to start before probing it:

docker run -d --name mint-nginx -p 127.0.0.1:18080:80 nginx:alpine
sleep 2
curl --noproxy '*' -fsSI http://127.0.0.1:18080 | sed -n '1p'

HTTP/1.1 200 OK

Remove the test container after the local check:

docker rm -f mint-nginx

Create a Small Docker Compose Project

Use the Compose plugin with a small project directory. The service still binds to localhost so the test is private to the Mint workstation:

mkdir -p ~/docker-mint-nginx
cd ~/docker-mint-nginx || exit

cat > compose.yaml <<'YAML'
services:
  web:
    image: nginx:alpine
    ports:
      - "127.0.0.1:18080:80"
YAML

docker compose up -d
sleep 2
curl --noproxy '*' -fsSI http://127.0.0.1:18080 | sed -n '1p'

HTTP/1.1 200 OK

Stop the Compose stack and remove its test network when finished:

docker compose down --volumes

Update or Remove Docker on Linux Mint

Update Docker Engine Packages

Docker Engine updates through APT after the repository is configured. Upgrade Docker’s package set with the rest of the system, or target the installed Docker packages directly:

sudo apt update
sudo apt install --only-upgrade docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Update Docker Desktop

Docker Desktop does not update through the Docker APT repository. Reuse the helper whenever Docker announces a new Desktop release or when the Desktop UI reports that an update is available:

update-docker-desktop

Remove Docker Desktop

Stop the user service, remove the Desktop package, and remove the updater helper if you no longer want local Desktop updates. Docker’s package scripts remove package-owned desktop files, the user service file, the AppArmor profile when present, and package-created symlinks.

systemctl --user stop docker-desktop 2>/dev/null || true
sudo apt remove docker-desktop
helper_path=/usr/local/bin/update-docker-desktop

if [ -e "$helper_path" ]; then
  if sudo grep -q '^# Managed Docker Desktop updater for Linux Mint$' "$helper_path" 2>/dev/null; then
    sudo rm -f "$helper_path"
  else
    printf 'Skipped unmarked helper path: %s\n' "$helper_path" >&2
  fi
fi

Docker Desktop also adds kubernetes.docker.internal to /etc/hosts during installation. Inspect the entry before changing the hosts file:

grep -n 'kubernetes.docker.internal' /etc/hosts || true

Remove only the exact Docker Desktop localhost entry if you do not use it elsewhere:

sudo cp -a /etc/hosts /etc/hosts.before-docker-desktop-cleanup
sudo sed -i '/^[[:space:]]*127\.0\.0\.1[[:space:]]\+kubernetes\.docker\.internal[[:space:]]*$/d' /etc/hosts

Desktop data cleanup deletes Docker Desktop’s VM-backed images, containers, volumes, and settings for your user account. Back up anything important from Docker Desktop before removing profile data.

Verify the Desktop profile path before deleting it. No output means that account has no matching Desktop data directory:

find "$HOME/.docker/desktop" -maxdepth 0 -print 2>/dev/null

Remove the Desktop profile only when you accept losing Desktop’s local VM data:

rm -rf "$HOME/.docker/desktop"

Removing Docker Desktop does not remove Docker Engine packages or Engine data under /var/lib/docker.

Remove Docker Engine Packages

Stop running containers before removing Docker Engine packages. Replace container_name_or_id with each container you want to stop:

docker ps
docker stop container_name_or_id

Remove Docker Engine, the Docker CLI, containerd, Compose, Buildx, and rootless extras:

sudo apt purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

Preview orphaned dependencies before removing them. Run the real autoremove only if the preview contains packages you no longer need:

sudo apt autoremove --dry-run
sudo apt autoremove

Remove Docker’s repository and signing key if no remaining package on the system should update from Docker’s APT source:

sudo rm -f /etc/apt/sources.list.d/docker.sources
sudo rm -f /etc/apt/sources.list.d/docker.list
sudo rm -f /etc/apt/keyrings/docker.asc
sudo rm -f /usr/share/keyrings/docker.gpg
sudo apt update

Confirm that Docker’s Engine packages are no longer installed:

dpkg-query -W -f='${db:Status-Abbrev} ${binary:Package}\n' \
  docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras \
  2>/dev/null || true

Delete Docker Engine Data

Engine data cleanup permanently removes Docker images, containers, volumes, networks, and daemon configuration. Back up important container data, bind-mounted project files, and Compose volumes before deleting Docker directories.

Remove Docker Engine data and daemon configuration:

sudo rm -rf /var/lib/docker
sudo rm -rf /etc/docker

Remove containerd data only after confirming no installed containerd package still owns that runtime state:

if ! dpkg-query -W -f='${db:Status-Abbrev} ${binary:Package}\n' containerd.io containerd 2>/dev/null | grep -Eq '^ii .*containerd'; then
  sudo rm -rf /var/lib/containerd
fi

Troubleshoot Docker on Linux Mint

APT Uses a Mint Codename Instead of noble or jammy

Repository 404 errors or missing docker-ce candidates usually mean the source file contains a Mint codename instead of the Ubuntu base suite. Inspect the Docker source file:

grep -R "download.docker.com/linux/ubuntu" /etc/apt/sources.list.d /etc/apt/sources.list 2>/dev/null
grep -R "^Suites:" /etc/apt/sources.list.d/docker.sources 2>/dev/null

Suites: zena

Replace the source file by repeating the repository setup section, then refresh package metadata and confirm the Docker candidate again:

sudo apt update
apt-cache policy docker-ce

Docker Daemon Is Not Running

A connection error from the Docker CLI can mean the Engine service is stopped, failed, or blocked by a lower-level containerd issue. Check the service before reinstalling packages:

systemctl status docker.service --no-pager
systemctl status containerd.service --no-pager

Start both services and retest the daemon:

sudo systemctl enable --now docker.service containerd.service
sudo docker run --rm hello-world

Use recent logs when the service still fails:

journalctl -u docker.service -n 80 --no-pager

Permission Denied on docker.sock

A socket permission error after installation usually means the current shell has not picked up docker group membership yet. Check your groups and the socket owner:

groups "$USER"
ls -l /var/run/docker.sock

srw-rw---- 1 root docker 0 May 27 10:00 /var/run/docker.sock

Add your user to the group if needed, then open a new login session or use newgrp docker for the current terminal:

sudo usermod -aG docker "$USER"
newgrp docker
docker ps

Docker Desktop Download or Checksum Fails

The Desktop helper uses curl to download both the DEB and Docker’s checksum file. If the helper stops before the APT install step, test the download endpoint directly and separate DNS, TLS, and HTTP errors with the curl command guide when needed:

curl -fLI https://desktop.docker.com/linux/main/amd64/docker-desktop-amd64.deb
curl -fLI https://desktop.docker.com/linux/main/amd64/checksums.txt

Retry update-docker-desktop after network access succeeds. Do not bypass the checksum check; a mismatch means the downloaded file and Docker’s published checksum file do not agree.

Docker Desktop Cannot Start Because KVM Is Missing

Docker Desktop needs KVM. If the app opens briefly, hangs, or reports virtualization errors, check virtualization, KVM device permissions, and the user service:

grep -Ec '(vmx|svm)' /proc/cpuinfo
ls -l /dev/kvm
systemctl --user status docker-desktop --no-pager

Enable virtualization in firmware, enable nested virtualization if Mint is running inside another hypervisor, add your user to the kvm group when required, then log out and back in.

Docker Desktop Launcher or Icon Is Missing

The current Docker Desktop DEB installs a desktop entry under /usr/share/applications and points the icon directly at the package-owned PNG under /opt/docker-desktop. Check those paths before creating any manual launcher or icon workaround:

desktop_file=/usr/share/applications/docker-desktop.desktop
grep -E '^(Name|Exec|Icon)=' "$desktop_file"
test -x /opt/docker-desktop/bin/docker-desktop
test -f /opt/docker-desktop/share/icon.original.png

Name=Docker Desktop
Exec=/opt/docker-desktop/bin/docker-desktop
Icon=/opt/docker-desktop/share/icon.original.png

Reinstall Docker Desktop with update-docker-desktop if a package-owned launcher or icon file is missing.

Published Container Ports Do Not Match Firewall Expectations

Docker manages packet-filtering rules for published container ports, so local firewall tools such as UFW are not the only control plane. Check how a container is published before assuming a firewall rule protects it:

docker ps --format "table {{.Names}}\t{{.Ports}}"

NAMES        PORTS
mint-nginx   127.0.0.1:18080->80/tcp

Use localhost bindings such as 127.0.0.1:18080:80 for private development services. For LAN or internet-facing containers, plan Docker port publishing and firewall policy together instead of relying on a generic deny rule.

Conclusion

Docker Engine is ready on Linux Mint after the Ubuntu-base repository, service state, Compose plugin, and user access are verified. Docker Desktop can sit beside it on Mint 22.x amd64 when the KVM and desktop requirements are met, with update-docker-desktop handling repeat downloads, checksum verification, package updates, and launcher-path checks.