Building a Lightweight Kubernetes Desktop Client GUI with Tauri and Rust

Atilla Deniz — Fri, 23 Jan 2026 18:46:14 +0000

I've been working with Kubernetes for years, and like many of you, I've tried various GUI tools to manage my clusters. They all had one thing in common: they felt heavy. Some consumed 500MB+ of RAM just sitting idle. That's more than some of my actual workloads.

So I built Kubeli - an open-source Kubernetes desktop client that stays under 150MB RAM idle.

Why Another K8s GUI?

The existing options fall into two categories:

Web-based dashboards - Great for quick checks, but limited for daily workflows
Electron-based desktop apps - Feature-rich but resource-hungry

I wanted something in between: native performance with modern UX.

The Tech Stack

Tauri 2.0 + Rust Backend

Tauri was the obvious choice. Instead of bundling Chromium like Electron, it uses the system's native webview. The backend is pure Rust, which means:

Direct Kubernetes API access via kube-rs
No Node.js runtime overhead
Native performance for watch streams and log tailing

// Real-time pod watching with kube-rs
let pods: Api<Pod> = Api::namespaced(client, &namespace);
let watcher = watcher(pods, Config::default());

Next.js Frontend

The UI is built with Next.js 16 (App Router), compiled to static files that Tauri serves. State management uses Zustand for global state and TanStack Query for server state.

The result? A responsive UI that doesn't lag when streaming logs from noisy pods.

Key Features

Real-time Everything: Pod status, logs, and events update via Kubernetes watch API - no polling.

Log Streaming: Tail logs with filtering, search, and export. The frontend batches updates to stay smooth even with high-volume streams.

Monaco Editor: Edit YAML with syntax highlighting and validation before applying.

Optional AI Integration: This was an experiment. Kubeli can connect to Claude Code CLI or OpenAI Codex CLI for log analysis and debugging assistance. It's completely optional and runs locally - no data leaves your machine unless you configure it.

Learnings

Rust's async ecosystem is mature now. kube-rs with Tokio handles complex K8s operations elegantly. The watch API, exec sessions, port forwarding - it all works reliably.

Tauri 2.0 is production-ready. Auto-updates, deep linking, window state persistence - the plugin ecosystem covers most needs.

Memory matters. Keeping idle usage under 150MB required attention to detail: lazy loading, proper cleanup of watch streams, and batched UI updates.

Current Status

macOS & Windows builds available now
Linux on the roadmap
MIT licensed

Try It

GitHub: github.com/atilladeniz/kubeli

I'd love feedback, especially from folks who've built similar tools or have opinions on the AI debugging features. Is AI-assisted K8s troubleshooting useful, or just a gimmick?

What's your current K8s GUI setup? I'm curious what workflows people have optimized for.

DEV Community: Atilla Deniz

[Boost]