Features03 Images

Pull, build, update. Watch every layer.

Pull with per-layer progress, see which newer versions are out and what is in them, scan for known vulnerabilities, and bring the containers that use it along. Build, tag and push without leaving the window.

What is an image, really?Read the comic: a recipe book for every station, with new editions and a shelf that needs clearing →
Fig. — The images, with the containers that use each one, and the actions of one image.

What you can do

Pull with progress

Every layer gets its own progress bar. Docker Hub is searched while you type the name.

Platform and emulation

Every image and container shows its platform. One that is not for the machine, such as an amd64 image on an arm64 machine, runs through emulation, slowly or not at all, and is pointed out, with whether the registry has a version for the machine and a pull for exactly that platform.

Private registries

Pull with the credentials you already stored with docker login.

Newer version available

The app checks the registry: a newer image behind the same tag, and newer tags of the same kind, by patch, minor and major.

What is new

A link to the release notes next to every newer version: from the source the image names, or its tags on Docker Hub.

Ignore a version

One version, or a whole major, per image; and back again from the same menu.

To the newer tag

Update to 1.27.4 from the menu: the image line in the compose file changes along, and everything goes back if the container does not come back. A stopped project only gets the new line, and when nothing uses the old tag the app just pulls the new one. When the version you have is signed and the new one is not, the app says so first.

A smaller image

Next to the newer versions, the same version as -alpine or -slim, such as redis:8-alpine next to redis:8, without Docker Scout. On request the sizes come from Docker Hub for the platform of the machine, with what may be different (musl, fewer tools), and switching goes the way of a newer tag: the plan first, and back if it does not start.

A better base image

Docker Scout looks at the image and suggests a newer version or another variant of its base image, with fewer vulnerabilities or smaller. The dialog shows the base image, the suggested tags ready for your FROM line with what they bring, and the full report. Scout sends the list of packages to Docker, so the app asks first; it needs Docker Scout and a login to Docker.

A Hardened Image

Docker keeps free, minimal versions of the official images on dhi.io: no shell or package manager, a user without rights, and as few vulnerabilities as possible. The app proposes the one of the same version, or the nearest, from the catalog on Docker Hub, with what Docker Scout found in it next to your own Trivy scan, the user it runs as, whether it has a shell, and the dev variant to build with. Pulling needs docker login dhi.io; the app only says whether you did.

Patch the OS packages

Patch with Copacetic… builds a new tag, ending in -patched, with only the packages of the operating system that have a fix, straight from a fresh Trivy report. The image you run stays. Before and after side by side, then switch the containers over with the same rollback as a newer tag. copa comes from its GitHub release once, checked against a fixed checksum; it needs the containerd image store.

Known vulnerabilities

Scan an image, or all running ones, with Trivy. The app says once what it fetches; the window shows each step, the megabytes pulled and copied, and stops when you ask. Then a label with the critical and high findings, and the list with a filter for what has a fix. Mark a finding as not applicable or as an accepted risk, with a reason and an end date, and it stops counting. Save a scan as CSV or SARIF.

An SBOM

Save the packages in an image as CycloneDX or SPDX, for whoever asks for that list.

Provenance and signature

Straight from the registry the image came from, without a login: the provenance BuildKit attached (the repository and commit, who built it and when), whether it carries a signature (Sigstore, Notation or cosign), and the SBOM of the publisher, ready to save. Every manifest is checked against its digest. The app finds a signature; checking it is up to cosign verify or notation verify.

Bring containers along

After an update, recreate the containers still running on the old image, compose ones included, and the old image goes. An untagged image still in use says which tag it used to be.

Who uses an image

The In use column names the containers that use an image, running or stopped, each a link to its page. With more than three, a button shows the rest.

Run from an image

Start a container from an image, and pick its network and alias. For images like mysql or postgres the usual environment variables are a click away.

A Dockerfile for a folder

For a folder without a Dockerfile, the build dialog recognises Node, Python, Go, Rust, Java, .NET, PHP or a static site, and writes a Dockerfile, compose.yaml and .dockerignore the way docker init does: a cache for the dependencies, more stages where it builds, and a user without rights. You see them first, can change the version, port and command, and nothing is overwritten unless you tick it. Then the build goes on with that folder.

Build

Build an image from a folder with a Dockerfile, on the machine you are on, with the build output as it happens. When it fails: a diagnosis to copy, or a conversation with Claude about it.

Target and build arguments

For a multi-stage Dockerfile, pick the stage to build. The ARGs of the Dockerfile are listed with their defaults, ready to fill in, and you can add one it does not name, such as HTTP_PROXY. Pick the same folder next time and your choices are back, except values whose name points to a secret.

Check the Dockerfile

Before a build, BuildKit's own checks run on the Dockerfile, with each remark next to its line and a link to the documentation. The app adds one of its own: a smaller variant of the image in the last FROM, with the sizes from Docker Hub. One click shows the line as it is and as it will be, and changes only that image on that line.

Build history

Every build on the machine you are on, from docker buildx history: from the app, from compose and from the command line. Each step is a bar on one timeline, so you see what took long, what ran side by side and what came from the cache, and a step opens to its output. For a failed build, the error and the lines of the Dockerfile around it. Build arguments by name only: a value can be a secret. After a build, Time per step opens the history on that build, and a build can be removed from the history; the image stays.

Tag and push

Tag, remove a tag and push, each after a confirmation.

Layers

See what every layer of an image costs, and where the size comes from. The Files tab lists per layer what was added, changed or removed, what a later layer overwrites or removes, and a score for the part you actually see, with a filter on path. The Tree tab shows the image as it is after a layer, folder by folder, with the changes of that layer marked, and opens a file as text.

Save and load

Save an image as a file and read it back in on another machine.

Updates

Update the image, then catch up the containers.

A newer image does nothing until the containers are recreated. The app shows which containers still run the old one, also after a pull from the command line, and for a compose project it updates the whole project at once, renewing only what changed. Afterwards it checks that they really moved, and removes the image they left behind.

Newer versions

From 1.27.3 to 1.27.4, or all the way to 2.0.0.

A pinned tag such as nginx:1.27.3 never changes, so a newer image behind it never comes. The app lists the newer tags of the same kind instead, by level, and links each one to what is new. The tags come from a helper container on the machine itself, with its own network, without your login and with tight limits; its image goes again after the check.

Fig. — forgejo, gotify and postgres have a newer major; docker:29-dind has a newer image behind its tag.

Known vulnerabilities

The image you run, checked where it runs.

Trivy scans the local image, not the one in the registry, in a helper container on the machine itself. It fetches its database first; then the container leaves every network, and only then does the image go in, read by an unprivileged user that cannot change the database or send anything anywhere. Afterwards the container, its 1.4 GB database and the Trivy image go again.

Fig. — docker-socket-proxy: six high, each with the version that fixes it.

Hardened Images

The same version, with less in it.

For an official image, the app looks up the Docker Hardened Image of the same version in the catalog on Docker Hub, and puts what Docker Scout found in it next to your own Trivy scan. It also says what changes: the user it runs as, whether there is a shell or a package manager, and how long that version is supported. Pulling from dhi.io needs a free Docker account; the app only checks whether you are logged in.

Fig. — postgres:17-alpine: 1 critical and 14 high now, 1 high in the hardened image of the same version.

All features

Try it on your own daemon.
Free and open source. Windows installer, Linux AppImage, or npx on any platform.
Download for Windows
$ npx docker-client-mx