[Feature] Try integrating xsettings into baseimage to have live DPI updates for applications

[thib-d]

Is this a new feature request?

• I have searched the existing issues

Wanted change

Context
Currently, when we want to change the zoom level / DPI inside the container, the only way that works reliably is to restart the container with a different scaling factor.

This is a bit heavy !

What I tried
1. Using gsettings at runtime:

dpi=178
dpi_scaled=$((dpi * 1024))
gsettings set org.gnome.settings-daemon.plugins.xsettings overrides "{'Gtk/Xft/DPI': <${dpi_scaled}>}"

But in the container I get:

No such schema “org.gnome.settings-daemon.plugins.xsettings”
(Docker...)

2.	Using Firefox’s remote debugging protocol:

firefox --no-remote --profile /tmp/test --remote-debugging-port=9222
then connect via http://127.0.0.1:9222/json

With this approach we could modify layout.css.devPixelsPerPx, but it’s a hack compared to having native DPI/zoom support via gsettings.

Expected behavior
It should be possible to adjust zoom or DPI scaling at runtime, without restarting the container.

Reason for change

It should be possible to adjust zoom or DPI scaling at runtime, without restarting the container.

Proposed code change

No response

[thelamer]

So first off you do not need to restart the container:

2025-08-16_09-22-02.mp4

This is just linux apps don't absorb the dpi change live unless they have some overarching compositor that can hot reload (like KDE)

Secondly this is a persistent setting that is stored in /config/.Xresources and as it is in the users home directory it is persistent.

Many ways to skin this cat if you are looking to automate it for newly spun up containers the easiest is to just have an .Xresources file in the mount point you use for /config 200% is Xft.dpi: 192

[thib-d]

Alright, so it’s true that we don’t have to restart the container itself, only Firefox. But still, that’s quite limiting.

The .Xresources approach works, but as far as I know Firefox only reads it at startup, once Firefox is running, it doesn’t reload those settings dynamically. What I’m looking for is a way to change DPI or zoom without restarting Firefox.

That’s why I mentioned alternatives like gsettings or using Firefox’s layout.css.devPixelsPerPx (via remote debugging). Ideally, there should be a way to adjust scaling live instead of relying on startup-only configs.

[thib-d]

It should be possible via gsetting: https://bugzilla.mozilla.org/show_bug.cgi?id=1235941 with notify::gtk-xft-dpi

[thelamer]

This remote desktop protocol is universal and wraps 100s of apps and Desktop environments.
Here is the specific logic:
https://github.com/selkies-project/selkies/blob/main/src/selkies/selkies.py#L584-L645

You are saying it is limiting but just in general that is Linux, universal app scaling is not flushed out for Linux and it certainly is not a consideration for Openbox which is the DE we are using for single app containers.

If you find it limiting use a webtop:

https://github.com/linuxserver/docker-webtop

Head XFCE in Alpine scales instantly, but then you need to go in and swap to a hiDPI theme and such. There is no silver bullet, and if you find it feel free to participate.

2025-08-16_09-58-24.mp4

[thib-d]

Thanks a lot for the detailed explanation and the example video.

I also wanted to mention that the phrase “remote desktop protocol” in the reply was a bit confusing at first , I initially thought of Microsoft RDP, but I understand now that you meant the container’s desktop/streaming stack in general.

I see why this repo is based on Openbox, it keeps things lightweight and fast. For my personal use case and for firefox app though I think XFCE with hot-reload of DPI might be more suitable, but that’s really just a matter of preference.

Given your explanation, I think this issue can be closed :)
Thx @thelamer

[thib-d]

I managed to create a quick POC using docker-firefox (Openbox) that allows changing the DPI without restarting. Here’s a short demo:

`
async def _run_xrdb(dpi_value, logger):
"""Helper function to apply DPI via xrdb."""
if not which("xrdb"):
logger.debug("xrdb not found. Skipping Xresources DPI setting.")
return False

xresources_path_str = os.path.expanduser("~/.Xresources")
try:
    with open(xresources_path_str, "w") as f:
        f.write(f"Xft.dpi:   {dpi_value}\n")
    logger.info(f"Wrote 'Xft.dpi:   {dpi_value}' to {xresources_path_str}.")

    cmd_xrdb = ["xrdb", xresources_path_str]
    process = await subprocess.create_subprocess_exec(
        *cmd_xrdb,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE
    )
    stdout, stderr = await process.communicate()
    if process.returncode == 0:
        logger.info(f"Successfully loaded {xresources_path_str} using xrdb.")
        XSETTINGS_PATH = "/config/.xsettingsd"
        dpi_value = int(dpi_value) * 1024  # GTK attend DPI × 1024


        # Construire le contenu complet du fichier
        new_content = f"""Xft/DPI {dpi_value}
        Xft/Antialias 1
        Xft/Hinting 1
        Xft/HintStyle "hintslight"
        Xft/RGBA "rgb"
        """

        # Écrire le fichier (overwrite complet)
        with open(XSETTINGS_PATH, "w") as f:
            f.write(new_content)


        logging.info(f"Reloading xsettingsd with new DPI {dpi_value} (raw value {dpi_value})")
        try:
            os.system("xsettingsd &") #need to install with apt xsettingsd
            logging.info("Successfully reloaded xsettingsd with new DPI settings.")
            return True
        except Exception as e:
            logging.error(f"Error reloading xsettingsd: {e}")
            return False
    else:
        logger.warning(f"Failed to load {xresources_path_str} using xrdb. RC: {process.returncode}, Error: {stderr.decode().strip()}")
        return False
except Exception as e:
    logger.error(f"Error updating or loading Xresources: {e}")
    return False`

[github-actions]

Thanks for opening your first issue here! Be sure to follow the relevant issue templates, or risk having this issue marked as invalid.