Statsviz is an MIT-licensed Go library that streams a running program's runtime/metrics over a WebSocket into a live browser dashboard, built for Go developers and operators who need to watch heap, goroutine, garbage-collector and scheduler behaviour without standing up an external monitoring stack.

What it is

Statsviz lives in the Go runtime-observability corner of the ecosystem, alongside the language's own runtime/metrics package. It ships as a library rather than a standalone daemon: the program registers Statsviz HTTP handlers with its own http.ServeMux, and the library serves both a user interface and a WebSocket endpoint from inside the process it is measuring. Internally it is two parts — the Index HTTP handler serves the dashboard at /debug/statsviz, and the Ws handler serves a WebSocket endpoint that pushes the program's runtime/metrics to the browser once per second.

The concrete problem is that runtime/metrics is a low-level API that yields raw numeric values, which are awkward to interpret in flight. Statsviz turns those same values into continuous plots of allocation and free rate, live bytes, live objects, goroutines, GC cycles and pauses, scheduling events, mutex wait, CGO calls and CPU broken out by GC, overall and scavenger. That means replacing hand-rolled introspection of raw metric values with a browser view that updates continuously, without introducing a separate metrics backend for runtime statistics alone.

Key capabilities

• statsviz.Register(mux) wires the handlers into any http.ServeMux, serving the dashboard at /debug/statsviz.
• statsviz.NewServer() exposes Index() and Ws() handler functions for custom mount paths such as /foo/bar, middleware wrapping, and https:// instead of http://.
• A WebSocket connection carries runtime/metrics data points to the browser once per second.
• Roughly twenty built-in plots cover Goroutines, Live Objects, Live Bytes, Heap (Details), GC Pauses, GC Cycles, GC Scan, GC Stack Size, Scheduling Events, Mutex Wait, Runnable Time, CGO Calls, Memory Classes, Size Classes, MSpan/MCache, and CPU (GC), CPU (Overall) and CPU (Scavenger).
• The interface provides a category selector for filtering plots, a visible time-range selector, a show/hide toggle for vertical GC event lines, and a pause/resume control for updates.
• Since v0.6, User Plots let an application add its own metrics to the dashboard beside runtime metrics, demonstrated in the _example/userplots/main.go example.
• Which plots appear depends on the Go version in use, since newer versions expose metrics that older ones do not.

Who uses it and how

• Developers debugging a single Go process locally, registering handlers and opening http://localhost:8080/debug/statsviz to watch GC pauses and heap growth while reproducing an issue.
• Teams running services behind echo, fasthttp, fiber or gin, where the examples directory shows registration with each framework.
• Services that need Statsviz at a non-default path or behind middleware, using statsviz.NewServer() and its Index() and Ws() handlers.
• Deployments serving the dashboard over https://, where the example set covers TLS configuration.

Getting started

Install with go get github.com/arl/statsviz@latest, register statsviz.Register(mux) with your http.ServeMux, and open http://localhost:8080/debug/statsviz in a browser.

How it compares

No competing or paid products are named in the facts provided for this entry. On the evidence available, Statsviz stands alone in this registry among runtime-visualisation tools, and it does not position itself against any commercial monitoring product.

When to use it — and when not to

Statsviz is an in-process library, so a self-hoster operates no database, object store or SMTP service to run it — the cost is exposing an internal debug endpoint from the application itself, which needs deliberate handling in production. It is the wrong choice for anyone who needs fleet-wide aggregation, long-term metric retention or alerting, because the data is streamed to a single browser and no persistence is described. The catalogue is also modest — 10 open issues, 124 forks and a last push in September 2026 — so teams wanting a broadly maintained, multi-language observability platform should look elsewhere.

go get github.com/arl/statsviz@latest

mux := http.NewServeMux()
statsviz.Register(mux)

go func() {
    log.Println(http.ListenAndServe("localhost:8080", mux))
}()

srv, err := statsviz.NewServer(); // Create server or handle error
if err != nil { /* handle error */ }

// Do something with the handlers.
srv.Index()     // UI (dashboard) handler func
srv.Ws()        // Websocket handler func