The Search for a GUI Docker

Docker is everything but pretty; let's try to fix that. Here's a rundown of some GUI options available for Docker.

I love Docker. At first it seemed a bit silly to me for a small-scale implementation like my home setup, but after learning how to use it, I fell in love. The standard features are certainly beneficial. It's great not worrying that one application's dependencies will step on or conflict with another's. But most applications are good about playing well with others, and package management systems keep things in order. So why do I docker run instead of apt-get install? Individualized system settings.

With Docker, I can have three of the same apps running side by side. They even can use the same port (internally) and not conflict. My torrent client can live inside a forced-VPN network, and I don't need to worry that it will somehow "leak" my personal IP data. Heck, I can run apps that work only on CentOS inside my Ubuntu Docker server, and it just works! In short, Docker is amazing.

I just wish I could remember all the commands.

Don't get me wrong, I'm familiar with Docker. I use it for most of my server needs. It's my first go-to when testing a new app. Heck, I taught an entire course on Docker for CBT Nuggets (my day job). The problem is, Docker works so well, I rarely need to interact with it. So, my FIFO buffer fills up, and I forget the simple command-line options to make Docker work. Also, because I like charts and graphs, I decided to install a Docker GUI. It was a bit of an adventure, so I thought I'd share the ins and outs of my experience.

My GUI Expectations

There are some things I don't really care about for a GUI. Oddly, one of the most common uses people have for a visual interface is the ability to create a Docker container. I actually don't mind using the command line when I'm creating a container, because it usually takes 5–10 attempts and tweaks before I get it how I want it. So for me, I'd like to have at least the following features:

  • A visual layout of all containers, whether or not they're running.
  • A way to start/stop/delete containers.
  • The ability to rename running containers, because I always forget to name them, and I get tired of seeing "chubby_cheetah" for container names.
  • A way to change the restart policy easily, so when I finally get a container right, I can have it --restart=always.
  • Show some statistics about the system and individual containers.
  • Read logs.
  • Work via web interface, so I can use it remotely.
  • Be a Docker container itself!

My list of needs is fairly simple, but oddly, many GUIs left me wanting. Since everyone's desires are different, I'll go over the most popular options I tried, and mention some pros and cons.


It has a strange name, but Kitematic has been around for a very long time. It actually was adopted officially by Docker, and it's now part of the Docker Toolkit. It's a fairly simple interface, but simplicity is sometimes a bonus, because finding the things it can do is straightforward.

If you check out the Kitematic website, you might get the impression it runs only on OS X or Windows, but thankfully, that's not the case. If you head over to the GitHub repository, you'll find an Ubuntu installer as well.

Kitematic is pretty, but it's a native application, not a web interface. It looks nice (Figure 1), but I'm often on someone else's computer when I'm out and about, so my web-based requirement is really vital. Still, if you don't need a web interface and want a supported, clean GUI, Kitematic is pretty slick. It's fairly simple, but again, that's not a bad thing.


Figure 1. Kitematic looks incredibly nice, but it's unfortunately a native non-web app (image via


  • Officially supported by Docker.
  • Very clear and simple interface.


  • Not a web app.

DockStation is another non-web-based solution, but I wanted to mention it because it's very powerful. It has a great, clean interface (Figure 2), but again, it requires installation on a local machine. It does have support for accessing a remote Docker server over SSH, but that still means installing an application locally, and configuration isn't straightforward.


Figure 2. DockStation also looks great, but it's proprietary and requires quite a bit of work to get working. Also, it's not web-based (image via

Plus, DockStation is closed source. That alone wouldn't be a showstopper for me, but when added to the frustration of a native application install, it's enough to turn me off. Still, it is free for personal use, and especially if you're a developer, DockStation might be very attractive. There are lots of screenshots on the website if you want to check it out.


  • Well-designed interface.
  • More powerful than Kitematic and has more features.
  • Supports remote SSH access (but is complex to configure).
  • Cons:

    • Not open source.
    • Not web-based.

    The closest thing I found to a perfect solution was Portainer. It's web-based, runs as a Docker container, and it's easy to get going. On the surface, it seems fairly basic, but I was impressed to see there is even a tiered user system, meaning you can give various users different levels of access to the Docker infrastructure.

    Portainer doesn't seem to keep historical performance statistics, but it does have a real-time monitor (Figure 3) that works in a pinch if I'm trying to troubleshoot a misbehaving container. I'm a little surprised to find that the application template feature (Figure 4) is one of my favorite things to play with. I know my original requirements did not include a way to deploy containers quickly, but grabbing a quick template and clicking deploy is surprisingly simple, and I find myself playing with containers more often. It's not that deploying a container via the command line is hard, but it's a lot of typing; whereas with Portainer, I simply can click "deploy", and it's all done for me. It seems silly, but anything that gets me playing with technology is a good thing.


    Figure 3. I love seeing graphs, and if a container is behaving poorly, this real-time look at performance is very useful.


    Figure 4. I'm not normally into templates like this, but I kind of felt like a kid in a candy store here!

    If you want a fairly simple interface to your running Docker server, Portainer is great. It can start and stop containers, edit existing running apps (and even rename them, something I always have to do), and it's a great way to clean up your system after a session of adding/removing images. For example, you can look at the volumes tab (Figure 5) and quickly identify volumes no longer associated with a running container. It's something I never think about, so I had hundreds of abandoned volumes just sitting there.


    Figure 5. It's not that abandoned volumes were taking up a lot of room on my system, but I hate leaving things lying around. Portainer made cleanup easy.

    My go-to system for interacting with running containers is Portainer. It does what I need in a pinch, runs via web browser, and it has enough features that it's worth keeping around. It's open source, and it's being actively developed. I highly recommend it. In fact, one of the best things about Portainer is how easy it is to set up. The following one-liner will download the image, get the container going and give you access to the interface on port 9000:

    docker run -d -p 9000:9000 \
    -v /var/run/docker.sock:/var/run/docker.sock \

    I don't expose that to the internet, but when I'm out and about, a quick ssh command with a port-forward allows me full access to the Portainer instance. Thanks to the UNIX socket system, Portainer directly interacts with Docker, and there aren't any system configuration changes to make in order to get things done. That one-liner above is literally all it takes. (And for me, the first order of business in the GUI is to change the name of the container, because I always forget to do that when creating one!)

    The folks at offer a fully functional demo here (login is admin:tryportainer), which will give you a feel for what it can do without deploying it in your own environment. I'll admit, I've had mixed luck getting the demo to work (it often hangs on me), so it might be easier to spin up a quick container and check it out on your own system. Still, offering a demo is nice.


    • Web-based.
    • Simple setup (it runs in a container).
    • Easy to navigate.
    • User management.


    • Couldn't figure out how to change the restart policy on containers!
    Dockly, the Weird Cousin

    I'd be remiss not to mention one more interesting option, which is technically a GUI, although not in the traditional sense. Dockly is a GUI, but it's a Curses-based text GUI. Basically, if Kyle Rankin were looking for a GUI interface to Docker, Dockly likely would be his first choice. Heck, it even looks a bit like Mutt (Figure 6).


    Figure 6. Dockly isn't the prettiest GUI for Docker, but it does most of the same things the other GUIs do, and it functions completely inside a terminal window. It's worth a look.

    Admittedly, navigating the GUI via the keyboard is a bit cumbersome at first. It took me a while to get the feel for what Dockly really can do. Once I got used to the interface, however, I must admit it's pretty nice. Of all the management systems, it's definitely the easiest to connect with, because it runs in an SSH window.

    For instructions on how to set up and use Dockly, head over to the GitHub page. It uses node.js, which has been an issue for me in the past regarding conflicting versions. But since this is Docker, it can, of course, be run in its own container, making sure it has the exact version it needs.


    • Runs from a container.
    • Easy to set up.
    • Kyle Rankin-friendly (terminal window only).


    • Limited ability to modify containers.
    My Final Thoughts

    You know how sometimes you search the internet for the name of a particular actor, and then three hours later find yourself watching YouTube videos of cats getting scared by cucumbers? Well, my dive in to the world of Docker GUI interfaces was something like that. Portainer was one of the first I tried, and it ended up being the best. Still, I spent more than five hours installing and configuring various GUIs, ranging from the now defunct "Shipyard" to the extremely advanced "Rancher". Many were native applications, several required additional VMs installed locally in order to run, and most were more complicated than I wanted.

    I honestly wish Kitematic was a web-based GUI, because its integration with Docker is nice, and its simplistic look makes it easy to manage a simple infrastructure. If you're at the same computer all the time, checking out a native-GUI option might be worth your time. In the end, even though I have Portainer and Dockly running, I actually find myself ssh-ing into my Docker server and running commands by hand. It can be cumbersome, and I don't always remember the particular arguments. Still, it's just as easy to google for the answer as it is to log in to a GUI.

    But the graphs—the graphs are awful nice to look at!

    Shawn is Associate Editor here at Linux Journal, and has been around Linux since the beginning. He has a passion for open source, and he loves to teach. He also drinks too much coffee, which often shows in his writing.

    Load Disqus comments