Comparison

Radar vs Lens: hosted team visibility, or desktop IDE?

Lens is a mature Kubernetes desktop IDE with millions of users. Radar comes in two flavors — Apache 2.0 OSS you self-host, or Radar Cloud as a hosted SaaS for teams. Here's an honest line-by-line comparison — no trash talk, no false equivalence.

Radar OSSApache 2.0

Self-hosted. Team-shared. Free forever.

Helm chart in your cluster, browser UI out. Apache 2.0 for any use, commercial included. No account, no telemetry, no per-seat cost.

Radar CloudHosted SaaS

Multi-cluster. IdP-native. Long retention.

Same engine, hosted by us. Priced per cluster. SAML/SCIM, fleet view, year-long event retention, SOC 2.

LensDesktop IDE

Local-first. Per-user. Live-only.

Electron app, per-device install, Lens Pro priced per user. Reads kubeconfigs directly. Great for individual power users, one cluster at a time.

The short version

Lens is the best single-cluster desktop experience. Radar OSS is the best self-hosted single-team view. Radar Cloud is the best multi-cluster, team-shared, historically-aware hosted experience.

The question isn't which one wins — it's which job you're hiring the tool for. Most teams that use both end up using Lens on individual laptops for kubectl-replacement tasks, Radar OSS (or Cloud) for the team's shared operational view.

When to pick what

An honest framework for choosing.

Lens is the right call when

You want a local-first desktop experience
If you're an individual engineer who lives in an IDE and wants Kubernetes to feel like one, Lens is genuinely excellent. It runs on your machine, it's fast, and it never leaves your laptop.
You need Kubernetes without any SaaS
Some regulated environments or airgapped setups don't allow outbound connections to hosted services. Lens reads kubeconfigs on-device. Radar OSS works here too — it's Apache 2.0 and self-hostable.
You rely on the Lens extensions ecosystem
Lens has a mature extensions marketplace with community-built integrations. If you've built your Kubernetes workflow around a specific Lens extension, that's a genuine lock-in.

Radar OSS is the right call when

You want team-shared views without paying per seat
Radar OSS runs in one cluster and serves a browser UI — everyone on the team gets the same view. Lens Pro charges $22-35/user/month the moment you use it at work.
Commercial use allowed, under Apache 2.0
Lens Personal is non-commercial only. Using Lens at work requires Lens Pro / Business / Enterprise. Radar OSS is Apache 2.0 — commercial, production, resale — all allowed.
You're in an airgapped or regulated environment
Radar OSS has no outbound SaaS dependency. Self-host it on-prem, in an isolated VPC, or on an airgapped cluster. Nothing leaves your network.
You want one engine for CLI and web
Radar OSS ships a CLI and a browser UI against the same backend. Scripts, CI, and terminal diehards share truth with the team's dashboard. Lens is the Electron app or nothing.

Radar Cloud is the right call when

You work on a team and want shared views
Radar Cloud is team-first. Everyone sees the same topology, the same filtered timeline, the same annotated resource. No kubeconfig distribution, no “can you screenshot it for me?”
You run more than one cluster
Lens shows one cluster at a time on one device. Radar Cloud unifies every cluster across every cloud in a single fleet view, with cross-cluster search and drift detection.
You need historical data for post-mortems or audits
Lens shows live state only. Radar Cloud persists events, Helm revisions, RBAC changes, and resource history — 30 days, 1 year, or forever depending on plan.
You want your team to grow without per-seat pricing
Lens Pro is ~$22-35 per user per month. On a 50-engineer team that's $13k-21k/year just to let everyone look. Radar Cloud prices per cluster and invites everyone for free.

Before you pay either one

Radar OSS already beats Lens on the basics.

Skip the hosted comparison for a second. The open-source Radar engine — Apache 2.0, self-installable, nothing to pay for — lands ahead of Lens on most of the things engineers actually need day to day.

Truly free, Apache 2.0

Lens Personal is free for individual non-commercial use only. Using Lens at work requires a Pro or Enterprise license. Radar OSS is Apache 2.0, commercial use allowed, no license server, no auth wall.

Browser UI out of the box

No Electron install per laptop. Radar OSS runs as a binary or Helm chart and serves a web UI. Share a port-forwarded URL, share the cluster view. Works on anything with a browser.

One install, every cluster

Helm chart in, topology out. Lens requires every engineer to install the desktop app, import kubeconfigs, and wrangle contexts. Radar OSS reads the cluster from inside — scoped ServiceAccount, no kubeconfig shuffling.

Live topology graph

Real workload-to-workload connections with traffic direction, not just a resource tree. Lens ships a static resource list by default; topology is an optional extension you have to hunt for.

Event history that survives restarts

Radar OSS persists events well past Kubernetes' ~1-hour default. Lens shows whatever the API happens to remember right now. When a pod crashlooped an hour ago, Lens has nothing.

GitOps-aware by default

ArgoCD and Flux sync state sits next to the resources they produced — no extension required. Lens treats GitOps as a third-party add-on.

CLI and web, same engine

Radar ships a CLI for scripts, CI, and terminal diehards, plus the web UI — same backend, same queries. Lens is the Electron app or nothing.

No per-user creep

Lens Pro is ~$22-35/user/mo the moment you use it for work. Radar OSS is free for ten engineers or ten thousand. Grow the team, not the bill.

Lightweight footprint

A single pod with a couple hundred megs of memory per cluster. No Electron process on every laptop, no per-machine updater, no per-machine config drift.

The honest middle ground

If you're deciding “Lens or Radar,” start with Radar OSS. It's free, takes ten minutes to install, and does most of what you'd otherwise upgrade to Lens Pro for. If you outgrow single-cluster / single-team, that's when Radar Cloud makes sense.

Install Radar OSS

The architectural split

Desktop vs hosted — what that actually means.

Lens · Desktop model

💻Your laptop — Lens Electron app

↓ reads kubeconfig (local)

🔑~/.kube/config (distributed how?)

↓ direct K8s API call

☸Your cluster(s) — one at a time

Each engineer maintains their own kubeconfig. State is ephemeral per session. Sharing a view means screensharing.

Radar Cloud · Hosted model

☸Your cluster(s) — Radar agent running in-cluster

↑ outbound WebSocket over TLS

☁Radar Cloud (SOC 2, US/EU regions)

↓ browser, authenticated via your IdP

👥Your team — every engineer, shared view

One workspace, one topology, one timeline — accessed by everyone via SSO. No kubeconfigs shared, no VPN, no inbound firewall rules.

Feature by feature

The full comparison matrix.

Check is full support. Dash is partial (we explain the nuance in the row). X is not supported. Where a tier or plan tier matters, we call it out.

Feature	Radar OSS (Apache 2.0) + Cloud (hosted)	Lens Desktop IDE, per-user
Deployment model
Where it runs Lens is a desktop Electron app installed per-machine; Radar is a hosted SaaS accessed through a browser.	Hosted SaaS + in-cluster agent	Desktop (macOS/Win/Linux)
Connection to cluster Lens reads local kubeconfigs directly; Radar connects via a lightweight in-cluster agent (outbound-only tunnel).	Agent, outbound WebSocket over TLS	Local kubeconfig
Shared team workspace		Via paid Lens Desktop Kubernetes (LDK) / Business
Works without sharing kubeconfigs
Web-accessible URLs you can paste in Slack
Multi-cluster & scale
Unlimited clusters in one view		Add clusters manually per machine
Cross-cluster resource search
Fleet topology (all clusters at once)
Staging vs prod drift detection
Historical data & incidents
Event timeline retention How far back you can look after an incident. Kubernetes' own retention is ~1 hour by default.	30 days to 1 year	None (live-only)
Post-mortem replay
Shareable incident deep-links
Audit log retention	7 days to unlimited
GitOps correlation (ArgoCD/Flux)		Via extensions
Auth & access control
SAML / OIDC SSO		Lens Business / Enterprise only
SCIM provisioning		Enterprise tier only
Group-to-namespace RBAC
Inherits Kubernetes RBAC
Granular permissions per workspace		Per-device only
Feature surface
Topology graph (live)		Extension-dependent
Helm release manager
Traffic visualization + mTLS
Image filesystem viewer
Cost insights (OpenCost)
Cluster audit (31 checks)
MCP / LLM agent integration Expose cluster state as a Model Context Protocol endpoint for Claude, Cursor, etc.
Extensions marketplace
kubectl embedded terminal	Via shareable Radar Shell
Collaboration
Slack / PagerDuty / MS Teams alerts
Annotations on resources
Webhooks
Invite unlimited teammates Radar prices per cluster, so new teammates are free. Lens prices per user, so each teammate is another seat.		Paid per user
Pricing model
Pricing axis	Per cluster	Per user
Free tier	3 clusters, unlimited users, forever	Lens Personal (individual, non-commercial)
Paid entry point	$99/cluster/mo (Team)	~$22-35/user/mo (Pro)
Compliance
SOC 2 Type 2
BYOC / on-prem deployment	Enterprise tier	Desktop is local by design
EU data residency	Enterprise	N/A — data stays on your device

The logs are gone. Events rolled off. Reconstruct from memory and Slack.

In Radar Cloud

Rewind the timeline to 7 days ago. The ArgoCD sync, the OOMKill, the pod churn — all still there.

Not mutually exclusive

Some teams we talk to run both.

Lens on the laptop for kubectl-replacement power use. Radar for the team's shared view. The tools solve different jobs.

Try both in an afternoon:

1
Install Radar OSS locally (Apache 2.0). It's the engine behind Radar.
brew install skyhook-io/tap/radar
2
Sign up for a free Radar workspace. Apache 2.0 OSS or hosted free for 3 clusters.
app.radarhq.io/signup
3
Connect a cluster to Radar with one Helm flag.
helm upgrade radar skyhook/radar --set cloud.token=$TOKEN
4
Open Lens, connect the same cluster, compare the experience side by side.
(Your existing Lens setup works unchanged.)

FAQ

Questions we get about Lens specifically.

Isn't Lens free?

Lens Desktop has a free Personal tier for individual, non-commercial use. Commercial use requires Lens Pro ($22-35/user/mo) or Enterprise. Since mid-2022 (Lens 6.0), even basic commercial use requires a paid license.

Can I use Lens and Radar together?

Yes. They target different needs. Many engineers run Lens locally for single-cluster power-user debugging and use Radar for the team's shared view, multi-cluster fleet, and historical timeline. Neither tool requires you to abandon the other.

Does Radar have a desktop app?

Not as a hosted product. But the open-source Radar (the foundation Radar is built on) is a local binary you can install on your laptop or in-cluster. It's Apache 2.0 and does a lot of what Lens does, locally.

What about OpenLens?

OpenLens was the community-maintained fork that restored the stripped-out features from Lens proper. Mirantis has been gradually limiting OpenLens (removing extensions, closing parts of the source). Radar's stance: the core engine stays open-source, and Apache 2.0 specifically. See our Open Source commitments for the details.

How does the agent differ from Lens reading kubeconfigs?

Lens uses your local kubeconfig to call the Kubernetes API directly. Radar's agent runs in-cluster as a ServiceAccount with read-only permissions and opens an outbound tunnel to the hosted control plane. The practical difference: no kubeconfig distribution, no VPN, no shared credentials, and no inbound firewall rules.

Is Lens more mature?

Yes, and we won't pretend otherwise. Lens has been around since 2016 and has millions of users. Radar's OSS hit 1.2k stars in under a year; Radar is newer still. If longevity is a required buying criterion, that's a real factor. If capability for team workflows is the criterion, we're comfortable with the comparison.

More comparisons

Radar vs k9s

vs the terminal-first Kubernetes CLI

Radar OSS vs Radar Cloud

Radar OSS vs Radar Cloud (our own comparison)

Radar All comparisons

See every tool we've compared against

Ready to see your whole fleet in one pane?

Apache 2.0 OSS or hosted free for 3 clusters. Connect in 60 seconds. Keep using Lens locally if you want — they play nicely together.

Install with Helm Start free Book a demo

Apache 2.0 OSS · Unlimited clusters self-hosted · Hosted free tier for up to 3 clusters