Lazydocker: Manage Docker Containers from Your Terminal

Lazydocker: Manage Docker Containers from Your Terminal

Docker's CLI is powerful, but managing containers through raw commands gets tedious fast. Checking logs means docker logs -f container_name. Viewing stats means docker stats. Restarting means docker restart container_name. Each operation requires remembering the exact command, the container name, and the right flags. Multiply that by a dozen containers in a Compose stack and you are constantly switching between terminal windows and re-typing boilerplate.

Lazydocker solves this by putting everything into a single terminal UI. Containers, images, volumes, logs, stats, and common actions are all visible at once. Navigate with arrow keys, press a single letter to restart or stop a container, and watch logs stream in real time -- all without leaving one terminal window.

What Is Lazydocker?

Lazydocker is an open-source terminal UI (TUI) for Docker and Docker Compose, written in Go by Jesse Duffield (the same developer behind Lazygit). It presents a multi-panel interface that shows your containers, images, and volumes in the left panel, with logs, stats, and configuration details in the right panel. You navigate between panels and items using keyboard shortcuts, and perform actions like restart, stop, remove, and exec with single keystrokes.

It connects to the Docker daemon on your machine and reads the same information you would get from docker ps, docker logs, docker stats, and docker inspect -- but presented in a unified, live-updating dashboard.

Installation

Lazydocker is a single Go binary with no dependencies beyond a working Docker installation. There are several ways to install it.

Homebrew (macOS / Linux)

brew install lazydocker

Go Install

If you have Go 1.19 or later installed:

go install github.com/jesseduffield/lazydocker@latest

Make sure $GOPATH/bin (or $HOME/go/bin) is in your PATH.

Binary Download

Grab a prebuilt binary from the GitHub releases page:

# Linux (amd64)
curl -Lo lazydocker.tar.gz \
  https://github.com/jesseduffield/lazydocker/releases/latest/download/lazydocker_Linux_x86_64.tar.gz
tar xzf lazydocker.tar.gz lazydocker
sudo mv lazydocker /usr/local/bin/

Docker (Ironic but Works)

You can run Lazydocker inside a container by mounting the Docker socket:

docker run --rm -it \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.config/lazydocker:/.config/jesseduffield/lazydocker \
  lazyteam/lazydocker

This is useful on systems where you do not want to install extra binaries, though running it natively is faster and simpler.

Package Managers

# Arch Linux
pacman -S lazydocker

# Fedora (COPR)
sudo dnf copr enable atim/lazydocker
sudo dnf install lazydocker

# Nix
nix-env -iA nixpkgs.lazydocker

# Scoop (Windows)
scoop install lazydocker

After installation, run lazydocker in any terminal and the interface appears immediately.

Core Features

Container Management

The left panel lists all containers with their current status (running, paused, exited). Select a container and the right panel updates to show its logs, stats, or configuration. From the container list, single keystrokes perform common actions:

• d -- Remove the container
• s -- Stop the container
• r -- Restart the container
• a -- Attach to the container
• e -- Open a shell (exec) inside the container
• m -- View top processes (like docker top)

No more typing docker exec -it my-container /bin/sh -- just press e.

Live Logs

The logs panel streams container output in real time, equivalent to docker logs -f. You can scroll through the history, and the output is color-coded. If a container is producing errors, you see them immediately without opening a separate terminal.

Resource Stats

The stats panel shows CPU usage, memory consumption, network I/O, and disk I/O for the selected container. This is the same data as docker stats but displayed inline alongside your logs and container list. Spotting a memory leak or CPU spike is as simple as glancing at the stats panel while browsing logs.

Image and Volume Management

Switch to the Images or Volumes panel to see all local Docker images and volumes. From there you can remove unused images, inspect layer details, or delete orphaned volumes. This is particularly useful for reclaiming disk space -- Docker images accumulate fast, and finding the ones you no longer need through docker images is cumbersome.

Docker Compose Awareness

If you launch Lazydocker from a directory containing a docker-compose.yml file, it automatically groups containers by their Compose service. You can see the entire stack at a glance and perform bulk operations. This is where Lazydocker really shines over raw CLI usage -- managing a multi-service Compose project becomes genuinely pleasant.

Keybindings

Lazydocker is keyboard-driven. Here are the most important bindings:

Press x on any selected item to see a context menu of every action available for that resource type. This is the best way to discover features you did not know existed.

Configuration

Lazydocker's configuration lives at ~/.config/lazydocker/config.yml. The defaults are sensible, but you can customize behavior, keybindings, and appearance.

gui:
  # Show all containers (including stopped)
  showAllContainers: true
  # Scroll speed
  scrollHeight: 2
  # Expand focused side panel
  expandFocusedSidePanel: true
  # Screen mode: normal, half, fullscreen
  screenMode: "normal"
  # Theme (the default is already quite good)
  theme:
    activeBorderColor:
      - green
      - bold
    inactiveBorderColor:
      - white

commandTemplates:
  # Customize the shell command used by 'exec'
  dockerCompose: "docker compose"
  # Override the restart command
  restartService: "docker compose restart {{ .Service.Name }}"

os:
  # Custom editor for viewing config files
  openCommand: "vim {{filename}}"

reporting: "off"

You can also define custom commands that appear in the x menu. For example, adding a command to tail the last 100 lines of logs for a specific service, or to run a database migration inside a container.

Lazydocker vs Portainer vs Docker Desktop

Each tool targets a different workflow. Choosing between them depends on where you work and how you work.

Lazydocker is the best option for solo developers who live in the terminal. It uses virtually no resources, works perfectly over SSH, and requires no setup beyond installing a single binary. If you are already comfortable in the terminal and just want a better way to interact with Docker, this is the tool.

Portainer is a web-based management UI that runs as a Docker container. It excels at managing multiple Docker hosts from a single dashboard and is the right choice for teams that need a shared interface. The Community Edition is free and covers most use cases. The tradeoff is that it runs as a service consuming resources, and you need a browser to use it.

Docker Desktop provides a full native GUI application with integrated Docker engine, Kubernetes, and build tools. It is the most feature-rich option but also the heaviest -- it runs a Linux VM on macOS and Windows, consuming significant memory. For larger organizations, it requires a paid subscription. If you are already using Docker Desktop and happy with it, Lazydocker can still be useful as a faster alternative when you just need to check logs or restart a container without opening a GUI.

When to Use Lazydocker

Lazydocker fits naturally into several common scenarios:

Local development with Docker Compose: When you have a multi-service stack running locally, Lazydocker gives you a single view of all containers, their logs, and their resource usage. This is its sweet spot.

Debugging production containers over SSH: SSH into a server, run lazydocker, and you have immediate visibility into everything running on that host. No need to install a web UI or forward ports.

Quick container cleanup: When your disk is full of old images and dangling volumes, Lazydocker makes it easy to browse and remove them interactively instead of chaining together docker image prune and docker volume prune commands.

Learning Docker: For developers new to Docker, the visual layout makes it much easier to understand the relationship between images, containers, and volumes than reading CLI output.

If your workflow involves Kubernetes, multi-host orchestration, or team-based access control, look at Portainer or dedicated Kubernetes tools instead. Lazydocker is intentionally focused on single-host Docker management, and that focused scope is what makes it so effective at what it does.

Conclusion

Lazydocker removes the friction from everyday Docker management. It replaces a dozen CLI commands with a single, unified terminal interface that stays out of your way. Installation takes thirty seconds, it runs anywhere Docker runs (including over SSH), and the keyboard-driven workflow is fast enough that you will probably stop opening Docker Desktop for routine tasks. For anyone who works with Docker regularly and prefers the terminal, Lazydocker is one of those tools that earns a permanent spot in your workflow.