News

What we shipped, and what comes next.

Docker Client MX moves in small releases — a handful of features, a real check against a real daemon, and out the door. This is the short version of the last few. The app updates itself, so you are on the newest one already.

Current release 1.119.0 ·

1.119.0

Backups on the minute, a dashboard on one screen, and an icon that fills its tile

A backup planned for 11:00 ran at 11:29: the app looked for what was due only once an hour, counted from the moment it started. It looks every minute now. And the dashboard, which had grown to six charts under each other with the counts below the fold, fits on one screen again.

  • Scheduled backups of volumes and projects are checked every minute instead of every hour from the start of the app, so they run at the time you set. A failed attempt still waits an hour.
  • The dashboard: one row of counts (containers, images, volumes, networks, and CPU, memory and network right now), the live charts side by side under it, and one panel with a tab for CPU, Memory, Network and Disk for the history, with disk usage and Needs attention next to it.
  • A long error line on Needs attention breaks inside its card instead of pushing it wider.
  • The icon on the Windows taskbar and as the favicon fills its tile; the old one read as a small square with a lot of air around it.
Dashboard →
1.118.0

A backup or a task from its own page, and a container that updates by itself

Two things you could only get to by going somewhere else. The Backups and Schedules pages could show every schedule but not make one; now they can, in two steps. And a container that is not part of a project can be updated, now or at a fixed time, from its own menu.

  • New backup… on the Backups page and New task… on the Schedules page: pick a volume or a Compose project (on Schedules also updating at a fixed time), then the schedule dialog you know from Volumes and Compose. What already has a schedule is marked.
  • Update now and Update by itself… in the menu of a container, in the list and on its own page. Where a container cannot be updated on its own they are greyed out and say why: it is part of a project, it is a swarm task, or it is pinned to a digest.
  • A container whose tag moved, because you pulled by hand and did not recreate it, now counts as behind, and Recreate on the new image works for a container of its own.
  • The command and its copy button in the Hardened Image dialog stay together.
Backups →
1.117.0

Where an image comes from, the hardened one of the same version, and a sidebar of your own

The eighteenth round from the list of what was still open. Most of it is about images: where one was built and whether it is signed, the Docker Hardened Image of the same version with its vulnerabilities next to yours, and a Dockerfile for a folder that has none. And the sidebar is now yours to order.

  • Provenance and signature… on an image: the repository and commit it was built from, who built it and when, whether it is signed (Sigstore, Notation or cosign), and the SBOM its publisher attached, ready to save. Straight from the registry it came from, without a login.
  • Updating to a newer tag warns when the version you have is signed and the new one is not.
  • Hardened Image… on an image: the Docker Hardened Image of the same version, what Docker Scout found in it next to your own Trivy scan, the user it runs as, and whether it has a shell. Pull it once you did docker login dhi.io.
  • Make a Dockerfile… in the build dialog, for a folder without one, like docker init: a Dockerfile, compose.yaml and .dockerignore for Node, Python, Go, Rust, Java, .NET, PHP or a static site, then straight on to the build.
  • Right-click the sidebar, or open Settings, to order its pages yourself and hide the ones you do not use. A hidden page is still one Ctrl+K away.
  • Refresh on the Backups page moved into its menu.
Images →
1.116.0

Every backup and every schedule on one page, an image you can patch, and why Docker does not start

The seventeenth round from the list of what was still open, and an evening of polishing after it. Backups and schedules each get a page of their own, an image can be patched without waiting for a new release, and when Docker does not start the app says why and fixes what it recognises. Four things went the other way: Count, Timeline, Columns and SQL left the logs. They added little and filled the bar.

  • Why does Docker not start? on the dashboard and on a machine card. The app looks outside Docker, in WSL as root or over SSH, recognises a broken daemon.json, -H fd:// next to hosts, live-restore on a swarm node, a stale pid file, a taken port or a full disk, and fixes what it recognised.
  • A Backups page with every schedule of every machine, its backups, the last one and a status. Open a row to restore, pick files or remove a backup.
  • A Schedules page with everything the app does by itself, yours and its own: where, when, how the last time went and when the next one comes. Backup and update schedules can be paused.
  • Passwords from Proton Pass or 1Password: pass:// or op:// in the .env, filled in only for the command that starts the project.
  • Decide per vulnerability, not applicable or an accepted risk with a reason and an end date, and save a scan as CSV or SARIF. The scan window shows its steps and can be stopped, and the app says once what it fetches.
  • Patch with Copacetic…: a new -patched tag with the fixed packages of the operating system, before and after side by side, then switch the containers over.
  • Init steps and jobs of Compose: a failed init step by its service, with its exit code, and a button for a job.
  • A new kind of error line after an update or a restart shows up under Needs attention and in the morning report.
  • Networks show the gateway and the containers on them by name, and the networks of a swarm no longer count as unused. Clean up offers named volumes without a container, with their names.
  • Right-click a row in any table, or a project or service on Compose, for its menu. Settings in three columns, and the flag of the European Union before the name: proud to be born in Europe.
  • Count, Timeline, Columns and SQL are gone from the logs. Filtering on a field stays.
Backups →
1.115.0

The containers of WSL itself, next to Docker

Since September, WSL has a container tool of its own: wslc. It has no Docker API, so it cannot be a machine like the others yet, but it has a command line, and the app now speaks it. A WSLC page appears in the sidebar only when wslc is on your computer. Docker stays what the app is for: wslc lives on its own page, and the pages of Docker do not change.

  • Containers, images, volumes and networks of wslc in four tabs, with the state, ports, CPU and memory of every container. Start, stop, restart and remove, logs with stderr in red, inspect, and clean up what is unused.
  • Copy an image from Docker into wslc, or from wslc back into Docker, without pulling anything: the empty wslc gets the images you already have.
  • Run a container with ports, environment, volumes, a network, a command and a health check. Pull, tag, build from a folder and push images, and log in to a registry, with the progress in the task list.
  • A terminal in a container, the same one as for Docker, and measurements of CPU, memory, network and disk over a day, a week, a month or a year.
  • The page refreshes the moment something changes in wslc, and a container that stops by itself gives a notification, as with Docker.
  • The settings of wslc in a form: processors, memory, disk and storage of the session, the address of published ports, and more. A restart of the session asks first, since its containers stop.
WSL →
1.114.0

Ask your logs in SQL, and Docker Scout on a base image

The last two points from the list of what was still open. After filtering, counting and columns, the logs now answer a question in SQL. And next to the smaller -alpine or -slim the app already suggested, Docker Scout can now say what a better base image would be.

  • SQL next to Columns, on the Logs page and in the log tab of a container: a query over the lines the filter leaves, as a table logs with time, container, stream, level, message and the fields of a JSON or logfmt line, such as fields->>'status'. Four examples to start from, and the answer as a table.
  • Nothing extra to install: SQLite comes with the app. Each query runs in a process of its own that may only read, and stops after ten seconds.
  • Better base image (Docker Scout) in the menu of an image: the base image Scout recognises, the tags it suggests with what they bring, and its full report. Scout sends the list of packages of the image to Docker, so the app asks first, and Scout needs you to be logged in to Docker.
Logs →
1.113.1

No live-restore on a machine in a swarm

Found the hard way, on the home server that builds these releases. It had live-restore switched on through the daemon.json editor of the app. Docker took it on a reload, but after the next boot it refused to start: live-restore and swarm mode do not go together. The containers kept running without Docker, so nothing looked wrong until the build runner and the app could no longer reach the engine.

  • The form and the JSON editor of daemon.json know whether the machine is in a swarm. There, live-restore on is an error with the reason, and Save stays off, also for a file that already had it.
  • Restart Docker refuses as well when the file on the host turns live-restore on in a swarm, and says what to do first.
1.113.0

Fixed local domains, the fields of your logs, and backups to a registry

Five rounds from the list of what was still open, thirty points in all. Containers get a fixed address under docker.localhost, also over https. JSON and logfmt logs can be filtered, counted and laid out by field, with a timeline above them. The app suggests a smaller image and a smaller base image, understands compose profiles, and can keep your backups in a registry.

  • Fixed local domains: switch them on in Settings, and every container on this computer gets an address such as web.shop.docker.localhost, through a small Traefik helper on 127.0.0.1. No port numbers to remember. Optionally https, with a local certificate authority of its own that may only sign for docker.localhost.
  • Logs: filter on a field of a JSON or logfmt line, such as status>=500, user.id=7 or msg~timeout. Count shows the most common values of a field, Columns puts the fields you pick next to the text, and a Timeline above the logs shows the lines per period with errors and warnings in colour. A click on a value or a bar takes you there.
  • The Layers dialog has a Tree tab: the image as it is after a layer, folder by folder, with what that layer added, changed or removed, and the contents of a file.
  • A smaller image of the same version, such as redis:8-alpine next to redis:8, with its size from Docker Hub and without Docker Scout. In the build dialog, the same for the last FROM of your own Dockerfile, with one click to change that line.
  • The platform of every image and container. One that runs through emulation, such as an amd64 image on an arm64 machine, is pointed out, with a pull for the platform of the machine.
  • Compose profiles: the Compose page names the services in a profile that are not started, Profiles… chooses which ones join on Start, and stopping takes them all down. A template or a git project lets you choose them when you deploy, and its review covers them all.
  • A registry such as Harbor, GitLab or GHCR as a destination for backups: each backup a small encrypted artifact in a repository of your choice. Manual backups are in the backup log too, and the log can be cleared.
  • A volume as an image, to push with the registries you already use, and a new volume from such an image, owners and permissions kept.
  • Twelve months in the long charts, with a point per day. Trends and rules for network and disk I/O. A machine you follow gets its trends, its log rules and its long charts from its own measurements, also while you are elsewhere.
  • The catalog checks templates for changes, also without a new version number, updates a swarm stack as a stack, and puts newer or changed templates on Needs attention and in the morning message.
  • The tokens of Ctrl+K count too, each model can get a price of your own per million tokens, and a monthly budget for the AI gives one notification when it is reached.
  • Moving to another machine takes a stopped project the app knows along, and a stack that mounts a host folder on a swarm with more nodes gets a warning before it deploys.
Logs →
1.112.0

The files of every layer, a move you can cancel, and a project from a machine the app is not on

The tenth round from the list of what was still open. The layers of an image show their files and what they waste, moving to another machine can be cancelled and can start from a machine the app is not on, a stack with a folder on C: runs on an engine in WSL, and the lists open a row with Enter.

  • A Files tab in the Layers dialog: per layer what was added, changed or removed, the largest first, what a later layer overwrites or removes, and a score for the part you actually see. A filter on path works across all layers. The app reads the image itself, without writing it to disk.
  • Moving a project to another machine, and the migration wizard, can be cancelled from the task list. What was already done is rolled back, and in the wizard the rest is shown as not done.
  • Moving a project can start from a machine the app is not on, such as Docker Desktop while the app runs on WSL, when the files of the project are on this computer.
  • A stack with a folder on C:, such as ./data, now runs on a swarm whose manager is an engine in WSL: the folder becomes /mnt/c. In a swarm with more nodes, place such a service on the manager.
  • In the lists, Enter opens the row under the cursor: the detail page of a container or a service, the layers of an image, the files of a volume. Shift with an arrow marks while moving, and Shift+click marks a range.
  • After a build, Time per step opens the build history on exactly that build, also after a failed one. A build can be removed from the history; the image stays.
Images →
1.111.0

A build history with the time per step, daemon.json that puts itself back, and swarm stacks from the catalog

The ninth round from the list of what was still open, and the Docker engine settings in tabs. Builds get a history with the time of every step, a daemon.json that keeps Docker down is put back by the host itself, the catalog deploys swarm stacks, and moving to another machine can start from a machine the app is not on.

  • Build history… on the Images page lists every build of 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, with what came from the cache and the output of the step. Build arguments are shown by name only.
  • Build image… now builds on the machine the app is on. Before, it built on the current context of the docker CLI, which after a switch in the app could be another machine.
  • When Docker does not come back after a restart for daemon.json, the host puts the previous file back by itself after two and a half minutes and starts Docker again, keeping the failing one next to it. Without systemd, the app restarts Docker through its init script.
  • The Docker engine settings have three tabs: Form, JSON in colour, and Earlier versions, with a menu per version to compare, load or name it.
  • Updating now, a backup, a database dump and a vulnerability scan can be cancelled from the task list, like a build and compose up or down.
  • Portainer templates for a swarm are in the catalog now, and deploy as a stack on the swarm of a manager, with the values from the .env.
  • A template that uses your user folder or name, such as HOME, USERPROFILE or USERNAME, is pointed out, and each template of Arcane is checked against its content_hash.
  • Moving to another machine can start from a machine the app is not on, such as Docker Desktop while the app is on WSL.
  • Everything the app fetches over HTTPS, such as Gotify, a template list or a local model, trusts the certificates Windows trusts, so a server behind your own home certificate authority works.
Images →
1.110.0

Containers that move along, daemon.json as a form, and a build you can cancel

The seventh and eighth rounds from the list of what was still open. The move to another machine now takes loose containers along, a rule can watch a machine you are not on, and long tasks can be stopped halfway. The catalog keeps your projects on the newest version of their template, the AI can switch models within a conversation and counts what it used, and daemon.json can be edited as a form.

  • Moving to another machine takes containers without a compose project along: the same name, ports, environment and restart policy, their image and named volumes first, and a folder under C: becomes /mnt/c in WSL. A running one stops here and starts there; if it does not start, it starts here again.
  • A build, a rebuild of one service, and compose up or down can be cancelled from the task list. A cancelled build is not a failed one, so no diagnosis.
  • daemon.json as a form with seventeen common settings in six groups, next to the text: an empty field goes back to the default of Docker, and a field that needs a restart says so. The helper image for the check gets two minutes to arrive.
  • A rule on numbers, a log or events can be for another machine. On a machine you follow, the app checks it also while you are elsewhere, and the notification names the machine. The disk of a machine you follow gets its forecast too.
  • The Catalog page lists projects whose template has a newer version: the change in compose.yaml, only the variables your .env does not have yet, the same review as a deploy, and your values kept.
  • Save as template… can move a secret written in the compose file into the .env.example, as an empty value.
  • A template list on the internet whose name points into your own network is refused, and the connection goes only to the addresses that were checked. A list you added as your own may live at home.
  • In the AI panel, each conversation can switch to another model, also of a local server. The tokens per model of the last thirty days are counted in Settings, for Claude and a local model, without amounts.
  • The AI can pull an image as an action (ask first, by default), and a container or a project can have a rule of its own: right away, ask first or never, before the rule per kind.
  • Named log filters can hold for one machine, work on the log tab of a single container, and be shared as text to paste in elsewhere.
  • Watch with options: pick the services to follow, and if you like their logs alongside through up --watch.
  • The diagnosis of a failed build runs the Dockerfile check itself if it had not, and a failed rebuild of a compose service gets one too.
  • Restore single files from a backup file you pick yourself, and put the compose files and .env of a project backup back over the project itself, with the current ones kept aside.
Connections →
1.109.0

Rules on images and volumes, side-by-side logs in your order, and icons from labels

A sixth round from the list of what was still open. Rules learned about images, volumes and networks, and how often they may act. The side-by-side logs take your order, pinned and hidden columns, and one scrollbar lined up in time. Builds remember what you chose per folder, your own templates can be updated, older versions get a note, and the icons you gave containers for Unraid or Homepage can show in the list.

  • A rule on events can watch an image (pulled or removed), a volume or a network (created or removed), by name or any. An image without a tag matches every tag. These rules only notify.
  • A rule that restarts or stops a container says how often an hour it may do that, from 1 to 10. A higher number asks for your yes again.
  • Side by side, each column header has a menu: move it left or right, pin it to the left so it stays in view when you scroll sideways, or hide it. The order is kept per container name.
  • One scrollbar puts every line on its own row in the column of its container, in the order of the stream, so what happened at the same time sits at the same height.
  • The build dialog takes arguments the Dockerfile does not name, such as HTTP_PROXY, and remembers the Dockerfile, name, stage and arguments per folder. A value whose name points to a secret is not kept.
  • Save as template… on a project that is already a template of yours updates it: the same id, the next version.
  • A version of a compose file can get a note, and a version with a note is kept. How many versions to keep is yours to choose, from 5 to 200.
  • An older daemon.json can be compared with what is in the editor, line by line, and given a note.
  • Icons from labels, off by default: the icon from net.unraid.docker.icon or homepage.icon next to the name in Containers, fetched by the app itself over https, at most 256 KB, and only if it really is an image.
Logs →
1.108.0

Project backups to a server and back, the filters everywhere, and the CPU in the forecasts

A fifth round from the list of what was still open. A project that backs itself up can now send that backup to an SFTP server, S3 or WebDAV, and Restore project brings it back from there, with the dumps of its databases. The filters of the lists came to the ports, the logs and Ctrl+K, the forecasts learned the CPU and slower leaks, and opening a project in an editor finds the editor you actually have.

  • An automatic backup of a compose project can go to an SFTP server, an S3 bucket or WebDAV, as one file per backup, keeping the newest ones there.
  • Restore project lists the backups of its schedule, newest first, also the ones on a server. It fetches one, checks every file in it before unpacking, and restores as usual.
  • Restore project brings back the database dumps of a project backup as well: through the running database, after the copies of the volumes.
  • The automatic backups of projects are listed in Settings next to those of volumes, with Change, Back up now and Stop, also for another machine.
  • A template from the catalog that would get a volume left over from an earlier project with the same name, or a volume of another project, says so in the review and needs a tick: it would come with the data and passwords of then.
  • Several words, !word, "a phrase" and /regular expression/ on the Ports page, in both log search boxes and in Ctrl+K. An expression can contain spaces and take flags, like /time ?out/i.
  • A forecast for the CPU: a container that used at least twice as much CPU in the last day as in the six days before, and at least a quarter of a core more, is on Needs attention with a link to its statistics, and gets a notification at most once a day.
  • The hint for climbing memory also looks back a day, three days and a week, so a slow leak shows up as well. A cache that filled up and then stayed flat does not count.
  • Open in an editor finds VS Code, Cursor, VSCodium, Windsurf and VS Code Insiders, with one line per editor you have. Without one, the menu says so instead of doing nothing.
Backups →
1.107.0

Back to what ran, network and disk over thirty days, and projects from git kept to their own repository

A fourth round from the list of what was still open. A project from git can go back to the version that ran when an update does not deploy, follows a tag that moved, and only reads files from its own repository. Network and disk got the long line that CPU and memory already had, and a few smaller things fell into place.

  • Back to the version that ran: after updating a project from git, the review step offers to go back to the commit that was deployed last, also when the deploy failed. It is reviewed again before it deploys.
  • A project on a tag follows that tag when it moves to another commit. The check says so beforehand, and says when a branch was rewritten.
  • Everything the compose files of a project from git read, through include, extends, env_file, label_file, a build or compose watch, must stay inside the repository, also through a link. An include from the internet is not deployed.
  • Network (received and sent) and disk (read and written) over 24 hours, 7 days, 30 days or a span of your own, on the dashboard and for each container, next to CPU and memory.
  • The links from Traefik and Caddy also in the header of a container, with the domain, and the labels of Traefik v1 count as well.
  • A choice for automatic updates: stop only what waits with restart: true under depends_on, as compose itself does, instead of everything that waits.
  • The logos of the catalog stay under 50 MB together, and go when you remove the list that showed them.
Compose →
1.106.0

A log of every backup, thirty days of charts, and marking with the space bar

The last round from the list of what was still open, and a few things that came from using the backups every day. Every backup attempt now ends up in a log, Back up now no longer keeps a dialog waiting, and a project backup takes a dump of its databases as well. The long charts look back a month or over a span you pick, and a list can be marked from the keyboard.

  • A log of every backup attempt, behind the Log button next to the automatic backups in Settings: when, how long, which machine, where the backup went and how large it is, or why it failed or was skipped. One switch shows only the problems.
  • Back up now closes the dialog and runs in the background as a task, with a notification when it is done. It is also in the menu of each automatic backup in Settings, and a schedule of another machine can be changed right there.
  • A backup of a whole compose project also takes a dump of each database that runs behind its volumes, before the pause; by hand and on a schedule.
  • The CPU and memory charts look back 30 days as well, with a point per six hours, or over a span of your own.
  • Mark rows with the space bar, like k9s: arrows or j and k move through Containers, Images, Volumes or Networks, space marks a row, Ctrl+A marks everything, and the bulk actions work on what you marked.
  • A template from the catalog or a project from git runs every compose command in a clean environment, not only when it is reviewed: a token from your computer never reaches it.
  • From the security reviews: a change in daemon.json to who can reach Docker, or to which program it starts as root, asks for confirmation in a window of the app itself; and compose files named in a container label are only read from the project folder.
Backups →
1.105.0

A project that backs itself up, private repositories, and commands of your own

Six things from the list of what was still open. A compose project can now be backed up on a schedule like a volume, a project from git can come from a private repository, and commands of your own land on the prompt of the terminal, filled in for the container you picked. The logs learned three more shapes, a stopped container has a debug shell, and the side buttons of your mouse go back and forward.

  • Automatic backup of a whole compose project, from its menu on the Compose page: every day or every week at a fixed time, to a folder, all its volumes together with the containers paused, the compose files and the .env, encrypted with the backup password if you like. A line under the project says when, or why the last attempt failed.
  • From git… clones a private repository with a token for https or an SSH key of its own for ssh. The access is stored encrypted and only sent to that address, never in the address or in .git/config; when a token expires, you change it in the update dialog.
  • Commands of your own with placeholders such as {{ .Container.Name }}, kept in Settings. They are in the menu of every container and in Ctrl+K, and put the filled-in command on the prompt of the host terminal without Enter.
  • The logs read the numeric levels of pino and bunyan, keep a Go panic together as one item, and show a JSON object written over several lines as one formatted item.
  • A stopped container offers a debug shell on its Terminal tab, with its volumes and bind mounts read-only unless you turn that off: for the configuration file that keeps it from starting.
  • Back and forward with the side buttons of the mouse, next to the buttons in the header and Alt+← and Alt+→.
  • From the security reviews of this release: a project name taken from a container label can no longer steer a backup outside its folder, also not a backup made by hand.
Backups →
1.104.0

Windows on ARM, a pull you can cancel, and a git update that says what changed

Until now there was one Windows installer, for x64; on an ARM processor it ran through emulation. Now there is a build of its own for ARM, and it updates itself like the other one. The rest of this release is about knowing what is going on: a pull you started is no longer something you can only wait for, a git update tells you what a new commit asks that the old one did not, and the log of a container reads like the Logs page.

  • Docker-Client-MX-Setup-arm64.exe next to the installer for x64 on every release, for Windows on an ARM processor. It updates itself; the x64 version on such a machine says so in Settings, with a button to the ARM build.
  • Cancel a pull or a push from the list of tasks in the status bar, also after you closed its dialog. Docker stops the transfer, and the dialog shows it as cancelled.
  • Updating a project from git compares what the compose file asks before and after: privileged, the Docker socket, folders of the host. What a new commit adds is marked as new, and what it no longer needs is listed apart.
  • The log tab of a container formats JSON lines and folds stack traces into one item, like the Logs page, with the same switches in its View menu.
  • Moving a project to WSL on this computer can keep a folder under C:\ where it is: in WSL it is the same folder, through /mnt/c, so nothing is copied. It is the first proposal, also for a big folder.
  • Updating by itself is turned on in a dialog, also from the Compose page, where it used to switch on without asking. In Settings the list is read only, with a pencil per line.
  • A backup to a destination over http needs a backup password, and the schedule now says so, with a button to Settings. The buttons at the bottom of that dialog fit again.
  • The helper container of the host terminal runs a pinned alpine image, by its digest.
Compose →
1.103.0

Who uses an image, a day of CPU next to memory, and the terminal from a machine card

Three small things that save a detour. The Images and Volumes pages said “1 container” where you wanted to know which one; a container showed a day of memory but not of CPU, although the app measured both; and the host terminal was a page away from the machine you were looking at.

  • The In use column on Images and Volumes names the containers, running or stopped, each with a small icon and a link to its page. With more than three, two show and a button opens the rest, so an image with many old swarm tasks does not stretch its row.
  • The Stats tab of a container has a CPU chart over 24 hours or 7 days, next to the memory chart, with the same switch for both. A quiet container stays a low line instead of noise across the full height.
  • The menu on the card of the machine you are on, on the Machines page, goes straight to its host terminal.
Images →
1.102.0

A card you can clear, restarts that mean something, and a cheat sheet of Docker commands

Needs attention kept telling you what you already knew. A server that is switched off every evening came back every morning with each of its containers “restarted eleven times this week”, and the lines stayed for the whole week. Now you can clear the card, only a container that falls over counts as restarting, and a new page has the Docker commands you need most, to copy or to put straight on the prompt of the terminal.

  • Clear on Needs attention hides what is on the card now, per machine. A line only comes back once it was gone for ten minutes and turns up again; a daemon that does not answer does not count as solved. Show again brings everything back, and cleared lines no longer turn the card red.
  • Needs attention as a table: the name, what is going on, and the actions as icons with a tooltip, instead of words like Events and Explain in between.
  • A restart now counts only when the container stopped on its own: it exited, or the OOM killer stopped it, and Docker started it again. A server that boots in the morning, docker restart, or a stop and a start no longer count.
  • The Cheat sheet page, under Events and in Ctrl+K: 32 Docker commands in eight topics, from containers and images to Compose, cleanup, contexts and Swarm, each with a short explanation and a few examples. Search them, or pick a topic.
  • Copy an example, or put it on the prompt of the host terminal without Enter, so you change web into the name of your container and run it yourself. Examples that remove data for good carry a warning, and every example works in PowerShell and in bash.
Terminal →
1.101.0

The WSL settings in three tabs

A small release. The dialog with the settings of .wslconfig had grown taller than the screen, with memory and processors, the network, and the disk and distros under each other. Each now has a tab of its own.

  • Each tab counts the fields you changed in it, and shows a ! when one of them has no valid value, so a mistake in a tab you are not looking at is still visible. The dialog opens on the first tab.
  • On the dashboard, the links to the WSL settings and the Docker engine settings are now buttons with an icon, next to the engine status.
WSL →
1.100.0

A catalog that gets out of the way, and installers with every release

A small release, made of what the first day with the catalog showed. Deploying a template no longer keeps you in its dialog, the page stops talking about lists you cannot change anyway, and the origin of a template reads the way you would say it. Behind the scenes, the Windows installer and the Linux AppImage are now built with every release. And version 1.100 seemed a good moment to count: the homepage of this site now lists all 250 things the app does.

  • Deploy closes the dialog straight away. The deploy runs as a task in the status bar, and a message says how it went; the project is on the Compose page like any other. The extra step afterwards, with Open folder and Go to Compose, is gone.
  • A deploy that fails keeps its folder and becomes a project, so you can see what went wrong and try again from Compose.
  • A quieter catalog: a Portainer list no longer puts two lines above the templates about entries it could not read or Swarm stacks it left out, since neither is something you can change there. The page only speaks up when a list could not be fetched; the Swarm count stays in the dialog with the lists.
  • The origin under a template names its host once: “From Arcane Community Templates”, not that name with the same address twice. A list that lives somewhere else than its compose files still says where.
  • The Windows installer and the Linux AppImage are built automatically for every release, so the download and the update inside the app follow the new version within minutes.
  • On this site: all 250 things the app does on one list on the homepage, with a search box, each line linked to its place on the feature page.
Catalog →
1.99.0

A catalog of ready-made projects, read before they run, and templates of your own

Setting up something new used to start with finding a compose file somewhere and reading it yourself. The new Catalog page shows ready-made projects from template lists, Arcane’s community templates to start with. Pick one, fill in a few fields, and before anything runs the app reads the compose file and tells you what it asks of your engine. A project of yours that works becomes a template in the same catalog, to share as a list.

  • The Catalog page: templates as tiles with their logos, with search and filters by tag and by list. Arcane’s list is there from the start; add the list of Portainer, another one on the web or on your own network, or a file on this computer.
  • A few fields to fill in: ports, names and the settings of the .env. Passwords and secrets get a random value of their own, and a value the list fixes is shown read-only.
  • Reviewed before it runs: privileged, the Docker socket, folders of the host, its network or processes, capabilities, devices, a volume or network of something else. Anything serious needs a tick.
  • Nothing of your own computer slips in: the app reads the file twice, once with a clean environment, and names every value that would come from yours, such as a token. Projects from git get the same check.
  • Refused outright: a template that would fetch more with include, extend another file, or read an env_file outside its folder. And if the files change after the review, nothing is deployed.
  • Save as template… on a compose project keeps it in the catalog, with passwords, secrets, tokens and keys left empty. Export my templates… writes them as a list for a repository or a friend.
  • Projects from git now deploy on Docker in WSL too: the engine there gets the path under /mnt, so a folder such as ./data works.
Catalog →
1.98.0

Only the files you need, a project as a whole, and the database before the app

Restoring used to mean the whole volume. Now you open a backup, find the two photos that went missing, and put back only those; the rest of the volume stays as it is. A compose project gets a backup of its own: all its volumes from the same moment, with the compose files and the .env, and back again as a whole. And the updates at night now know which service waits on which: the database goes first, and the app waits.

  • Only what you choose: open a backup, walk through its folders or search by name, and tick files and folders. They go back into the volume, or into a new one to look first; everything else stays. Also from an encrypted backup, and from a file elsewhere.
  • Back up a compose project as a whole: all its named volumes, paused together for one consistent moment, with the compose files and the .env, in one folder per backup. With the backup password everything is encrypted, the .env with its passwords too; without it, the dialog says so.
  • Restore a project: per volume whether it comes back, clean or merged, with a backup of what is there first. The project stops meanwhile and starts again in the order of depends_on. A volume that is gone is created again with its labels, so compose sees it as its own, and the compose files can go to a folder you pick without overwriting anything.
  • Updates in order: a round updates what others depend on first, so the database before the app. Containers that wait on it, also through another (a proxy on the app on the database), stop just before it is recreated and start again one by one once it is back. If one of them does not come back, the previous version returns.
  • depends_on from the compose file itself: compose clears it on a container it recreates on its own, as an update does, so the app reads the file. The depends-on label of Watchtower works too.
  • A stricter look after an update: a container without a health check counts only once it has run for five seconds, and one that stops with an error is broken at once, instead of after five minutes of waiting.
Backups →
1.97.0

Limits that fit, a warning before it breaks, a checkup that runs itself, and resilience per project

This release turns what the app measures into advice. It proposes a memory limit from a week of measurements, warns before memory, restarts or a disk get out of hand, checks every machine you follow on a schedule and tells you only what changed, and shows per compose project what happens when a service fails, with the change written out. Next to every finding the AI can explain it and propose a change you see as a diff first.

  • A memory limit that fits: from a week of measurements, the peak times one and a half, rounded up. On the Stats tab of a container with the limit dialog filled in, and in the checkup: a limit too tight, one far too high, and limits that together are more than the machine has.
  • Before it goes wrong: memory that will reach its limit within a day, a container that restarts far more often than last week, and a disk that is full within a month (in WSL, the Windows drive with the disk file). On Needs attention, and as a notification of its own, at most once a day.
  • A scheduled checkup: every day or every week at a time you pick, over every machine you follow, optionally with Trivy on the machine of the app. A notification only when something changed, and the last round as a card on the Checkup page; Check all machines now is in the same menu.
  • Three rules from the CIS benchmark: logs without rotation, live-restore off, and containers without no-new-privileges. The checkup now has thirty-two rules.
  • Resilience… on a compose project: no healthcheck, depends_on that does not wait until healthy, no restart policy, a database without a backup. The app writes the fixed cases as a diff and saves them through the editor, after compose has read the file. On a swarm stack: one replica without a volume, and an update that does not roll back.
  • Explain and propose on every finding, trend and point of resilience: the AI explains it for this machine and may propose one key of one service, which compose checks before and after. Nothing changes until you apply it.
  • The Stats tab of a container puts CPU, memory, network and disk in one row, so the chart of the last day fits below them.
  • A smaller download: the editor and the diagram library were shipped twice, once inside the app and once beside it. Now only once, so app.asar shrinks from 156 to 47 MB.
Checkup →
1.96.0

From Docker Desktop to WSL in one go, and log filters you keep

Leaving Docker Desktop for Docker in WSL used to mean copying images, volumes and projects one at a time. The Machines page now has a wizard that shows what the machine you are on has, next to what the other one already has, and moves it over in one go. The Logs page remembers filters under a name, and shows a line you found between all the others. And everything about the AI in the settings now has a tab of its own.

  • Move over: the images, named volumes and compose projects of the machine you are on, to another machine. Docker Desktop to the daemon in your WSL distro is the usual case, and the app recognises both for what they are, whatever the contexts are called.
  • Per image whether it is already there, with the same or another ID; per volume its size, who uses it, and whether it already exists on the other side; the projects, and what does not move along, such as containers without compose and volumes without a name.
  • Images and volumes are copied one by one, each with its own progress and error. A project goes through the existing move, with the machine already chosen. Nothing changes on Docker Desktop: you remove things there yourself once everything works.
  • A compose project without ports or bind mounts can be moved again; compose refused the empty override the app passed along.
  • Logs: the Filters button saves the search, case sensitivity, levels and optionally the container choice under a name, up to twenty. Apply one from the list, or from Ctrl+K with "Logs with filter…".
  • Show in context: after a search or a level filter, a line you found is shown between all the others, highlighted, and one click takes you back to the filter. Also side by side, and on the log tab of a container.
  • Settings has a fourth tab, AI assistant: who answers, the model or the key, what the AI may do, and the MCP endpoint. A notification about an action the rules stopped opens that tab.
  • A long error in a notification, such as a failed docker compose up, scrolls inside the window instead of pushing its close button out of sight, and shows the error without the pull progress.
WSL →
1.95.0

Rules on Docker events, and rules that do something about it

Your own rules get two additions. A rule can now watch what Docker reports about a container or a project: stopped, crashed, out of memory, started or unhealthy, once or a number of times within a window. And a rule on a measure or an event can restart or stop the container itself, within limits, checked right before, with a notification that says what it did. The site also has two new feature pages, for AI and for WSL, each with a comic.

  • Rules on events, next to rules on measures and on the log: stopped (also cleanly, with code 0), crashed (stopped with an error code without anyone stopping it), out of memory, started, and unhealthy. Started three times within ten minutes is a restart loop.
  • A stop that takes its time, such as a database with a long grace period, still counts as a stop and not as a crash. A rule also works on a machine you follow, and its notification names that machine.
  • Then: only notify (the default, also for every older rule), restart or stop. After stopped only notify, because that is also your own docker stop; after started only stop, from twice within the window, to break a restart loop.
  • Right before, the app checks whether it still makes sense: a container you just stopped, one its restart policy already brought back, one that is healthy again, or a swarm task is left alone. At most three times an hour per rule and container, ten per rule, and three per container together with auto-heal.
  • A rule that acts by itself asks for your confirmation in a window of the app when you save it or turn it on. Rules on the log never act: a log line can contain text from outside.
  • New feature pages for AI and WSL, each with a comic. The Claude comic is about the Claude tab again; the AI comic has the advisor from next door, the rules and the visitor at the back door.
Background & settings →
1.94.0

Your own model, an AI that may act if you let it, and an MCP endpoint

Four things around AI, all optional and all off until you turn them on. Claude now helps when a build fails. A model on your own machine, such as Ollama or Docker Model Runner, can take Claude's place. The AI can be allowed to start, stop or restart containers within rules you set, and it still only suggests until you change that. And other AI tools, such as Claude Code, can look at your containers through an MCP endpoint in the app.

  • When a build fails, the build dialog offers a diagnosis to copy, with secrets left out, or a conversation with Claude that starts from the Dockerfile and the last lines of the build output.
  • A local model next to Claude: any address that speaks the OpenAI API, such as Ollama, Docker Model Runner or LM Studio. Buttons fill in the address, the models come from its own list, and a test says how fast it answers and whether it can use tools. The Claude tabs, the help with a build and the palette then use that model, under its own name. An address beyond this computer and your own network needs https and a confirmation in a window of the app, and a key for it is bound to that one address.
  • The Claude models are now Opus 5.5 (the default), Sonnet 5.5, Fable 5.1 and Haiku 4.5.
  • What the AI may do: suggest only (the default, as before), strict (every action waits for your yes in the conversation) or balanced (what your rules allow happens right away, the rest asks). Per kind of action right away, ask first or never, machines where the AI never acts, and the label docker-client-mx.ai=never on a container it must leave alone.
  • The AI can start, stop, restart, pause and resume containers, recreate a compose service or bring a project up, and nothing else: removing, prune, volumes, files and exec do not exist for it. Every action becomes a notification, and what goes to your phone says only what happened, where.
  • An MCP endpoint on 127.0.0.1, off by default, with a token that never leaves the app except when you copy the configuration for Claude Code or as JSON. Clients can list machines, containers, images and volumes, and read logs, inspect data and measurements, with secrets left out.
  • An MCP client can act too, with the same rules, but only on the machine the app is on, and the app asks you in a window first every time, unless you turn that off. Giving the endpoint more room always asks for a confirmation from the app itself.
Claude →
1.93.0

A project straight from git, and the names your labels already give

A compose project that lives in a git repository can now be cloned and deployed from the app, and brought up to date later. Because a repository is someone else's code, the app first shows what its compose file asks of your engine, and nothing runs until you have seen it. And containers that already carry a name or a group for Dozzle, Homepage or Dockpeek show up that way in the list.

  • Project from git… on the Compose page clones an https or ssh address into a folder of its own. Addresses with a password in them, plain http and git://, and anything that is not https or ssh are refused before git starts.
  • git runs without a shell, with only https and ssh allowed, without submodules, LFS filters or hooks from the repository, and without ever asking for a password: what needs one fails with a message. Private repositories work with an ssh key or a credential manager that is already set up.
  • Before deploying, the app reads the compose file with compose itself and lists what goes beyond an ordinary container: privileged, the host network or process list, extra capabilities, devices, the Docker socket, bind mounts of system folders or of folders outside the project, and images built from the repository. Serious findings need a tick first. Nothing found does not mean safe, and the dialog says so.
  • Git projects… lists what came from git. Update shows the new commits first, then moves the clone forward only if that is a plain fast-forward, and reviews the compose file again before it deploys. A branch that was rewritten is never overwritten quietly.
  • Close the dialog without deploying a new clone and it is removed again. Removing a project removes its clone; the containers keep running.
  • In the container list, a name from docker-client-mx.name, dev.dozzle.name or homepage.name is shown with the real name beside it, and search finds both. A group from docker-client-mx.group, dev.dozzle.group, homepage.group or the first tag of dockpeek.tags gathers its containers under one heading, marked as coming from labels. Your own groups still come first.
Compose →
1.92.0

Restart Docker from the app, and go back to an earlier daemon.json

Some settings in daemon.json only apply after a restart of Docker, and until now that meant logging in on the host. The Docker settings dialog now has a Restart Docker button, with a check before it does anything and a wait until Docker is back. And when a change turns out wrong, an earlier version of the file is one click away.

  • Restart Docker… in the Docker settings dialog asks for confirmation first. It says how many running containers stop, and whether this node leaves its swarm for a moment.
  • Before restarting, the host checks daemon.json with dockerd itself. If Docker would not accept the file, nothing is restarted and the message says why, because a Docker that does not come back would take the app's own connection with it. The flags of the service are not checked.
  • The restart is planned as a timer in systemd on the host, outside the helper container, because stopping Docker also stops the container that asked for it. Without systemd on the host the app does nothing, and Docker Desktop keeps its own restart.
  • Earlier versions… in the same dialog lists the last five files the app replaced, with their time and size. Load puts one in the editor; nothing is saved until you save, so it goes through the same check and leaves a backup of what is there now, and going back can be undone too.
  • The app waits until Docker has gone away and answers again, at most two minutes. It shows in the task list, and if Docker does not come back the message says where to look on the host: the service status, the journal, and the backup of daemon.json.
Dashboard →
1.91.0

The settings of the Docker engine, and moving a project in the task list

Two things that were missing. The daemon.json of the engine can be edited from the dashboard, checked before it goes to the host, and moving a project to another machine now shows up in the task list with its steps.

  • Docker settings on the engine card of the dashboard: the daemon.json on the host of the engine, in an editor. It is checked as you type, so a value of the wrong type or a mirror without https cannot be saved, and warnings explain settings that are risky, such as hosts or another data-root.
  • Saving keeps the old file next to the new one (the last five stay), keeps its owner and permissions, and refuses when the file changed on the host in the meantime, with a choice to overwrite or load it again.
  • Save and reload makes Docker read the file again without restarting. The app lists which changes need a restart of Docker to apply, before and after saving. It does not restart Docker itself, because that would cut its own connection.
  • It works on any engine the app can reach, including a remote one, through a short-lived helper container. Docker Desktop keeps its configuration in its own settings, so there the app only points you to them.
  • Copying or moving a project to another machine, and updating, stopping or starting it there, show in the task list with the step they are in and the percentage of the data transferred.
Dashboard →
1.90.0

Logs side by side, a task list, and compose watch

The logs got a lot easier to read, and the things that take minutes now have a list of their own. Logs can show every container in its own column, JSON lines and stack traces are tidied up, and the status bar keeps track of what is running.

  • Logs side by side: each container in its own column with its own scrollbar, scrolling sideways when there are many. The filters, search and the other options work the same way. The choice is remembered.
  • JSON log lines show as their message with the fields behind it, and search still looks at the raw text. A bar next to lines from stderr is optional.
  • A stack trace is one item that opens with a click, instead of tens of lines between those of other containers. Search finds a trace by any of its lines.
  • A task list in the status bar: compose up and down, updates, backups, scans, pulls, pushes and builds, with the time and the reason when something failed. Pull and push show their progress as a percentage.
  • Compose watch: start docker compose watch for a project from its menu and follow its output in the project card, until you stop it. Stopping takes the whole process tree with it, so nothing keeps running in the background.
Logs →
1.89.0

A week of history, filters like k9s, and a build you can aim

A mix of things that each cost a few clicks too many. The charts look back a week, the lists filter the way k9s does, a multi-stage Dockerfile can be built up to one stage, and the header got back and forward buttons.

  • The CPU and memory charts on the dashboard and the memory chart of a container switch between 24 hours and 7 days. For the week there is a point per hour, the mean of the five-minute points of that hour, kept in the file with the rest of the history.
  • The search box of the lists takes several words that all have to match, !word to exclude, and /regular expression/. A tooltip explains it.
  • Building an image: pick the stage of a multi-stage Dockerfile as the target, and the ARGs of the Dockerfile are listed with their defaults.
  • The Stats tab of a container shows disk I/O, how often and how long the CPU limit throttled it, and the number of processes.
  • Copy a diagnosis of an image or a volume, as for a container, with secrets left out.
  • Back and forward buttons in the header, and Alt+Left and Alt+Right, through the pages you visited.
  • A compose project opens in VS Code from its menu.
Dashboard →
1.88.0

The domain of a container, one click away

A container behind Traefik or Caddy is not reached on its port but on a domain, and that domain only lived in its labels. The container list and the Ports page now turn it into a link.

  • A link icon after the name of a container in the list, to the domain its labels name. The tooltip gives the whole address. On the Ports page the address, without the scheme, stands after the container name.
  • Traefik: the Host() of a router rule, several domains in one rule or joined with ||, and a PathPrefix() with it. The link is https when the router has tls or listens on an entrypoint such as websecure, and http otherwise. traefik.enable=false turns it off, and a HostRegexp is not a domain, so it gets no link.
  • Caddy (caddy-docker-proxy): the caddy and caddy_0, caddy_1 labels, with several addresses separated by spaces. Without a scheme it is https, on port 80 http; an address without a domain, or with an asterisk, is skipped.
  • The text comes from labels that anyone on the engine can set, and it becomes a link, so only a domain or an IP address with a port gets through, and only as http or https. At most six links per container.
Containers →
1.87.0

A shell for a container that has none, and the compose file you can go back in

Two things that stopped people: a distroless container has no shell to open, and a compose file you saved is gone the moment you save it. The Terminal tab now has a debug shell for the first, and the compose editor keeps what it overwrote for the second.

  • A Debug shell button in the Terminal tab of a container. The app starts a helper container (alpine) that shares the processes and the network of the container, with its files at /proc/1/root, where you start. Add tools with apk add curl strace tcpdump. For a container that is not running it shares its volumes and bind mounts. Closing the tab removes the helper.
  • The helper is not privileged and not in the host, but it is also not bound by the limits of the container it looks at (capabilities, seccomp, read-only), and the tab says so. A container that shares the process list of the host is refused: use the host terminal for that.
  • Versions in the compose file dialog: each time the editor overwrites the file, what was there is kept, the last 30 per file. Pick one to see the difference with what is in the editor now, and restore it into the editor; the file only changes when you save. A .env is never kept, because it holds passwords.
  • A tag move (the update to a newer tag) writes through the same editor, so it keeps what it replaced too.
  • The note "As root: what you change, changes as root." under the user choice of the terminal is gone.
Terminal →
1.86.0

From docker run to a compose file, and the .env beside it

Nearly every guide on the internet ends in a docker run command, and what you want is a compose file. Paste the command and get the file; paste nothing and have the containers that run now written as one. And the .env of a project, where its passwords live, can now be edited without leaving the app.

  • From docker run to compose, in the menu of Compose and of Containers: paste one or more docker run commands and a compose.yaml appears beside them. Nothing is run. A flag compose does not know is listed under the file, not dropped, so you never copy one that quietly lost a security flag. Compose reads the result before you copy or save it.
  • Containers as a compose file: choose containers, or one from its menu, and they are written as one file, with their networks and volumes at the top, marked external so the file hangs on the data that is already there. Passwords are hidden on screen and present in what you save. A container that is already in a compose project, or is a task of a swarm service, is skipped and named.
  • The .env of a project and the files its services name under env_file are editable in the same dialog as the compose file, below a line in its menu. After saving one, the dialog says the containers keep the old values until they are recreated, and offers Redeploy.
  • Only files that look like environment files are offered, and only inside the project folder. A symlink pointing outside it is not followed, and a project folder that holds your home folder gives nothing.
  • The file you save with Save as… is written readable for you only, and the dialog asks before it overwrites one.
Compose →
1.85.0

Where a container lives, and fewer buttons in a row

Two small things people asked for: the address of a container, and the rows in Settings that carried a pair of buttons side by side.

  • The container list has a column with the IP address of each running container on each network it is attached to, wide enough for two. The swarm nodes table shows the address of each node.
  • The buttons beside a server, a backup schedule, a backup destination and a notification channel in Settings (Test, Change, Stop, Remove) now sit in the hamburger menu of that row, like on the other pages.
Containers →
1.84.0

A scan you can watch, and a quiet kitchen while it runs

A scan or an update check used to run behind your back: you pressed the button and nothing told you it was busy. Now there is a window with a bar and the name of the image it is on, and the labels of one kind of result no longer sit beside those of the other.

  • Scanning and checking for updates open a window with a progress bar, the name of the image being scanned or checked, and how many are done. It closes by itself when the round is finished.
  • A new check clears the scan labels and a new scan clears the update labels, and leaving the Images page clears both. The page no longer loads old scans when you come back; run a scan and the labels are there.
  • While a scan runs, and for ten seconds after, the app stays quiet about the helper container it sets up and tears down: no crash, unhealthy, wiring or memory notices. They still reach the log, greyed out as muted.
  • A machine whose Docker keeps only the manifest of an image (the containerd store after a half pull) used to give the file-not-found error of Trivy. The scan now says the image is incomplete and that pulling it again fixes that.
Images →
1.83.0

Telegram leaves the list of channels

Notifications elsewhere now go to ntfy, Gotify, Discord, Slack, Pushover or a webhook with your own JSON template. Telegram is no longer one of the channels.

  • The Telegram channel is gone from the list in Settings, with its fields.
  • A Telegram channel you had saved is left out when the channels are read, and disappears from the encrypted file the next time you save a channel.
Background →
1.82.0

Backups that leave the computer, and the database's own dump

A backup that sits on the same disk as the volume, unencrypted, copied while the database was writing, is not much of a backup. This release makes the backup of a volume something to rely on: checked after writing, encrypted if you like, sent to another machine, and for a database a dump it makes itself.

  • Backups are now .tar.zst, read back completely after writing, with a .json beside them that holds the sha256. A schedule runs at a fixed time of day, belongs to the machine it was made on (also when the app shows another one), and gives a notice after three skips in a row.
  • Encrypt with a password (age), set once under Settings and kept in the encrypted store of your system. Restore merges as before, empties the volume first, or goes into a new volume to look first, and makes a backup of what is there before it writes.
  • Send scheduled backups to an SFTP server, with its fingerprint confirmed before the first login, to an S3 bucket (AWS, Backblaze B2, Wasabi and the like) or to WebDAV (Nextcloud, a NAS). Each backup is written and checked here first, then uploaded; old ones are cleared on the server, and restore fetches from there.
  • For Postgres, MySQL/MariaDB and MongoDB a schedule can make a dump instead of copying files: consistent without pausing, with the user and password the container already has. A dump goes back through the running database, after a dump of what is there now.
  • Commands before and after a backup from the labels of offen/docker-volume-backup: archive-pre runs before the containers pause, archive-post once they run again.
  • The build dialog checks the Dockerfile with BuildKit's own checks before you build, and lists each remark next to its line, with a link to the documentation.
  • Settings is split into three tabs: General, Notifications and Servers, with the backup destinations under Servers.
Volumes & networks →
1.81.0

What is in an image, and what is known about it

A newer version is only better if it does not bring problems of its own. The app now scans images for known vulnerabilities with Trivy, lists the packages inside them, and lets a schedule check a new version before it goes in.

  • "Scan for vulnerabilities" per image, or "Scan running images" from the page menu. A label next to the image shows the critical and high findings; a click opens the list, with a filter for what already has a fix and a link per CVE.
  • Trivy runs in a helper container on the machine itself and reads the local image, not the one in the registry. It fetches its database first; then the container leaves every network before the image goes in, and Trivy reads it as an unprivileged user. Afterwards everything goes again, the 1.4 GB database included, and nothing is sent to Aqua.
  • The label says no more than the scan knows: "no critical or high" when there are lesser findings, "nothing recognised" when Trivy found nothing to check, and a clean scan expires after a week.
  • A running image with critical vulnerabilities that have a fix shows up in the checkup and under Needs attention on the dashboard.
  • "Save SBOM" writes the packages in an image as CycloneDX or SPDX to a file you choose.
  • A schedule can scan first: after the pull and before anything is recreated, the new version and the one the containers run are scanned together, and the update only goes in when the new one has no more critical vulnerabilities. "Update now" does the same.
Images →
1.80.0

To the newer tag, and back if it breaks

Seeing that 1.27.4 is out was the first half. Now the app takes you there, by hand or overnight, with the same care as before: it waits until the container is healthy again and puts everything back if it is not. And for those coming from Watchtower, the commands in their compose files work as they did.

  • "Update to 1.27.4…" on the Images page first shows the line it changes in each compose file, then pulls, saves the file with the same checks as the editor, recreates the services and waits for them. If they do not come back, the file and the containers go back.
  • A container without compose is recreated on the new image without the settings that came from the old one, so NGINX_VERSION and the version label follow the new image while your own environment stays.
  • A schedule can now follow a newer patch, or patch and minor, as well as the same tag; never a major. The morning report says from which tag to which.
  • Watchtower's labels work: lifecycle.pre-update runs in the old container before the update, post-update in the new one after it. A failing pre-update leaves everything as it was. enable=false and monitor-only=true keep a schedule away, and the container page shows the commands.
  • A schedule can wait until a new version is a few days old, so a release that is pulled again after a day never reaches you.
  • Fixed overnight updates: a container without compose was pulled but not recreated, and still reported as updated; a schedule also recreated other projects on the same tag; and the old image went before a rollback could use it.
Updates →
1.79.0

Newer versions, and what is in them

Run nginx:1.27.3 or postgres:16.4, as the images themselves recommend, and that tag never changes again. So the app never told you that 1.27.4 was out: it only checked whether the same tag pointed somewhere new. Update tools such as WUD and Diun show newer versions by level, and that was the next step.

  • "Check for updates" now also lists newer tags of the same kind: nginx:1.27.3 shows 1.27.4, 1.28.1 and 2.0.0, a patch in green, a minor in yellow and a major in red, with the level spelled out when you point at it.
  • Only tags of the same shape count: 1.27 is compared with 1.28, -alpine with -alpine, and never a release candidate with a release. The build number linuxserver puts behind every version counts too, and a date used as a tag is not a new major. latest and stable keep the check on the digest.
  • Not interested in 2.x yet? Ignore one version or a whole major per image, and bring them back from the same menu.
  • A "What's new" link takes you to the release notes: the releases on GitHub, Codeberg or GitLab when the image names its source, otherwise its website, otherwise its tags on Docker Hub. The overnight report on the dashboard has the same link.
  • Running images with newer tags get a calm row under Needs attention, and the container page shows them next to the image.
  • The tags come from a short-lived helper container with crane on the machine itself, pinned to a digest and without your login: a private image keeps the digest check only. It runs with tight limits, and its image is removed again after each check.
Images →
1.78.0

Your own rules, on the numbers and on the log

The app already told you about a crash or an unhealthy container. What it could not know is what counts as trouble for you: a container at 90% CPU for five minutes, or a deadlock in the log of the database. Now you write that down yourself, and the notification goes wherever your other notifications go.

  • A rule on a measure: CPU, memory as a share of the limit, or memory in MB, above a threshold for a number of minutes, for one container or every container of a compose project. The app measures once a minute anyway, so such a rule costs nothing extra.
  • A rule on the log: an error or a warning, a text, a regular expression, or a field in a JSON log such as error.code. The app reads along only with the running containers that have a rule, from the moment you add it, and picks the log up again after a restart.
  • After a notification a rule stays quiet for a time you choose, at least five minutes for a rule on the log. A rule holds for the machine you made it on.
  • A regular expression that would keep searching back is refused when you save it. One that still takes too long on a log is switched off, with the reason next to it in Settings.
  • The log line that set off a rule shows in the app, with passwords and tokens covered up. A channel elsewhere only hears that the rule went off, and rules get their own 20 an hour per channel, so a busy log never crowds out a crash.
  • Make a rule under Settings, or from a container: "Notify when…" and "Notify on the log…" fill in its name.
Background & settings →
1.77.0

Notifications that reach you, and containers that pick themselves up

A notification only helped if you sat at the computer, and a container that turned unhealthy stayed that way until someone looked. Every web UI for Docker sends its notifications elsewhere, and two of them restart an unhealthy container by themselves. So that was next after WSL.

  • Notifications go to ntfy, Gotify, Discord, Slack, Telegram, Pushover or a webhook with your own JSON template. Per channel you choose which kinds, and you send a test before you save; a new channel gets the problems, not the reports.
  • A notification you turned off, or a container without notifications, stays in the app. At most 20 per channel per hour; after that, one message says until when.
  • Tokens and webhook addresses are stored encrypted and never shown again. Change the server of a channel and the stored secrets do not go along: you type them again.
  • Turn on "Restart when unhealthy" for a container with a health check, on the machine you are on or one you follow. The app restarts it right away, then after 2 and after 8 minutes, and stops after three times in an hour until it was healthy again.
  • Before each restart it checks that the container still runs and is still unhealthy, so a container you stopped stays stopped. Every restart is a notification, and the Health tab and Needs attention say when it happened.
  • "All notifications" in the tray now opens the notifications panel, not only the dashboard.
  • With DOCKER_HOST set to the address of a context, such as wsl, the app starts on that context instead of default, so it keeps its own name on the Machines page.
  • The dashboard puts the counts next to the network chart, and a menu grows with its longest label instead of breaking it over two lines.
Background & settings →
1.76.0

WSL, looked after

The app was built around Docker Engine in a WSL distro, without Docker Desktop. Everything around that distro you still did yourself: .wslconfig in an editor, a disk file that only grows, a port nobody else on your network could reach, and a WSL that hangs after the laptop slept. Comparing the app with other Docker apps put exactly this at the top of the list. So WSL has a page of its own now.

  • A WSL page in the sidebar: the WSL version, the distro with the daemon, the networking mode, memory and processors, and the disk file. Every action sits in the menu at the top right, and each one asks first.
  • Adjust .wslconfig in a dialog: memory, processors, swap, networking and more. You see the change line by line before it is saved, and the old file stays as a .bak. Restart WSL from the same page to make it count.
  • Shrink the disk file. ext4.vhdx grows but never gives space back; the app trims the distro, stops WSL, compacts the file with diskpart after one Windows permission prompt, and starts the distro again. On the laptop it was built on, 17.1 GB became 11.7 GB.
  • Share a port on your network, from the Ports page: under mirrored networking a Hyper-V firewall rule, under NAT a portproxy and a firewall rule. One permission prompt, private and domain networks only unless you say otherwise, and the WSL page lists what is shared and stops it.
  • VS Code, Testcontainers and docker.exe look for the pipe of Docker Desktop. The app can set DOCKER_HOST for your Windows user so they find the engine in WSL instead, and it only removes a value it set itself.
  • After sleep, WSL sometimes stops answering. The app checks when the laptop wakes up, and if WSL hangs, a notification takes you to Restart WSL.
  • The checkup has a WSL chapter with five rules: a credsStore that Docker Desktop left behind, containers that cannot resolve names, a daemon that does not start with the distro, bind mounts from /mnt/c, and programs on Windows that find no Docker at all.
  • German and French now address you formally everywhere.
Connections →
1.75.0

The compose file, editable

For a long time the app showed the compose file and left editing to your own editor: it is source code, and editing it gives the app a way to write to your disk. Then came the question whether it could be the Monaco editor, with saving. It can, with a narrow way to write.

  • The file dialog of a compose project opens the file in Monaco, the editor of VS Code, in the colours of the app. Ctrl+S saves. Which file you see, or what compose makes of it, you pick from the menu at the top right.
  • Before saving, compose reads the new text on a copy. What compose does not read is not saved, unless you say so, and the message names your file and the line.
  • If the file changed outside the app since you opened it, you choose: reload, or overwrite.
  • The app writes only the YAML files of that project. A file that is not UTF-8 stays read-only, a BOM and the line endings stay as they were, and a network path is not opened at all.
  • With unsaved changes, Escape or a click outside does not close the dialog; the button says "Close without saving".
Compose →
1.74.0

Twenty machines, and a link that goes to the server

Two things from a morning on the home server. A port link opened localhost, also when the container ran on the server. And the Machines page, fine with four machines, would not be with twenty.

  • Machines has a search field: the name, address or description of a machine, or a container, image or compose project on it. A card found through what runs on it says which containers.
  • A switch shows only the machines that answered, and the app remembers it.
  • A port link on Containers and Ports opens the machine the engine runs on: 4200 on a server at 192.168.1.16 opens 192.168.1.16:4200, not localhost:4200. A port bound to one address opens that address.
  • A port on the loopback of a server cannot be reached from here; it gets no link, but a note that says why. Ports 443 and 8443 open over https.
Connections →
1.73.0

A project on one sheet

The idea was simple: one overview of everything a compose project uses, its networks, volumes, containers and ports, in a dialog. The first version used a graph library and looked like nothing you would draw yourself. What people draw such things in is draw.io, so the overview now uses maxGraph, the engine inside draw.io, looks like draw.io, and goes out as a .drawio file.

  • Compose and Containers have "Overview…" in the menu of a project: networks on the left, the services with their ports in the middle, volumes and folders on the right, and depends_on as dashed arrows between the services.
  • It reads compose config, so a service that never started is there too, dashed. A running one is green and a stopped one red, in the default colours of draw.io.
  • Drag a block and the lines follow while you drag; select a line and drag a piece of it to route it your way. Lines keep square corners and jump where they cross.
  • Save as .drawio, or open it in draw.io straight away, as it is on screen: what you moved goes along. Arrange again puts everything back.
  • Double-click a service, network or volume to go to its page.
Compose →
1.72.0

A network by another name

The question was short: can we rename an existing network? Docker cannot; there is no rename, not even in the API. So the app does it the long way round, carefully: it creates the network again under the new name, with the same subnet, and moves everything on it across. Also for a network of a compose project or the swarm, which know a network by name.

  • Networks has "Rename…" in the menu of a row. The dialog first shows what will happen to each container, compose project and swarm service, and only then renames, with a check or the error per step.
  • A container with the network as its main network is recreated exactly as it was: ports with their address, anonymous volumes, its own hostname, alias and fixed IP. Docker 29 will not connect such a container anywhere while that network is missing, and after a restart it ran without any network at all.
  • For compose, the dialog gives the lines for the compose file and checks with compose config that the file uses the new name. Compose then creates the network itself and recreates its services, anonymous volumes included; a next up leaves them alone.
  • Swarm services let go of the network and get the new one with the same aliases, and the app waits until their tasks run again: a node can refuse the new task for half a minute while it still knows the old network.
  • If the old network cannot be replaced, everything goes back as it was.
  • On Compose, a service with build: had two buttons that were both called Rebuild. They are now in one menu per service: Rebuild makes a new image from the Dockerfile, Recreate a new container from the same image.
Volumes & networks →
1.71.0

Who uses it, and what else is on that port

The recipe app moved from Docker Desktop to the home server, and its database had to go to port 5433: the server ran a PostgreSQL of its own on 5432. The Ports page did not know that, because it only looked at containers. Networks already showed who is attached; now volumes show who uses them, and the Ports page shows what listens outside Docker as well.

  • The Ports page lists what else listens on the machine, marked "outside Docker", with the addresses and where to see which program it is. A short-lived helper container in the host network reads it; ports that Docker itself holds, for containers, swarm services and the swarm, are left out. A switch hides them again.
  • Search for a port number that nothing uses and the page says it is free. With Docker Desktop the machine is its VM, so the page says instead that ports on your own computer are not in the list.
  • Volumes has "Who uses it…": every container with the volume, running or stopped, with the path inside it. An unnamed volume that would not go away turned out to be /data/configdb of a running mongo.
  • A volume copied to another machine keeps its compose labels, so compose up there no longer warns that the volume was not created by Compose.
  • An ssh connection whose handshake timed out could make the app stop with "A JavaScript error occurred in the main process". It now gives a normal error.
Volumes & networks →
1.70.0

One engine, one name, and the image you forgot to catch up

Two more questions from the same afternoon. Why does default still show up next to desktop-linux, when they are the same? And why do two images without a name stay behind after a pull? The first was the app counting contexts instead of engines. The second was containers still running on the image they were made from, and in one case the same image under a second id, which compose did not see as a change at all.

  • Contexts that reach the same engine, such as default and desktop-linux with Docker Desktop on Windows, are one machine. The Machines page shows one card that is also reachable as default, the picker in the status bar and Ctrl+K offer one name, and copying or comparing no longer offers the machine you are on under its other name. The app goes by the id of the engine, so a default with an engine of its own stays a machine of its own.
  • After a pull the tag moves, but a running container stays on its image. Containers now shows the tag it was made from with an "older version" label instead of an image id, Images calls the untagged image "was nginx:stable-alpine", and the attention card on the dashboard gets one line per project with a Recreate button.
  • Recreate asks first, and names what is gone for a moment. It really recreates, also when compose sees no change, checks afterwards that the container moved, and says so when it did not. The image left behind is removed, unless something else still uses it or it still has a tag.
  • With the containerd image store in Docker 29, one image can end up under two ids, for example after docker load. The app sees that by its layers and calls it the same image under another id, not an older version, and leaves it off the attention card: there is nothing newer.
Images →
1.69.0

Created, and why

Another question with a screenshot of Containers, this time on WSL: a project with two containers, none running and no CPU or memory, while it ran with four on Docker Desktop. The two came from a compose up in a WSL shell, where docker points to the engine in WSL. Their ports were already taken, so they never got past created, and the list only said "Created". Now it says why, and where the project does run.

  • A container that stayed in created because starting failed gets the orange warning, with the reason as its tooltip, such as port 5432 already taken on this machine. One made on purpose with docker create stays as it was.
  • The header of a compose project says where else a project with that name has containers, such as "also on desktop-linux: 4 of 4 running", with a link to the Machines page. Only machines you follow and that answered count, and the app asks them at most once a minute.
  • On Windows, default and desktop-linux are both Docker Desktop. The app sees that it is the same engine and names them together, and a context of the engine you are on does not count at all.
Containers →
1.68.0

What the swarm keeps

A question with a screenshot of the Containers page on the home server: the stack showed mongo five times, and only one of them ran. That is the swarm itself. It never restarts a task that stopped; it makes a new one, and keeps the old one as history, with its container on the node, five per replica by default. The app now keeps them out of sight, lets you choose how many the swarm keeps, and can clear them away itself. And a cold start no longer shows nothing at all.

  • On Containers the stopped tasks of a stack sit behind one line in its header, such as "4 old tasks", with "1 failed" in orange when one exited with an error or never got started. A click shows them; nothing is removed, so the logs of a crash stay readable, and a search still finds them.
  • The Overview tab of a manager has a task history under the heartbeat: 1, 2, 3, 5 or 10 tasks per replica, the running one included. The swarm removes older ones itself, with their containers, on every node, also when the app is closed. It does so the next time a new task arrives in that place, so what is there now stays until then.
  • A new switch under Cleaning up in the settings, off by default, removes the containers of old swarm tasks on the machine you are on once they have stood still for an hour. That hour leaves time to read a crash. Anonymous volumes stay, in case someone forgot to mount a volume, and the swarm still lists the task with its reason.
  • A cold start with a window shows a small splash with the name and a sliding bar while the main window loads, for at least two seconds, in the theme you chose. Starting to the tray at sign-in or opening from the tray goes without it.
Swarm →
1.67.2

What a day of testing the swarm turned up

A day of going through the swarm test plan on three machines: a laptop with Docker in WSL, a home server, and a server borrowed for the day. Draining nodes, deploying and replacing, leaving and joining again, all through the buttons of the app. Most of it did what it should; these are the things that did not, and are fixed now.

  • A service whose only task was on a node that went down now counts as short, so the notice that it has nowhere to run comes. Docker counts such a task as running, since the node can no longer report; after a node left, a service showed 2/1 until the old node was removed.
  • A task waiting for a node says per node why none fits, on the Tasks tab and on the page of its service, like the notice already did. The words of the swarm stay as the tooltip.
  • A new service and a rollout pin the digest of the image, like docker service create does, so every node runs the same version. A service without one, such as a build of your own that is in no registry, says that every node fetches the image by itself.
  • After replacing a secret, Adjust still shows the variable as coming from that secret, so you can choose another one.
  • Rolling back by hand no longer raises the notice meant for a rollback the swarm started itself.
  • A machine you stop following on the Machines page is no longer measured for the usage of the swarm, from the next round on.
  • A join that hangs on an address nobody answers now names that address, also when the machine never reached a manager.
  • Deploying a stack again while removing what is no longer in the file no longer says that nothing changes right above the services that go away.
Swarm →
1.67.0

Why a node is gone, and what the swarm uses

It began with a question about the sessions of a swarm: every node keeps one open with the leader and reports over it every few seconds. Docker does not show those sessions, but what they tell now has a place in the app: why a node is not ready, how often nodes report, and, in the empty room to the right of the Overview, what the tasks of the swarm use.

  • A node that is not ready says why under its state on the Nodes tab: no heartbeat, a new leader waiting for it, silent since a new leader, or looking for a manager. The tooltip says what to check, such as port 2377/tcp, with the words of the swarm itself behind it.
  • A node that is unknown or disconnected is yellow instead of red: after a change of leader that usually passes by itself. Only a node that is down stays red.
  • The Overview tab shows how often every node reports to the leader, 5 seconds by default, and after how long a silent node counts as down. Nodes on a slow network can report every 10 to 60 seconds; the leader takes a new choice over at once.
  • Next to the Overview: CPU, memory and network of all swarm tasks together over the last three minutes, and per node its tasks and what they use. The app measures every node that is also a machine in the app, and says for any other node why it is not measured.
Swarm →
1.66.0

Which version, and more room

Two small things that were asked for. The app now says which version it is without a trip to the settings, and the sidebar can make way for the page you are working on.

  • At the right end of the status bar the app shows its own version, like Docker Client MX 1.66.0, next to the version of Docker, also while the engine is still connecting.
  • A button at the bottom of the sidebar collapses it to its icons, with the name of each page as a tooltip, and expands it again. The choice is kept after a restart.
Dashboard →
1.65.0

Linux is not WSL

A question from the same evening: the app often talks about WSL, but what does someone see who runs it on Linux, or with a server? For the swarm nothing changes, as that advice was already tied to where the engine runs. A few other places mentioned WSL whatever the machine; they now ask the same question first.

  • A port taken outside Docker says where to look for that engine: ss inside the distro and netstat on Windows under WSL, ss on the other machine for a server, and netstat, lsof or ss on this computer for Docker Desktop or a local engine. Before, the advice for WSL came for the home server too.
  • That C:\data is /mnt/c/data under WSL is only said when the app runs on Windows, in the dialog for a new volume and in its message.
  • For Docker Desktop, WSL with mirrored networking is only offered as the way out on Windows; Docker Desktop also runs on Linux and macOS.
  • Claude hears where the app and the engine run at the start of a conversation, instead of assuming Docker in WSL on Windows.
  • The Terminal page names where its shell can be: a WSL distro, the VM of Docker Desktop, or a server.
Containers →
1.64.0

A password from a secret

Asked the evening before: a password for a new service should be able to come from a secret of the swarm, instead of standing in its spec for anyone who inspects it. It can now, in the form for a new service and when you adjust one. The same evening a mongo went into the swarm as a stack, and brought two smaller things to light.

  • A password row in the form for a service has a key. Choose a secret the swarm already has, or let what you typed become a new one, with a name suggested. The row becomes NAME_FILE=/run/secrets/…, and the service gets the secret as a file. For mysql, mariadb, postgres, mongo and wordpress; not for rabbitmq, which no longer reads _FILE.
  • Adjusting a service shows such a variable as a row from its secret again. A secret without a variable, like one an init script reads, stays on the service.
  • Deploying a stack with the option to remove services that are no longer in the file now names those services first, in red, and says their volumes stay.
  • Under WSL with mirrored networking the laptop itself reaches its own published ports through localhost, not through its own address, unless .wslconfig sets hostAddressLoopback. The firewall card of a service or stack says so, with the two lines to add.
  • The tabs of the Swarm page have an icon, like the steps of moving a project.
Swarm →
1.63.0

The rest of what the swarm taught us

Three things from the trial with a laptop and a home server in one swarm were still only on the troubleshooting page. A task on the WSL laptop could not be reached by the other nodes, a machine that tried to join while the port was closed kept waiting after it opened, and a server that goes off at nine left the services with nowhere to run. The app now says each of them where it happens, with the step that helps.

  • Under WSL with mirrored networking, traffic between containers on different machines never reaches the laptop. The Nodes tab says so while that node is still active and another one is ready, with a button that asks to drain it. The advice for starting and joining says it too, and the checkup has a twentieth rule for it; that node no longer counts as drained for days, since there drain is the point.
  • A machine that stays in pending or error says through which manager it tries, and that the attempt will not start over by itself. Stop and join again asks first, lets go of the attempt and opens joining with that manager proposed. The message for a join that times out points to it.
  • When a service stays below its count and there is no node it can run on, the notice says why, per node: down, drained, paused, or not matching the placement rules.
  • Promoting a node that went down twice or more in the last week comes with advice against it. A manager that leaves regularly puts the majority at risk; as a worker it just takes part again.
  • The Hyper-V rules to paste now carry their ports in the name, like stack-infra-tcp-27017. A second port for the same stack no longer fails with "Cannot create a file when that file already exists".
Swarm →
1.62.0

A mysql in the swarm, and what it taught the app

Putting a mysql into a real swarm, as a stack next to a Compose project of the same name, went wrong in three ways the app did not see coming. The stack mounted the volume of the other mysql, because both were named infra_mysql-data; a network left by an earlier stack made the deploy fail with "not found"; and the port was only reachable through localhost, because the Hyper-V firewall held it back. The app now sees all three before you deploy, and a new service gets its user and password as it should.

  • A new service takes its environment variables as rows of name and value. For images like mysql, postgres or mariadb the usual names are one click away, with a line when the image will not start without one. A password is masked, and a pasted .env becomes one row per line.
  • A Tasks tab on the Swarm page: every task of every service in one list, with its node, its state, since when, and why it stopped. Filter by node or service; the tasks the swarm let go come with a switch.
  • Deploying a stack first lays its names next to what the machine has. A volume of a Compose project is shown in red and holds the button until you confirm; a network left by an earlier stack is named, with what to do. A deploy that still fails with "network not found" says why.
  • Under WSL with mirrored networking the app reads the Hyper-V firewall, which only lets ping and mDNS in, and gives the rules to paste: for the swarm ports when you start or join, and for the ports a service or stack publishes.
  • On Containers a task of a swarm service stands with its stack instead of among the standalone containers, and renaming it is off: the swarm finds a task by its name, and a renamed one stays behind when its service goes.
  • A port that is only exposed inside a container, like 3306/tcp, now says so, so two databases on 3306 no longer look like a clash.
  • Focus rings in dialogs are no longer cut off at the edge of a part that scrolls.
Swarm →
1.61.0

Moving a project, as a wizard that knows the ports

The first move of a real project to a home server showed where it could still surprise you. nginx, redis and keycloak held ports 80, 6379 and 8080 there, outside Docker, so the copy failed at the very last step, after minutes of pulling and building without a sign of life. Moving a project is now a wizard: it finds those ports before anything happens, lets you pick another port there, and shows how far each long step is.

  • A wizard with tabs side by side: the machine, folders and files, ports, images and volumes, and copy or move. Each tab counts what is still open, and the last one takes you there.
  • Ports taken by a program outside Docker are found up front: the app briefly starts an empty container with that port on the other machine, and Docker refuses it when the port is in use. Nothing stays behind.
  • Per port a choice: the same port, another port there, or not published there. Another port is checked right away, and the choice is kept when you update the project there later.
  • Every mounted folder is measured first. A big one, like a whole projects folder with hundreds of thousands of files, is proposed to be left out instead of packed into a volume.
  • Long steps show how far they are: the last line of compose while pulling and building, bytes while copying volumes and filling folders, and which containers are not up yet.
  • Joining a swarm through a manager in Docker Desktop is refused up front: its address lies inside its own virtual machine, where no other machine can reach it.
  • Plain words when compose does not work in WSL, or when ssh gets its connection closed.
Compose →
1.60.0

Linux, as an AppImage that updates itself

Until now, Linux meant npx. From this release on, every release also carries an AppImage for Linux, built in a clean Linux container from the released tag, and on Linux the app keeps itself up to date the way the Windows installer does.

  • Docker-Client-MX-x86_64.AppImage next to the Windows installer on every release. Make it executable and start it; on a machine without FUSE, start it with --appimage-extract-and-run.
  • The AppImage checks for new versions and downloads them in advance, like the installed app on Windows. The npm version still updates through npm.
  • Joining a swarm from Docker Desktop, or from WSL without mirrored networking, now says what that means for joining: the other nodes cannot reach it there, so it cannot take part properly.
  • On this site: Volumes, the comic, and a troubleshooting page for a swarm between a laptop with WSL and a home server.
Background & settings →
1.59.0

The Swarm page starts with the swarm

A small release that comes from using the Swarm page: adding a machine to a swarm starts on the Overview, with who is in charge and the tokens a new machine needs. So that is where the page opens now, with less to click on the way.

  • On a manager, the Swarm page opens on the Overview, now its first tab: the leader, the number of nodes, and the join tokens.
  • Show, copy, copy the join command and renew sit in one menu per token. Renew stands apart at the bottom: after it, the old token no longer works.
  • Autolock is a switch. It still asks first, shows your choice while the swarm works on it, and springs back when you cancel.
  • Links that mean the list of services, like back from a service or a stack in Ctrl+K, open the Services tab.
  • New to swarms? This site now has a comic that explains one from scratch: a restaurant, a head chef, and a cook who goes home at nine. The Swarm page links to it.
Swarm →
1.58.0

A project to your own server

First on your laptop, then on your own server: that step was a handful of copies in the app and a compose up in a terminal, hoping the folders the project mounts would exist there. They do not. Docker quietly makes an empty folder of a path from this computer, and the project starts without its data. This release takes a compose project to another machine in one go, and says first what goes along and what needs a choice.

  • See what goes along: images, volumes with their size, the folders and files the project mounts from this computer, ports already taken there, and another architecture.
  • Per folder or file a choice: a volume filled with what is here, a config with its content, a folder on the server, or left out. The app adds a compose file of its own; yours stays as it is.
  • Copy it, so it keeps running here too, or move it. Step by step with the time per step, and if a step fails, everything is put back as it was.
  • Afterwards, update it there from here: see what changed against the files here, put the folders and files there again, or stop and start it there.
  • Comparing two machines now also shows, per compose project, which version each service runs here and there.
  • Before anything moves, the app checks that compose can reach the other machine, and says in plain words when ssh does not know the server yet.
Compose →
1.57.0

Swarm

Until now every machine on the Machines page was an island: a container runs where you started it. Swarm, built into every Docker Engine, makes a few machines one. You ask for three of a service, and the swarm decides where they run and starts them again when a node falls away. This release brings all of it into the app — seeing a swarm, running it, starting one and keeping an eye on it — with a question first wherever one click reaches more than one machine.

  • Every machine card says whether it is a manager or a worker; machines in the same swarm share a mark, and a locked swarm shows up in the status bar.
  • On a manager: services per stack, where each task runs and why one stopped, and the logs of all tasks together. Scale, roll out, roll back, adjust or remove a service, or create a small one.
  • Stacks from their compose file: deploy one, see where it differs from its file, deploy it again with what changes shown first, or remove it.
  • Nodes: drain one after seeing which tasks move, pause or activate it, promote or demote it with a warning about the quorum, and change its labels.
  • Secrets and configs with the services that use them. Replace one in a single step; what a secret holds is never kept or shown.
  • Start a swarm with advice on the address to announce and the ports to open, or join one through a manager the app already knows. Join tokens, autolock, and leaving without breaking the swarm.
  • Swarm events on the Events page, notices for a node that goes down or a service below its count, a swarm chapter in the checkup, and "scale web to 3" in Ctrl+K.
  • Also fixed: compose runs on the machine the app is on, even when the docker CLI points elsewhere, and the machine picker no longer shows contexts removed outside the app.
Swarm →
1.56.0

A menu on Containers, and events that stay with their machine

Two loose ends from the day before. Containers was the last list page without a menu at the top right; now it has one. And the Events page mixed up machines: what happened to images, volumes and networks was one list for every machine, so a pull on the home server showed up on the laptop. It now stays with the machine it happened on, the way container events already did.

  • Containers: refresh, select everything shown or clear the selection, and remove stopped containers after one question — only those, volumes and images stay.
  • Events of images, volumes and networks are kept per machine. The history from before this version goes to the machine the app starts on.
  • The Events page reloads when you switch machine, instead of showing the previous one until you refresh.
History →
1.55.0

The other machine, without switching

The Machines page said that two containers on the home server needed attention, but not which two. Finding out meant switching over, and then the whole app spent half a minute talking to another daemon. Now the page answers the question itself, lets you act on what it finds, and puts two machines side by side.

  • The counters on a machine card are buttons: running, stopped and attention unfold into the containers they count, grouped per compose project.
  • On a machine you are not on, each container has a menu: read its log, start, stop or restart — with the machine’s name in every question, so you know where it goes.
  • A notice from another machine opens that spot on the Machines page, instead of switching the whole app.
  • Compare two machines: which images run on both and with which tag, differences first, and "same tag, other build" when latest is not the same latest.
  • Copy an image to the other machine straight from the comparison. Nothing is brought in line on its own.
Connections →
1.54.0

The menu where you expect it, and a switch that clears the screen

A day of tidying up after the big features. Every page now keeps its actions in the same place — a menu at the top right — and the rows of buttons that had grown on Logs, Events, Checkup and the container page are folded into a list or two. Switching machine also got honest: what belonged to the previous machine leaves the screen, even when the app switched for you.

  • Logs: one Containers list, grouped per compose project with a tick per project. What you switch off is not just hidden but no longer streamed.
  • Events: kind and period in one dropdown, and "Update live" to follow the engine while it happens, without polling.
  • Checkup: mark every finding as on purpose, or none, in one go; a finding stays in its place when you mark it; a new check runs when you switch machine.
  • A container’s log tab: errors, warnings, follow, timestamps and the time range in one View list; copy, save and clear in a menu next to it.
  • Opening a notice marks it as read, from the panel, the tray and the Windows notification alike.
  • Already in 1.53.2: remote engines over ssh stay reachable with more than ten streams open, because docker-api-mx 0.2.1 opens a second connection instead of running into the server’s limit.
Logs →
1.53.1

docker-api-mx

Underneath every page of the app sits a client for the Docker Engine API. That used to be dockerode; it is now docker-api-mx, a library written for this app and published on npm on its own. Nothing on the screen changed. What changed is that the part that talks to Docker is typed, small and ours — and that a connection over ssh is no longer something the app has to build by hand.

  • Typed and class-based: Docker, Container, Image, Network, Volume and Exec, with promises and async iterators instead of callbacks.
  • Streams done properly: pull and build progress, logs, events and stats come as async iterables, and stdout and stderr are split for you.
  • Its own transport for Unix sockets, Windows named pipes, TCP, TLS and ssh — the ssh tunnel the app used to carry around is gone.
  • Every call can be cancelled, and failures come back as errors with a status code instead of a sentence to parse.
  • Open source and on npm as docker-api-mx, for anyone who wants to talk to Docker from Node.js.
1.53.0

Images that update themselves — and roll back when they do not come up

Pick a moment, pick a project or a container, and the app pulls the newer image, recreates what runs on it, and watches it for five minutes. If it does not stay up, the old image goes back exactly as it was. You read about it afterwards instead of babysitting it.

  • A fixed time per project or container, and a list of what is behind right now.
  • A five-minute settle window; a container that exits or turns unhealthy is rolled back to the image it had.
  • Anything a compose file owns is skipped, because the file is the truth there.
  • One notice in the morning and a round on the dashboard: what was updated, what stayed, what was put back.
Update by itself →
1.52.0

Choose the machine the app starts on

The app used to open on whatever the Docker CLI pointed at. Now you decide: the machine you were last on, one you name yourself, or the CLI context after all. The setting sits on the settings page, and the status bar says which of the three you got.

  • Three options: last used, a fixed machine, or follow the CLI.
  • DOCKER_HOST still wins, because the environment is a deliberate choice too.
  • The machine you switch to is remembered, so "last used" needs no maintenance.
Machines and connections →
1.51.0

A machine that does not answer no longer holds up the window

A startup machine is only useful if the app survives it being off. It now probes before it commits, falls back to one that does answer, and says on the dashboard what it fell back from. Nothing hangs while a laptop waits for a server that is asleep.

  • A four-second probe per machine, then a fallback with the reason in plain words.
  • Volumes finally show up in the engine events: Docker puts a volume name in a field nobody expects.
  • A divider in the sidebar between the pages you work on and the app itself.
Events and history →
1.50.0

A day of CPU and memory, the notices you missed, and every engine event

Three pieces of the same idea: a problem that starts while you are not looking should still be there when you get back. The app keeps a day of usage per container, holds on to the notifications you did not see, and lists what the engine reported.

  • A rolling day of CPU and memory, so a leak has a shape instead of a number.
  • Notices you missed stay readable; a Windows toast that nobody saw is not a report.
  • One page with everything the daemon announced: created, started, died, pulled, removed.
Events and history →
1.49.0

A checkup that says what could be better before it breaks

Not a scanner and not a grade — a short list of things worth fixing on this machine, each with the reason and the way out. It also produces a written report of what runs where, for the moment you need to hand that to somebody.

  • Containers without limits, without a healthcheck, restarting in a loop, publishing on every interface.
  • Passwords stay off the screen, and the checkup points out where they should not be sitting.
  • A report of a machine, yours or another, that you can keep.
Checkup →
1.48.0

Every Docker machine on one page

Every context you have, with what runs on it and whether it answers at all. Switching is one click, copying an image or a volume to another machine is another, and notifications from the machines you are not on now reach you where you are.

  • Each context with its version, its containers and its reason for staying quiet.
  • Copy an image or a volume from one machine to another, without a registry in between.
  • Notifications from machines you are not currently on.
Machines and connections →
1.47.0

Volumes you can actually restore

Backing up is the easy half. This release does the other half: restore from the backups the app made itself, stop whatever is using the volume first, and start it again when the restore is done.

  • Restore from the backups the app made, or back up right now.
  • Users of a volume are stopped during a restore and started again afterwards.
  • Volumes, folders and the healthcheck of a standalone container are editable.
  • A notice when a container sits at its memory limit.
Volumes →
1.45.0

Where the disk went, and a backup schedule per volume

Docker is quietly expensive on disk, and the answer is usually one image or one volume you forgot about. The dashboard now says which. Volumes got a schedule of their own, so the backup does not depend on you remembering.

  • The biggest images, volumes and containers, with what is safe to remove.
  • A backup schedule per volume, and a weekly cleanup of untagged images and build cache.
  • Edit and upload a file inside a volume without starting a container for it.
Dashboard →
Every release, in full.
The changelog and the downloads live on Codeberg. Free and open source.
Releases on Codeberg
$ npx docker-client-mx