lazydocker: a terminal UI for Docker and Compose
/lazydocker
lazydocker is a terminal UI that turns docker and docker-compose commands into single keypresses inside one gocui-based screen. Reach for it if you restart and tail logs across several Compose services all day; skip it if you need Swarm orchestration or a browser dashboard for teammates who don't live in a terminal.
What is lazydocker?
lazydocker is a terminal user interface for managing Docker and Docker Compose environments, built in Go on top of the gocui library. It shows container and service status, logs, and resource graphs in one terminal window, with keybindings for restarting, rebuilding, and removing containers instead of typing separate docker commands. It also prunes unused containers, images, and volumes from the same screen.
What you can do with lazydocker
- ✓See every container and Compose service's status in one panel, updated live, instead of re-running `docker-compose ps`.
- ✓Jump into a container or service's log stream with one keypress — a built-in docker logs viewer that stays open across restarts.
- ✓Watch ascii graphs of CPU, memory, and other container metrics in the terminal, and customize which metrics they track.
- ✓Attach to a running container or service directly from the panel.
- ✓Restart, remove, or rebuild containers and services without typing the docker or docker-compose command by hand.
- ✓Inspect the ancestor layers of any image to see what it's built from.
- ✓Prune containers, images, or volumes that are eating disk space, all from the same screen.
- ✓Built on the gocui terminal-UI library in Go, with mouse support alongside keybindings.
When lazydocker is the right tool
- •You're running several Docker Compose services locally and keep switching terminal tabs to check which one crashed.
- •You want to tail a service's logs without the stream dying every time that service restarts.
- •You need to restart, rebuild, or remove a container quickly without recalling the exact docker or docker-compose flags.
- •You want a quick visual read on container CPU and memory without wiring up a separate monitoring stack.
Installing lazydocker
lazydocker's README lists several install paths. On macOS or Linux with Homebrew, use `brew install jesseduffield/lazydocker/lazydocker` (the tapped formula) or `brew install lazydocker` from Homebrew core. On Windows, Scoop (`scoop install lazydocker`) and Chocolatey (`choco install lazydocker`) both work. Arch Linux users can run `yay -S lazydocker` via the AUR. If you have Go >= 1.19, `go install github.com/jesseduffield/lazydocker@latest` builds it directly; for Go <= 1.17 the README gives `go get github.com/jesseduffield/lazydocker` instead. There's also a one-line install script for Linux — `curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash` — though the README itself cautions you to check what you're piping into bash before running it. Binary releases for Linux, macOS, and Windows are on the GitHub releases page, and a Docker image (`lazyteam/lazydocker`) is available for running it in a container with the Docker socket mounted in. Requirements: Docker >= 29.0.0 (API >= 1.24) and, optionally, Docker-Compose >= 1.23.2.
Getting started with lazydocker
Run `lazydocker` in a terminal to open it. No config file is required to start. Add an alias since you'll type it often: `echo "alias lzd='lazydocker'" >> ~/.zshrc` (swap `.zshrc` for whatever shell rc file you use). The main screen splits into panels for projects, containers, services, and images; navigate with arrow keys or the mouse, and every action — restart, logs, attach — is bound to a single letter shown on screen. The README points to a separate keybindings reference and a short video walkthrough for the full key list rather than documenting every shortcut in prose.
Strengths
- ✓Every common docker and docker-compose action — restart, remove, rebuild, attach, view logs — sits behind a single keypress instead of a remembered command.
- ✓The panel layout keeps project, containers, services, and images visible at once, so you're not tabbing between terminal windows to check status.
- ✓Ascii graphs of container metrics render right in the terminal without wiring up a separate dashboard.
- ✓Ships as a single Go binary with install paths for Homebrew, Scoop, Chocolatey, the AUR, and `go install`, so it drops into an existing terminal workflow without a GUI app to manage.
What lazydocker doesn't do
- △No Swarm support is documented — the README's own alternatives section points to Portainer for that.
- △Only shows the last hour of logs by default; seeing more requires editing `commandTemplates` in the config file yourself.
- △Selecting text with the mouse needs an extra key (hold Option on Mac) since normal dragging is captured for clicking containers instead.
- △The README flags a known bug: running lazydocker inside its own Docker container hides logs and CPU stats.
- △Text wrapping in the main log panel is off by default because of CPU cost, so long lines get cut instead of wrapped unless you turn `gui.wrapMainPanel` on.
Alternatives to lazydocker
Frequently asked questions
lazydocker runs on macOS, Linux, and Windows. The README lists install methods for each: Homebrew works on macOS and Linux, Scoop and Chocolatey cover Windows, and binary releases are published for Linux, macOS, and Windows on the GitHub releases page.
lazydocker needs Docker version 29.0.0 or higher (API 1.24 or higher) installed and running. Docker-Compose 1.23.2 or higher is optional — lazydocker works without it, but Compose-specific features need it present.
Open lazydocker, click the project panel in the top left, and press 'o' (or 'e' if your editor is Vim) to open its config file directly. lazydocker's README points to a separate Config Docs page for the full list of settings.
lazydocker's own documentation doesn't mention Docker Swarm support. In its README's alternatives section, lazydocker points to Portainer specifically because Portainer supports Docker Swarm, which suggests Swarm isn't part of lazydocker's scope.
Select a container or service in lazydocker's panel and its log stream shows in the main window, no separate `docker logs` command needed. By default lazydocker only shows the last hour of logs; showing more requires editing `commandTemplates` in its config file.
lazydocker runs entirely in your terminal, while Portainer is a browser-based dashboard you access over the network. lazydocker's README also notes that Portainer supports Docker Swarm, a case lazydocker's own docs don't cover.
The problem it solves
Debugging a flaky Docker Compose service usually means juggling terminal windows: one running `docker-compose logs --follow myservice` that dies whenever the service restarts, another for `docker-compose ps` to check status, and a mental note of which alias does what. lazydocker's README describes this exact loop — checking status, restarting a container, then losing the log stream again — as the reason it exists.
Who should try it — and who should skip
This fits a developer who spends part of every day inside `docker` or `docker-compose` on the command line and is tired of retyping the same restart-then-check-logs loop. It also suits anyone comfortable in a terminal who wants one more keybinding-driven tool alongside things like vim or tmux. It's a worse fit for a team that needs a dashboard non-terminal users can open in a browser, or for anyone running Docker Swarm, since lazydocker's docs don't cover that case.
Is lazydocker worth your time?
ChatGPT, Claude and Perplexity can all read this page. Ask one of them what it makes of lazydocker.