Srelens

Why srelens?

Kubernetes troubleshooting often means moving between terminals, dashboards, YAML editors, logs, and cluster contexts. srelens brings that investigation loop into one local-first desktop workspace.

• One workspace from investigation to action — browse resources, inspect events and YAML, follow logs, use terminals, manage port forwards, and take cluster actions without constantly switching tools.
• Built for engineers and AI agents — supported backend capabilities are also available through the built-in MCP server.
• Local-first cluster access — srelens uses credentials from your local kubeconfig and connects directly to Kubernetes API servers, without routing cluster access through a srelens cloud service.
• Safe operations — destructive actions are identified and confirmation-gated.
• Open source — licensed under MIT, with public code, releases, issues, and roadmap on GitHub.

srelens uses the operating system WebView through Tauri v2 and a Rust backend built with kube-rs and tokio. It is independently developed and is not affiliated with Mirantis Lens or the Freelens project.

See the user guide for how to use each of these.

• Multi-cluster workspace — discover kubeconfig contexts, add or paste more files, give each context a name, logo, and colour, and switch clusters from the cluster hotbar. Contexts that share a name across files (e.g. default) are disambiguated so every cluster stays visible and reachable.
• Live Kubernetes resources — browse workloads, networking, storage, RBAC, admission, autoscaling, and custom resources with live watch updates, search, column pickers, namespace scoping, and bulk actions.
• Resource details and YAML — inspect manifests, events, relationships, and metrics, and edit schema-aware YAML with validation, dry-run diffs, and server-side apply.
• Logs — stream pod or workload logs with previous-instance (post-crash) logs, timestamps, tail and since-window controls, per-source colouring, container filtering, and buffer or all-container export.
• Terminals and shells — open pod exec sessions, a context-scoped local terminal, ephemeral debug containers for distroless pods, and privileged node shells.
• Port forwarding — create, inspect, copy, and stop forwards across every open cluster.
• Helm — list and inspect releases, and install, upgrade, roll back, or uninstall them with a values editor and rendered-diff preview.
• Toolbox — install and manage kubectl, krew, helm, and krew plugins, and diagnose a context's exec-auth tool requirements.
• Metrics — node and pod CPU and memory when metrics-server is available.
• Operational actions — scale workloads, restart rollouts, evict or delete pods, suspend or trigger CronJobs, and cordon or drain nodes, with confirmation gates for destructive actions.
• Command palette — keyboard-first navigation (Cmd/Ctrl-K) across views, contexts, and resources.
• Application logs — read srelens's own rotating log file from Settings to diagnose issues after they happen.
• MCP access — expose supported backend capabilities to MCP-capable clients over stdio or loopback HTTP.

Install

Download the latest beta for your platform from GitHub Releases.

See the installation guide for platform-specific installation, first-launch, updating, verification, and uninstall instructions.

MCP server

srelens includes an MCP server generated from the same capability registry used by the desktop backend. Supported backend capabilities can therefore be used by MCP-capable clients without creating a separate cluster integration layer.

Open Settings → MCP to:

• run the MCP server over loopback HTTP;
• install the srelens CLI for stdio connections;
• copy client configuration for supported MCP clients.

You can also start the server directly:

srelens --mcp-stdio
srelens --mcp-http 127.0.0.1:8765

Mutating tools require an explicit _confirm: true argument before they run.

Example stdio configuration:

{
  "mcpServers": {
    "srelens": {
      "command": "srelens",
      "args": ["--mcp-stdio"]
    }
  }
}

MCP access uses your locally authenticated cluster contexts. Review tool calls and use appropriate Kubernetes RBAC permissions, especially with critical clusters.

Quick start

Prerequisites

• Rust stable
• Node.js 22+
• pnpm 9+
• Tauri v2 system dependencies
• A reachable Kubernetes cluster for cluster-dependent workflows

Run locally

git clone https://github.com/srelens/srelens
cd srelens
pnpm install
pnpm dev

Useful commands

See the developer guide for architecture, testing standards, and instructions for adding capabilities.

Architecture

React 19 + TypeScript
        │
        │ Tauri commands and events
        ▼
Tauri v2 desktop shell
        │
        ▼
Pure-Rust backend
├── capability registry
├── Kubernetes integration with kube-rs
├── live watches, logs, exec, and port forwarding
├── Helm and metrics
└── MCP server over stdio and loopback HTTP

Repository layout:

apps/desktop/
  src/                   React and TypeScript desktop UI
  src-tauri/             Tauri application and Rust command bridge
crates/
  capability/            Backend capability registry
  kube/                  Kubernetes clients, watches, actions, Helm, and metrics
  mcp/                   MCP server
docs/                    Installation, usage, development, and project documentation

Project status

srelens is currently in beta. It is ready for evaluation and everyday testing, but users should review release notes and take extra care when using it with critical clusters.

Breaking changes may still occur before a stable release. Feedback, bug reports, and reproducible troubleshooting details are welcome.

• Latest release
• All releases
• Issues and roadmap

Community

• r/srelens on Reddit — announcements, questions, and feedback
• Issues — bugs and feature requests
• Website

Contributing

Contributions are welcome. Start with:

• Contribution guide
• Developer guide
• Open issues

Please review the Code of Conduct before participating.

License

srelens is open source under the MIT License.