Skip to content
olexiybPublic

About

Terminal UI for Talos Linux clusters: nodes, logs, etcd, storage (LINSTOR/DRBD, ZFS), diagnostics and safe node operations. A fork of talos-pilot.

Resources

Stars

2 stars

Watchers

0 watching

Forks

Repository files navigation

talos9s

A terminal UI for Talos Linux Kubernetes clusters: nodes, services, logs, etcd, network, storage and diagnostics in one place, with safe node operations.

talos9s is a fork of talos-pilot by Ken Udovic, continued with storage views (LINSTOR/DRBD, ZFS), views across a cluster's nodes and more. It is a community project, not affiliated with Sidero Labs.

CI Release License

Talos has no SSH; everything goes through its API, and talosctl is a long list of subcommands. talos9s puts that API, and the Kubernetes state that depends on it, on one screen. It complements k9s rather than replacing it:

Layer Answers
k9s Kubernetes (:6443) "Why won't my pod start?"
talos9s Talos OS (:50000) and the cluster around it "Why won't my node join?", "Is it safe to reboot this node?"

How it compares

Checked against each project's source and README in November 2026 (talos-pilot 0.1.11, its last release; t9s 0.2.0, its Homebrew cask).

talos9s k9s talos-pilot t9s
Layer Talos OS and the cluster around it Kubernetes Talos OS Talos OS
State Released, active Mature, very active Released, upstream of talos9s Young (22 stars, no tagged release)
Language, UI library Rust, ratatui Go, tview Rust, ratatui Go, Bubble Tea; wraps talosctl
License MIT Apache-2.0 MIT Source-available, non-commercial
Multi-cluster, all nodes at once yes one context at a time yes one context, switched with x
Views across a node group (logs, network, disks, diagnostics) yes – node by node –
Logs, processes, network, etcd yes pod logs yes logs, dmesg, processes, containers, addresses; no etcd
Packet capture yes – yes –
KubeSpan yes – peers in Network –
Disks and Talos partitions yes – disks disks
LINSTOR/DRBD and ZFS LocalPV checks yes – – –
Machine config viewer (secrets masked) yes – – yes
Diagnostics with suggested fixes yes, with the fix command for you to run Popeye sanitizer yes talosctl health, streamed
Drain, reboot, shutdown, rolling yes cordon, drain, delete, edit, shell, port-forward drain, reboot, rolling reboot, shutdown
Talos and Kubernetes upgrades – (planned) – – yes, with the extension catalog
Operation confirmation and audit log yes confirmation; --readonly flag yes confirmation for upgrades
Mouse clicks, double-clicks, wheel optional, off by default – –
Remembers where you left off yes per-context config – –
Skins, plugins, custom hotkeys – yes – –
Needs a kubeconfig no, fetched from a node yes no no

k9s answers questions about workloads, so use it next to the Talos tools, not instead of them. Compared with talos-pilot, talos9s adds the storage checks, the group and cluster views, the machine config viewer, the mouse and the remembered state, and tightens safety (suggested fixes are never applied, reboots check etcd members that are already down).

Install

Prebuilt binaries (macOS, Linux):

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/olexiyb/talos9s/releases/latest/download/talos9s-installer.sh | sh

Windows (PowerShell):

powershell -ExecutionPolicy Bypass -c "irm https://github.com/olexiyb/talos9s/releases/latest/download/talos9s-installer.ps1 | iex"

Or download an archive from Releases.

From source (needs Rust 1.95 or newer; rustup update gets it):

cargo install --git https://github.com/olexiyb/talos9s --locked talos9s

With Nix:

nix run github:olexiyb/talos9s           # try it
nix shell github:olexiyb/talos9s         # put it on PATH

Quick start

You need a talosconfig (~/.talos/config or $TALOSCONFIG) and network access to your nodes on port 50000. The Kubernetes views fetch a kubeconfig through the Talos API, so no separate kubeconfig is needed. A context in your KUBECONFIG with the same cluster CA is used instead when it works.

To see and act on Kubernetes as your own identity (an OIDC user, a read-only role) instead of the admin one, pass --kubeconfig (or set TALOS9S_KUBECONFIG). Only that file is used, with the context whose CA matches the cluster; when it has none, or its user may not list something, the views say so rather than fall back to admin.

talos9s                         # every context in the talosconfig
talos9s --context homelab       # one context
talos9s --tail 1000             # lines of log history to load
talos9s --kubeconfig ~/.kube/oidc.yaml   # Kubernetes as that kubeconfig's user
talos9s --debug --log-file ~/talos9s.log

Without --log-file, each run logs to <temp dir>/talos9s-<pid>.log; logs older than a week are removed at startup.

New cluster on machines in maintenance mode? The bootstrap wizard generates the configs, applies them and bootstraps etcd:

talos9s --insecure --endpoint <node-ip>

Features

Workspace and Dashboard

The cluster tree and the menu stay on the left; the chosen view fills the right side for whatever is selected. Move the selection and the view follows (a node's network, then the next node's, or the whole group's on a group row). Recently shown views come back instantly.

The menu groups the views: Overview (dashboard, diagnostics, logs, processes), Node, Network, Storage and Cluster. The Node entries (containers, machine config, extensions) need a node and are dimmed on a cluster or group row.

The Dashboard shows:

  • All contexts at once, each with its control plane and workers, node health and etcd quorum.
  • Per cluster: a node table (versions, memory, disk, ZFS, load, uptime, services, clock offset, gateway), the KubeSpan peer matrix and LINSTOR nodes and pools.
  • Per node: resources, addresses, routes, DNS, Tailscale, KubeSpan peers, clock, and every Talos service with its state.

Logs

  • Service logs, searchable and colored by level; several services interleaved (Stern-style). JSON and logfmt lines (kubelet, zap, slog, Pino ...) read as their message, then the other fields.
  • On a cluster, control plane or workers row: the same services from every node merged by time with a node column, including the kernel log.

Per node

View Shows
Processes htop-like process list and tree, sorted by CPU or memory
Network Interface traffic and connections, packet capture (filtered so it doesn't capture itself)
KubeSpan The node's WireGuard peers; on a cluster or group row, the peer matrix
Disks The node's disks, read-only ones marked RO; virtual devices (loop, dm, md, DRBD, zvol) hidden until A, which is remembered
Partitions Talos volumes: the partitions with their filesystem, encryption and mount point
Containers Every container on a node, a group or the cluster, read from containerd through the Talos API, so it works when the Kubernetes API doesn't: one row per container, Talos services included, exited ones hidden until A, sort by any column (1-7 or a header click), W namespace warp. Enter shows one container with its logs, as in Workloads (levels, search, wrap, V to select and copy lines, v opens them in hl); y copies the talosctl logs command
Machine config The config in effect, read-only, searchable, secrets masked; flags a staged change waiting for a reboot; the outline shows each part's size in bytes, # switches to lines
Extensions Installed system extensions
Diagnostics Health checks with suggested fixes, etcd member checks on control plane nodes (apply lag, behind the leader, fragmentation with the defrag command, quota), CNI checks (Flannel, Cilium, Calico) and addon checks (cert-manager and more)

On a cluster, control plane or workers row, network, storage and diagnostics show every node at once; diagnostics as a node × category grid with each warning listed once with its nodes.

Cluster-wide

View Shows
etcd Quorum, members, leader, alarms, advertised and listen addresses (running vs config), live member log
Volumes LINSTOR/DRBD and ZFS LocalPV volumes, with problems first (see below); W warps into a PVC namespace, shared with Workloads
Workloads Unhealthy Deployments, StatefulSets, DaemonSets and pods in one list, worst first; NODES shows where each runs, or for a failing one, where its unready pods are; A shows healthy ones too, S groups by namespace, / filters; W warps Workloads and Volumes into namespaces (a picker: Space marks several, prefix* warps by prefix, the last 4 warps kept per cluster, 1-4 pick them, 0 all); P lists every pod instead (ready, node, state, restarts, age, owner; static and Job pods too), a click on any column header or 1-8 (the columns left to right) sort it, by state (worst first) by default; below the list, the selected pod's containers, last termination and latest event, and y copies the kubectl command. Enter focuses a workload: its pods, and the logs of all of them merged by time; select a pod for its containers' logs, Enter on it lists its containers, init containers too, select one for only its logs (p the previous run, where a container restarted, w wrap, 1-5/0 levels as in Logs, / search with n/N, PgUp/PgDn/g/G or the wheel scroll, follows the end; w wraps long lines under the message; V selects lines, j/k extend, y copies them as shown, while a bare y copies the kubectl logs command; v opens the lines read in hl, or the viewer TALOS9S_LOG_VIEWER names), levels coloured, JSON and logfmt lines shown as message and fields, terminal colour codes removed, the date shown when the lines span days
Kubernetes Every cluster of the talosconfig in one list, read-only: the unhealthy Deployments, StatefulSets, DaemonSets and pods of all of them (a CLUSTER column; A shows everything), any kind from API discovery, CRDs included (: picks one: the common kinds until you type, then every kind that matches, with the clusters serving it), or a search (s: a name, l:app=web a label selector, i:redis an image). Each cluster is read on its own: one that can't be reached or answers 403 shows ? with its error, the rest are listed. X shows one cluster at a time, / filters. Enter shows an object: status, conditions, events and its YAML, masked (Secret values never leave the API answer). d diffs it with the same object in another cluster (or marks it, and d on a second row compares the two). l reads its pods' logs, L those of the same selector in every cluster, or of every pod a label search found. y copies the kubectl get -o yaml command
GitOps Flux Kustomizations, HelmReleases and sources and Argo CD Applications across clusters, worst first: health and sync (out of sync counts as degraded, suspended is called out), the applied revision and the source (repo, path or chart, target revision)
Lifecycle Talos and Kubernetes versions across nodes; a saved config that differs from the one in effect is flagged "staged, reboot"
Security Certificate expiry, encryption status

Volumes compares LINSTOR's view with each node's kernel and flags what LINSTOR alone doesn't show:

  • DRBD devices or filesystems not grown after a resize;
  • out-of-sync blocks on connected links, including those that can make a Primary fail its I/O after a short link loss (LINBIT/drbd#153);
  • disconnected and StandAlone links (split-brain), suspended I/O, missing replicas, resync progress with an ETA, filesystems filling up;
  • orphaned volumes: no PersistentVolume uses them, or their claim is gone.

Where a fix is provably safe, it suggests the exact commands to copy (y). talos9s never runs them.

Operations

The Operations view (o) lists what can run on the selected node, group or cluster, and every run so far. On a group or cluster an operation runs node by node and stops at the first failure.

Operation What it does
Cordon / Uncordon Stop new pods on the node(s), keeping the running ones / allow them again
Drain Cordon and evict pods, respecting PodDisruptionBudgets; stays cordoned
Reboot Drain, reboot, wait for Ready with a new boot ID, uncordon; on a group, one node at a time with etcd quorum checked before each control plane node
Shutdown Drain, power off; stays cordoned until you uncordon it (one node only)
  • Starting: pick the operation: o (or Enter or a click on it) opens the drop list, 1-5 pick one directly; the cursor then moves to the nodes. Check them with Space or a click (on a group none is checked, "all nodes" checks every one; a single node is checked already). Enter opens the confirmation: the checked nodes, the equivalent kubectl/talosctl commands, etcd quorum and blocking PDBs; y starts it, n/Esc cancels. The history's TARGET is the group when all its nodes ran, else the nodes.
  • Node state: each node row shows TALOS (up and its uptime, or offline), K8S (Ready), SCHEDULE (cordoned or not), PODS (what a drain evicts) and its last run, read every 15 s and when a run ends. A node the operation can't run on shows [-] and why: Cordon needs an uncordoned node, Uncordon a cordoned one, Reboot and Shutdown a node answering the Talos API (Cordon and Drain also work on a node that is down). A state that can't be read blocks nothing.
  • Drain options (Drain, Reboot, Shutdown): the confirmation fills the screen, tree included (a click elsewhere can't lose it), with the options on top and a table of every pod on the checked nodes and what happens to it (stops the drain, blocked by a one-instance CloudNativePG cluster, waits for a PodDisruptionBudget that allows no disruption now, gone for good, emptyDir data lost, a CloudNativePG primary that switches over first, evicted, stays), worst first; PgUp/PgDn and the mouse wheel scroll it, and the pods the option under the cursor decides about are bold. r reads the pods again, and they are read every 10 s (a toggles). Ignore DaemonSets, Delete emptyDir data and Force check boxes, grace period, timeout (5 min per node), Wait to finish (off, 5 min to 1 h: after cordoning, wait for pods no controller recreates, such as CI agents, and with "also Job pods" for Jobs, to end by themselves before draining; what is left then follows Force) and, for a reboot of several nodes, the wait between them. j/k move, Space toggles, ←/→ change a value, a click toggles. Each counts what it hits on the checked nodes (15 pods stay, stops the drain: 1 pod). As with kubectl, a pod an option doesn't allow (a DaemonSet pod, one no controller recreates, one with emptyDir data) stops the drain before the node is cordoned. The choice is kept per cluster, except Force, which starts off every time.
  • A node cordoned before a Drain, Reboot or Shutdown stays cordoned: a run uncordons only what it cordoned itself.
  • Runs in the background: switch views or nodes freely; the header shows the run and its step on every view. One run at a time per cluster context. x cancels after the current step (a failed or cancelled node is uncordoned again). While a run goes, q and Ctrl+C don't quit; a second Ctrl+C within 2 seconds does.
  • History: every run is kept in ~/.talos9s/operations/ (one private file each: time, context, nodes, commands, every step, how it ended) until you delete it with D. On a node the list shows that node's runs (A: every run); on a group or cluster every context's (A: this one only), / filters by node, operation, status or command, Enter shows a run's output (search, wrap, V/y lines, v viewer), y copies its commands.

Every step also goes to the audit log.

Keys

In the tree (each key switches the view on the right; the left menu and the mouse do the same):

Key On a node On a cluster, control plane or workers row
D Dashboard: node details Dashboard: cluster or group summary
l / L Logs Logs merged across the nodes
n Network Network of every node
K KubeSpan peers KubeSpan peer matrix
s / t Disks / partitions Disks / partitions of every node
d Diagnostics Diagnostics grid
p Processes Processes
C Containers Containers of every node
m / x Machine config / extensions
o Operations: cordon, uncordon, drain, reboot, shutdown; run history Same, node by node (no shutdown)
v / w Volumes / workloads on this node Volumes / workloads on those nodes
i / g Kubernetes / GitOps across every cluster same
e b c etcd, lifecycle (boot and upgrades), security (cluster-wide) same

Everywhere:

  • ? lists every key that works now: the view's own (as on the bottom line), the view letters, the tree's and the shared ones. j/k scroll it, Esc, q or ? close it.
  • j/k or arrows move the selection and the view follows; g/G or Home/End jump to top or bottom, PageUp/PageDown move a page.
  • →, Enter or a click puts the keyboard in the view; ←, Esc or q gives it back (q doubles for Esc because some terminals, IntelliJ's among them, never pass Esc). Tab / Shift+Tab cycle Nodes → menu → view.
  • q in a view returns to the Dashboard; there it asks before quitting (y). Ctrl+C quits at once, unless an operation runs (then twice).
  • / filter or search, r refresh, a auto-refresh, A show all (or issues only), 0 all levels, services or nodes in logs, y copy, Space fold. The same letter means the same thing in every view; uppercase in the tree (L) is the across-nodes version of a view.
  • [ / ] narrow or widen the left pane, Z zooms the view to full width.
  • Mouse: click a row to select it, double-click to open it, click a menu entry or a sortable column header (Network) to switch or sort; the wheel scrolls the pane under the pointer.
  • The top line lists the keys that work everywhere; the bottom line only what acts in the focused window right now.

talos9s starts where you left it (see Safety for the state file).

Safety

talos9s runs with your talosconfig, which usually means full admin on every node, so it is careful about what it changes:

  • Reads by default. It changes a node only for cordon, uncordon, drain, reboot, shutdown, cluster install and bootstrap, each after a confirmation dialog, and logs every step to ~/.talos9s/audit.log (operations also to their run file in ~/.talos9s/operations/).
  • Never runs suggested commands. Diagnostic fixes (talosctl) and storage fixes (drbdadm, kubectl) are shown and copied for you to review and run.
  • Never shows secrets. The machine config viewer masks keys, tokens, passwords, private keys and Secret data before anything is drawn.
  • Writes only: the audit log, the operation runs, the remembered view state (~/.talos9s/state.yaml: selection, view, pane width, folded groups, sort orders and toggles, no cluster data, no text filters; delete it to start fresh), its debug log (temp dir or --log-file), packet captures you save (/tmp, owner-only) and the wizard's output directory. It has no configuration file.
  • No in-cluster access needed. Nothing runs in the cluster and no Kubernetes namespace needs Talos API rights.
  • One connection besides your clusters: at start (at most once an hour) and once a day while running, it asks GitHub for the latest talos9s release, to show "0.4.0 available" on the top line. --no-update-check, TALOS9S_NO_UPDATE_CHECK=1 or DO_NOT_TRACK=1 turns it off.

How it works

  • State over logs. Health comes from current state (files, Talos and Kubernetes APIs), not from log lines, so an old error in a log doesn't raise an alarm.
  • Unknown over wrong. If a source can't be read, a check says unknown instead of guessing; nothing crashes, the rest of the screen keeps working.
  • Nodes, not the VIP. The Talos API is addressed at each node; the cluster VIP needs a healthy control plane, so it fails exactly when you need diagnostics. Talos resources (COSI) aren't exposed on :50000, so they are read through talosctl get. Every call has a timeout, so a dead node never freezes the UI.

Development

cargo test --all
cargo clippy --all --all-targets -- -D warnings
TALOS9S_CONTEXT=my-cluster cargo dev   # rebuild and restart on every change (needs cargo-watch)

The workspace has three crates: talos-rs (Talos client), talos9s-core (logic, unit-tested without a terminal or cluster) and talos9s-tui (the ratatui app). Git hooks, cargo deny, regenerating the Talos API client and the other conventions are in CLAUDE.md.

Contributions are welcome. Keep changes in line with How it works: check real state, degrade gracefully, and never report failure when "unknown" is the honest answer.

License

MIT, see LICENSE.

Acknowledgments

About

Terminal UI for Talos Linux clusters: nodes, logs, etcd, storage (LINSTOR/DRBD, ZFS), diagnostics and safe node operations. A fork of talos-pilot.

Resources

Stars

2 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages