feat(docker): default dev container to Ubuntu 24.04, keep 22.04 selectable

The Util/Docker dev environment isolates the CARLA UE5 toolchain (CMake,
ninja, clang, Python, libtiff, libpng, glibc shims, UE5 prerequisites)
from whatever the host happens to have installed. That isolation gives
contributors three things that matter in practice:

1. Host independence: building CARLA does not require uninstalling or
   shadowing the system Python, system CMake, or other versions a host
   distro and other projects already rely on.
2. Reproducibility: a build or test failure inside the image reproduces
   bit-for-bit on a different machine by rebuilding the same image,
   instead of turning into a per-host investigation of CMake versions
   and LD_LIBRARY_PATH state.
3. Stable compilation across many computers: the recipe travels
   unchanged across Ubuntu 22.04, Ubuntu 24.04, Fedora, Pop_OS, etc.,
   which keeps "works on my machine" from becoming a per-developer
   scavenger hunt.

PR #9596 added host-side Ubuntu 24.04 build support (the
__isoc23_strtol glibc shim, the libtiff5-dev to libtiff-dev swap, and
the PEP 668 pip handling) but deferred the Docker side. This PR closes
the developer-facing half of that gap so a contributor on a 24.04 host
no longer gets a 22.04 image whose Base.Dockerfile fails on a missing
libtiff5-dev package.

Layout

* The two Dockerfiles that the helper scripts actually invoke are
  reorganised into a per-distro layout: Util/Docker/22.04 and
  Util/Docker/24.04, each holding a linear, conditional-free
  Base.Dockerfile and Development.Dockerfile. Util/Docker/build.sh
  resolves --ubuntu-distro to the matching subdirectory and refuses
  values with no directory; Util/Docker/run.sh defaults to the
  ue5-24.04 image and container names.
* Util/Docker/Release.Dockerfile has no caller anywhere in the repo
  (build.sh, run.sh, .github/workflows, Util/Tools/Deploy.{sh,bat},
  the CMake graph) and is left untouched. Cleaning up that orphan is
  out of scope for this PR.
* build.sh passes --build-context carla-root=<repo root> so each
  Dockerfile reads requirements.txt and PythonAPI/{examples,util}/
  requirements.txt directly via COPY --from=carla-root, replacing the
  previous .tmp staging copy.

24.04 image

* Base.Dockerfile installs libtiff-dev (the noble package name),
  upgrades pip with --ignore-installed (the dpkg-managed pip on noble
  has no RECORD file so a normal self-upgrade fails), and compiles
  Python 3.10.14 from source via Util/Docker/24.04/build_scripts/
  build_cpython.sh so the Python API can target either 3.10 or 3.12
  via -DPython_ROOT_DIR. CMake comes from apt and resolves to 3.28.3,
  which clears CARLA's current 3.27.2 minimum.
* Development.Dockerfile reuses an existing group when the host
  docker GID collides with systemd-journal at GID 999 inside the
  noble base image, instead of failing groupadd.

22.04 image

* Base.Dockerfile keeps its previous shape minus the upstream CMake
  tarball download. apt cmake on jammy is 3.22.1, below the project
  minimum, so users opting back into 22.04 must upgrade CMake
  themselves; the Dockerfile keeps a single apt install cmake line
  and the 22.04 path becomes best-effort.

Docs and CHANGELOG

* Docs/build_devcontainer.md documents the new default, adds a "Build
  for a different Ubuntu version" subsection, and updates every
  docker exec example plus the devcontainer.json snippet.
* Docs/build_linux_ue5.md no longer says "Ubuntu 22.04 at minimum",
  it lists 22.04 and 24.04 as supported and points at the Docker
  fallback for any other host.
* CHANGELOG.md gains one user-facing bullet.

Out of scope

CI workflow changes are intentionally not included. PR #9601 owns the
_ci-ubuntu.yml matrix and is blocked on the carlasim/carla-builder
image being available, which this PR produces locally so the same
recipe can be published.

Validated on Ubuntu 24.04 (RTX 50, driver 590.48): carla-base and
carla-development images build clean, libcarla_test_server 44/44 and
libcarla_test_client 58/58 pass, cmake --build Build --target package
succeeds with both Python 3.10 and Python 3.12 wheels.

Related: #9596 (host-side 24.04, merged), #9597 (umbrella issue,
"24.04 CI image" checkbox), #9601 (CI matrix, open).

Author: JArmandoAnaya

CHANGELOG.md

@@ -4,6 +4,7 @@
 * Enabled the LibCarla GoogleTest suite (server + client) on ue5-dev and gated both in CI.
 * Fixed Digital Twin Tool crashes on dense metropolitan OSM data, vegetation spawning inside driving lanes on rural maps, and one-way streets being silently excluded from generation (#9565, #9678)
 * Added Ubuntu 24.04 support alongside Ubuntu 22.04
+* Docker dev environment now defaults to Ubuntu 24.04 and ships a per-distro Dockerfile layout under `Util/Docker/22.04/` and `Util/Docker/24.04/`. The 24.04 image installs Python 3.10 from source alongside the system Python 3.12 so the CARLA Python API can target either interpreter via `-DPython_ROOT_DIR`. Use `Util/Docker/build.sh --ubuntu-distro 22.04` to opt back into the older base.
 * Added NVIDIA RTX 50 series (Blackwell) support with driver 570+ and CDI-based Docker instructions
 * Fixed compiler warnings across 20 LibCarla files including signed/unsigned conversions, pessimizing moves, deep copies in range-for loops, and C-style casts (ported from ue4-dev)
 * Fixed camera fx calculation in ROS2 CameraInfo, large map actor tagging, pedestrian bounding box using skeletal mesh bounds, and camera frame/timestamp consistency (ported from ue4-dev)

Docs/build_devcontainer.md

@@ -1,6 +1,6 @@
 # CARLA Docker Dev Environment (UE5)
 
-CARLA UE5 can be built inside a Docker container running Ubuntu 22.04. This is useful when your host OS (e.g., Ubuntu 24.04) does not meet UE5's compilation requirements. The container provides the correct toolchain and dependencies while you keep all source code on the host.
+CARLA UE5 can be built inside a Docker container running Ubuntu 24.04 (default) or Ubuntu 22.04. This is useful when your host OS does not meet UE5's compilation requirements, or when you want to validate the build on a specific Ubuntu version without changing your host. The container provides the correct toolchain and dependencies while you keep all source code on the host.
 
 ## Prerequisites
 
@@ -20,17 +20,27 @@ Util/Docker/build.sh
 
 This builds two images:
 
-1. `carla-base:ue5-22.04` — base image with all build dependencies
-2. `carla-development:ue5-22.04` — development image with user matching your host UID/GID
+1. `carla-base:ue5-24.04` — base image with all build dependencies
+2. `carla-development:ue5-24.04` — development image with user matching your host UID/GID
 
 Options:
 
 ```sh
 Util/Docker/build.sh --force-rebuild                  # Rebuild from scratch (no cache)
 Util/Docker/build.sh --user 1000:1000                 # Custom UID:GID
-Util/Docker/build.sh --ubuntu-distro 22.04            # Specify Ubuntu version (default: 22.04)
+Util/Docker/build.sh --ubuntu-distro 24.04            # Specify Ubuntu version (default: 24.04, also supports 22.04)
 ```
 
+### Build for a different Ubuntu version
+
+The default is Ubuntu 24.04. To build the image (and the matching development container) on Ubuntu 22.04 instead, pass `--ubuntu-distro`:
+
+```sh
+Util/Docker/build.sh --ubuntu-distro 22.04
+```
+
+This produces `carla-base:ue5-22.04` and `carla-development:ue5-22.04`, with a separate `carla-development-ue5-22.04` volume so the two distros never share state. You can keep both images on the same host and switch between them by passing the matching `--ubuntu-distro` flag to `run.sh`.
+
 ---
 
 ## Run the container
@@ -66,7 +76,7 @@ Both are **bind mounts** — they point directly to the directories on your host
 - **Stop and restart** the container without losing any work — source code and build artifacts live on the host.
 - **Share the same UE5 build** across multiple containers or workflows.
 
-The container itself only provides the Ubuntu 22.04 environment, toolchain, and dependencies. Your actual project data never lives inside the container.
+The container itself only provides the Ubuntu environment (24.04 by default, 22.04 if you passed `--ubuntu-distro 22.04` at build time), toolchain, and dependencies. Your actual project data never lives inside the container.
 
 Use `--rebuild` to rebuild the image before running:
 
@@ -146,28 +156,28 @@ cmake --build Build --target package
 
 ## Running commands from additional terminals
 
-While the container is running, you can execute commands inside it from any terminal on the host using `docker exec`. The container name is `carla-development-ue5-22.04`.
+While the container is running, you can execute commands inside it from any terminal on the host using `docker exec`. The container name follows the pattern `carla-development-ue5-${UBUNTU_DISTRO}`, so the default 24.04 build is named `carla-development-ue5-24.04`. If you launched with `--ubuntu-distro 22.04`, swap the suffix in every example below to `22.04`.
 
 **Open an interactive shell** in the running container:
 
 ```sh
-docker exec -it carla-development-ue5-22.04 bash
+docker exec -it carla-development-ue5-24.04 bash
 ```
 
 **Run a single command** without entering the container:
 
 ```sh
 # Build the Python API from a second terminal while the editor is running
-docker exec carla-development-ue5-22.04 cmake --build Build --target carla-python-api-install
+docker exec carla-development-ue5-24.04 cmake --build Build --target carla-python-api-install
 
 # Build a package in the background
-docker exec carla-development-ue5-22.04 cmake --build Build --target package
+docker exec carla-development-ue5-24.04 cmake --build Build --target package
 
 # Run a Python example against the running simulator
-docker exec carla-development-ue5-22.04 python3 PythonAPI/examples/generate_traffic.py
+docker exec carla-development-ue5-24.04 python3 PythonAPI/examples/generate_traffic.py
 
 # Check build configuration
-docker exec carla-development-ue5-22.04 cmake --build Build --target help
+docker exec carla-development-ue5-24.04 cmake --build Build --target help
 ```
 
 This is useful for running parallel builds, launching Python scripts against a running simulator, or integrating with external tools (CI runners, editors, etc.) that need to invoke build commands inside the container.
@@ -181,9 +191,9 @@ Create `.devcontainer/devcontainer.json` in your CARLA repository:
 ```json
 {
     "name": "CARLA UE5 Dev",
-    "image": "carla-development:ue5-22.04",
+    "image": "carla-development:ue5-24.04",
 
-    "initializeCommand": "./Util/Docker/build.sh --ubuntu-distro 22.04",
+    "initializeCommand": "./Util/Docker/build.sh --ubuntu-distro 24.04",
 
     "updateRemoteUserUID": false,
 
@@ -201,19 +211,21 @@ Create `.devcontainer/devcontainer.json` in your CARLA repository:
     "runArgs": [
       "--rm",
       "--runtime", "nvidia",
-      "--name", "carla-ue5-development-22.04",
+      "--name", "carla-ue5-development-24.04",
       "--env", "NVIDIA_VISIBLE_DEVICES=all",
       "--env", "NVIDIA_DRIVER_CAPABILITIES=all",
       "--env", "CARLA_UNREAL_ENGINE_PATH=/workspaces/unreal-engine",
       "--env", "DISPLAY=${localEnv:DISPLAY}",
       "--volume", "/tmp/.X11-unix:/tmp/.X11-unix",
       "--volume", "${localEnv:CARLA_UNREAL_ENGINE_PATH}:/workspaces/unreal-engine",
-      "--mount", "source=carla-development-ue5-22.04,target=/home/carla",
+      "--mount", "source=carla-development-ue5-24.04,target=/home/carla",
       "--gpus", "all"
     ]
 }
 ```
 
+To target Ubuntu 22.04 instead, replace every `24.04` suffix above with `22.04` (image tag, container name, mount source) and pass `--ubuntu-distro 22.04` in `initializeCommand`.
+
 ---
 
 ## Tips & Known Issues

Docs/build_linux_ue5.md

@@ -1,10 +1,10 @@
 # Building CARLA in Linux with Unreal Engine 5.5
 
 !!! note
-    The Unreal Engine 5 version of CARLA requires Ubuntu version 22.04 at minimum. It has not been configured to build on older Ubuntu versions.
+    The Unreal Engine 5 version of CARLA supports Ubuntu 22.04 and Ubuntu 24.04. Older Ubuntu versions are not configured to build.
 
 !!! note
-    If you are using a different Ubuntu version (e.g., 24.04) and experiencing compilation issues, you can use the Docker-based development environment to build CARLA inside an Ubuntu 22.04 container. See [CARLA Docker Dev Environment (UE5)](build_devcontainer.md) for instructions.
+    If your host OS does not match either supported Ubuntu version (or you want to validate against a specific one without changing your host), use the Docker-based development environment. The `Util/Docker/build.sh` script defaults to Ubuntu 24.04 and accepts `--ubuntu-distro 22.04` to build the older variant. See [CARLA Docker Dev Environment (UE5)](build_devcontainer.md) for instructions.
 
 * __[Set up the environment](#set-up-the-environment)__  
 * __[Build and run CARLA UE5](#build-and-run-carla-ue5)__  

Util/Docker/Base.Dockerfile Util/Docker/22.04/Base.DockerfileUtil/Docker/Base.Dockerfile renamed to Util/Docker/22.04/Base.Dockerfile

@@ -1,8 +1,4 @@
-ARG UBUNTU_DISTRO="22.04"
-
-FROM ubuntu:${UBUNTU_DISTRO}
-
-ARG UBUNTU_DISTRO
+FROM ubuntu:22.04
 
 # Disable interactive prompts during package installation.
 ENV DEBIAN_FRONTEND=noninteractive
@@ -20,7 +16,7 @@ RUN apt-get update && \
 ENV LANG=en_US.UTF-8
 ENV LC_ALL=en_US.UTF-8
 
-COPY .tmp/requirements.txt /tmp/requirements.txt
+COPY --from=carla-root requirements.txt /tmp/requirements.txt
 
 # ---------------------------
 # Install CARLA prerequisites
@@ -31,10 +27,11 @@ USER root
 # Core build tools and UE5-specific dependencies:
 # - build-essential make ninja-build: core compilation tools
 # - libvulkan1: Vulkan runtime needed by Unreal Engine for rendering
-# - python3 python3-dev python3-pip python-is-python3: Python runtime, headers, package manager
+# - python3 python3-dev python3-pip python-is-python3: system Python (3.10 on jammy), headers, pip
 # - autoconf libtool: required for building dependencies from source
 # - wget curl rsync unzip git git-lfs: essential CLI tools used in CARLA build scripts
-# - libpng-dev libtiff5-dev libjpeg-dev: image libraries for CARLA's Python API
+# - libpng-dev libtiff-dev libjpeg-dev: image libraries for CARLA's Python API
+#   (libtiff-dev on 22.04 is a transitional metapackage that pulls libtiff5-dev)
 # - tzdata sed libxml2-dev: build utilities
 # - libnss3-dev libatk-bridge2.0-dev libxkbcommon-dev libgbm-dev: required by UE5 editor
 # - libpango1.0-dev libasound2-dev: display and audio support for UE5
@@ -57,7 +54,7 @@ RUN apt-get update && \
         git \
         git-lfs \
         libpng-dev \
-        libtiff5-dev \
+        libtiff-dev \
         libjpeg-dev \
         tzdata \
         sed \
@@ -73,13 +70,12 @@ RUN apt-get update && \
 # Enable git lfs
 RUN git lfs install
 
-# Minimum required version is 3.28.0.
-# Install a newer version manually, as Ubuntu 22.04 includes an outdated CMake from the upstream repository.
-RUN curl -L -O https://github.com/Kitware/CMake/releases/download/v3.28.3/cmake-3.28.3-linux-x86_64.tar.gz \
-    && mkdir -p /opt \
-    && tar -xzf cmake-3.28.3-linux-x86_64.tar.gz -C /opt \
-    && rm -rf cmake-3.28.3-linux-x86_64.tar.gz
-ENV PATH=/opt/cmake-3.28.3-linux-x86_64/bin:$PATH
+# Install CMake from the distro's apt repository. Ubuntu 22.04 ships CMake 3.22.1,
+# which is below CARLA's current minimum (3.27.2), so users on 22.04 may need to
+# upgrade CMake out-of-band before running `cmake` against this repo.
+RUN apt-get update \
+    && apt-get install -y cmake \
+    && rm -rf /var/lib/apt/lists/*
 
 # SDL2 libraries:
 # Required for Unreal Engine to interact with the display.
@@ -91,10 +87,6 @@ RUN packages='libsdl2-dev libsdl2-2.0' \
 # -------------------
 # Install pip packages
 # -------------------
-# Allow pip to install packages system-wide (required on Ubuntu 22.04 due to PEP 668).
-RUN echo '[global]' > /etc/pip.conf && \
-    echo 'break-system-packages = true' >> /etc/pip.conf
-
 RUN python3 -m pip install --upgrade pip \
     && python3 -m pip install -r /tmp/requirements.txt \
     && rm /tmp/requirements.txt

Util/Docker/Development.Dockerfile Util/Docker/22.04/Development.DockerfileUtil/Docker/Development.Dockerfile renamed to Util/Docker/22.04/Development.Dockerfile

@@ -1,8 +1,4 @@
-ARG UBUNTU_DISTRO="22.04"
-
-FROM carla-base:ue5-${UBUNTU_DISTRO}
-
-ARG UBUNTU_DISTRO
+FROM carla-base:ue5-22.04
 
 ARG UID="1000"
 ARG GID="1000"
@@ -31,27 +27,22 @@ RUN packages="vulkan-tools fontconfig xdg-user-dirs" && \
 ENV XDG_RUNTIME_DIR=/run/user/${UID}
 
 # Install runtime python libraries (to run examples and utils)
-COPY .tmp/examples_requirements.txt /tmp/examples_requirements.txt
-COPY .tmp/util_requirements.txt /tmp/util_requirements.txt
+COPY --from=carla-root PythonAPI/examples/requirements.txt /tmp/examples_requirements.txt
+COPY --from=carla-root PythonAPI/util/requirements.txt /tmp/util_requirements.txt
 
 RUN python3 -m pip install -r /tmp/examples_requirements.txt \
     && python3 -m pip install -r /tmp/util_requirements.txt \
     && rm /tmp/examples_requirements.txt /tmp/util_requirements.txt
 
-# Starting with Ubuntu 23.04, official Docker images include a default `ubuntu` user with UID 1000.
-# This can cause conflicts when remapping the container's UID/GID to match the host user.
-RUN id -u ${UID} &>/dev/null \
-    && userdel -r $(getent passwd ${UID} | cut -d: -f1) \
-    || echo ""
-
 # Create a dedicated non-root user and group to limit root access.
 # Add the user to the sudoers group and configure it password-less.
 RUN groupadd --gid ${GID} ${USERNAME} \
     && useradd -m --uid ${UID} -g ${USERNAME} ${USERNAME} \
     && passwd -d ${USERNAME} \
     && usermod -a -G sudo ${USERNAME}
 
-# Add the carla user to the docker group to allow running Docker commands without sudo when bind-mounting the Docker socket.
+# Add the carla user to the docker group to allow running Docker commands without sudo
+# when bind-mounting the Docker socket.
 RUN groupadd -g ${DOCKER_GID} docker \
     && usermod -a -G docker ${USERNAME}
 

Util/Docker/24.04/Base.Dockerfile

@@ -0,0 +1,131 @@
+FROM ubuntu:24.04
+
+# Disable interactive prompts during package installation.
+ENV DEBIAN_FRONTEND=noninteractive
+
+WORKDIR /
+
+# ---------------------------
+# Configure UTF-8 locale
+# ---------------------------
+# Required by CMake's archive extraction for filenames with non-ASCII characters (e.g., Boost).
+RUN apt-get update && \
+    apt-get install -y locales && \
+    locale-gen en_US.UTF-8 && \
+    rm -rf /var/lib/apt/lists/*
+ENV LANG=en_US.UTF-8
+ENV LC_ALL=en_US.UTF-8
+
+COPY --from=carla-root requirements.txt /tmp/requirements.txt
+COPY build_scripts /tmp/build_scripts
+
+# ---------------------------
+# Install CARLA prerequisites
+# ---------------------------
+# https://carla.readthedocs.io/en/latest/build_linux_ue5/
+USER root
+
+# Core build tools and UE5-specific dependencies:
+# - build-essential make ninja-build: core compilation tools
+# - libvulkan1: Vulkan runtime needed by Unreal Engine for rendering
+# - python3 python3-dev python3-pip python-is-python3: system Python (3.12 on noble), headers, pip
+# - autoconf libtool: required for building dependencies from source
+# - wget curl rsync unzip git git-lfs: essential CLI tools used in CARLA build scripts
+# - libpng-dev libtiff-dev libjpeg-dev: image libraries for CARLA's Python API
+# - tzdata sed libxml2-dev: build utilities
+# - libnss3-dev libatk-bridge2.0-dev libxkbcommon-dev libgbm-dev: required by UE5 editor
+# - libpango1.0-dev libasound2-dev: display and audio support for UE5
+RUN apt-get update && \
+    apt-get install -y \
+        build-essential \
+        make \
+        ninja-build \
+        libvulkan1 \
+        python3 \
+        python3-dev \
+        python3-pip \
+        python-is-python3 \
+        autoconf \
+        libtool \
+        wget \
+        curl \
+        rsync \
+        unzip \
+        git \
+        git-lfs \
+        libpng-dev \
+        libtiff-dev \
+        libjpeg-dev \
+        tzdata \
+        sed \
+        libxml2-dev \
+        libnss3-dev \
+        libatk-bridge2.0-dev \
+        libxkbcommon-dev \
+        libgbm-dev \
+        libpango1.0-dev \
+        libasound2-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Enable git lfs
+RUN git lfs install
+
+# Install CMake from the distro's apt repository. Ubuntu 24.04 ships CMake 3.28.3,
+# which clears CARLA's minimum (3.27.2) without any extra apt source or tarball.
+RUN apt-get update \
+    && apt-get install -y cmake \
+    && rm -rf /var/lib/apt/lists/*
+
+# SDL2 libraries:
+# Required for Unreal Engine to interact with the display.
+RUN packages='libsdl2-dev libsdl2-2.0' \
+    && apt-get update \
+    && apt-get install -y $packages \
+    && rm -rf /var/lib/apt/lists/*
+
+# -------------------
+# Install pip packages
+# -------------------
+# Allow pip to install packages system-wide (Ubuntu 24.04 ships the PEP 668 marker;
+# opt out so pip can install into the system site-packages).
+RUN echo '[global]' > /etc/pip.conf && \
+    echo 'break-system-packages = true' >> /etc/pip.conf
+
+# `--ignore-installed` is required on Ubuntu 24.04: the system-shipped pip is
+# installed via dpkg and lacks a RECORD file, so a normal pip self-upgrade fails
+# with "Cannot uninstall pip 24.0". Layering the new pip on top sidesteps the
+# uninstall step.
+RUN python3 -m pip install --upgrade --ignore-installed pip \
+    && python3 -m pip install -r /tmp/requirements.txt
+
+# ---------------------------
+# Install Python 3.10 from source (alongside system 3.12)
+# ---------------------------
+# CARLA's Python API supports building against multiple interpreters via
+# -DPython_ROOT_DIR. Ubuntu 24.04's apt only provides Python 3.12, so compile
+# 3.10 from source via `make altinstall` and install the shared CARLA
+# requirements against it. Result: /usr/local/bin/python3.10 sits alongside
+# /usr/bin/python3.12 and is selectable at configure time.
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        libbz2-dev \
+        libffi-dev \
+        libgdbm-dev \
+        libgdbm-compat-dev \
+        liblzma-dev \
+        libncurses-dev \
+        libreadline-dev \
+        libsqlite3-dev \
+        libssl-dev \
+        tk-dev \
+        uuid-dev \
+        zlib1g-dev \
+        pkg-config && \
+    bash /tmp/build_scripts/build_cpython.sh --python-version 3.10.14 && \
+    python3.10 -m pip install --upgrade --ignore-installed pip && \
+    python3.10 -m pip install -r /tmp/requirements.txt && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN rm -f /tmp/requirements.txt && rm -rf /tmp/build_scripts
+
+USER root