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.
Top comments (3)
Always nice to see more Rust desktop apps in the wild. Did you evaluate going pure Rust with something like egui/iced versus the Tauri hybrid approach?
I went full Rust + egui for a project recently and the single binary deployment is chef's kiss, but I definitely miss having a proper web inspector for debugging UI issues. What's your experience been with the Tauri devtools?
Hi @olaproeis Thanks! Yes, I looked at egui and iced. For a Kubernetes tool I needed rich UI components like sortable tables, tree views, and a YAML editor. The web ecosystem just made more sense for these UX requirements while Rust handles the backend logic.
Devtools experience has been great actually. Full Chrome DevTools for frontend, standard Rust debugging for backend. The clear separation helps.
How's your experience been with egui so far?
It's been great actually. egui handles everything I've thrown at it: live preview, syntax highlighting, native mermaid diagrams, handling large files.
Main trade-off is exactly what you said, no web inspector. When something looks off, I describe the problem to the AI and let it debug. Works, but definitely less convenient than Chrome DevTools.
For rich components like sortable tables and tree views, I can see why Tauri made more sense for your use case. The web ecosystem just has more of that ready to go. For a markdown editor where I wanted that single binary simplicity, egui fit well.