k10s is a fast, modern Kubernetes terminal dashboard (TUI) built with Go and Bubble Tea. Navigate pods, nodes, namespaces, services, and container logs with vim keybindings — a lightweight, extensible alternative to k9s designed for large-scale and AI hyperscaler clusters.

🌐 Website: https://k10s.dev

• Faster than k9s for large clusters with thousands of pods and nodes
• Vim-native navigation — j/k, h/l, g/G, : command mode — feels like home
• Drill-down workflow — pod → containers → logs, all without leaving the terminal
• Plugin system — extend k10s with custom commands, games, and tools
• Lightweight — single binary, zero runtime dependencies

• Drill-Down Navigation: Press Enter on any pod to view its containers, then drill into container logs with full text wrapping and search
• Paginated Tables: Browse pods, nodes, and namespaces with configurable page sizes
• Vim Keybindings: Navigate efficiently with j/k, h/l, g/G, and command mode with :
• Command Mode: Type : to enter command mode, then use commands like pods, nodes, ns, or quit
• Log Viewing: View container logs with timestamps, text wrapping (w), autoscroll (s), and fullscreen mode (f)
• Customizable: Configure page sizes and UI elements via ~/.k10s.conf
• Fast & Lightweight: Built in Go with minimal dependencies
• Plugin System: Extend k10s with custom commands and tools

brew tap shvbsle/tap
brew install k10s

# Download the latest release
wget https://github.com/shvbsle/k10s/releases/latest/download/k10s_0.1.1_linux_amd64.rpm

# Install
sudo yum install ./k10s_0.1.1_linux_amd64.rpm

# Or using rpm directly
sudo rpm -i k10s_0.1.1_linux_amd64.rpm

# Download the latest release
wget https://github.com/shvbsle/k10s/releases/latest/download/k10s_0.1.1_linux_amd64.deb

# Install
sudo dpkg -i k10s_0.1.1_linux_amd64.deb

Download the latest release for your platform from GitHub Releases:

# macOS ARM (M1/M2/M3)
wget https://github.com/shvbsle/k10s/releases/latest/download/k10s_0.1.1_darwin_arm64.tar.gz
tar -xzf k10s_0.1.1_darwin_arm64.tar.gz
sudo mv k10s /usr/local/bin/

# macOS Intel
wget https://github.com/shvbsle/k10s/releases/latest/download/k10s_0.1.1_darwin_amd64.tar.gz
tar -xzf k10s_0.1.1_darwin_amd64.tar.gz
sudo mv k10s /usr/local/bin/

# Linux AMD64
wget https://github.com/shvbsle/k10s/releases/latest/download/k10s_0.1.1_linux_amd64.tar.gz
tar -xzf k10s_0.1.1_linux_amd64.tar.gz
sudo mv k10s /usr/local/bin/

git clone https://github.com/shvbsle/k10s.git
cd k10s
make build

The binary will be available at bin/k10s.

go install github.com/shvbsle/k10s/cmd/k10s@latest

Once installed, start k10s:

k10s

• j or ↓: Move down in the table
• k or ↑: Move up in the table
• h or ← or PgUp: Previous page
• l or → or PgDown: Next page
• g: Jump to top of table
• G: Jump to bottom of table
• Enter: Drill down into selected resource (pod → containers → logs)
• Esc: Go back to previous view
• :: Enter command mode
• :quit or :q: Quit k10s

When viewing container logs:

• w: Toggle text wrapping
• t: Toggle timestamps
• s: Toggle autoscroll
• f: Toggle fullscreen mode
• Esc: Go back to container list

• Type a command and press Enter to execute
• Press Esc to cancel and return to normal mode

When in command mode (press :), you can use:

• pods or po: Show all pods across all namespaces
• pods <namespace>: Show pods in specific namespace
• nodes or no: Show all nodes in the cluster
• namespaces or ns: Show all namespaces
• services or svc: Show all services
• quit or q: Exit k10s

k10s reads configuration from ~/.k10s.conf. On first run, a default config file is created automatically.

# k10s configuration file
# Number of items per page in table views
page_size=20

# Pagination style: "bubbles" (dots) or "verbose" (text like "Page 1/10")
# Default: bubbles
pagination_style=bubbles

# ASCII logo (between logo_start and logo_end)
logo_start
 /\_/\
( o.o )
 > Y <
logo_end

• page_size: Number of rows to display per page (default: 20)
• pagination_style: Pagination display style - bubbles for dot-based paginator or verbose for text like "Page 1/10" (default: bubbles)
• logo_start/logo_end: Custom ASCII art logo to display

k10s features a built-in extensible plugin system that allows adding custom functionality like games, tools, or utilities. The plugin architecture is a core k10s feature designed to enable seamless integration of additional commands while maintaining isolation between plugins and the core system.

A fun infinite runner platformer game! Try typing :play, :game, or :kitten to launch it.

Features:

• Infinite procedural platform generation
• Pattern-based fish collectibles with combo system
• High score persistence (stored in ~/.k10s/plugins/kitten/highscores.json)
• Space theme with stars
• Progressive difficulty scaling

Plugins are compiled into k10s and implement a simple interface. Here's how to create one:

mkdir -p internal/plugins/myplugin

Create internal/plugins/myplugin/myplugin.go:

package myplugin

import "github.com/shvbsle/k10s/internal/plugins"

type MyPlugin struct{}

func (p *MyPlugin) Name() string {
    return "my-plugin"
}

func (p *MyPlugin) Description() string {
    return "A description of what my plugin does"
}

func (p *MyPlugin) Commands() []string {
    return []string{"myplugin", "mp"}  // Command aliases
}

func (p *MyPlugin) Launch() error {
    // Your plugin logic here
    fmt.Println("Hello from my plugin!")
    return nil
}

func New() *MyPlugin {
    return &MyPlugin{}
}

In cmd/k10s/main.go, import and register your plugin:

import (
    // ... existing imports ...
    "github.com/shvbsle/k10s/internal/plugins/myplugin"
)

func main() {
    // ... existing setup ...

    // Initialize plugin registry
    pluginRegistry := plugins.NewRegistry()
    pluginRegistry.Register(kitten.New())
    pluginRegistry.Register(myplugin.New())  // Add your plugin

    // ... rest of main ...
}

make build
./bin/k10s
# Type :myplugin to launch your plugin

See the Plugin interface definition for the complete API with documentation.

Plugins implement:

• Name() - Unique identifier (kebab-case)
• Description() - Shown in help text
• Commands() - Command aliases (e.g., ["play", "game"])
• Launch() - Execute plugin, returns to k10s on exit

• Commands: Use short, memorable command aliases (e.g., play, debug, tool)
• Error Handling: Handle errors gracefully within your plugin
• Dependencies: Add any required dependencies to go.mod
• Data Storage: Store plugin data in isolated directories to avoid cross-contamination
  • Use config.GetPluginDataDir(pluginName) to get your plugin's data directory
  • Path format: ~/.k10s/plugins/{plugin-name}/
  • Each plugin gets its own isolated directory automatically created
  • Example: High scores for kitten are stored in ~/.k10s/plugins/kitten/highscores.json

For TUI-based plugins using Bubble Tea:

func (p *MyPlugin) Launch() error {
    program := tea.NewProgram(myModel{})
    if _, err := program.Run(); err != nil {
        return fmt.Errorf("error running plugin: %w", err)
    }
    return nil  // Return to k10s after plugin exits
}

For more details, see internal/plugins/README.md.

• Go 1.24 or later
• Access to a Kubernetes cluster (via ~/.kube/config or in-cluster config)

make build

make run

make test

make lint

make fmt

Contributions are welcome! Please feel free to submit a Pull Request.

Check out our roadmap.md for a list of planned features and improvements. This is a great place to find tasks to pick up if you're looking to contribute!

Join the k10s community on Discord to:

• 💬 Get help and support
• 🚀 Share your k10s workflows and configurations
• 🐛 Report bugs and request features
• 🤝 Connect with other Kubernetes enthusiasts
• 📢 Stay updated on the latest developments

Discord: https://discord.gg/rngaJustFD

We'd love to hear from you!

See RELEASING.md for detailed instructions on creating releases.

Apache 2.0 - see LICENSE file for details