ryn

ryn is a terminal UI for inspecting active network sockets on Linux and the processes that own them. It reads live socket statistics from the kernel, matches each socket back to the process holding it open, and presents everything in an interactive, sortable table - enriched with human-readable descriptions of ports, protocols, connection states, and queue semantics.

Think of it as a friendlier, interactive take on ss / netstat, with built-in process attribution, reverse-DNS lookups, and WHOIS ownership details for remote peers.

• Live socket table - every active non-loopback TCP and UDP socket, with protocol, connection state, receive/send queue sizes, local and peer addresses, and ports.
• Process attribution - each socket is matched to the owning process (PID, name, and user) by correlating socket inodes with open file descriptors.
• Human-readable metadata - well-known ports, protocols, TCP states, and queue meanings are annotated from embedded lookup tables, so you don't have to memorize them.
• Reverse DNS - remote peer addresses are resolved to hostnames in the background.
• WHOIS lookups - drill into a connection to see ownership information for the remote IP.
• Keyboard-driven - sort, scroll, refresh, and open detail popups without leaving the keyboard.

• Linux (the collector reads kernel socket and process information that is specific to Linux).
• Go 1.24 or newer to build from source.
• To attribute sockets owned by other users' processes, run with elevated privileges (for example via sudo). Without them, sockets you don't own will still appear, but their process column will be blank.

Build and install with the standard Go toolchain:

go install github.com/rykth/ryn/cmd/ryn@latest

Or build from a checkout using the provided make targets:

make build      # compile into the dist/ directory
make install    # install into your GOBIN
make run        # build and run immediately

Run make help to see all available targets (build, test, vet, lint, tidy, docker, clean).

Launch the application:

ryn

To see all sockets system-wide, including those owned by other users:

sudo ryn

Check the version:

ryn --version

The detail popup shows the full command line of the owning process along with reverse-DNS and WHOIS information for the remote peer.

A containerized example is included so you can try ryn without installing a Go toolchain, and so you can test it in a controlled environment.

The important caveat: ryn inspects the kernel's sockets and processes. A container has its own, mostly empty network and process namespaces, so by default it would show almost nothing. The example therefore runs the container against the host's network and PID namespaces so the table reflects what is actually happening on your machine.

Build and run against the host in one step:

make docker-test

This builds the image and launches ryn inside a container with:

• host networking - so the container sees the same sockets as your machine,
• the host PID namespace - so it can see and name host processes, and
• the SYS_PTRACE capability - which is required to read the file descriptors of host processes. Without it, sockets still appear but the process column shows only -, because the kernel denies access to other processes' descriptor links.

Build the image only, without running:

make docker-build

Run inside the container's own (isolated, mostly empty) namespace instead of the hosts (useful for confirming behavior in a clean environment):

scripts/docker-test.sh --isolated

Pass arguments straight through to the binary (anything after --):

scripts/docker-test.sh -- --version

Run scripts/docker-test.sh --help for the full list of options.

Note: host networking, the host PID namespace, and SYS_PTRACE are intentionally broad permissions. They are appropriate for local inspection on a machine you control, but you should understand what they grant before running the container elsewhere.

make test    # run the test suite with the race detector
make vet     # run go vet
make lint    # run golangci-lint, if installed
make check   # vet + lint + test