# Klustr documentation > Klustr is a free, open-source Kubernetes desktop client for macOS, Linux and Windows. Built in Go, it reads your kubeconfig and drives the API directly: live resources, RBAC review, Helm, Argo CD, Flux, Gateway API and cert-manager, with nothing installed in the cluster. This file is the full text of the Klustr site: the install steps, every user guide in the order of the documentation index, the FAQ and the comparisons, each under its own H1 with the page it comes from. The short index, with a markdown link for every page, is at https://klustr.dev/llms.txt. The latest release is v0.93.1, published 10 November 2026. The guides are licensed [CC-BY-4.0](https://github.com/SametKUM/klustr.dev/blob/main/docs/guide/LICENSE); the install, FAQ and comparison text is part of the site's [Apache-2.0](https://github.com/SametKUM/klustr.dev/blob/main/LICENSE) source. --- # Install Klustr on macOS, Linux and Windows Source: https://klustr.dev/install/ > Every release is built by CI from a tagged commit and published on GitHub Releases; the current version is v0.93.1. Pick your platform, then point Klustr at a kubeconfig context. ## macOS Apple Silicon. Signed with a Developer ID certificate and notarized by Apple. ### Homebrew ```sh brew tap sametkum/klustr brew install klustr ``` After the initial tap, `brew search klustr` and `brew info klustr` find it like any other formula. ### Manual Download the darwin-arm64 tarball from the [latest release](https://github.com/SametKUM/klustr/releases/latest), then: ```sh tar -xzf klustr-*-darwin-arm64.tar.gz mv klustr.app /Applications/ open /Applications/klustr.app ``` Gatekeeper opens the notarized bundle directly, even offline. ## Arch, CachyOS, Manjaro AUR package klustr-bin, bumped automatically on every release. ```sh paru -S klustr-bin # or yay -S klustr-bin ``` The PKGBUILD uses the prebuilt release tarball, so the install completes in seconds. ## Debian, Ubuntu amd64 .deb attached to every release. ```sh V=$(curl -fsSL https://api.github.com/repos/SametKUM/klustr/releases/latest \ | grep -oP '"tag_name":\s*"\K[^"]+') curl -LO https://github.com/SametKUM/klustr/releases/download/$V/klustr_${V#v}_amd64.deb sudo apt install ./klustr_${V#v}_amd64.deb ``` The package pulls in webkit2gtk-4.1 and gtk-3 automatically and registers a desktop entry. Run the three commands one at a time; the first one resolves the latest tag. ## Linux tarball amd64, for any distribution that ships the runtime libraries. Download the linux-amd64 tarball from the [latest release](https://github.com/SametKUM/klustr/releases/latest), then: ```sh tar -xzf klustr-*-linux-amd64.tar.gz install -Dm755 klustr ~/.local/bin/klustr ``` ## Windows amd64 zip, tested on Windows 11. Not code-signed yet. ```powershell $V = (Invoke-RestMethod https://api.github.com/repos/SametKUM/klustr/releases/latest).tag_name Invoke-WebRequest "https://github.com/SametKUM/klustr/releases/download/$V/klustr-$V-windows-amd64.zip" -OutFile klustr.zip Expand-Archive klustr.zip "$env:LOCALAPPDATA\Programs\Klustr" -Force & "$env:LOCALAPPDATA\Programs\Klustr\klustr.exe" ``` Run the commands one at a time in PowerShell; the first one resolves the latest tag. Klustr renders through the WebView2 runtime that ships with Windows 11. Downloaded with a browser instead, the unsigned `klustr.exe` gets a SmartScreen warning on first launch: choose More info, then Run anyway. With Smart App Control on, Windows blocks unsigned apps outright. ## Build from source mise pins Go, Node and the Wails v3 CLI. Install Git and [mise](https://mise.jdx.dev/) first. On Linux, install the GTK3 and WebKit2GTK 4.1 development headers before running mise (`libgtk-3-dev libwebkit2gtk-4.1-dev` on Debian and Ubuntu). ```sh git clone https://github.com/SametKUM/klustr.git cd klustr mise install npm --prefix frontend ci wails3 task build ``` The release build for your host platform is written to `build/bin/`. For development with Vite hot reload, run `wails3 dev` after the same setup instead. ## Updating Klustr checks GitHub Releases for a newer version and tells you when one exists; it never replaces itself. Homebrew: ```sh brew upgrade klustr ``` AUR: ```sh paru -Syu ``` The .deb, the tarballs and the Windows zip are replaced by downloading the new release. ## Verify a download Every release ships a SHA256SUMS file, and each asset carries build provenance that ties it to the commit and workflow run that produced it. Swap the asset name for the one you downloaded. On Windows, `Get-FileHash` prints the SHA-256 to compare with the zip's line in SHA256SUMS. ```sh V=$(curl -fsSL https://api.github.com/repos/SametKUM/klustr/releases/latest \ | grep -oP '"tag_name":\s*"\K[^"]+') curl -LO https://github.com/SametKUM/klustr/releases/download/$V/SHA256SUMS sha256sum -c --ignore-missing SHA256SUMS # macOS: shasum -a 256 -c --ignore-missing SHA256SUMS gh attestation verify klustr-$V-linux-amd64.tar.gz --repo SametKUM/klustr ``` ## Requirements - A kubeconfig. Klustr reads `~/.kube/config` and honors `KUBECONFIG`; if kubectl works, Klustr works. - macOS on Apple Silicon. - Linux amd64 with `webkit2gtk-4.1` and `gtk-3`. Ubuntu 24.04+, Fedora 39+ and Arch ship them; Ubuntu 22.04 needs `libwebkit2gtk-4.1-0 libgtk-3-0` first. - Windows 11 on amd64, which ships the WebView2 runtime. - Nothing in the cluster. Klustr installs no agent, operator or CRD. All assets, including older versions, are on [GitHub Releases](https://github.com/SametKUM/klustr/releases). --- # Getting started Source: https://klustr.dev/docs/getting-started/ Klustr is a pure client: it installs nothing in your cluster and uses the same `~/.kube/config` your `kubectl` already reads. Launch the app, point it at a context, and you see a live view of everything that context has permission to see. ## Connecting to a context 1. On launch, Klustr reads `~/.kube/config` and lists every context it finds on the **Connections** screen. 2. Click a context to connect. You land on the resource browser with the sidebar on the left. 3. The header's **Disconnect** button drops you back to the Connections screen at any time. You can pin a context as the default with **Auto-connect** on its card — Klustr will connect to it directly on the next launch instead of showing the picker. Connecting starts only the Namespace and Pod informers up front; every other resource kind starts watching the first time you open it. Opening a kind you have no permission to list shows an empty table rather than erroring — Klustr probes your access on connect and simply hides what you can't see. ## Selecting namespaces The namespace selector in the header filters every list view: - Leave it empty for **all namespaces** (the default). - Pick one or more namespaces to narrow the view. The selection is remembered per cluster (and per multi-cluster set) across restarts. - Press `⌘N` to search namespaces quickly, and star the ones you use most so they float to the top. Switching namespaces only changes what the lists query — it never restarts the underlying watches, so it's instant. ## Read-only mode Each context has a per-context **read-only** switch. When it's on, every mutating action (apply, delete, scale, restart, Helm install/upgrade, sync, …) is blocked for that context. Use it to browse a production cluster with confidence that no button can change anything. ## Reading a resource Click a row and the resource opens in the **inspector** beside the list. The list stays live and keeps its filter, scroll position and page, and the row you are reading stays highlighted, so you never lose your place. - Drag the divider to resize the inspector. Double-click it, or focus it and press `Enter`, to go back to the default width. The expand button in the inspector header fills the workspace with it, and a window too narrow for both panes shows it at full width. - Beside a narrow inspector the list switches to compact columns. Your saved column settings are left as they are. - The arrows in the inspector header, or `Alt+↑` / `Alt+↓`, step through the current filtered and sorted results, across pages. Moving to another resource of the same kind keeps the tab you were reading. - Links inside the inspector open the referenced resource in place; the back arrow returns to the previous one and to the tab you were on. - `F6` moves focus between the list and the inspector, and `Esc` closes it. - Navigating away from an unapplied YAML edit asks you to **Keep editing** or **Discard changes**. Log, exec and editor sessions keep running while you resize or expand the inspector. ## Finding things fast - `⌘K` — command palette: jump to any view or custom resource kind, toggle contexts, or open the terminal. - `⌘P` — search pods by name. - `⌘N` — namespace search. - `/` — focus the filter of the current list. - `?` — keyboard shortcut cheatsheet. On Linux and Windows, use `Ctrl` in place of `⌘`. ## Next steps - Connecting to more than one cluster at once: [Multi-context & aggregated mode](https://klustr.dev/docs/multi-context/). - Your kubeconfig uses `aws-vault` or another exec credential helper and Klustr can't authenticate when launched from the Dock: [Credential helpers](https://klustr.dev/docs/credential-helpers/). --- # Multi-context & aggregated mode Source: https://klustr.dev/docs/multi-context/ Klustr can drive two or more contexts at once and present them as a single virtual cluster. This is useful for comparing environments, or for operating a fleet of clusters that share workloads. ## Aggregated mode On the **Connections** screen, check **two or more** contexts instead of one. When you connect: - Every list view fans out across all selected contexts and adds a **Context** column so you can tell rows apart. - Cluster overviews aggregate CPU / memory / pod counts across the whole set. - Resource details, logs, exec and the rest operate on the specific context of the row you opened. A single selected context behaves exactly as before — aggregation kicks in only at two or more. ## Saved groups A recurring multi-context selection can be saved as a named **group** with its own color: - Save the current selection as a group from the Connections screen. - Activate a saved group with one click — it sets the active context set in a single step. - Groups also appear at the top of the in-session **context switcher** dropdown, so you can jump between groups mid-session without returning to the Connections screen. ## Per-context health The status bar pings every active context roughly every 25 seconds (a `/version` call with a short timeout). Each context gets a dot: - **green** — healthy, - **amber** — slow ping, - **red** — failed; hover for the actual error. ## Context tags and the color stripe You can attach up to three colored **tags** to a context (and define your own tag colors). The top bar paints a thin stripe matching the context's primary tag — or the active group's color — so you always have a constant visual reminder of which environment you're touching. Today the stripe (plus per-context [read-only mode](https://klustr.dev/docs/getting-started/#read-only-mode)) is the main guardrail against running a destructive action on the wrong cluster, so it's worth tagging production distinctly. ## Namespace selection across a set The namespace filter is remembered **per active-context set**: a single cluster keeps its own filter, and each distinct multi-cluster set keeps its own. Namespaces that don't exist in a given context are simply ignored for that context. --- # Credential helpers (aws-vault & friends) Source: https://klustr.dev/docs/credential-helpers/ Many kubeconfigs authenticate through an `exec` credential plugin — for example `aws eks get-token` wrapped in `aws-vault exec `. These plugins rely on two things that a terminal gives them but a GUI launch does not: - a populated `PATH` (so the helper binary is found), and - ambient cloud credentials / environment (so the helper can mint a token). When you launch Klustr from Finder, the Dock, or a `.desktop` entry, the OS starts it **without** your shell's startup files — so an exec plugin that works in your terminal can fail in the app. Klustr fixes this in two layers. ## Layer 1: shell-environment import (automatic) On a GUI launch (macOS/Linux only — never on Windows, never when started from a terminal), Klustr runs your login shell once, captures its environment, and merges into its own process: - your full `PATH`, plus - an allowlist of relevant variables (`AWS_VAULT_BACKEND`, `AWS_CONFIG_FILE`, `KUBECONFIG`, proxy variables, …). This happens before the first connection attempt, so the first exec plugin run already sees the merged environment. In most setups this alone makes terminal-only kubeconfigs work from the Dock with no configuration. ## Layer 2: credential providers (aws-vault) If your cluster needs an `aws-vault` profile's credentials specifically, map the context to a profile: 1. Open the **Connections** screen → **Credential helpers** section. 2. Find your context. Klustr preselects a likely profile from the kubeconfig exec block's `--profile` / `AWS_PROFILE` hint. 3. Pick the aws-vault profile to use and save the mapping. On connect, Klustr runs `aws-vault export --format=json ` (you may see the macOS Keychain prompt the first time) and injects the captured keys into the exec plugin's environment — so `aws eks get-token` behaves exactly as it would under `aws-vault exec -- ...`. ### What's stored where - **Secrets** live in memory only. They are never written to disk and never logged. - The on-disk store (under your user config directory) holds the **provider and profile names only** — never credential values. ### Refresh and expiry Klustr re-captures credentials about five minutes before they expire and rebuilds the context's clients automatically (the exec authenticator snapshots its environment, so a refresh needs fresh clients). If a refresh fails, you'll get an error toast with a **Retry** action. ## Troubleshooting - **Still can't authenticate from the Dock, but it works from a terminal.** Confirm the helper binary is on the `PATH` your login shell exports (Layer 1 uses `$SHELL -ilc`). If you keep tools in a non-standard directory, make sure your shell rc adds it to `PATH`. - **Keychain prompt keeps appearing.** That's aws-vault unlocking its backend; it's expected on first capture and after the backend locks. - **Wrong profile picked.** Re-open Connections → Credential helpers and change the mapping; the kubeconfig hint is only a default. Other providers (granted, saml2aws, …) can slot in beside aws-vault in the future — the provider interface is generic. --- # Cluster & workloads overviews Source: https://klustr.dev/docs/overview/ Klustr has two dashboard views that summarize a whole context set at a glance — one for cluster capacity, one for workload health. Both aggregate across every active context and honor the current namespace selection, so they work the same in single-cluster and [aggregated](https://klustr.dev/docs/multi-context/) mode. ## Cluster overview Under **Cluster → Overview**. Three donuts plus a couple of counts: - **CPU** and **Memory** — usage vs requests vs limits, against the cluster's allocatable / capacity. Usage comes from `metrics.k8s.io`; requests and limits are summed from running pods. - **Pods** — running pods vs the allocatable / capacity the nodes advertise. - **Node count**, **pod count** and **namespace count**. The pod count includes finished (Succeeded or Failed) pods, so it can be higher than the Pods donut. Usage numbers need a metrics server. If `metrics.k8s.io` isn't available, the capacity/requests/limits parts still render and the usage slice is replaced with a short "metrics unavailable" note — see [Workloads & debugging](https://klustr.dev/docs/workloads-and-debugging/) for the one-click metrics-server install. ## Workloads overview Under **Workloads → Overview**. One health bar per workload kind — Pods, Deployments, StatefulSets, DaemonSets, ReplicaSets, ReplicationControllers, Jobs and CronJobs: - The bar splits into **healthy** (green) and **unhealthy** (red). - Intentionally-idle resources aren't counted as broken: a scaled-to-zero Deployment/ReplicaSet, or a suspended CronJob, shows as a neutral segment rather than red. - Click a card to jump straight to that resource's list. Below the cards is a **recent events** feed with a search box. In aggregated mode it spans every active context and tags each row with its context. ## Refresh behavior Both overviews refresh live: workload counts update on the debounced resource change stream, and everything re-polls periodically. The events feed is a real apiserver list (there is no Events informer), so it refreshes on the slower poll only rather than on every pod churn. --- # Workloads & debugging Source: https://klustr.dev/docs/workloads-and-debugging/ Klustr gives every workload the live operations you'd otherwise reach for `kubectl` to do — logs, exec, port-forward, events — plus a few that are normally awkward, like a root node shell and in-place pod resize. All of them respect a context's [read-only mode](https://klustr.dev/docs/getting-started/#read-only-mode). ## Logs Open a pod (or a workload) and switch to the **Logs** tab for a streaming, stern-style view: - Multi-pod streaming with a distinct ANSI color per pod. - Follow mode, log-level highlighting, and a filter with a regex toggle. - A line-count picker sets how far back the stream starts. On a pod it offers the last 200, 1,000 or 10,000 lines, or the whole log. On a Deployment, StatefulSet or DaemonSet it offers 50, 200 or 1,000 lines per container, starting at 50: the limit applies to every container of every matched pod, so it stays small. Changing it restarts the stream. - On a pod, **Previous** shows the log of the container's last terminated instance, the one `kubectl logs --previous` reads, for a container that has restarted. - **Pause** holds the view while lines keep buffering, **Wrap** toggles line wrapping, and the overflow menu saves the filtered lines to a file or clears the view. In aggregated mode the stream spans the pods across every active context. ## Exec The **Exec** tab opens an interactive shell into any container using WebSocket, with SPDY fallback when the opening request is rejected for a supported compatibility reason. Pick the container if the pod has more than one. Fallback also supports roles that allow `create` on `pods/exec` but reject the WebSocket `get` request. A command is never retried after the connection upgrades; if the session disconnects, start another shell explicitly. Copy and paste follow the terminal conventions in [Terminal → Copy and paste](https://klustr.dev/docs/terminal/#copy-and-paste): `⌘C` / `⌘V` on macOS, `Ctrl+Shift+C` / `Ctrl+Shift+V` or the right-click menu on Linux and Windows. ## Debug (shell-less containers) Distroless and hardened images ship no shell, so Exec has nothing to run. Switch the Exec tab's mode picker to **debug** and Klustr injects an ephemeral debug container — the same thing `kubectl debug` does — then opens a shell in it. Pick the target container, an image (`netshoot`, `busybox`, `alpine` or your own) and press **Start debug**. The debug container joins the target's process namespace and the pod's network namespace, so you see the target's processes and can reach whatever it can reach — `curl`, `dig` and `tcpdump` from netshoot all run against the target's network. Reading the target's *filesystem* through `/proc/1/root` additionally needs the **SYS_PTRACE** capability, which the checkbox adds. It is off by default because that capability also exposes the target process's memory, and the PodSecurity baseline policy rejects pods that add it. Ephemeral containers cannot be removed once added; the debug container lingers until the pod restarts. **Reattach** re-enters the existing one instead of injecting another. ## Port-forwarding Start a forward from a pod or service. Klustr suggests a free local port, keeps a persistent indicator in the header while forwards are active, and lets you click-to-open an HTTP forward in your browser. Active forwards are listed in the header indicator and can be stopped individually. Port-forwarding also prefers WebSocket and falls back to SPDY for compatible upgrade rejections, including roles that grant only `create` on `pods/portforward`. Stopping a forward or disconnecting its context closes its connection and local port, including connections still waiting for a server or proxy response. ## Node shell From a node, **Node shell** gives you a root shell on that node. It works by launching a temporary privileged `nsenter` pod, attaching to it over exec, and removing the pod when the session ends — no SSH, nothing pre-installed on the node. Treat this like `kubectl debug node/...`: it is a powerful, explicitly user-initiated action that runs with node-level privileges. ## Cordon, uncordon & drain A node offers one-click **cordon** / **uncordon**, and a **drain** that evicts pods through the Eviction API with live progress. The drain is PDB-aware and skips DaemonSet and mirror pods, matching `kubectl drain` semantics. ## Events The **Events** tab on a resource shows the core `Events` filtered to that object, so you see exactly what the control plane has said about it. It refreshes every 15 seconds while open, and **Refresh** reloads it right away. Event messages can be selected and copied here, in the Events view and in the overview feeds; each message also has a copy button that shows on hover. The rest of a resource's detail tabs is selectable the same way. ## Pod diagnosis When a pod is unhealthy, Klustr surfaces a diagnosis card explaining *why* — for common states like `CrashLoopBackOff` or `OOMKilled` — so you don't have to reverse-engineer it from raw status fields. ## Editing and rolling out - **YAML edit** — a Monaco editor with a server-side dry-run diff shown before apply. - **Scale / restart / pause-resume** — replica controls, one-click rolling restart, inline pause/resume, and inline HPA min/max editing. - **In-place pod resize** — change a running container's CPU / memory requests and limits via the `pods/resize` subresource, with no pod recreation; the live resize status (Deferred / Infeasible) is shown. - **Rollout history & rollback** — a side-by-side template diff across revisions and one-click revert for Deployments, StatefulSets and DaemonSets. --- # Terminal Source: https://klustr.dev/docs/terminal/ Klustr has a built-in terminal drawer at the bottom of the window. Each tab is a real shell **on your machine** — not in the cluster — with its `KUBECONFIG` already pointed at the context you opened it for. Your installed CLIs (`kubectl`, `helm`, `stern`, `k9s`, …) run against the right cluster with no extra setup. > The terminal is a local shell wrapper, not an in-cluster session. For a shell > *inside* a container use **Exec**, and for a root shell *on a node* use > **Node shell** — both in [Workloads & debugging](https://klustr.dev/docs/workloads-and-debugging/). ## Opening and toggling - Press **`⌘\``** (macOS) / **`Ctrl+\``** (Linux and Windows) to toggle the drawer. - Opening it with a single active context auto-creates the first tab for that context. - Drag the drawer's top edge to resize it; the height is remembered across restarts. On Windows a tab runs `SHELL` when it points at a program Windows can find (Git Bash, for example), otherwise PowerShell 7, then Windows PowerShell, then `cmd`. Running `wsl` in a tab keeps its `KUBECONFIG` and context: Klustr lists them in `WSLENV`, translating the kubeconfig path for Linux. ## Tabs and contexts - Each tab is bound to one context. The **`+`** button adds a tab; in multi-context / aggregated mode it lets you pick which context the new tab targets. - The shell inherits your environment (so your normal `PATH` and tools are there) but gets a `KUBECONFIG` that is a minified, single-context copy of your kubeconfig — so `kubectl` in that tab always talks to that tab's cluster. - Hiding the drawer keeps tabs alive: their shells and scrollback are preserved. Closing the last tab closes the drawer. - Disconnecting a context closes every terminal bound to it. ## Copy and paste The same bindings apply to every terminal surface — this drawer, **Exec**, **Node shell** and the **Logs** viewers (copy only there): | | macOS | Linux / Windows | |---|---|---| | Copy selection | `⌘C` | `Ctrl+Shift+C` or `Ctrl+Insert` | | Paste | `⌘V` | `Ctrl+Shift+V` or `Shift+Insert` | On Linux and Windows a plain `Ctrl+C` copies while text is selected and is the shell's interrupt otherwise — the same rule Windows Terminal and VS Code use. `Ctrl+V` is never intercepted; it reaches the shell as `^V`. Right-click any terminal for a **Copy / Paste / Select all** menu. ## Opening an external terminal app Prefer your own terminal? A tab can launch an external app (Terminal, iTerm2, Ghostty, Warp, Alacritty, kitty, WezTerm, Hyper on macOS; the same tools probed on `PATH` on Linux) with the context already selected. - Klustr remembers your **preferred app** and launches it directly next time. - **Alt/Option-click** the external-launch button to force the picker and change the default. On Windows there is no app list: Klustr opens PowerShell in a new console, which Windows shows in your default terminal app (Windows Terminal unless you picked another in Settings). Each external window gets its own single-context copy of the kubeconfig, deleted when the window closes. On Windows, closing the window with its close button after Klustr has quit leaves the copy behind; the first Klustr start a day or more later removes it. --- # Helm Source: https://klustr.dev/docs/helm/ Klustr speaks Helm v3 directly against the cluster using the upstream Helm library — there is **no `helm` binary on your PATH** and nothing is shelled out. The **Helm** sidebar group is always available. ## Browsing releases Helm stores each release as a Secret of type `helm.sh/release.v1`. Klustr reads those from the same informer cache it already maintains for Secrets, so the release list stays live as releases change — no extra polling. ## Installing and upgrading Install or Upgrade from the Helm views. The flow is two-step on purpose: 1. Klustr runs the action as a **dry-run** first and shows you the resulting diff. 2. Only after you confirm does it apply for real. You get the usual options (values editor, Wait, Atomic). Mutations run against a Helm client built from Klustr's existing connection — so they use exactly the permissions your kubeconfig grants. ## Rollback and uninstall - **Rollback** to a previous revision. - **Uninstall** a release. Both go through the Helm library directly, the same as Install/Upgrade. ## Repositories and chart search Repositories are kept in a JSON file under your user config directory (`helm-repos.json`). Once a repo is added, chart search and version listing use the repo index files Helm has written — so you can find a chart and pick a version without leaving Klustr. > All Helm mutations respect a context's [read-only mode](https://klustr.dev/docs/getting-started/#read-only-mode). --- # GitOps: Argo CD & Flux Source: https://klustr.dev/docs/gitops/ Klustr drives both Argo CD and Flux **through the Kubernetes API** — no `argocd-server` ingress, no Argo login, and no `argocd` or `flux` CLI on your PATH. The only requirement is that your kubeconfig user can update the relevant resources. Each integration's sidebar group appears only when its CRDs are detected on the cluster, so nothing clutters the sidebar on a cluster that doesn't run it. ## Argo CD Shown when the `applications.argoproj.io` CRD is present. - **List** — Applications with Sync / Health status pills, watch-backed. - **Sync** — implemented as the same PATCH (`operation.sync`) that `argocd app sync` issues. - **Refresh** — flips the `argocd.argoproj.io/refresh` annotation. - **Rollback** and cascade-aware **Delete** are available from the Application. - **Resources tab** — the Application detail reads `.status.resources` and lists every managed object. Each row opens that object in the inspector, so you can drill `App → Deployment → Pod → Logs` and return with the back arrow in its header. ## Flux CD Klustr covers the Flux toolkit kinds: Kustomization, HelmRelease, GitRepository, HelmRepository, OCIRepository, Bucket, Provider, Alert and Receiver. - Each shows its Ready state (**Ready**, **Not ready**, **Unknown**, or **Suspended** while suspended), conditions, source, and applied revision. - **Reconcile** and **Suspend / Resume** buttons hit the standard Flux annotations — again, no `flux` CLI involved. ### Image automation When the `image.toolkit.fluxcd.io` CRDs are present, the Flux group also lists the image automation kinds: - **ImageRepositories** — the image, the registry provider, when it was last scanned and how many tags it found, with the latest tags and the exclusion patterns in the detail. - **ImagePolicies** — the repository a policy reads, its policy type (semver, alphabetical or numerical) with the range or order, the tag filter, and the image it selected: tag, digest and the previous pick. - **ImageUpdateAutomations** — the Git source, checkout and push branches, the update path and strategy, and the last run, push and commit. References between them open the referenced object, across namespaces too. An ImagePolicy has no reconcile of its own: reconcile its ImageRepository to rescan tags, and the policy follows. Suspend needs the `v1` ImagePolicy API, the first that has the field. > All sync / reconcile / suspend actions respect a context's > [read-only mode](https://klustr.dev/docs/getting-started/#read-only-mode). ## Which tool manages a resource Argo CD, Flux and Helm set no ownerReference on what they deploy; the only record is the labels and annotations they stamp. Klustr reads them and shows a chip in the detail header for each tool that manages the resource: - **Argo CD** — from the `argocd.argoproj.io/tracking-id` annotation (the default since Argo CD 3.0), or from the `app.kubernetes.io/instance` label once the Application's status lists the object. Helm charts set the same label, so it counts only with that confirmation. - **Flux** — the Kustomization or HelmRelease named by the `kustomize.toolkit.fluxcd.io/*` or `helm.toolkit.fluxcd.io/*` labels. - **Helm** — the release named by the `meta.helm.sh/release-name` and `meta.helm.sh/release-namespace` annotations. A chip opens its owner. An Argo CD Application often runs in a different cluster from the resources it deploys; when that cluster is one of your active contexts, the chip opens the Application there. Chips follow ownership changes live, without reopening the resource. ### Edits the owner will revert The YAML tab's **Edit** and the **Scale** dialog warn before you apply a change that the owner will undo, for example *Argo CD Application argocd/shop will revert this change because self-heal is on. Change it in the source instead.* The warning appears for: - an Argo CD Application with automated sync and self-heal, except for fields in its `ignoreDifferences`, so scaling a Deployment whose replicas Argo CD ignores does not warn; - a Flux Kustomization, which reapplies its objects on every interval, unless the object opts out with `kustomize.toolkit.fluxcd.io/reconcile: disabled` or `kustomize.toolkit.fluxcd.io/ssa: IfNotPresent` / `Ignore`; - a Flux HelmRelease with drift detection enabled, except for its ignore rules and objects marked `helm.toolkit.fluxcd.io/driftDetection: disabled`. Opt-outs count as a label or an annotation. A suspended owner gives no warning, since it reverts nothing until it is resumed. --- # Tekton Pipelines Source: https://klustr.dev/docs/tekton/ When the `tekton.dev` CRDs are present, Klustr adds a **Tekton** sidebar group with **PipelineRuns**, **TaskRuns**, **Pipelines** and **Tasks**, plus the [Triggers](https://klustr.dev/docs/tekton/#tekton-triggers) kinds when Tekton Triggers is installed. Each entry appears only in contexts that serve its CRD, lists update live, and the served API version is read from the discovered CRD. No `tkn` CLI and no Tekton Dashboard are involved. ## PipelineRuns The list shows the Pipeline, the status with the controller's own reason (`Succeeded`, `Completed`, `PipelineRunTimeout` and so on), a task tally such as `11 done, 1 failed, 4 skipped`, when the run started and how long it took. Newest runs come first, and a running run's duration keeps counting. A PipelineRun's detail joins three things into one **task table**: - every task of the resolved pipeline, in pipeline order, with its task reference and `runAfter` dependencies; - the TaskRun that executed it, with status and duration (a matrixed task gets one row per TaskRun); - tasks that never ran: **Skipped** with the reason (usually a `when` expression), or **Not run** when the pipeline ended first. Finally tasks get their own table. A row opens its TaskRun, and the back button returns to the PipelineRun. Above the table, a **Graph** draws the tasks left to right in dependency order, from `runAfter` and from result references, each colored by its state. Clicking a task opens its TaskRun. The detail also lists params, workspaces with their volume source (`Secret git-credentials`, `PVC template (1Gi)`), results, the service account and timeout, and links to the Pipeline. Tekton's events for the run are on the **Events** tab. ## TaskRuns The list shows the Task, the PipelineRun it belongs to, status, finished and total steps, and duration. The detail lists each **step** with its state, exit code, image and duration, and links to the Task, the PipelineRun and the pod. The **Logs** tab streams the TaskRun's pod with the most useful step preselected: the running one, else the first that failed, else the last that ran. Tekton deletes the pods of finished runs when they are pruned; for such a run the tab says the pod is gone instead of showing an error. ## Pipelines and Tasks - **Pipelines** — the declared tasks with their task reference (linked to the Task), `runAfter` and the number of `when` conditions, plus params with types and defaults, workspaces and results. A **Graph** draws the same tasks in dependency order, and clicking one opens its Task. The **Runs** tab lists the pipeline's runs, newest first. - **Tasks** — each step with its image or StepAction, command and script, plus params, workspaces, results and sidecars. ## Start a pipeline **Start** on a Pipeline opens a form for a new PipelineRun: - **Params** — one field per declared param, prefilled with its default. An array takes one item per line and an object one `key=value` per line; a param without a default is marked required. Params left at their default are not sent, so Tekton applies them as the Pipeline declares them. - **Workspaces** — each workspace binds to a new volume per run (with a size and an optional storage class), an empty directory, an existing PVC, a ConfigMap or a Secret. An optional workspace can stay unbound. - **Service account** and **Timeout**, both optional. Klustr creates the PipelineRun and opens it as soon as its watch is running, so you follow the run from its first task. ## Cancel and rerun - **Cancel** appears on an active PipelineRun or TaskRun. It sets `spec.status` the way `tkn pipelinerun cancel` and `tkn taskrun cancel` do: cancelling a PipelineRun stops its running TaskRuns and skips the finally tasks, and cancelling a TaskRun that belongs to a PipelineRun fails that PipelineRun. - **Rerun** creates a new PipelineRun from the same spec, named `-r-`, the naming the Tekton Dashboard uses. It starts right away with the same params and workspaces. Both ask for confirmation first. Start, Cancel and Rerun all respect a context's [read-only mode](https://klustr.dev/docs/getting-started/#read-only-mode). ## Tekton Triggers When the `triggers.tekton.dev` CRDs are present, the Tekton group also lists: - **EventListeners** — the address the listener serves, its readiness, the Deployment and Service it runs as, the service account, and each trigger with its bindings, template and interceptor chain. Namespace and label selectors show which Triggers a listener picks up. - **Triggers** — bindings, template and interceptors, and the EventListeners that refer to the Trigger by name. - **TriggerTemplates** — their params and the resources each one creates, by kind and name. A PipelineRun or TaskRun in the template links to the Pipeline or Task it runs. - **TriggerBindings** and **ClusterTriggerBindings** — the params they extract from an event and the expressions behind them. A trigger's bindings and template open their own detail. ## Large CI clusters Tekton copies the whole resolved Task or Pipeline spec into every run's status. Klustr drops those copies from its cache and reads a run in full only when its detail is open, which keeps memory in check on clusters with thousands of runs. Opening a PipelineRun lists just its own TaskRuns, so the cluster-wide TaskRun list loads only when you open **TaskRuns**. With thousands of TaskRuns, that first load can take a few seconds; the view shows that it is starting its watch until the list arrives. --- # Gateway API Source: https://klustr.dev/docs/gateway-api/ When the `gateway.networking.k8s.io` CRDs are present, Klustr adds a **Gateway API** sidebar group. Each entry requires its CRD and permission to list and watch that resource in the same context. Lists update live through typed informers, including when access is limited to the namespace configured in your kubeconfig context. It is vendor-neutral: Envoy Gateway, Cilium, Istio, Contour, NGINX Gateway Fabric or any conformant implementation all work. ## What you get - **Gateways** with their **listener table** and status. - **HTTPRoutes / GRPCRoutes** showing parents, hostnames, and accepted status pills. - **TLSRoutes / TCPRoutes / UDPRoutes** with parent references, backend ports and weights, and per-controller route conditions. TLSRoutes also show hostnames. - **ListenerSets** with parent Gateway, listener protocols, TLS certificates, allowed route kinds, attached routes, and listener conditions. - **BackendTLSPolicies** with target resources, SNI hostname, certificate names, CA references or system trust, and per-ancestor controller conditions. - **GatewayClasses** and **ReferenceGrants**. Klustr discovers the served API version for each resource. It prefers `v1` and also supports TLSRoute `v1alpha3`/`v1alpha2`, TCPRoute and UDPRoute `v1alpha2`, BackendTLSPolicy `v1alpha3`, and ReferenceGrant `v1beta1`. ListenerSet requires `gateway.networking.k8s.io/v1`; experimental `XListenerSet` remains in the generic browser. Multi-context views query only contexts that support each resource. ## Reading route status The route detail renders a per-rule **match → backend → weight** matrix plus the `RouteParentStatus` block. That's what makes a broken route quick to spot: a parent that hasn't **Accepted** a route, or a backend that came back `ResolvedRefs=False` with `RefNotPermitted` (typically a missing ReferenceGrant across namespaces), is one click away rather than buried in YAML. TLS, TCP, and UDP routes show backend sets for each rule without HTTP match fields. Links to supported parents and backends preserve the resource's context and namespace. Missing or stale status on these routes, ListenerSets, and BackendTLSPolicies is shown as unknown; condition reasons and messages remain available for diagnosis. ## When to use the generic browser instead If your cluster has Gateway API CRDs that Klustr doesn't render with a typed view, they still show up under the generic [Custom Resources](https://klustr.dev/docs/custom-resources/) browser by API group, with a YAML detail. --- # Kyverno & policy reports Source: https://klustr.dev/docs/kyverno/ When Kyverno's CRDs are present, Klustr adds a **Kyverno** sidebar group. Each entry appears only in contexts that serve its CRD, and the served API versions are read from the discovered CRDs. The integration is read-only: Klustr shows policies, exceptions and reports and changes none of them. ## ClusterPolicies and Policies The lists show each policy's title, category and severity (from the `policies.kyverno.io/*` annotations the Kyverno policy library sets), its validate action, its rule counts, whether it runs in background scans, and whether Kyverno reports it **Ready**. The action is resolved per rule: a rule's `validate.failureAction` wins over the deprecated policy-wide `validationFailureAction`, and Kyverno's default is **Audit**. A policy that mixes the two shows **Mixed**. A policy's detail lists every rule with its type (`validate` with `pattern`, `anyPattern`, `deny`, `cel`, `podSecurity` and so on, or `mutate`, `generate`, `verifyImages`), its action, its message and a summary of what it matches and excludes, such as `Pod · namespaces: kube-system, kyverno`. It also shows whether the policy runs on admission, and: - **Autogen rules** — the `autogen-…` rules Kyverno derives from Pod rules for Deployments, Jobs and the other Pod controllers. Reports and exceptions refer to rules by these names. - Whether Kyverno generated a ValidatingAdmissionPolicy for the policy, or why not. - Kyverno's `PolicyViolation` events for the policy on the **Events** tab. ## CEL policies Each of Kyverno's CEL policy kinds (`policies.kyverno.io`) has its own entry, next to its namespaced variant (**Namespaced ValidatingPolicies**, **Namespaced MutatingPolicies** and so on). Every detail shows the resources the policy matches, namespace and object selectors, match conditions, variables and the policy's conditions. The views apply the controller's defaults, so a field the policy leaves out reads the way Kyverno treats it. - **ValidatingPolicies** — their actions (Deny, Audit, Warn) and each validation's CEL expression and message. A policy without `validationActions` is **Deny**. - **ImageValidatingPolicies** — the images they match and the image extractors, the attestors they trust (cosign keys, keyless identities and certificates, or Notary) and the attestations they check, whether a signature is required, digest handling, registry credentials and the failure policy. - **MutatingPolicies** — each mutation with its patch type and expression, the target resources and conditions, whether they mutate existing resources in the background as well as on admission, and the reinvocation policy. - **GeneratingPolicies** — the triggers and what each one generates, whether the generated objects are kept in sync, and whether existing triggers are processed too. **On policy delete** says whether the generated objects stay: Kyverno keeps them unless the policy synchronizes. - **DeletingPolicies** — the schedule with the last and next run, the conditions under which matched resources are deleted, and the deletion propagation. The next run comes from Kyverno's own cron parser, in UTC. ## PolicyExceptions Each exception lists the policies and rules it exempts, linked to the policy, and what it applies to, including any pod security controls it relaxes. ## Policy reports **PolicyReports** and **ClusterPolicyReports** are the Kubernetes Policy Working Group's `wgpolicyk8s.io` reports. Kyverno writes one per resource, so the list names the resource and counts its results; the reports with the most failures come first. A report's detail lists the results worst first (fail, error, warn, skip, pass), links to the resource it is about, and links each Kyverno result to the policy that produced it. Two links connect policies and resources: - **Violations** — when the cluster has the report CRDs, every policy's detail has a tab listing the resources it fails or warns on, across all reports. Each row opens the resource. DeletingPolicies have no such tab. - **Policy** — when Kyverno keeps a report for a built-in resource, that resource's detail gets a **Policy** tab, with the number of failing results on the tab itself. Resources without a report show no such tab. Kyverno names each report after its resource's UID, so this lookup is a single request. ## When the reports are empty Kyverno's reports controller writes the reports. If it is disabled, the report views stay empty, policies show no violations, and resources show no **Policy** tab, while the policies themselves still enforce or audit. Audit failures may still show up as `PolicyViolation` events on the policy's **Events** tab. --- # Cilium Source: https://klustr.dev/docs/cilium/ When Cilium's CRDs are present, Klustr adds a **Cilium** sidebar group with views for 14 `cilium.io` kinds. Each entry appears only in contexts that serve its CRD, and each is read at the API version the cluster serves, so `v2` and `v2alpha1` kinds sit side by side. ## The lists Every list has a **Reported status** column, the CRD's conditions as `Type=Status`; endpoints show their state there instead. Two more columns are chosen per kind: - **NetworkPolicies** and **ClusterwideNetworkPolicies** — the endpoint or node selector, and the number of ingress, egress and deny rules. - **Endpoints** — the endpoint's addresses and its security identity. - **Nodes** — the pod CIDRs and how many IPs are allocated. - **Identities** — the security labels. - **CIDRGroups** — the external CIDRs. - **LoadBalancerIPPools** — the IP blocks and the service selector. - **L2AnnouncementPolicies** — the service and node selectors. - **EgressGatewayPolicies** — the destination CIDRs and the selectors. - **BGPClusterConfigs**, **BGPPeerConfigs**, **BGPAdvertisements**, **BGPNodeConfigs** and **BGPNodeConfigOverrides** — the node selector or node, and the BGP instances, address families, advertisement types or overrides. ## Network policies A policy's detail splits it into two tables: - **Traffic rules** — one row per ingress, egress and deny rule: the peers (endpoints, entities, CIDRs with their exceptions, CIDR groups, FQDNs), ports and port ranges, ICMP types, and L7 matches such as HTTP method, path and headers. - **Policy selectors** — the endpoint or node selector of each rule set and its default-deny settings for ingress and egress. A ClusterwideNetworkPolicy reads the same way, including its node selectors. ## Endpoints, nodes and identities - An **endpoint** shows its state, endpoint ID, security identity and labels, the node it runs on, the identities its policy allows in each direction, its named ports, and any controllers that keep failing with their last error. - A **node** shows its pod CIDRs, health addresses, IPAM pre-allocation and limits, its node addresses, and its allocated and available IPs. - An **identity** shows its security labels; a **CIDR group** its external CIDRs. ## IP pools, L2 announcements and egress gateways - **LoadBalancerIPPools** — the IP blocks, the service selector, and the total, used and available IPs Cilium reports. - **L2AnnouncementPolicies** — the service and node selectors, the interfaces, and whether external and LoadBalancer IPs are announced. - **EgressGatewayPolicies** — the destination and excluded CIDRs and the egress gateways with their node selectors. ## BGP - **BGPClusterConfigs** — the node selector and the BGP instances with their peers. - **BGPPeerConfigs** — transport and timers, graceful restart, eBGP multihop TTL, the address families with their advertisements, and the authentication Secret by name. - **BGPAdvertisements** — what each advertisement announces. - **BGPNodeConfigs** and **BGPNodeConfigOverrides** — the per-node instances and overrides, and the peers and routes Cilium reports for the node. ## Related resources and what stays out A detail's **Related resources** section links to the objects it names explicitly, such as an endpoint's Pod, a node's Node, a policy's CIDR groups and TLS Secrets, or a peer config's authentication Secret, in the same context. Klustr projects only the fields above and never shows a raw spec: BGP authentication and policy TLS settings can point at secret material, so a Secret appears by name only. Cilium has no actions of its own here; YAML edit and delete work as for any custom resource and respect a context's [read-only mode](https://klustr.dev/docs/getting-started/#read-only-mode). --- # Platform integrations: cert-manager, Istio, Karpenter & KEDA Source: https://klustr.dev/docs/integrations/ Beyond [GitOps](https://klustr.dev/docs/gitops/) and [Gateway API](https://klustr.dev/docs/gateway-api/), Klustr promotes a few more CRD families from the generic [Custom Resources](https://klustr.dev/docs/custom-resources/) browser to first-class, typed views. Each sidebar group appears only when its CRDs are detected in an active context, so nothing clutters a cluster that doesn't run it. Each reads its CRDs at the API version the cluster serves, so it tracks whichever release the cluster runs. A **Ready** column reads the same in every integration: **Ready**, **Not ready** or **Unknown**, from the resource's Ready condition. All mutating actions below respect a context's [read-only mode](https://klustr.dev/docs/getting-started/#read-only-mode). ## cert-manager Shown when the `cert-manager.io` CRDs are present. - **Certificates** — ready state and expiry at a glance. - **Issuers / ClusterIssuers** — the one-of spec (`acme` / `ca` / `selfSigned` / `vault` / `venafi`) is collapsed into a single **Type** column; ACME issuers also show their server and email. - **Issuance chain** — a Certificate's detail drills down the full chain, `Certificate → CertificateRequest → Order → Challenge`, each as a tab whose rows deep-link into the matching detail. When issuance is stuck, this is where you see which step failed and why. - **Renew** — one click, no `cmctl` on your PATH. ## Istio Shown when Istio's `networking.istio.io` and `security.istio.io` CRDs are present. - **VirtualServices** — hosts, gateways and every HTTP, TLS and TCP route as a match with weighted destinations. - **DestinationRules** — host, TLS mode, load balancer and subsets. - **Gateways** — servers with their ports, hosts and TLS credential, the gateway proxy pods the selector matches, and the VirtualServices bound to the gateway. - **ServiceEntries** — hosts, addresses, ports, location, resolution, endpoints and the namespaces the entry is exported to. - **Sidecars** — the workloads a Sidecar applies to, its ingress listeners, egress hosts and outbound traffic policy. - **AuthorizationPolicies** — action, rules and the workloads they select. An `ALLOW` policy without rules reads **Allows no requests (default deny)**. - **RequestAuthentications** — JWT issuers, audiences and keys, where the token is read from and whether it is forwarded, and the workloads they select. - **PeerAuthentications** — mTLS mode, port-level overrides and selector. Links connect the mesh config to what it routes: - A VirtualService's hosts and destinations and a DestinationRule's host open their Service. Short names resolve the way Istio resolves them, relative to the resource's namespace. - Each DestinationRule subset lists the pods its labels select. - A VirtualService's gateways open the Istio Gateway they name. - AuthorizationPolicies, RequestAuthentications and Sidecars list the pods they select. A selector policy in Istio's root namespace applies **in all namespaces**. The links follow Services and Pods live, so a subset's pods update during a rollout or scale. ## Karpenter Shown when the `karpenter.sh` CRDs are present. - **NodePools** — weight, node class, consolidation policy, CPU / memory limits and current usage, node count and ready state. - **NodeClaims** — provisioning status for the nodes Karpenter is bringing up. - **EC2NodeClasses** — shown when the AWS provider's `karpenter.k8s.aws` CRDs are present: readiness, AMI family, IAM role and instance profile, and the subnets, security groups and AMIs the selector terms resolved to, each AMI with its requirements. A NodePool's or NodeClaim's node class opens its EC2NodeClass. ### Why a node is not disrupted Karpenter-managed nodes and NodeClaims have a **Disruption** tab that answers "why isn't Karpenter removing this node?". It lists what holds the node right now: - `karpenter.sh/do-not-disrupt` on the node, its NodeClaim or one of its pods, including the duration form; - PodDisruptionBudgets that allow no eviction, or that overlap on one pod; - the NodePool's disruption budgets that are active now, with the nodes already being disrupted subtracted; - `consolidateAfter` set to `Never` or still cooling down, a `WhenEmpty` policy on a node that still runs pods, and a NodeClaim that is not initialized. Each blocker names the disruption reasons it holds back, so the headline can say, for example, that the node will not be consolidated but can still be replaced when it drifts. The tab also shows the NodePool's consolidation and expiry settings, its budgets with their schedules (in UTC), and Karpenter's own disruption events for the node, its NodeClaim and its NodePool. When your access does not include Pods or PodDisruptionBudgets in every namespace, the tab says it cannot tell rather than reporting that nothing blocks the node. On a cluster running Karpenter, every node has the tab; one Karpenter does not manage says so. ## KEDA Shown when the `keda.sh` CRDs are present. - **ScaledObjects** — target workload, replica range, triggers, and the **Ready**, **Active**, **Fallback** and **Paused** state. A one-direction pause (`paused-scale-in` or `paused-scale-out`) shows as such. The detail lists each trigger with its metric and authentication, the scaling settings (polling interval, cooldowns, fallback, the formula that combines several scalers), and links to the HPA KEDA created. - **ScaledJobs** — triggers, scaling strategy and the job template, with a **Jobs** tab listing the Jobs KEDA started. - **TriggerAuthentications** and **ClusterTriggerAuthentications** — the sources each one reads credentials from (Secrets, ConfigMaps, environment variables, bound service account tokens, pod identity, HashiCorp Vault, Azure Key Vault, AWS Secrets Manager, GCP Secret Manager) and the ScaledObjects and ScaledJobs that use it. Klustr never reads a secret value; a Vault token written into the spec shows as **token in spec**. **Pause** on a ScaledObject either keeps the current replica count or scales to a number you give and holds it there, through KEDA's `autoscaling.keda.sh/paused` and `paused-replicas` annotations. ScaledJobs pause and resume as a whole. **Resume** clears every pause annotation, the one-direction ones included. ### KEDA-managed HPAs A KEDA-managed HPA is a vanilla HorizontalPodAutoscaler whose metrics are all `External` and named `s0-…`, `s1-…` — without help they render as a wall of identical "external" rows. Klustr maps each back to its ScaledObject trigger and relabels it with the real trigger type plus the metadata that predicts scaling (Prometheus metric + threshold, cron schedule, Kafka topic + lag, and so on). Open a KEDA-owned HPA under **Config → HorizontalPodAutoscalers** and the Targets read as real triggers instead of opaque external metrics. --- # Custom Resources (CRDs) Source: https://klustr.dev/docs/custom-resources/ Klustr discovers Custom Resource Definitions automatically — you don't configure anything. Any CRD on the cluster becomes browsable. ## How discovery works On connect, Klustr lists `CustomResourceDefinition` objects and groups them in the sidebar **by API group**, below the built-in resource groups. When you open a CR list view, Klustr lazily starts a watch for that specific resource, so subsequent list and detail reads come from the local cache rather than hitting the apiserver again. A brand-new CRD installed while you're connected shows up without a restart. ## Browsing and editing - The generic CR list shows the objects for that kind. - The inspector shows **YAML by default**. A CR that one of the integrations below covers opens on that integration's overview instead, even from the generic list. - YAML edit, delete and (where applicable) scale work through the dynamic client, the same as built-in kinds — subject to a context's [read-only mode](https://klustr.dev/docs/getting-started/#read-only-mode). ## Promoted integrations Some CRDs get a first-class, typed UI instead of the generic YAML view when their API is detected: - **Argo CD** and **Flux** — see [GitOps](https://klustr.dev/docs/gitops/). - **Tekton** — PipelineRuns, TaskRuns, Pipelines and Tasks; see [Tekton Pipelines](https://klustr.dev/docs/tekton/). - **Gateway API** — see [Gateway API](https://klustr.dev/docs/gateway-api/). - **Kyverno** — policies, PolicyExceptions and the `wgpolicyk8s.io` policy reports; see [Kyverno & policy reports](https://klustr.dev/docs/kyverno/). - **cert-manager** — Certificates, Issuers / ClusterIssuers and the full issuance chain (CertificateRequest → Order → Challenge), with ready/expiry status and a one-click **Renew**. - **Istio** — VirtualServices, DestinationRules and PeerAuthentications. - **Karpenter** — NodePools and NodeClaims with provisioning status, surfaced when the `karpenter.sh` CRDs are present, and the AWS provider's EC2NodeClasses. - **Cilium** — network policies, endpoints, nodes, identities, IP pools and BGP configuration; see [Cilium](https://klustr.dev/docs/cilium/). Each integration reads its CRDs at the API version the cluster serves, so an older install, such as Karpenter before 1.0 or Flux before 2.3, works as well as a current one. Everything else stays under the generic CRD browser — which is enough for most operators most of the time. --- # Frequently asked questions Source: https://klustr.dev/faq/ > Short answers with links to the guide that goes deeper. If your question is missing, open an issue and it will be added here. ## Does Klustr install anything in my cluster? No. Klustr is a pure client: it reads `~/.kube/config` and talks to the API server the same way `kubectl` does. There is no agent, operator, CRD or sidecar. The one exception is the opt-in **Install metrics-server** action, which applies the upstream manifest and which Klustr can remove again by the label it stamps on those objects. ## Which platforms does Klustr run on? macOS on Apple Silicon, signed with a Developer ID certificate and notarized by Apple, so Gatekeeper opens it directly. Linux amd64 as a tarball, a `.deb` and the `klustr-bin` AUR package; the binary links against `webkit2gtk-4.1` and `gtk-3`, which Ubuntu 24.04+, Fedora 39+ and Arch ship by default (Ubuntu 22.04 needs `libwebkit2gtk-4.1-0 libgtk-3-0` first). Windows amd64 as a zip, tested on Windows 11, which ships the WebView2 runtime Klustr renders with; the build is not code-signed yet, so SmartScreen warns on first launch and Smart App Control, when on, blocks it. ## Is Klustr free? Is there a paid tier? Klustr is free software under the Apache License 2.0. There is no account, no activation and no paid tier, and the full source is on [GitHub](https://github.com/SametKUM/klustr). Every release is built by CI from a tagged commit. ## Does Klustr send telemetry or phone home? The app contains no analytics. The only network request that does not go to one of your clusters is an update check against GitHub Releases, which reports whether a newer version exists and never downloads or replaces the binary. Development builds skip that call entirely. ## Do I need the helm, argocd or flux CLIs installed? No. Helm runs inside Klustr through the upstream Helm v3 library. Argo CD **Sync** is the same PATCH that `argocd app sync` sends and **Refresh** flips the refresh annotation; Flux **Reconcile** and **Suspend** set the standard Flux annotations. Nothing is shelled out. The only requirement is that your kubeconfig user is allowed to update those resources. See the [GitOps guide](https://klustr.dev/docs/gitops/) and the [Helm guide](https://klustr.dev/docs/helm/). ## How does authentication work? My kubeconfig uses aws-vault. Klustr uses whatever your kubeconfig defines, including `exec` credential plugins. Because a Dock or Finder launch skips your shell startup files, Klustr first runs your login shell once and imports its `PATH` and an allowlist of variables, so `aws eks get-token` and friends are found. If a context needs a specific aws-vault profile, map it in **Connections → Credential helpers**; Klustr then runs `aws-vault export` on connect, keeps the keys in memory only and refreshes them about five minutes before they expire. Details are in the [credential helpers guide](https://klustr.dev/docs/credential-helpers/). ## Can I look at several clusters at once? Yes. Check two or more contexts on the Connections screen and every list view fans out across them with a **Context** column. Save the selection as a named group for one-click reconnect, and tag contexts with colors so the top bar stripe tells you which environment you are touching. See [multi-context and aggregated mode](https://klustr.dev/docs/multi-context/). ## What does read-only mode do? Each context has a read-only switch. When it is on, every mutating action for that context is blocked: apply, delete, scale, restart, Helm install and upgrade, Argo CD sync, Flux reconcile, drain and the rest. Turn it on to browse a production cluster knowing no button can change anything. ## Why is a resource list empty when I know objects exist? On connect Klustr probes your access for every kind with SelfSubjectAccessReview. A kind you may list cluster-wide is watched cluster-wide; a kind you may only list in the namespace your kubeconfig context names is watched there; a kind you may not list at all shows an empty table instead of failing with 403s in the background. Check the namespace selector in the header and the RBAC granted to your user. ## Does Klustr poll the API server? No. Resource lists are kept live by client-go informers, which use the watch API and push each change as it lands. Only `Namespace` and `Pod` informers start on connect; every other kind starts watching the first time you open it. The single exception is `metrics.k8s.io`, which has no watch, so CPU and memory usage is polled every 15 seconds and the columns are hidden when the API is not available. ## How are custom resources handled? CRDs are discovered on connect and grouped in the sidebar by API group. Opening a kind lazily starts a watch for it, and a CRD installed while you are connected appears without a restart. The detail view shows YAML, and edit, delete and scale work through the dynamic client. Argo CD, Flux, Tekton, Gateway API, cert-manager, Istio, Karpenter, Kyverno and Cilium get typed views instead of the generic browser, and KEDA triggers are mapped onto the HPAs they drive. See [custom resources](https://klustr.dev/docs/custom-resources/) and [platform integrations](https://klustr.dev/docs/integrations/). ## Where does Klustr store its settings? In your user configuration directory, for example `~/Library/Application Support/klustr` on macOS and the XDG equivalent on Linux. Helm repositories live in `helm-repos.json`, and the credential-helper store holds provider and profile names only, never credential values. Window, theme and table preferences are kept in the app’s local storage. ## How is Klustr different from Lens? Klustr is Apache-2.0 licensed, needs no account and installs nothing in the cluster, renders through the operating system’s webview instead of Electron, can show several clusters in one table, and ships typed views for Helm, Argo CD, Flux, Gateway API and cert-manager without extensions. Lens has a Windows installer, an extension marketplace and team features. The [full comparison](https://klustr.dev/compare/lens/) goes row by row. ## How do I report a bug or a security issue? Bugs go through the [bug report template](https://github.com/SametKUM/klustr/issues/new?template=bug_report.yml), which asks for the version, OS and cluster details needed to reproduce. Security issues should be reported privately as described in the [security policy](https://github.com/SametKUM/klustr/blob/main/SECURITY.md), never in a public issue. ## Can I contribute? Yes. Read [CONTRIBUTING.md](https://github.com/SametKUM/klustr/blob/main/CONTRIBUTING.md) and the architecture notes in [AGENTS.md](https://github.com/SametKUM/klustr/blob/main/AGENTS.md) first, use Conventional Commits, and include a screenshot or short clip for user-facing changes. Bug reports and focused pull requests are both welcome. --- # Klustr compared with other Kubernetes UIs Source: https://klustr.dev/compare/ > Lens, k9s and Headlamp are all good tools with different shapes. This page puts them next to Klustr on the questions people ask before switching, and links to a page for each. ## At a glance 20 rows, reviewed 2026-10-16. ### The project | Criterion | Klustr | Lens | k9s | Headlamp | | --- | --- | --- | --- | --- | | License and price | Apache-2.0, free | Proprietary. Free Personal plan with eligibility limits, paid plans beyond | Apache-2.0, free | Apache-2.0, free | | Runtime | Go + OS webview. Wails, no bundled browser | Electron. Bundled Chromium and Node.js | Go terminal UI | Electron or in-cluster web. Go backend, React frontend | | Platforms | macOS, Linux, Windows. Windows build not code-signed | macOS, Windows, Linux | macOS, Linux, Windows | macOS, Windows, Linux, browser | ### What it needs from your cluster | Criterion | Klustr | Lens | k9s | Headlamp | | --- | --- | --- | --- | --- | | Installed in the cluster | Nothing. Optional one-click metrics-server, removable from Klustr | Nothing required. Optional metrics stack | Nothing | Optional. Desktop app runs locally; web mode is deployed in-cluster | | Account or sign-in | None. Your kubeconfig is the only credential | Lens ID required. Needed to activate the desktop app | None | None on desktop. Token or OIDC when deployed in-cluster | ### Working across clusters | Criterion | Klustr | Lens | k9s | Headlamp | | --- | --- | --- | --- | --- | | Several clusters at once | Aggregated table. Two or more contexts in one list, named groups, color tags | One cluster per view. Catalog and hotbar to switch | One context at a time. Switch with :ctx | Multi-cluster view. Select clusters and compare side by side | | RBAC | Access Review matrix. Subject to effective permissions with the binding chain | Roles and bindings | RBAC and policy views. Reverse lookup for a user, group or ServiceAccount | Roles and bindings | ### Platform tooling | Criterion | Klustr | Lens | k9s | Headlamp | | --- | --- | --- | --- | --- | | Helm | Built in. Install, upgrade, rollback, uninstall with a dry-run diff; repo search | Built in. Charts and releases, upgrade and rollback | Release view. Values, history and rollback; no install or upgrade | Via plugin. App Catalog plugin, bundled with the desktop app | | Argo CD and Flux | Built in, through the API. Sync, refresh, reconcile, suspend; no CLIs | Built in, paid plans. Not in the free Personal plan | Community plugins. Sync, refresh, reconcile, suspend; Flux needs the flux CLI | Via plugins. Official Flux plugin and Argo CD plugin (alpha) | | Tekton | Typed views. PipelineRun task table and graph, step logs, start, cancel and rerun, Triggers; no tkn | Generic CRDs | Generic CRDs | Generic CRDs | | Gateway API | Typed views. Listeners, rule matrix, RouteParentStatus | Built in. Including TCP, UDP and TLS routes and ListenerSets | Generic CRDs | Built in. Including TCPRoute and UDPRoute | | Istio | Typed views. Eight networking and security kinds, hosts linked to Services and subsets to pods | Generic CRDs. A community extension draws them in a traffic graph | Generic CRDs | Via plugin. Community Istio plugins | | Cilium | Typed views. Policies as rule tables, endpoints, IP pools, BGP | Generic CRDs | Generic CRDs | Generic CRDs | | cert-manager | Typed views. Issuance chain and one-click renew | Generic CRDs | Community plugin. Status and renew through cmctl | Via plugin. Official cert-manager plugin | | Kyverno | Typed views. Policies, every CEL policy kind, exceptions, policy reports and each policy’s violations | Via extension. Community extension; installing extensions needs a paid plan | Generic CRDs | Via plugin. Official plugin with policy reports | | Karpenter | Typed views. NodePools against their limits, NodeClaims, EC2NodeClasses, disruption blockers per node | Generic CRDs | Community plugin. Jumps between NodePools, NodeClaims and Nodes | Via plugin. Official plugin, marked alpha | | KEDA | Typed views. ScaledObjects, ScaledJobs and authentications, pause and resume, triggers on the HPA | Generic CRDs | Community plugin. Pause and resume ScaledObjects | Via plugin. Official KEDA plugin | ### Day-to-day operations | Criterion | Klustr | Lens | k9s | Headlamp | | --- | --- | --- | --- | --- | | Logs | Multi-pod stream. Per-pod colors, follow, regex, save | Per container | Per pod or workload. Aggregated for a deployment, filters | Per container | | Shell access | Exec, debug container, node shell | Pod and node shell | Pod and node shell. Node shell behind a feature gate | Pod terminal | | Local terminal | Drawer per context. KUBECONFIG preset to the active context | Built in | Is the terminal | None | ## Head-to-head pages Each page goes row by row and says where that tool is the better pick. - [Klustr vs Lens](https://klustr.dev/compare/lens/): The best-known Kubernetes IDE. Electron, cross-platform, with an extension marketplace, team features and paid plans. Activation needs a Lens ID. - [Klustr vs k9s](https://klustr.dev/compare/k9s/): Keyboard-driven terminal UI in Go. One context at a time, fast to navigate, extensible through plugins and hotkeys. Apache-2.0. - [Klustr vs Headlamp](https://klustr.dev/compare/headlamp/): Kubernetes SIG UI project with a plugin system. Runs as an Electron desktop app or is deployed into the cluster as a web UI. Apache-2.0. ## How this table is kept honest Every cell about another tool comes from that tool’s public documentation, README or release notes, and the table was last reviewed on 2026-10-16. Cells are worded as capabilities, not judgements, and where a feature exists only through plugins or extensions the cell says so. There are no memory or speed numbers here because none have been measured side by side. If a row is wrong or out of date, [open an issue](https://github.com/SametKUM/klustr/issues) with a link to the source and it will be corrected. --- # Klustr vs Lens: open-source Lens and OpenLens alternative Source: https://klustr.dev/compare/lens/ > Klustr compared with Lens Desktop, for OpenLens and Freelens users too: license and sign-in, Electron vs native webview, multi-cluster, Helm, Argo CD, Flux, Gateway API and RBAC. Lens is the best-known Kubernetes desktop IDE: a mature, cross-platform Electron app with an extension marketplace, team features and paid plans. Klustr is a smaller, Apache-2.0 licensed desktop client for macOS, Linux and Windows that trades the marketplace and the team layer for a direct workflow with no account: your kubeconfig, the Kubernetes API, and typed views for the platform tooling most clusters already run. If you arrived here looking for an OpenLens alternative or a Freelens alternative: OpenLens was the community build of Lens’s open-source core and has not been maintained for over two years, and Freelens is the community fork started in 2024 that carries it on. Both keep Lens’s Electron architecture and one-cluster-per-view model, so most rows below apply to them as well. Freelens, like Klustr, needs no account. Facts about Lens come from its public documentation and were reviewed on 2026-10-16. If something is out of date, [open an issue](https://github.com/SametKUM/klustr/issues) and it will be corrected. ## At a glance ### The project | Criterion | Klustr | Lens | | --- | --- | --- | | License and price | Apache-2.0, free | Proprietary. Free Personal plan with eligibility limits, paid plans beyond | | Runtime | Go + OS webview. Wails, no bundled browser | Electron. Bundled Chromium and Node.js | | Platforms | macOS, Linux, Windows. Windows build not code-signed | macOS, Windows, Linux | ### What it needs from your cluster | Criterion | Klustr | Lens | | --- | --- | --- | | Installed in the cluster | Nothing. Optional one-click metrics-server, removable from Klustr | Nothing required. Optional metrics stack | | Account or sign-in | None. Your kubeconfig is the only credential | Lens ID required. Needed to activate the desktop app | ### Working across clusters | Criterion | Klustr | Lens | | --- | --- | --- | | Several clusters at once | Aggregated table. Two or more contexts in one list, named groups, color tags | One cluster per view. Catalog and hotbar to switch | | RBAC | Access Review matrix. Subject to effective permissions with the binding chain | Roles and bindings | ### Platform tooling | Criterion | Klustr | Lens | | --- | --- | --- | | Helm | Built in. Install, upgrade, rollback, uninstall with a dry-run diff; repo search | Built in. Charts and releases, upgrade and rollback | | Argo CD and Flux | Built in, through the API. Sync, refresh, reconcile, suspend; no CLIs | Built in, paid plans. Not in the free Personal plan | | Tekton | Typed views. PipelineRun task table and graph, step logs, start, cancel and rerun, Triggers; no tkn | Generic CRDs | | Gateway API | Typed views. Listeners, rule matrix, RouteParentStatus | Built in. Including TCP, UDP and TLS routes and ListenerSets | | Istio | Typed views. Eight networking and security kinds, hosts linked to Services and subsets to pods | Generic CRDs. A community extension draws them in a traffic graph | | Cilium | Typed views. Policies as rule tables, endpoints, IP pools, BGP | Generic CRDs | | cert-manager | Typed views. Issuance chain and one-click renew | Generic CRDs | | Kyverno | Typed views. Policies, every CEL policy kind, exceptions, policy reports and each policy’s violations | Via extension. Community extension; installing extensions needs a paid plan | | Karpenter | Typed views. NodePools against their limits, NodeClaims, EC2NodeClasses, disruption blockers per node | Generic CRDs | | KEDA | Typed views. ScaledObjects, ScaledJobs and authentications, pause and resume, triggers on the HPA | Generic CRDs | ### Day-to-day operations | Criterion | Klustr | Lens | | --- | --- | --- | | Logs | Multi-pod stream. Per-pod colors, follow, regex, save | Per container | | Shell access | Exec, debug container, node shell | Pod and node shell | | Local terminal | Drawer per context. KUBECONFIG preset to the active context | Built in | [Lens website](https://k8slens.dev/) ## Where Klustr is different - **No sign-in.** Lens Desktop needs a Lens ID to activate, and the free Personal plan is limited to education and to companies under a revenue threshold. Klustr has no account, no activation and no plan tiers. It is Apache-2.0 licensed and free for any use. - **Nothing installed in the cluster.** Both tools read your kubeconfig. Klustr never asks to deploy anything either; the single opt-in exception is a one-click metrics-server install that Klustr can also remove. - **Several clusters in one table.** Lens shows one cluster per view. Klustr drives two or more contexts as one virtual cluster with a Context column, named groups and color tags, so a fleet or a prod-versus-staging comparison is one screen. - **Platform tooling without a plan, CLIs or extensions.** Argo CD, Flux, Tekton, cert-manager, Istio, Cilium, Kyverno, Karpenter and KEDA get typed views out of the box, driven through the Kubernetes API. Lens builds in Gateway API for everyone and Argo CD and Flux on its paid plans; the others are generic custom resources there or come from community extensions, which also need a paid plan to install. - **Access Review.** Klustr answers “what can this ServiceAccount do in this namespace?” with a live permission matrix and the binding and role chain behind every entry. Lens lists roles and bindings. - **Native webview instead of Electron.** Klustr is a Go binary that renders through the operating system’s webview via Wails, so there is no bundled Chromium. The macOS archive is about 22 MB. ## Where Lens is stronger - **Windows installer.** Lens ships Windows installers. Klustr ships a portable zip that is not code-signed yet. - **Extensions.** Lens has an extension API and a marketplace; installing extensions needs a paid plan. Klustr has no plugin system; its integrations are built in. - **Argo CD breadth.** On its paid plans Lens covers ApplicationSets, Projects, Repositories and Clusters next to Applications, and adds a Flux health dashboard. Klustr’s Argo CD view is Applications; the other Argo CD kinds stay in the generic CRD browser. - **Team and cloud features.** Lens offers shared catalogs, cloud-connected clusters and enterprise SSO. Klustr is a single-user desktop client. - **Metrics dashboards.** Lens can install and read a Prometheus stack. Klustr reads metrics-server for CPU and memory and does not chart Prometheus. ## Which one to pick Pick Lens if you need a Windows installer, extensions or team features. Pick Klustr if you want a free, open-source client with no account that covers Helm, GitOps, Tekton and Gateway API without a paid plan and can show several clusters at once. --- # Klustr vs k9s: a desktop companion to the terminal UI Source: https://klustr.dev/compare/k9s/ > Where a desktop client adds to k9s and where the terminal UI stays ahead: several clusters at once, typed GitOps and Gateway API views, diffs, RBAC review and keyboard speed. k9s is the terminal UI many operators live in: fast, keyboard-driven, free under Apache-2.0 and extensible through plugins and hotkeys. Klustr is not trying to replace it. It is a desktop client for the parts of cluster work that benefit from a second dimension: many clusters at once, status tables you can scan, diffs, and drill-downs across resource kinds. Facts about k9s come from its README and documentation and were reviewed on 2026-10-16. Corrections are welcome as [an issue](https://github.com/SametKUM/klustr/issues). ## At a glance ### The project | Criterion | Klustr | k9s | | --- | --- | --- | | License and price | Apache-2.0, free | Apache-2.0, free | | Runtime | Go + OS webview. Wails, no bundled browser | Go terminal UI | | Platforms | macOS, Linux, Windows. Windows build not code-signed | macOS, Linux, Windows | ### What it needs from your cluster | Criterion | Klustr | k9s | | --- | --- | --- | | Installed in the cluster | Nothing. Optional one-click metrics-server, removable from Klustr | Nothing | | Account or sign-in | None. Your kubeconfig is the only credential | None | ### Working across clusters | Criterion | Klustr | k9s | | --- | --- | --- | | Several clusters at once | Aggregated table. Two or more contexts in one list, named groups, color tags | One context at a time. Switch with :ctx | | RBAC | Access Review matrix. Subject to effective permissions with the binding chain | RBAC and policy views. Reverse lookup for a user, group or ServiceAccount | ### Platform tooling | Criterion | Klustr | k9s | | --- | --- | --- | | Helm | Built in. Install, upgrade, rollback, uninstall with a dry-run diff; repo search | Release view. Values, history and rollback; no install or upgrade | | Argo CD and Flux | Built in, through the API. Sync, refresh, reconcile, suspend; no CLIs | Community plugins. Sync, refresh, reconcile, suspend; Flux needs the flux CLI | | Tekton | Typed views. PipelineRun task table and graph, step logs, start, cancel and rerun, Triggers; no tkn | Generic CRDs | | Gateway API | Typed views. Listeners, rule matrix, RouteParentStatus | Generic CRDs | | Istio | Typed views. Eight networking and security kinds, hosts linked to Services and subsets to pods | Generic CRDs | | Cilium | Typed views. Policies as rule tables, endpoints, IP pools, BGP | Generic CRDs | | cert-manager | Typed views. Issuance chain and one-click renew | Community plugin. Status and renew through cmctl | | Kyverno | Typed views. Policies, every CEL policy kind, exceptions, policy reports and each policy’s violations | Generic CRDs | | Karpenter | Typed views. NodePools against their limits, NodeClaims, EC2NodeClasses, disruption blockers per node | Community plugin. Jumps between NodePools, NodeClaims and Nodes | | KEDA | Typed views. ScaledObjects, ScaledJobs and authentications, pause and resume, triggers on the HPA | Community plugin. Pause and resume ScaledObjects | ### Day-to-day operations | Criterion | Klustr | k9s | | --- | --- | --- | | Logs | Multi-pod stream. Per-pod colors, follow, regex, save | Per pod or workload. Aggregated for a deployment, filters | | Shell access | Exec, debug container, node shell | Pod and node shell. Node shell behind a feature gate | | Local terminal | Drawer per context. KUBECONFIG preset to the active context | Is the terminal | [k9s website](https://k9scli.io/) ## Where Klustr is different - **Several contexts in one table.** k9s works in one context and switches with `:ctx`. Klustr aggregates two or more contexts into one list with a Context column, saved groups and a color stripe that tells you which environment you are touching. - **Typed views for platform tooling.** Argo CD Applications, Flux reconcilers, Tekton runs, Gateway API routes and cert-manager chains render as tables with status pills and actions. In k9s they are generic custom resources, with community plugins adding actions for some of them. - **Diffs before changes.** Helm upgrades show a dry-run diff, YAML edits show a server-side dry-run diff, and rollout history shows a side-by-side template diff before you roll back. - **Access Review.** k9s can reverse-look-up what a subject may do. Klustr renders the answer as a resource-by-verb matrix with the binding and role behind every cell, live across every active context. - **k9s stays one keystroke away.** The built-in terminal drawer opens a local shell with KUBECONFIG already set to the active context, so `k9s`, `kubectl` and `stern` run against the right cluster without any setup. ## Where k9s is stronger - **Keyboard speed.** For an operator who knows the shortcuts, nothing beats k9s for moving through a single cluster. - **Works over SSH.** k9s runs anywhere a terminal does, including a bastion host. Klustr is a desktop app. - **Plugins and hotkeys.** k9s is scriptable: custom commands, plugins and skins with a small config file. - **Footprint.** k9s is a single small binary. ## Which one to pick Keep k9s for fast single-cluster navigation and remote sessions. Add Klustr when you need several clusters in one view, typed GitOps and Gateway API status, or a diff before you change something. --- # Klustr vs Headlamp: desktop client or in-cluster dashboard Source: https://klustr.dev/compare/headlamp/ > Two open-source Kubernetes UIs compared: Headlamp’s plugin system and in-cluster mode against Klustr’s pure-client design, built-in Helm and GitOps, cert-manager views and RBAC review. Headlamp is a Kubernetes SIG UI project with a plugin system, an in-cluster deployment mode and desktop builds. It is a natural comparison: both tools are open source, both read your kubeconfig, both support several clusters and both render Gateway API resources. Facts about Headlamp come from its documentation and release notes and were reviewed on 2026-10-16. Corrections are welcome as [an issue](https://github.com/SametKUM/klustr/issues). ## At a glance ### The project | Criterion | Klustr | Headlamp | | --- | --- | --- | | License and price | Apache-2.0, free | Apache-2.0, free | | Runtime | Go + OS webview. Wails, no bundled browser | Electron or in-cluster web. Go backend, React frontend | | Platforms | macOS, Linux, Windows. Windows build not code-signed | macOS, Windows, Linux, browser | ### What it needs from your cluster | Criterion | Klustr | Headlamp | | --- | --- | --- | | Installed in the cluster | Nothing. Optional one-click metrics-server, removable from Klustr | Optional. Desktop app runs locally; web mode is deployed in-cluster | | Account or sign-in | None. Your kubeconfig is the only credential | None on desktop. Token or OIDC when deployed in-cluster | ### Working across clusters | Criterion | Klustr | Headlamp | | --- | --- | --- | | Several clusters at once | Aggregated table. Two or more contexts in one list, named groups, color tags | Multi-cluster view. Select clusters and compare side by side | | RBAC | Access Review matrix. Subject to effective permissions with the binding chain | Roles and bindings | ### Platform tooling | Criterion | Klustr | Headlamp | | --- | --- | --- | | Helm | Built in. Install, upgrade, rollback, uninstall with a dry-run diff; repo search | Via plugin. App Catalog plugin, bundled with the desktop app | | Argo CD and Flux | Built in, through the API. Sync, refresh, reconcile, suspend; no CLIs | Via plugins. Official Flux plugin and Argo CD plugin (alpha) | | Tekton | Typed views. PipelineRun task table and graph, step logs, start, cancel and rerun, Triggers; no tkn | Generic CRDs | | Gateway API | Typed views. Listeners, rule matrix, RouteParentStatus | Built in. Including TCPRoute and UDPRoute | | Istio | Typed views. Eight networking and security kinds, hosts linked to Services and subsets to pods | Via plugin. Community Istio plugins | | Cilium | Typed views. Policies as rule tables, endpoints, IP pools, BGP | Generic CRDs | | cert-manager | Typed views. Issuance chain and one-click renew | Via plugin. Official cert-manager plugin | | Kyverno | Typed views. Policies, every CEL policy kind, exceptions, policy reports and each policy’s violations | Via plugin. Official plugin with policy reports | | Karpenter | Typed views. NodePools against their limits, NodeClaims, EC2NodeClasses, disruption blockers per node | Via plugin. Official plugin, marked alpha | | KEDA | Typed views. ScaledObjects, ScaledJobs and authentications, pause and resume, triggers on the HPA | Via plugin. Official KEDA plugin | ### Day-to-day operations | Criterion | Klustr | Headlamp | | --- | --- | --- | | Logs | Multi-pod stream. Per-pod colors, follow, regex, save | Per container | | Shell access | Exec, debug container, node shell | Pod terminal | | Local terminal | Drawer per context. KUBECONFIG preset to the active context | None | [Headlamp website](https://headlamp.dev/) ## Where Klustr is different - **Never runs in the cluster.** Headlamp can be deployed as an in-cluster web UI or run as a desktop app. Klustr only runs on your machine and installs nothing in the cluster; there is no deployment to expose, upgrade or secure. - **Helm, Argo CD and Flux without plugins.** Headlamp covers them through official plugins, the Argo CD one still in alpha. Klustr ships Helm v3 with a dry-run diff, Argo CD sync and refresh, and Flux reconcile and suspend, with no plugins or CLIs. - **Tekton, Cilium and the other platform tools built in.** Headlamp has no Tekton or Cilium plugin, and covers cert-manager, Kyverno, Karpenter and KEDA through official plugins and Istio through community ones. Klustr ships typed views for all of them, including a PipelineRun task table with step logs, the full certificate issuance chain with one-click renew, and Cilium policies as rule tables. - **Access Review.** Headlamp lists roles and bindings. Klustr computes a subject’s effective permissions as a matrix with the binding chain behind every entry. - **Aggregated rows, not side-by-side panes.** Both tools support several clusters. Headlamp compares clusters side by side; Klustr merges them into one table with a Context column so a fleet reads as one cluster. - **Operations from the desktop.** A local terminal drawer bound to the active context, a root node shell, cordon and PDB-aware drain, and ephemeral debug containers for shell-less images. ## Where Headlamp is stronger - **In-cluster mode for a team.** Deploy Headlamp once with OIDC and every teammate gets a browser UI without installing anything locally. - **Plugin ecosystem and resource map.** Headlamp has a documented plugin API and a resource relationship map. - **CNCF governance.** Headlamp is a Kubernetes SIG UI project with community governance, and the UI the archived Kubernetes Dashboard points its users to. Klustr is a single-maintainer open-source project. ## Which one to pick Pick Headlamp for a shared, in-cluster web UI or if you want to write plugins. Pick Klustr for a desktop client that installs nothing, treats Helm, GitOps and cert-manager as first-class and can show several clusters as one.