* [wip] port to stereoscope
* revert wip stereoscope port
- the v1/v2 split behind `dev.use-stereoscope` is being replaced by an in-place port onto stereoscope
- reusable pieces (progress handlers, bubbletea setup) get pulled back from f14b994 as needed
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* add docker-free image fixture builder
- `internal/imagefixture` writes deterministic image tarballs from handwritten layer specs: legacy `docker save`, docker 25+ OCI `docker save` (uncompressed, gzip or zstd layers) and plain oci-archive
- named fixture set covering whiteouts (file, dir, opaque, missing target), links, history edge cases, mode/uid only changes and duplicated files, plus the checked in `.data` save tarballs
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* record export and CI parity goldens from the current parser
- `internal/imagefixture/testdata/golden/<fixture>.export.json` and `<fixture>.ci.json` capture what the pre-stereoscope code produces for every fixture, so the stereoscope port can be checked against them without the old code
- regenerate with `UPDATE_GOLDEN=true go test ./cmd/dive/cli/internal/command/...`
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* add stereoscope v0.3.4 and wire its bus and logger
- stereoscope publishes on dive's partybus and logs through dive's logger (nested under `from-lib=stereoscope`)
- `go` directive moves to 1.26.8 (stereoscope's minimum), CI bootstraps go 1.26.x to match
- `docker/cli` moves to v29.8.2 (via stereoscope), `docker/docker` to v28.5.2 so the existing resolver still builds against the newer `go-connections`
- `scylladb/go-set` stays on the pseudo version stereoscope pins (386 fix, never tagged); a `replace` back to v1.0.2 would break `go install ...@latest`
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* build linux releases with containers-storage support
- linux builds get `-tags containers_image_openpgp,exclude_graphdriver_btrfs` (same as syft), which compiles in stereoscope's containers-storage provider for podman/buildah stores
- still `CGO_ENABLED=0` and static; darwin/windows are unchanged since there's no local store there
- linux/amd64 binary grows about 7MB (21MB to 28MB)
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* add stereoscope based image analysis
- `dive.Analyze(ctx, ref, img)` derives layer info (diff ID, history command, size) and efficiency stats from a
stereoscope image, exposing the image itself on `Analysis`
- efficiency walks each layer's own tree and sizes whiteouts from the squashed tree of the layers below, no
restacking
- a whiteout of a path no lower layer has is skipped instead of cutting the layer's walk short
- inefficiencies come sorted largest first with ties ordered by path
- `imagefixture.Load` reads a fixture through stereoscope
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* cover stereoscope efficiency on fixture images
duplicates, removed files and dirs, opaque dirs, whiteouts of missing paths and hardlinks
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* add JSON export from the stereoscope analysis
`export.NewExportFromAnalysis` sits alongside `NewExport` with the same JSON shape:
- `layer[].id` and `layer[].digestId` are both the diff ID
- file lists walk each layer's own tree using the tar header as written, so hardlinks stay links
- implicit parent dirs (no tar header) are left out instead of showing up as empty entries
- `FileInfo` is now export's own type rather than `dive/filetree`'s
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* evaluate CI rules from a stats value
rules and the report read `ci.Stats` (efficiency, wasted bytes, user wasted percent, inefficient files) instead of
`*image.Analysis`, so both analyses can feed the evaluator. `ci.NewStats` reads the stereoscope analysis,
`ci.NewStatsFromImageAnalysis` the old one. Rules and report text are unchanged
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* check export and CI goldens against the stereoscope path
the golden tests now load every fixture through stereoscope and run `dive.Analyze`, `NewExportFromAnalysis` and
the CI evaluator. The old parser versions of these tests are gone (git history has their goldens).
every difference from the old goldens is intentional:
- all 17 `*.export.json`: `layer[].id` is now the diff ID (was the legacy layer dir hash, or `"blobs"` for OCI saves)
- `history-fewer-than-layers.export.json`, `no-history.export.json`: `digestId` is the diff ID even without a
history entry (was `""`)
- `implicit-parent-dirs.export.json`: implicit parent dirs no longer show up as empty `path: ""` entries
- `duplicate-files-across-layers.{export,ci}.json`, `test-docker-image.{export,ci}.json`,
`test-oci-docker-image.{export,ci}.json`: equal size inefficient files are ordered by path (was `sort.Sort` order)
- `whiteout-missing-target.{export,ci}.json`: a whiteout of a path no lower layer has no longer aborts the layer's
efficiency walk, so `/opt/a` counts as 250 wasted bytes, efficiency goes 0.99 -> 0.5 and both rule sets now fail
`lowestEfficiency` and `highestUserWastedPercent`
- `oci-archive-gzip`: layer order comes from the index now, but the fixture has one layer so only `id` changes
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* add stereoscope based image source loading
- `source.Load` resolves a reference to a stereoscope image, caller owns `img.Cleanup()`
- accepts dive's `docker://` style and stereoscope's `docker:` style schemes
- new sources: oci-archive, oci-dir, registry (`oci-registry`), containerd, containers-storage, auto
- docker client keeps dive's host resolution (`DOCKER_HOST`, `DOCKER_CONTEXT`, config context, ssh hosts)
- podman reads containers-storage first on linux, then the podman socket
- `source.Build` wraps `docker build` / `podman build` and returns a loadable reference
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* accept the new image sources and add --platform
- `--source` / `container-engine` accept every `source.Sources` value plus the `docker-tar` and `oci-registry` aliases
- new `--platform` / `platform` option
- `Analysis.Reference` keeps the image argument as given (scheme included) for `source.Load`
- the old resolver path keeps working off `Analysis.Source` and `Analysis.Image`
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* add bubbletea progress handlers copied from syft
- depend on `github.com/anchore/bubbly` v0.2.2 (brings in bubbletea v1.3.10)
- handlers for stereoscope's pull docker, pull containerd, fetch image and read image events, copied from syft v1.55.0 without the cataloger/SBOM parts
- per layer rows from the new `ReadLayer` event, nested under the read image row and dropped once each layer is indexed
- dive's `TaskStarted` events render as one task tree; tasks that reuse an ID (dive passes the image name for several tasks) still get their own row
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* add a bubbletea progress UI that hands off to the TUI
- `ui.New` picks the bubbletea progress UI on an interactive terminal and the existing line based UI otherwise (no TTY, piped stdin, `--quiet`, `-v`, `NO_TTY`, or `CI` set)
- on `ExploreAnalysis` the progress program quits and restores the terminal before the gocui TUI starts; both UIs share one handoff function
- reports and notifications are held until the progress UI exits, the report text on stdout matches the line based UI
- ctrl-c / esc while the progress UI owns the terminal publishes an interrupt exit event
- console log output (dive's and stereoscope's, which share a logger) is muted while a UI draws, file logging is left alone
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* add a UI-only file tree built from stereoscope trees
- ported the view parts of `dive/filetree` (nodes, view info, render, sort, diff marks) into `ui/v1/filetree`
- the bottom of a layer range is the layer's precomputed `SquashedTree`, each top layer's own tree is compared in turn, same marks as before
- compare trees are built on demand per range and cached, instead of eagerly for every range
- "modified" content checks hash lazily through the image file catalog, only for files present on both sides with equal metadata, cached per file reference
- file metadata comes from the original tar header so hardlinks, sizes and modes look the same as before
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* run the TUI and extract on the stereoscope analysis
- `ExploreAnalysis` now carries a `*dive.Analysis` and blocks the publisher until the TUI is done with it, so the caller can clean up the image afterwards (the payload type sits in the `event` package for now, `payload` importing `dive` is an import cycle until the old resolvers go)
- layer views derive the id, short id and "FROM <id>" from the layer diff ID; image details list inefficiencies in their new (largest first) order
- extract reads the selected layer's files under the selected path from the loaded image instead of re-saving it, and writes them relative to the cwd as before, refusing absolute or `..` tar names, paths through symlinks that leave the cwd, and existing symlinks at a file's own path. It now matches the selected path exactly instead of as a string prefix
- temporary bridge: the old command path loads the image again through `dive/source` for the TUI
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* run dive and dive build on the stereoscope path
- both commands now go options -> `source.Load` -> `dive.Analyze` -> `--json` export, `--ci` evaluation or the TUI, the temporary bridge and the old resolver/adapter calls are gone
- `dive build` runs `source.Build` and loads the built image by its ID; `auto` builds with docker. It keeps the line UI since the build subprocess writes to the terminal
- `dive` uses `ui.New` (bubbletea progress UI where the terminal allows it)
- same task rows as before (Loading, Analyzing, Exporting, Evaluating, Building), and a failed task now stops its spinner
- every `source.Load` temp dir hangs off one generator and `source.Cleanup()` runs after `app.Run()`, so an interrupt (which skips the command's own cleanup) no longer leaves the image copy behind
- the "this can take a while" notification is dropped
- `--json` truncates an existing file instead of writing over its start
- `options.Analysis` keeps only `Image` (the raw reference), `V1UI` is now `LineUI`
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* delete the old image parser and file tree
- `dive/filetree`, `dive/image` (docker and podman resolvers included), `dive.GetImageResolver` and `command/adapter` are gone, stereoscope is the only image model now
- `export.NewExportFromAnalysis` is now `export.NewExport`, `ci.NewStatsFromImageAnalysis` is gone
- the `ExploreAnalysis` payload moves back to `internal/bus/event/payload`
- `docker/docker` is no longer a dependency
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* move the TUI from ui/v1 to ui/tui
- package `v1` is now `tui`, the line UI lives in `ui/line_ui.go`, no behavior change
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* deprecate --ignore-errors
- path errors no longer block the TUI, so the flag gates nothing. It is still accepted (flag and `ignore-errors` config) and warns when set
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* make the CLI tests run without docker
- tests that need docker or podman skip with the reason when the engine (or dive's docker config) isn't reachable
- new docker-free tests run the real command against docker-archive and oci-archive fixtures for `--json` (checked against the export goldens) and `--ci` pass/fail
- the default CI config test now runs `--ci` on the archive instead of relying on a load failure
- snapshots no longer embed the repo path; layer `id` in the JSON snapshot is now the diff ID, and inefficient file ties are ordered by path
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* move to golangci-lint v2
- v1.64.8 is built with go1.24 and refuses the go 1.26 module, binny now pins v2.14.0
- `.golangci.yaml` migrated with `golangci-lint migrate` (same funlen limits, default linters)
- fixes the staticcheck findings v2 reports
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* document the new image sources
- sources table with the new values, both scheme forms, `auto` and `--platform`
- podman reads containers-storage on linux (build tag, on in linux release builds) and the socket elsewhere
- pulls go through the docker API, layer `id` in the JSON is the diff ID, `ignore-errors` is deprecated
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* address review feedback on the stereoscope port
- `dive/source` moves to `internal/source`, and `dive.WalkTree` / `dive.TarHeader` are replaced by an internal `layertree` walker, so the only public surface left is `dive.Analyze` (which now honors ctx)
- docker client is built from the context endpoint (context TLS and ssh kept), `DOCKER_TLS` / `DOCKER_TLS_VERIFY` honored for env hosts
- podman client is built in dive and refuses ssh destinations, since stereoscope's fallback skipped host key checks
- registry http fallback limited to `localhost` and loopback literals, User-Agent no longer carries the binary path
- ctx reaches the TUI, cleanup waits for in-flight loads, and a second ctrl-c during cleanup no longer kills dive
- notifications always print (quiet aside), are escaped, show above the progress frame, and are drained on teardown
- extract writes with `O_EXCL` inside an `os.Root` and reports problems after the TUI exits instead of ending it
- TUI marks opaque whiteouts and their ancestors, implicit dirs no longer render Modified, failed hash reads aren't cached
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* keep go.uber.org/atomic v1.11.0 from main
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* allow CC0-1.0 licensed dependencies
`github.com/therootcompany/xz` (pulled in through stereoscope) is CC0-1.0, a public domain dedication like the already allowed `Unlicense`.
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* escape untrusted text in the final command error
Load errors carry text a registry or daemon controls (response bodies, pull messages), and clio prints the command's error raw, so a registry could drive the terminal (e.g. OSC 52 to set the clipboard).
- root and `build` errors now go through the same escaping as notifications, wrapped so `errors.Is` / `errors.As` still work
- the shared filter also escapes Unicode format characters (bidi overrides, zero width), so a path can't display as something else
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* find the podman machine socket on macOS
Since the ssh fallback was dropped, `--source podman` (and `dive build` with podman) on macOS found nothing unless `CONTAINER_HOST` was set, because podman machine only records ssh destinations in its config.
When no other socket is found, dive now asks `podman machine inspect` for the default machine's API socket and uses it if it exists.
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* check the snapshot cleanup error in the CLI tests
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* point the acceptance tests at the renamed snapshot build dirs
Splitting the goreleaser builds into `linux-build` and `build` changed the snapshot output dirs (`linux-build_linux_amd64_v1`, `build_darwin_amd64_v1`, `build_windows_amd64_v1`), so the acceptance jobs couldn't find the binaries.
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
* read OCI archives through docker-archive too
main's parser accepted an OCI archive under `--source docker-archive`, stereoscope's docker-archive provider needs a `manifest.json`. `docker-archive` now falls back to the oci-archive provider, so existing invocations keep working.
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
---------
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
|
||
|---|---|---|
| .data | ||
| .github | ||
| cmd/dive | ||
| dive | ||
| internal | ||
| .binny.yaml | ||
| .bouncer.yaml | ||
| .dockerignore | ||
| .gitignore | ||
| .golangci.yaml | ||
| .goreleaser.yaml | ||
| Dockerfile | ||
| go.mod | ||
| go.sum | ||
| LICENSE | ||
| Makefile | ||
| README.md | ||
| RELEASE.md | ||
| Taskfile.yaml | ||
dive
A tool for exploring a Docker image, layer contents, and discovering ways to shrink the size of your Docker/OCI image.
To analyze a Docker image simply run dive with an image tag/id/digest:
dive <your-image-tag>
or you can dive with Docker directly:
alias dive="docker run -ti --rm -v /var/run/docker.sock:/var/run/docker.sock docker.io/wagoodman/dive"
dive <your-image-tag>
# for example
dive nginx:latest
or if you want to build your image then jump straight into analyzing it:
dive build -t <some-tag> .
Building on macOS (supporting only the Docker container engine):
docker run --rm -it \
-v /var/run/docker.sock:/var/run/docker.sock \
-v "$(pwd)":"$(pwd)" \
-w "$(pwd)" \
-v "$HOME/.dive.yaml":"$HOME/.dive.yaml" \
docker.io/wagoodman/dive:latest build -t <some-tag> .
Additionally you can run this in your CI pipeline to ensure you're keeping wasted space to a minimum (this skips the UI):
CI=true dive <your-image>
This is beta quality! Feel free to submit an issue if you want a new feature or find a bug :)
Basic Features
Show Docker image contents broken down by layer
As you select a layer on the left, you are shown the contents of that layer combined with all previous layers on the right. Also, you can fully explore the file tree with the arrow keys.
Indicate what's changed in each layer
Files that have changed, been modified, added, or removed are indicated in the file tree. This can be adjusted to show changes for a specific layer, or aggregated changes up to this layer.
Estimate "image efficiency"
The lower left pane shows basic layer info and an experimental metric that will guess how much wasted space your image contains. This might be from duplicating files across layers, moving files across layers, or not fully removing files. Both a percentage "score" and total wasted file space is provided.
Quick build/analysis cycles
You can build a Docker image and do an immediate analysis with one command:
dive build -t some-tag .
You only need to replace your docker build command with the same dive build
command.
CI Integration
Analyze an image and get a pass/fail result based on the image efficiency and wasted space. Simply set CI=true in the environment when invoking any valid dive command.
Multiple Image Sources and Container Engines Supported
With the --source option, you can select where to fetch the container image from:
dive <your-image> --source <source>
or prefix the image with a <source>:// scheme:
dive <source>://<your-image>
The file based sources also take the <source>:<path> form other anchore tools use (e.g. dive oci-dir:./layout).
For every other source a single colon is read as an image name and tag, so dive docker:dind analyzes the
docker:dind image.
| Source | Reads the image from |
|---|---|
docker |
the Docker engine (the default). Images missing locally are pulled through the docker API, with credentials from your docker config. DOCKER_HOST, DOCKER_CONTEXT and the current docker context are honored |
podman |
Podman. On linux the local store is read directly (no socket needed, see containers-storage, and a short name like myapp also finds podman's localhost/myapp), falling back to the podman socket. On macOS the running podman machine's API socket is used (found through podman machine inspect); CONTAINER_HOST=unix://... overrides it, ssh connections are refused |
docker-archive |
a docker save tarball on disk, or an OCI archive (docker-tar is an alias) |
oci-archive |
an OCI image layout tarball on disk |
oci-dir |
an OCI image layout directory on disk |
registry |
a registry, without a container engine (credentials from your docker config). Registries on private IP addresses are refused, since they would be reached over plain http |
containerd |
the containerd daemon (CONTAINERD_NAMESPACE selects the namespace) |
containers-storage |
the local podman/buildah store (linux only, see below) |
auto |
detect it: files on disk first, then docker, podman, containerd and containers-storage, then a registry pull. The source it picked is reported, since an image no local engine has quietly comes from a registry (Docker Hub for a short name). Only valid for --source, not as a scheme |
For a multi-platform image, --platform picks the variant to analyze (e.g. --platform linux/arm64). A docker save
tarball holds a single platform, dive reports when it doesn't match.
containers-storage support is compiled in only with the containers_image_openpgp build tag, which the linux
release builds (and the docker image) have. Without it the source reports that it isn't available. To build it
yourself: go build -tags containers_image_openpgp,exclude_graphdriver_btrfs ./cmd/dive.
JSON export
--json <path> skips the UI and writes the analysis to a file. Each layer's id is the layer's diff ID (the same value as digestId).
Installation
Ubuntu/Debian
Using debs:
DIVE_VERSION=$(curl -sL "https://api.github.com/repos/wagoodman/dive/releases/latest" | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/\1/')
curl -fOL "https://github.com/wagoodman/dive/releases/download/v${DIVE_VERSION}/dive_${DIVE_VERSION}_linux_amd64.deb"
sudo apt install ./dive_${DIVE_VERSION}_linux_amd64.deb
Using snap:
sudo snap install docker
sudo snap install dive
sudo snap connect dive:docker-executables docker:docker-executables
sudo snap connect dive:docker-daemon docker:docker-daemon
Caution
The Snap method is not recommended if you installed Docker via
apt-get, since it might break your existing Docker daemon.
RHEL/Centos
DIVE_VERSION=$(curl -sL "https://api.github.com/repos/wagoodman/dive/releases/latest" | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/\1/')
curl -fOL "https://github.com/wagoodman/dive/releases/download/v${DIVE_VERSION}/dive_${DIVE_VERSION}_linux_amd64.rpm"
rpm -i dive_${DIVE_VERSION}_linux_amd64.rpm
Arch Linux
Available in the extra repository and can be installed via pacman:
pacman -S dive
Mac
If you use Homebrew:
brew install dive
If you use MacPorts:
sudo port install dive
Or download the latest Darwin build from the releases page.
Windows
If you use Chocolatey
choco install dive
If you use scoop
scoop install main/dive
If you use winget:
winget install --id wagoodman.dive
Or download the latest Windows build from the releases page.
Go tools
Requires Go version 1.26 or higher (add -tags containers_image_openpgp,exclude_graphdriver_btrfs on linux for containers-storage support).
go install github.com/wagoodman/dive@latest
Note: installing in this way you will not see a proper version when running dive -v.
Nix/NixOS
On NixOS:
nix-env -iA nixos.dive
On non-NixOS (Linux, Mac)
nix-env -iA nixpkgs.dive
X-CMD
x-cmd is a toolbox for Posix Shell, offering a lightweight package manager built using shell and awk.
x env use dive
Docker
docker pull docker.io/wagoodman/dive
# or alternatively
docker pull ghcr.io/wagoodman/dive
When running you'll need to include the Docker socket file:
docker run --rm -it \
-v /var/run/docker.sock:/var/run/docker.sock \
docker.io/wagoodman/dive:latest <dive arguments...>
Docker for Windows (showing PowerShell compatible line breaks; collapse to a single line for Command Prompt compatibility)
docker run --rm -it `
-v /var/run/docker.sock:/var/run/docker.sock `
docker.io/wagoodman/dive:latest <dive arguments...>
Note: depending on the version of docker you are running locally you may need to specify the docker API version as an environment variable:
DOCKER_API_VERSION=1.37 dive ...
or if you are running with a docker image:
docker run --rm -it \
-v /var/run/docker.sock:/var/run/docker.sock \
-e DOCKER_API_VERSION=1.37 \
docker.io/wagoodman/dive:latest <dive arguments...>
if you are using an alternative runtime (Colima etc) then you may need to specify the docker host as an environment variable in order to pull local images:
export DOCKER_HOST=$(docker context inspect -f '{{ .Endpoints.docker.Host }}')
CI Integration
When running dive with the environment variable CI=true then the dive UI will be bypassed and will instead analyze your docker image, giving it a pass/fail indication via return code. Currently there are three metrics supported via a .dive-ci file that you can put at the root of your repo:
rules:
# If the efficiency is measured below X%, mark as failed.
# Expressed as a ratio between 0-1.
lowestEfficiency: 0.95
# If the amount of wasted space is at least X or larger than X, mark as failed.
# Expressed in B, KB, MB, and GB.
highestWastedBytes: 20MB
# If the amount of wasted space makes up for X% or more of the image, mark as failed.
# Note: the base image layer is NOT included in the total image size.
# Expressed as a ratio between 0-1; fails if the threshold is met or crossed.
highestUserWastedPercent: 0.20
You can override the CI config path with the --ci-config option.
KeyBindings
| Key Binding | Description |
|---|---|
| Ctrl + C or Q | Exit |
| Tab | Switch between the layer and filetree views |
| Ctrl + F | Filter files |
| ESC | Close filter files |
| PageUp or U | Scroll up a page |
| PageDown or D | Scroll down a page |
| Up or K | Move up one line within a page |
| Down or J | Move down one line within a page |
| Ctrl + A | Layer view: see aggregated image modifications |
| Ctrl + L | Layer view: see current layer modifications |
| Space | Filetree view: collapse/uncollapse a directory |
| Ctrl + Space | Filetree view: collapse/uncollapse all directories |
| Ctrl + A | Filetree view: show/hide added files |
| Ctrl + R | Filetree view: show/hide removed files |
| Ctrl + M | Filetree view: show/hide modified files |
| Ctrl + U | Filetree view: show/hide unmodified files |
| Ctrl + B | Filetree view: show/hide file attributes |
| PageUp or U | Filetree view: scroll up a page |
| PageDown or D | Filetree view: scroll down a page |
UI Configuration
No configuration is necessary, however, you can create a config file and override values:
# where to load an image without a scheme from: docker, podman, docker-archive, oci-archive, oci-dir, registry,
# containerd, containers-storage or auto
container-engine: docker
# platform to select from a multi-platform image (e.g. linux/arm64), empty means the source's default
platform: ""
# deprecated and has no effect (kept so existing configs still load), same for the --ignore-errors flag
ignore-errors: false
log:
enabled: true
path: ./dive.log
level: info
# Note: you can specify multiple bindings by separating values with a comma.
# Note: UI hinting is derived from the first binding
keybinding:
# Global bindings
quit: ctrl+c
toggle-view: tab
filter-files: ctrl+f, ctrl+slash
close-filter-files: esc
up: up,k
down: down,j
left: left,h
right: right,l
# Layer view specific bindings
compare-all: ctrl+a
compare-layer: ctrl+l
# File view specific bindings
toggle-collapse-dir: space
toggle-collapse-all-dir: ctrl+space
toggle-added-files: ctrl+a
toggle-removed-files: ctrl+r
toggle-modified-files: ctrl+m
toggle-unmodified-files: ctrl+u
toggle-filetree-attributes: ctrl+b
page-up: pgup,u
page-down: pgdn,d
diff:
# You can change the default files shown in the filetree (right pane). All diff types are shown by default.
hide:
- added
- removed
- modified
- unmodified
filetree:
# The default directory-collapse state
collapse-dir: false
# The percentage of screen width the filetree should take on the screen (must be >0 and <1)
pane-width: 0.5
# Show the file attributes next to the filetree
show-attributes: true
layer:
# Enable showing all changes from this layer and every previous layer
show-aggregated-changes: false
dive will search for configs in the following locations:
$XDG_CONFIG_HOME/dive/*.yaml$XDG_CONFIG_DIRS/dive/*.yaml~/.config/dive/*.yaml~/.dive.yaml
.yml can be used instead of .yaml if desired.

