o
r
e
concepts you need to understand:- **Panels**: The left side shows categorized lists (Containers, Services, Images, Volumes, Networks). The right side shows details, logs, or stats for the selected item.
- **Context-aware actions**: The same key performs different actions depending on which panel is focused. Pressing `d` on a container removes it; pressing `d` on an image removes the image.
- **Docker Compose integration**: When launched inside a directory with a `docker-compose.yml` file, LazyDocker groups services by project and adds Compose-specific actions like `up` and `down`.## Installation & SetupLazyDocker installs in under 60 seconds on any platform. You need Docker installed and your user added to the `docker` group (or equivalent access to the Docker socket).### Prerequisites```
bas
h
# Verify Docker is installed and running
docker --version
docker ps# Add your user to the docker group (Linux)
sudo usermod -aG docker $USER
# Log out and back in for group change to take effect
```### Method 1: Homebrew (macOS & Linux)```
bas
h
# Tap the official formula for frequent updates
brew install jesseduffield/lazydocker/lazydocker# Verify installation
lazydocker --version
# Output: Version: v0.24.5, Build date: 2026-04-15, Commit: abc1234
```### Method 2: Official Install Script (Linux)```
bas
h
# Automated install to ~/.local/bin
curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash# Add to PATH if needed
echo 'export PATH=$PATH:$HOME/.local/bin' >> ~/.bashrc
source ~/.bashrc
```### Method 3: Binary Download (All Platforms)```
bas
h
# Fetch latest release version
LAZYDOCKER_VERSION=$(curl -s "https://api.github.com/repos/jesseduffield/lazydocker/releases/latest" | grep '"tag_name":' | sed 's/.*"v\([^"]*\)".*/\1/')# Download Linu```
bas
h
# Verify Docker is installed and running
docker --version
docker ps

# Add your user to the docker group (Linux)
sudo usermod -aG docker $USER
# Log out and back in for group change to take effect
```st
e
m
-wide
tar xf lazydocker.tar.gz lazydocker
sudo install lazydocker /usr/local/bin/
rm lazydocker lazydocker.tar.gz
```### Method 4: Go Install```
bas
h
# Requires Go >= 1.19
go install github.com/jesseduffield/lazydocker@latest# Binary ```
bas
h
# Tap the official formula for frequent updates
brew install jesseduffield/lazydocker/lazydocker

# Verify installation
lazydocker --version
# Output: Version: v0.24.5, Build date: 2026-04-15, Commit: abc1234
```s
o
c
k
\
  -v ~/.config/lazydocker:/.config/jesseduffield/lazydocker \
  lazyteam/lazydocker:latest# Create a shell alias for convenience
echo "alias lzd='docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock -v ~/.config/lazydocker:/.config/jesseduff```
bas
h
# Automated install to ~/.local/bin
curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash

# Add to PATH if needed
echo 'export PATH=$PATH:$HOME/.local/bin' >> ~/.bashrc
source ~/.bashrc
```a
y
s
the main interface. The layout splits into left navigation panels and a right content panel showing logs or stats for the selected item.![LazyDocker Interface Demo](https://raw.githubusercontent.com/jesseduffield/lazydocker/master/assets/demo.gif)![LazyDocker Screenshot](https://raw.gith```
bas
h
# Fetch latest release version
LAZYDOCKER_VERSION=$(curl -s "https://api.github.com/repos/jesseduffield/lazydocker/releases/latest" | grep '"tag_name":' | sed 's/.*"v\([^"]*\)".*/\1/')

# Download Linux x86_64 binary
curl -Lo lazydocker.tar.gz "https://github.com/jesseduffield/lazydocker/releases/download/v${LAZYDOCKER_VERSION}/lazydocker_${LAZYDOCKER_VERSION}_Linux_x86_64.tar.gz"

# Extract and install system-wide
tar xf lazydocker.tar.gz lazydocker
sudo install lazydocker /usr/local/bin/
rm lazydocker lazydocker.tar.gz
```w
help overlay |
| `/` | Filter current list |### Container Actions| Key | Action |
|-----|--------|
| `r` | Restart container |
| `s` | Stop container |
| `d` | Remove container (with confirmation) |
| `p` | Pause / unpause container |
| `e` | Hide/show stopped containers |
| `E` | Exec into container (open shell) |
| `a` | Attach to container |
| `m` | View logs |
| `u` | View CPU/memory stats |
| `w` | Open exposed port in browser |
| `b` | View bulk commands |
| `c` | Run custom predefined command |### Docker Compose Service Actions| Key | A```
bas
h
# Requires Go >= 1.19
go install github.com/jesseduffield/lazydocker@latest

# Binary lands in ~/go/bin
export PATH=$PATH:$HOME/go/bin
```| Stop service |
| `S` | Start service |
| `r` | Restart service |
| `R` | View restart options |
| `E` | Exec shell in service container |### Image & Volume Actions| Key ```
bas
h
# Run without installing — mounts Docker socket for full access
docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.config/lazydocker:/.config/jesseduffield/lazydocker \
  lazyteam/lazydocker:latest

# Create a shell alias for convenience
echo "alias lzd='docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock -v ~/.config/lazydocker:/.config/jesseduffield/lazydocker lazyteam/lazydocker'" >> ~/.bashrc
```i
o
u
s
/ next log page |## Configuration & CustomizationLazyDocker stores configuration in platform-specific paths. Press `o` in the Project panel (or `e` to edit in your default editor) to open the config file directly from the TUI.### Config File Locations| OS | Path |
|----|------|
| Linux | `~/.config/lazydocker/config.yml` |
| macOS | `~/Library/Application Support/jesseduffield/lazydocker/config.yml` |
| Windows | `C:\Users\<User>\AppData\Roamin```
bas
h
# Launch LazyDocker
lazydocker

# Launch with debug output for troubleshooting
lazydocker --debug
```langua
g
e
: "en"  # auto | en | fr | de | es | pl | nl | tr | zh
  border: "rounded"  # rounded | single | double | hidden
  theme:
    activeBorderColor:
      - cyan
      - bold
    inactiveBorderColor:
      - white
    selectedLineBgColor:
      - black
    selectedLineFgColor:
      - yellow
    optionsTextColor:
      - blue
  scrollHeight: 2
  sidePanelWidth: 0.333
  screenMode: "normal"  # normal | half | fullscreen
```### Log Display Settings```
yam
l
logs:
  timestamps: true
  since: "60m"    # Show logs from last 60 minutes; '' = all time
  tail: "200"     # Number of lines to display
```### Custom CommandsAdd your own commands accessible via the `c` key:```
yam
l
customCommands:
  containers:
    - name: bash
      attach: true
      command: "docker exec -it {{ .Container.ID }} bash"
      serviceNames: []
    - name: debug-network
      attach: false
      command: "docker inspect {{ .Container.ID }} --format='{{range $k, $v := .NetworkSettings.Networks}}{{$k}}: {{.IPAddress}}\n{{end}}'"
```Availa
b
l
e
template variables: `{{ .Container.ID }}`, `{{ .Container.Name }}`, `{{ .Service.Name }}`, `{{ .DockerCompose }}`.### Podman SupportLazyDocker works with Podman by swapping the command templates:```
yam
l
commandTemplates:
  docker: "podman"
  dockerCompose: "podman-compose"
  containerInspect: "podman inspect {{ .Container.ID }}"
```## Integration with Popular Tools### Docker Compose ProjectsLazyDocker automatically detects `docker-compose.yml` or `compose.yml` in the current directory. Services appear grouped under the Services panel with project-level actions.```
bas
h
# Navigate to your Compose project
cd ~/projects/my-app# Launch — services panel populates automatically
lazydocker
```Wit
h
i
n
the Services panel:
- Press `u` to bring up a single service
- Press `U` to start the entire project
- Press `D` to tear down the full stack
- Press `E` to exec into a service container### Tmux IntegrationFor tmux users, add a keybinding to launch LazyDocker in a popup or split:```
bas
h
# ~/.tmux.conf
# Open LazyDocker in a popup window
bind D display-popup -E -w 90% -h 90% "lazydocker"# Or open in a new vertical split
bind d split-window -h "lazydocker"
```Rel
o
a
d
and use `Ctrl+b D` to open:```
bas
h
tmux source-file ~/.tmux.conf
```### Zsh / Bash Aliases```
bas
h
# ~/.bashrc or ~/.zshrc
alias lzd="lazydocker"
alias lzd-logs="lazydocker --logs"# Quick jump to project and launch
alias lzd-here="cd $PWD && lazydocker"# Source your shell config
source ~/.bashrc
```### VS Code IntegrationAdd a VS Code task to launch LazyDocker in the integrated terminal:```
jso
n
// .vscode/tasks.json
{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "LazyDocker",
      "type": "shell",
      "command": "lazydocker",
      "problemMatcher": [],
      "presentation": {
        "```
yam
l
# ~/.config/lazydocker/config.yml
gui:
  language: "en"  # auto | en | fr | de | es | pl | nl | tr | zh
  border: "rounded"  # rounded | single | double | hidden
  theme:
    activeBorderColor:
      - cyan
      - bold
    inactiveBorderColor:
      - white
    selectedLineBgColor:
      - black
    selectedLineFgColor:
      - yellow
    optionsTextColor:
      - blue
  scrollHeight: 2
  sidePanelWidth: 0.333
  screenMode: "normal"  # normal | half | fullscreen
```thubuserconte
n
t
.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash
          sudo mv ~/.local/bin/lazydocker /usr/local/bin/      - name: Start services
        run: docker compose up -d      - name: Inspect with LazyDocker
        run: |
          lazydocker --version
          # Export container list for logs
          docker ps --format "table {{.Names}}\t{{.Status}}"
```## Benchmarks & Real-World Use Cases### Resource Overhead ComparisonLazyDocker adds virtu```
yam
l
logs:
  timestamps: true
  since: "60m"    # Show logs from last 60 minutes; '' = all time
  tail: "200"     # Number of lines to display
```u
p
Time | Background Process |
|----------|------------|---------------|--------------|-------------------|
| LazyDocker | ~15 MB | ~20 MB | <200 ms | None |
| Docker Desktop | ~1.5 GB | ~400-800 MB | 10-30 s | Yes (```
yam
l
customCommands:
  containers:
    - name: bash
      attach: true
      command: "docker exec -it {{ .Container.ID }} bash"
      serviceNames: []
    - name: debug-network
      attach: false
      command: "docker inspect {{ .Container.ID }} --format='{{range $k, $v := .NetworkSettings.Networks}}{{$k}}: {{.IPAddress}}\n{{end}}'"
```inst
a
n
t
container status, live log tailing, and quick restarts over SSH without running a web service. Resource footprint: zero when not running.**Scenario 2: Microservices Development (8 services)**
A team runs 8 Docker Compose services locally. LazyDocker groups services by project, shows which containers are restarting, and lets developers exec into failing services with a single keystroke. Average debugging workflow reduced from 45 seconds of CLI typing to 5 seconds of keyboard navigation.**Scenario 3: CI/CD Debugging**
A DevOps engine```
yam
l
commandTemplates:
  docker: "podman"
  dockerCompose: "podman-compose"
  containerInspect: "podman inspect {{ .Container.ID }}"
``` but the `--logs` export and container list commands provide structured debug output.## Advanced Usage & Production Hardening### Running on Remote Hosts via SSHLazyDocker does not natively support remote Docker hosts, but you can forward the Docker socket over SSH:```
bas
h
# Forward remote Docker socket to local machine
ssh -nNT -L /tmp/docker_remote.sock:/var/ru```
bas
h
# Navigate to your Compose project
cd ~/projects/my-app

# Launch — services panel populates automatically
lazydocker
```lazydock
e
r
# Clean up when done
kill %1
rm /tmp/docker_remote.sock
```Alternative
l
y
, use SSH context directly:```
bas
h
# Create Docker context for remote host
docker context create remote --docker "host=ssh://user@remote-server"
docker context use remote# LazyDocker uses the active context automatically
lazydocker
```### Non-Root User Setup```
bas
h
# Create docker group if it doesn't exist
sudo groupadd```
bas
h
# ~/.tmux.conf
# Open LazyDocker in a popup window
bind D display-popup -E -w 90% -h 90% "lazydocker"

# Or open in a new vertical split
bind d split-window -h "lazydocker"
```/bash
# ~/bin/docker-cleanup.sh
# One-key cleanup script integrated with LazyDockerecho "Removing stopped containers..."
docker container prune -fecho "Removing dangling images..."
docker image prune -fecho "```
bas
h
tmux source-file ~/.tmux.conf
``` prune -fecho "Removing unused networks..."
docker networ```
bas
h
# ~/.bashrc or ~/.zshrc
alias lzd="lazydocker"
alias lzd-logs="lazydocker --logs"

# Quick jump to project and launch
alias lzd-here="cd $PWD && lazydocker"

# Source your shell config
source ~/.bashrc
```tor
i
n
g
by piping `docker stats` to Prometheus Node Exporter textfile collector:```
bas
h
#!/bin/bash
# cron job every 60 seconds
while true; do
  docker stats --no-stream --format \
    "container_cpu_usage{name=\"{{.Name}}\"} {{.CPUPerc}}\ncontainer_memory_usage{name=\"{{.Name}}\"} {{.MemUsage}}" \
```j
s
o
n
// .vscode/tasks.json
{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "LazyDocker",
      "type": "shell",
      "command": "lazydocker",
      "problemMatcher": [],
      "presentation": {
        "echo": true,
        "reveal": "always",
        "focus": true,
        "panel": "new"
      }
    }
  ]
}
```nst
a
l
l
size | ~15 MB | ~1.5 GB | ~80 MB image | ~300 MB image |
| RAM overhead | ~20 MB (ephemeral) | ~400-800 MB | ~100-200 MB | ~500 MB+ |
| Multi-host | No (SSH workarounds) | Limited | Yes (agents) | Yes (clusters) |
| Kubernetes | No | Yes (local) | Yes | Yes (primary) |
| Docker Compose | Full support | Full support | Stack-based | Limited |
| Multi-user / RBAC | No | No | Yes (BE edition) | Yes |
| Works over SSH | Yes | No | Via```
yam
l
# .github/workflows/debug.yml
name: Debug Containers
on: workflow_dispatch
jobs:
  debug:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install LazyDocker
        run: |
          curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash
          sudo mv ~/.local/bin/lazydocker /usr/local/bin/

      - name: Start services
        run: docker compose up -d

      - name: Inspect with LazyDocker
        run: |
          lazydocker --version
          # Export container list for logs
          docker ps --format "table {{.Names}}\t{{.Status}}"
```g
e
containers from a phone or tablet, Portainer's responsive web UI is the better choice.
- **No RBAC or user management**: LazyDocker inherits your OS user's Docker permissions. There is no concept of teams, roles, or audit trails.
- **No Kubernetes support**: LazyDocker handles Docker and Docker Compose only. For Kubernetes workloads, use `k9s`, Rancher, or `kubectl` directly.
- **Single-user only**: Two engineers cannot simultaneously use the same LazyDocker session. Each user runs their own instance.
- **TUI learning curve**: Engineers unfamiliar with keyboard-driven interfaces (vim, tmux) may find the initial learning curve steeper than clicking through a web UI.
- **Read-heavy, write-cautious**: While LazyDocker supports destructive actions (remove, stop), it adds confirmation prompts that slow down bulk operations compared to scripted CLI workflows.## Frequently Asked Questions**Q: Does LazyDocker replace the Docker CLI?**No. LazyDocker complements the CLI by providing a visual overview and quick actions. For scripting, automation, and CI/CD pipelines, the Docker CLI remains the correct tool. Many developers use both: LazyDocker for interactive exploration and `docker` commands for reproducible workflows.**Q: Can I use LazyDocker with Podman?**Yes. LazyDocker supports Podman through configuration overrides. Set `commandTemplates.docker` to `podman` and `commandTemplates.dockerCompose` to `podman-compose` in your `config.yml`. A community wrapper called `lazypodman` also exists for seamless Podman integration.**Q: How do I view logs from a crashed container?**Navigate to the Containers panel, press `e` to toggle visibility of stopped containers, select the crashed container, and press `m` to view its logs. Use `g` to jump to the start of the log stream and `G` to jump to the end.**Q: Is LazyDocker safe to use in production?**LazyDocker is safe because it is a client-side tool with no background service. It connects to the Docker socket with whatever permissions your user has. In production, limit Docker socket access to authorized users, avoid running LazyDocker on production hosts unless necessary, and prefer read-only operations (viewing logs and stats) over destructive actions.**Q: Can I run LazyDocker inside a Docker container?**Yes. Mount the host's Docker socket into the container with `-v /var/run/docker.sock:/var/run/docker.sock`. T```
bas
h
# Forward remote Docker socket to local machine
ssh -nNT -L /tmp/docker_remote.sock:/var/run/docker.sock user@remote-server &

# Point LazyDocker at the forwarded socket
export DOCKER_HOST=unix:///tmp/docker_remote.sock
lazydocker

# Clean up when done
kill %1
rm /tmp/docker_remote.sock
```v
a
r
/run/docker.sock`. Ensure your user is in the `docker` group, the Docker daemon is running (`sudo systemctl status docker`), and the `DOCKER_HOST` environment variable is not set to an invalid value. On macOS, verify Docker Desktop is running.**Q: How do I customize keybindings?**LazyDocker does not support full keybinding rem```
bas
h
# Create Docker context for remote host
docker context create remote --docker "host=ssh://user@remote-server"
docker context use remote

# LazyDocker uses the active context automatically
lazydocker
```t
o
the TUI.### Self-Hosting NoteRunning this on your own VPS? Try DigitalOcean with $200 free credit
 — enough for 2 months of moderate self-hosting to test the setup risk-free.```
bas
h
# Create docker group if it doesn't exist
sudo groupadd -f docker

# Add current user
sudo usermod -aG docker $USER

# Apply without logout (Linux only)
newgrp docker

# Verify
lazydocker
```, a single-binary distribution, and sub-200-millisecond startup, it eliminates the friction of context-switching between browser tabs or memorizing CLI flags. For individual developers, homelab operators, and anyone who lives```
bas
h
#!/bin/bash
# ~/bin/docker-cleanup.sh
# One-key cleanup script integrated with LazyDocker

echo "Removing stopped containers..."
docker container prune -f

echo "Removing dangling images..."
docker image prune -f

echo "Removing unused volumes..."
docker volume prune -f

echo "Removing unused networks..."
docker network prune -f

echo "Cleanup complete. Remaining resources:"
docker system df
```A
d
d
shell aliases for `lzd` and integrate with tmux for popup accessJoin the [dibi8 Telegram community](https://t.me/dibi8_chat) to share your LazyDocker workflow tips and get help from other developers managing containers at scale.







## Recommended Hosting & InfrastructureBefore you deploy any of the tools above into production, you'll need solid infrastructure. Two options dibi8 actually uses and recommends:- **DigitalOcean
** — $200 free credit for 60 days across 14+ global regions. The default option for indie devs running open-source AI tools.
- **```
bas
h
#!/bin/bash
# cron job every 60 seconds
while true; do
  docker stats --no-stream --format \
    "container_cpu_usage{name=\"{{.Name}}\"} {{.CPUPerc}}\ncontainer_memory_usage{name=\"{{.Name}}\"} {{.MemUsage}}" \
    > /var/lib/node_exporter/textfile_collector/docker_stats.prom
  sleep 60
done
```js
o
n
[LazyDocker GitHub Repository](https://github.com/jesseduffield/lazydocker)
- [Official Keybindings Reference](https://github.com/jesseduffield/lazydocker/blob/master/docs/keybindings/Keybindings_en.md)
- [Configuration Documentation](https://github.com/jesseduffield/lazydocker/blob/master/docs/Config.md)
- [LazyDocker Installation Guide](https://github.com/jesseduffield/lazydocker#installation)
- [LazyDocker Official Website](https://lazydocker.com)
- [Portainer vs LazyDocker Comparison (OneUptime)](https://oneuptime.com/blog/post/2026-03-20-portainer-vs-lazydocker-terminal/view)
- [DataCamp LazyDocker Tutorial](https://www.datacamp.com/tutorial/lazydocker)
- [LazyDocker Podman Extension](https://github.com/szchan/lazydocker-podman)<!--auto-references-->
## References & Sources- [LazyDocker](https://github.com/jesseduffield/lazydocker)
- [LazyGit](https://github.com/jesseduffield/lazygit)
- [gocui](https://github.com/jroimartin/gocui)
- [Podman](https://github.com/containers/podman)
- [podman-compose](https://github.com/containers/podman-compose)
- [k9s](https://github.com/derailed/k9s)
- [Portainer](https://github.com/portainer/portainer)
- [Rancher](https://github.com/rancher/rancher)
- [Prometheus Node Exporter](https://github.com/prometheus/node_exporter)