Skip to content

Why v8s stays fast ​

Performance is v8s's first design constraint. A Kubernetes UI usually gets slow because it downloads every object, keeps it in the browser, and re-renders all of it on every change. v8s avoids that in four ways.

1. The agent does the heavy work ​

A Go agent talks to the Kubernetes API. The UI never sees the API server. The agent builds sorted, filtered views itself, so a sort or filter over 50,000 rows is a few milliseconds of work in the agent, and the UI asks for "rows 400 to 460 of this view".

2. Only the fields you see are kept ​

When the agent reads a list, it keeps only what the UI and the Problems checks need: a handful of fields per object, with repeated strings stored once. It drops managedFields and last-applied-configuration at ingest, which are half the bytes of a typical object. Built-in types are requested as protobuf, which decodes about six times faster than JSON.

The numbers below come from a spike that decoded 10,000 deliberately heavy pods (median 11.7 KB of JSON each) on an M1 Max:

Measured, 10k podsResult
Parse as JSON in V8473 ms
Go JSON decode into typed objects614 ms
Go protobuf decode into typed objects101 ms
Agent memory holding full objectsabout 180 MB
Agent memory holding projected rows14 MB
What a UI window of 9-column rows needs2.3 MB
Send full objects across a thread boundary vs rows487 ms vs 3.7 ms
Sort 25k rows by name / filter by substring5.3 ms / 0.6 ms

The spike's code and results are in the decode-bench README.

3. The UI shows a window, not a list ​

The UI holds only the rows around what you are looking at, usually a few hundred, however large the cluster is. Rows have a fixed height, and the table only renders what is on screen. Data arrives as small patches, at most once per screen frame, and the agent remembers what it last sent, so reconnecting costs one window, not a full reload. A bigger cluster makes the agent's work bigger, not the page's.

4. v8s is gentle on your API servers ​

v8s must never be the reason a cluster is slow. It uses streaming lists (WatchList) where the cluster supports them, so the API server serves the initial state from cache without a big allocation. It honors rate limits and 429 responses, and it caps its concurrent requests and watches per cluster. Large objects such as vulnerability reports are watched as tiny table rows and fetched in full only when you open one. Deselected clusters release their memory.

The budgets ​

These are the targets v8s is built against. They are design budgets, not guarantees on your hardware: the design gives each one a benchmark in CI that fails the build on regression.

MetricDesktop (local agent)Hosted, desktop browserPhone
Cold start to interactive1.5 s1.5 s3.5 s
Select a cluster to first rows (10k pods)1.0 s p951.0 s + networkas hosted
Full sync of 50k pods on a LAN8 s8 sn/a
Sort or filter over 50k rows20 ms in the agent, 50 ms on screen50 ms + network150 ms + network
Scrolling60 fps60 fps8 ms scripting per frame
Cluster event to visible row, p95150 ms400 ms1.5 s
Sustained churn1,000 events/s with the main thread under 10% busysamen/a
Agent memory50 MB base plus 50 MB per 10k pods; 600 MB at 200k objects50 MB per 10k pods per active user and clustern/a
UI memory80 MB; 10k to 200k objects adds at most 10 MBsame50 MB
Log streaming5,000 lines/ssame1,000 lines/s
Idle data with Problems openn/a30 KB/min30 KB/min, 0 when hidden

Reference hardware is an M1 MacBook Pro for desktop, and a Pixel 6a-class phone on throttled 4G.

Read more ​

The full design, including the wire protocol and the checks that run in CI, is in Performance architecture. The agent and UI protocol is documented too.

Released under the MIT License.