K9s vs Lens vs Headlamp: Cluster UIs

Pick Your Weapon

Managing a Kubernetes cluster without a decent UI is like trying to defuse a bomb using only a text editor and good intentions. It works, technically. You’ll probably be fine. But at 2 AM when pods are crashlooping and you’re tab-completing kubectl get pods -n kube-system for the fifteenth time, you start wondering if there’s a better way.

There is. Three of them, actually, and they couldn’t be more different from each other.

K9s is a terminal UI that’ll make your mouse feel irrelevant. Lens started as a brilliant Kubernetes IDE before pivoting into a subscription model that has a lot of people shopping for the exits. Headlamp is the scrappy open-source project, now a full Kubernetes SIG UI project, that’s quietly becoming the answer to “what do I use now that Lens went commercial?”

Let’s break all three down so you can stop waffling and actually pick one.

K9s, The Terminal Purist’s Dream

K9s is written in Go, ships as a single binary under 30 MB, and runs entirely in your terminal. It has no mouse support, no settings panel, no subscription tier. It has keyboard shortcuts and strong opinions, and that’s the whole pitch.

Install

# macOS
brew install k9s

# Ubuntu/Debian
curl -sS https://webinstall.dev/k9s | bash

# or grab the release binary directly
curl -Lo k9s.tar.gz https://github.com/derailed/k9s/releases/download/v0.51.0/k9s_Linux_amd64.tar.gz
tar -xzf k9s.tar.gz k9s
sudo mv k9s /usr/local/bin/

# Windows (Scoop)
scoop install k9s

Then just run k9s. It picks up your current kubectl context automatically.

The Keyboard Flow

K9s runs on a command-palette model. You type :po to jump to pods, :svc for services, :ns for namespaces. From there:

The log tail is genuinely excellent, color-coded, filterable, and you can toggle timestamps with t. Port-forwarding is two keystrokes and it just works. Exec-ing into a pod and getting a shell is faster than any GUI alternative I’ve tried.

One genuinely underrated feature: resource diffs. When you edit a resource live with e, K9s shows you what will change before you apply it. Not groundbreaking, but it’s the kind of thing that saves you from fat-fingering a replicas count into oblivion.

Plugins

K9s supports plugins via YAML files dropped into ~/.config/k9s/plugins.yaml. They let you bind custom commands to keys that run arbitrary shell commands against the selected resource.

plugin:
  debug-pod:
    shortCut: Shift-D
    description: "Attach debug container"
    scopes:
      - pods
    command: kubectl
    background: false
    args:
      - debug
      - -it
      - $NAME
      - -n
      - $NAMESPACE
      - --image=nicolaka/netshoot
      - --target=$NAME

The community plugin library covers everything from Helm diff previews to Trivy vulnerability scans. If you live in the terminal, this is legitimately your endgame tool.

Who It’s For

Terminal-native engineers who already know kubectl and want to move faster. If the idea of a mouse-driven UI makes you twitch, K9s is home.

Lens, The Original That Lost Its Way

Lens Desktop was, for a while, genuinely the best Kubernetes GUI. It connected to multiple clusters, gave you real-time pod metrics, had a usable log viewer, and the resource browser actually worked. People loved it.

Then, in late 2022, Mirantis (who acquired Lens) announced they were splitting it into a free “personal use” tier and a paid “Lens Pro” subscription. The free tier is now restricted, teams, commercial use, and certain features require a subscription that runs $19$49/user/month depending on tier.

The UI itself is an Electron app sitting at around 800 MB installed. It connects via your kubeconfig contexts, shows you pod statuses, logs, exec sessions, and has Helm chart integration. It works. But every time you open it, there’s a nudge toward Pro. The welcome screen has pricing. The upgrade prompts are persistent. It has the energy of software that used to trust you but now needs something from you.

Honestly, it’s fine if you’re using it for pure personal hobby use and you don’t mind the weight. But if you’re in a homelab with a couple of other people, or you’re evaluating tools for a small team, the licensing math gets uncomfortable fast.

Install if you must:

# Download the .AppImage or .dmg from https://k8slens.dev/
# Or via brew on macOS:
brew install --cask lens

The fact that I’m writing an install section that just says “go to the website and click download” tells you a lot about where this project’s energy is focused these days.

The Honest Take

Lens was the right tool in 2021. In 2026, it’s a Kubernetes UI with a sales funnel attached. There are better options that don’t require you to read a licensing FAQ before sharing a cluster with a friend.

Headlamp, The One to Watch

Headlamp came out of Kinvolk (acquired by Microsoft in 2021) and was donated to the CNCF, it’s since moved up to being a full Kubernetes project, living under SIG UI in the kubernetes-sigs org. It’s Apache 2.0 licensed, no asterisks, no tiers. You can run it as an Electron desktop app or, and this is the genuinely interesting part, as a self-hosted web app inside your cluster.

Installed footprint sits around 400 MB for the desktop app. The web-hosted version is just a container, so footprint on your workstation is zero.

Desktop Mode

The desktop app works similarly to Lens: it reads your kubeconfig, lists your contexts, lets you browse resources, tail logs, exec into containers, and browse Helm releases. It’s clean. It’s not trying to upsell you anything.

# macOS
brew install --cask headlamp

# Linux (.deb)
wget https://github.com/kubernetes-sigs/headlamp/releases/download/v0.43.0/headlamp_0.43.0_amd64.deb
sudo dpkg -i headlamp_0.43.0_amd64.deb

Web Mode, The Interesting Part

This is where Headlamp earns its recommendation for homelabs. You can deploy it as a Kubernetes workload and access it via browser, which means your whole team (or just “you from the couch with the tablet”) gets cluster visibility without installing anything locally.

helm repo add headlamp https://kubernetes-sigs.github.io/headlamp/
helm repo update

helm install headlamp headlamp/headlamp \
  --namespace headlamp \
  --create-namespace \
  --set replicaCount=1

Basic access uses a service account token. If you want to expose it properly and add real authentication, Headlamp in web mode supports OIDC out of the box, which means you can wire it up to Authentik or Keycloak and give people actual user accounts.

OIDC Config with Authentik or Keycloak

Create your OIDC application in Authentik first (or Keycloak, same idea). Then deploy Headlamp with the OIDC values:

replicaCount: 1

config:
  oidc:
    clientID: "headlamp"
    clientSecret: "your-client-secret-here"
    issuerURL: "https://auth.yourdomain.com/application/o/headlamp/"
    scopes: "openid profile email groups"

ingress:
  enabled: true
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
  hosts:
    - host: headlamp.yourdomain.com
      paths:
        - path: /
          pathType: Prefix
  tls:
    - secretName: headlamp-tls
      hosts:
        - headlamp.yourdomain.com

helm install headlamp headlamp/headlamp \
  --namespace headlamp \
  --create-namespace \
  -f headlamp-values.yaml

Once that’s up, users hit headlamp.yourdomain.com, authenticate through your SSO provider, and get a read/write cluster UI scoped to whatever RBAC you’ve wired up for their groups. For a homelab where you’re onboarding someone who doesn’t know kubectl, this is a genuinely good setup.

RBAC Visibility

One thing Headlamp does well that K9s doesn’t really surface: RBAC visualization. You can browse RoleBindings and ClusterRoleBindings in context, see what subjects have what access, and trace permissions without assembling the picture from three separate kubectl get commands. When you’re running OIDC + group-based RBAC, this is actually useful.

Plugin SDK

Headlamp has a TypeScript/JavaScript plugin SDK. You can write browser extensions that add custom views, resource actions, or sidebar links. The ecosystem is still small compared to K9s plugins, but it’s growing and the SDK is legitimately well-documented.

// headlamp-plugin example: add a custom sidebar link
import { registerSidebarEntry } from '@kinvolk/headlamp-plugin/lib';

registerSidebarEntry({
  parent: null,
  name: 'custom-view',
  label: 'My View',
  url: '/custom-view',
  icon: 'mdi:chart-bar',
});

Head-to-Head

Who Should Use What

Terminal natives and power users: K9s. No contest. If you already think in kubectl commands and your workflow is terminal-first, K9s makes everything faster. The keyboard shortcuts have muscle memory within a week and you’ll stop thinking about it, it just becomes how you interact with the cluster.

Onboarding non-Kubernetes people: Headlamp web mode. Seriously. If you’re the homelab person who wants to give a partner, family member, or friend visibility into what’s running without explaining what a kubeconfig is, deploy Headlamp, wire up OIDC, hand them a URL and a login. Done. They get a dashboard, you maintain access control, nobody has to install anything.

Small team with shared cluster access: Headlamp self-hosted. The OIDC + RBAC combination is the right answer here. Each person has their own identity, access is scoped appropriately, and the UI is approachable enough that not everyone needs to be a kubectl expert.

Current Lens users: Start planning the migration. If you’re on personal free tier and happy, fine, keep going. But if you’re in a shared or team context and you’re either paying for Pro or nervously ignoring the licensing terms, Headlamp is a clean exit. It’s not quite feature-for-feature with Lens Pro, but for most homelab and small-team use cases, it’s close enough.

The Bottom Line

K9s is the tool that respects your time if you already know what you’re doing. It’s a 30 MB binary that does everything except hold your hand, and that’s a compliment. If you spend more than two hours a week in Kubernetes clusters and you’re comfortable in a terminal, install it today.

Headlamp is the tool that respects your users. It’s what Lens should have become, open source, self-hostable, OIDC-ready, and not trying to charge you for the privilege of sharing a dashboard with someone. The 0.43 release in mid-2026 is noticeably more stable than where it was 18 months ago, and living under the Kubernetes SIG UI umbrella means it’s not going anywhere.

Lens is the tool that used to respect you. It still works. It’s just a different relationship now, and not one I’d start fresh in 2026.

Pick your terminal personality or your browser. Either way, you’ve got solid options, and neither one requires you to read a licensing FAQ before you share your kubeconfig.

Related Reading

• Capsule: Multi-Tenancy for Home Lab k3s
• Cilium on k3s: When eBPF Networking Pays
• Crossplane vs Terraform for Home Lab
• Goldilocks + VPA: Right-Size Pods Without Guessing
• Headlamp: K8s UI Without the License Drama