CLI tool
derailed/k9s avatar
derailed/k9s

K9s: A Terminal UI for Kubernetes That Watches While You Work

🐶 Kubernetes CLI To Manage Your Clusters In Style!

34,981 stars2,350 forksGoApache-2.0

At a glance

What is it?
K9s is a Go-based terminal UI for Kubernetes that continuously watches cluster resources and offers commands to manage them. It suits engineers who live in a shell, but its release cadence and dev-mode installs deserve scrutiny.
Who is it for?
Adopt K9s if you are a Kubernetes operator who prefers a terminal over a web dashboard and wants a live view of cluster state. It is a good fit for daily monitoring and quick edits, especially for those who already use kubectl.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • derailed/k9s34,981 ★ · +598
Star history
Repository2026-08-182026-11-15
derailed/k9s34.4k35k

598 Stars in the last 89 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What K9s Actually Solves

K9s addresses the problem of navigating Kubernetes clusters without leaving the terminal. kubectl is powerful but stateless: every command is a fresh query, and you must remember resource names, namespaces, and flags. K9s provides a persistent terminal UI that shows resources in a list format, similar to a text-based dashboard. The README states its aim is to make it easier to navigate, observe, and manage applications. This is for engineers who already spend their day in a shell and want a visual layer over kubectl, not for those who prefer a web dashboard like the Kubernetes dashboard. The tool is written in Go, so it is a single binary, and it watches Kubernetes for changes, giving you a live view without manual refreshes.

How the Continuous Watch Mechanism Works

The core mechanism is continuous watching. K9s does not just fetch resources once; it subscribes to Kubernetes watch events and updates the UI in real time. The README says it 'continually watches Kubernetes for changes and offers subsequent commands to interact with your observed resources.' This means when a pod crashes or a deployment scales, the UI reflects that without you pressing refresh. The data flow is a loop: Kubernetes API server sends watch events, K9s processes them, and the terminal UI re-renders. This is a significant difference from running `kubectl get pods` repeatedly.

Getting K9s Running: Install Methods and First Commands

Installation is straightforward across platforms. The README lists many package managers: Homebrew on macOS or Linux with `brew install derailed/k9s/k9s`, snap on Linux with `snap install k9s --devmode`, and Windows via winget, scoop, or chocolatey. For a quick test, the Ubuntu .deb download is a one-liner: `wget https://github.com/derailed/k9s/releases/latest/download/k9s_linux_amd64.deb && sudo apt install ./k9s_linux_amd64.deb && rm k9s_linux_amd64.deb`. If you prefer source, clone the repo and run `make build && ./execs/k9s`, but note that `go install github.com/derailed/k9s@latest` installs the dev version, not a stable release. Before running, the README gives two preflight checks: set `TERM=xterm-256color` for 256-color mode, and set `KUBE_EDITOR` to your preferred editor so that edit commands work. The README points to the k9scli.io documentation for usage and customization.

Docker and Multi-Platform Builds: A Containerized Path

For those who want to avoid installing a binary, K9s runs as a Docker container. The README shows mounting your kubeconfig: `docker run --rm -it -v $KUBECONFIG:/root/.kube/config derailed/k9s`. This is convenient for ephemeral use, but it requires your kubeconfig to be accessible inside the container. The Dockerfile also supports building your own image with a specific kubectl version via `--build-arg KUBECTL_VERSION`. The `make imgx` target builds multi-platform images for linux/amd64 and linux/arm64 using Docker buildx, with QEMU emulation for cross-arch builds. This is useful for ARM users, but the README warns that plain Docker Engine needs manual emulation setup. The container approach adds a layer of indirection: you must keep the image updated and ensure your kubeconfig paths match. For a terminal tool that is already a single binary, the container path is optional, not a necessity.

Genuine Limitations and Failure Modes

K9s has real constraints. First, it requires a 256-color terminal; if your TERM is not set correctly, the UI may render poorly or fail. The README explicitly says to set `TERM=xterm-256color` on Nix systems. Second, the tool prefers recent Kubernetes versions, specifically 1.28 or above. If you run an older cluster, you may encounter compatibility issues. The README includes a K8S compatibility matrix mapping k9s versions to Kubernetes client versions. Third, the snap install uses `--devmode`, which means the snap is installed in development mode; check what that implies for your environment. Fourth, the README notes the project is not backed by a big corporation and demands a lot of the maintainer's time, so bug fixes and feature requests depend on limited maintainer time. If your organization relies on vendor support, K9s is the wrong tool.

Alternatives: kubectl and Terminal Dashboards

The most direct alternative is plain kubectl. It is the standard CLI, has no watch UI, and requires manual commands for each operation. kubectl also supports `kubectl get --watch` for a raw watch, but it is not interactive. K9s builds on top of kubectl concepts but adds a persistent, navigable interface. Another alternative is a web dashboard like the Kubernetes Dashboard or Lens, which provide a GUI with mouse interaction. The difference in approach is fundamental: K9s is keyboard-driven and lives in the terminal, while web dashboards are graphical and require a browser. For users who prefer clicking, a web dashboard is better. The choice depends on whether you want to stay in the shell or switch to a GUI.

Maintenance and Upgrade Cost

The recent releases are v0.51.0 in June 2026, with v0.50.18 and v0.50.17 in January 2026. The upgrade cost is low for package manager installs, but higher for manual tarball downloads. The Docker image also needs periodic pulls. The project is Apache-2.0 licensed, which permits commercial use and modification, but the README's sponsorship plea indicates that long-term maintenance is not guaranteed. You should verify the compatibility matrix before each upgrade, as the Kubernetes client version may change. The README says building from source needs Go 1.23 or above, but go.mod declares go 1.26.8, so use at least that version.

Editorial conclusion

Adopt K9s if you are a Kubernetes operator who prefers a terminal over a web dashboard and wants a live view of cluster state. It is a good fit for daily monitoring and quick edits, especially for those who already use kubectl. Do not adopt it if you need a GUI with mouse support or if your cluster runs Kubernetes versions older than 1.28, as the README states a preference for recent versions. Before adopting, verify your TERM is set to xterm-256color, set KUBE_EDITOR for edit commands, and test K9s against your specific cluster version. Also, check the K8S compatibility matrix in the README to confirm your Kubernetes client version matches. K9s is Apache-2.0 licensed and free, but the README says it is not backed by a big corporation, so budget time for potentially slower fixes.

Frequently asked questions

What is k9s vs kubectl?

kubectl is a stateless command line client where each invocation stands alone. k9s is a terminal UI that continually watches Kubernetes for changes and then offers commands against the resources it has observed, acting on live objects as you press keys.

What is the current version of k9s?

The newest tagged release is v0.51.0, published 2026-06-06, and the Makefile default matches it. The last push to the repository was on 2026-11-02, so master is ahead of that tag.

Can I use k9s on Windows?

Yes. The README lists Windows support with three routes: `winget install k9s`, `scoop install k9s` and `choco install k9s`. There is also a Webi installer for Windows using `curl.exe -A MS https://webinstall.dev/k9s | powershell`.

Can you provide a detailed cheat sheet for k9s?

Key bindings and configuration are documented on the k9scli.io site, which the README points to for installation, usage, customization and tips.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
  4. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/derailed-k9s.svg)](https://hysenlabs.com/projects/derailed-k9s)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/derailed-k9s.svg)](https://hysenlabs.com/projects/derailed-k9s)

Was this useful?