Running Firefox Nightly in a container

Published on February 1, 2026

This post explains how to run GUI applications in containers, using Firefox Nightly as an example.

Recent trends in web browsers

My primary browser on desktop these days is Waterfox, installed via Flathub, and it also has an Android app. I like that these have AI-related features disabled by default. Perhaps I’m just an old-fashioned person who can’t keep up with human progress, but for now, I still can’t bring myself to like the situation where AI features are being shoehorned into everything.

Ladybird is another interesting candidate worth mentioning, but as it’s in a pre-alpha state, it doesn’t seem suitable for everyday use yet.

If you’d like to try Ladybird, there is an instruction for running it with Flatpak. You can explore it with just a few commands as shown below.

1
git clone --depth=1 https://github.com/LadybirdBrowser/ladybird.git
2
cd ladybird
3
flatpak-builder \
4
    --user \
5
    --force-clean \
6
    --install-deps-from=flathub \
7
    --ccache \
8
    --repo=Build/repo \
9
    --install Build/flatpak \
10
    Meta/CMake/flatpak/org.ladybird.Ladybird.json
11
flatpak run \
12
    --env=SSL_CERT_FILE=/etc/ssl/cert.pem \
13
    org.ladybird.Ladybird

In the codebase at the time of writing, I initially encountered an SSL verification error in my environment, so I resolved it by setting the SSL_CERT_FILE environment variable as above.

Screenshot of Ladybird

from Bear Discovery feed

There is an image format called JPEG XL. After Chromium dropped support for it, they recently re-added it, whereas Waterfox already supports it. Looking at the support matrix (Can I use…), among widely used browsers, it seems that only Safari currently supports JPEG XL. Before building this blog, I decided to check whether the image format displays correctly in Firefox.

Back in 2023, there was an announcement that an APT repository providing Firefox Nightly had been set up. And just a few weeks ago, there was a post stating that packages for RPM-based systems had also been provided. However, as expected, it hasn’t been packaged for the musl-based Void Linux I use. Building the browser locally seemed a bit of a hassle, so I decided to run it in a container instead. I’ll explain the steps in the next section.

Run a graphical browser with sound using podman

Prerequisites

The following assumes that Podman is used for container management and that the podman-compose command is available.

1
podman compose version

podman-compose version 1.5.0
podman version 5.7.1

As this assumes the use of a Wayland compositor, the environment variables XDG_RUNTIME_DIR and WAYLAND_DISPLAY must be set as shown below. The output may differ from the example.

1
printf '%s\n' ${XDG_RUNTIME_DIR:?} ${WAYLAND_DISPLAY:?}

/run/user/1000
wayland-1

For audio output, ensure that files $XDG_RUNTIME_DIR/pulse/native and $XDG_CONFIG_HOME/pulse/cookie are present. These can be created by pipewire-pulse.

Files

Create an empty directory and save the following content as Containerfile.

1
FROM docker.io/debian:trixie-slim
2

3
ARG MOZILLA_KEY_PATH=/etc/apt/keyrings/mozilla.asc
4
ARG MOZILLA_KEY_DIGEST=sha256:3ecc63922b7795eb23fdc449ff9396f9114cb3cf186d6f5b53ad4cc3ebfbb11f
5

6
ADD \
7
	--checksum=${MOZILLA_KEY_DIGEST:?} \
8
	--chmod=644 \
9
	https://packages.mozilla.org/apt/repo-signing-key.gpg \
10
	${MOZILLA_KEY_PATH:?}
11

12
COPY \
13
	<<-EOF /etc/apt/sources.list.d/mozilla.sources
14
	Types: deb
15
	URIs: http://packages.mozilla.org/apt
16
	Suites: mozilla
17
	Components: main
18
	Signed-By: ${MOZILLA_KEY_PATH:?}
19
EOF
20

21
RUN \
22
	--mount=type=cache,sharing=locked,target=/var/cache/apt \
23
	--mount=type=cache,sharing=locked,target=/var/lib/apt \
24
	set -eux; \
25
	mv -v /etc/apt/apt.conf.d/docker-clean /tmp/; \
26
	apt-get update; \
27
	apt-get -y satisfy --no-install-recommends \
28
		firefox-nightly \
29
		libpulse0 \
30
		; \
31
	mv -v /tmp/docker-clean /etc/apt/apt.conf.d/; \
32
	:
33

34
ENTRYPOINT ["firefox-nightly"]

In the same directory, save the following as compose.yaml.

1
---
2
# yaml-language-server: $schema=https://raw.githubusercontent.com/compose-spec/compose-spec/refs/heads/main/schema/compose-spec.json
3

4
x-vars:
5
  environment:
6
  - &env-wayland-display null
7
  - &env-xdg-runtime-dir /tmp
8
  volumes:
9
  - &volume-user-config-mozilla
10
    source: user-config-mozilla
11
    target: /root/.config/mozilla
12
    type: volume
13
  - &bind-pulse-cookie
14
    read_only: true
15
    source: ${XDG_CONFIG_HOME:-~/.config}/pulse/cookie
16
    target: /root/.config/pulse/cookie
17
    type: bind
18
  - &bind-pulse-socket
19
    read_only: true
20
    source: ${XDG_RUNTIME_DIR:?}/pulse/native
21
    target: /tmp/pulse/native
22
    type: bind
23
  - &bind-wayland-socket
24
    read_only: true
25
    source: ${XDG_RUNTIME_DIR:?}/${WAYLAND_DISPLAY:?}
26
    target: /tmp/${WAYLAND_DISPLAY:?}
27
    type: bind
28

29
services:
30

31
  firefox-nightly:
32
    build:
33
      context: .
34
      dockerfile: Containerfile
35
    environment:
36
      WAYLAND_DISPLAY: *env-wayland-display
37
      XDG_RUNTIME_DIR: *env-xdg-runtime-dir
38
    volumes:
39
    - *volume-user-config-mozilla
40
    - *bind-pulse-cookie
41
    - *bind-pulse-socket
42
    - *bind-wayland-socket
43

44
volumes:
45
  user-config-mozilla: null

Play around with it

In the directory containing the two files, running the following command will open a browser.

1
podman compose run --rm firefox-nightly

When you open Firefox Labs, you should find a checkbox to enable JPEG XL.

Screenshot of Firefox Labs configuration page

Enable the above settings and visit JPEG XL Test Page, and you should see JPEG XL being rendered.

Since we’ve also set up the audio, you should be able to play your favorite Taylor Swift music clip with sound.

Practical example

As a practical example, I’ve created an example project for using the container to develop an Astro site.

Clone the repository and launch the containers.

1
git clone https://github.com/mocknen/blog-resource.git
2
cd blog-resource/posts/running-firefox-nightly-in-a-container/example-project
3
podman compose up

The example webpage on http://node:4321/ will open in the browser inside the container. Once Astro’s development server starts up, reload the page to view it.

Astro supports hot reloading, so you can see changes in real time by editing index.astro.

You can also access it from your host environment’s browser using the following command.

1
(port=$(podman compose port node 4321) && xdg-open http://localhost:${port:?})

After the experiment is finished, delete them as follows.

1
podman compose down -v

Wrap-up

By default, utilities run in containers cannot access the host’s display. However, as explained in this post, you can handle not only CLI tools but also GUI ones with just a little configuration.

While containers have limitations, once you create an image, it becomes easier to secure a reproducible environment isolated from the host system. This point may find value in web developments where rendering results can vary depending on browser type and version.

Compared to system containers or virtual machines, application containers are lightweight, and I like how easy it is to create them and instantly discard after use.