Trippy

Trippy is a network diagnostic tool written in Rust that combines the functionality of ping and traceroute in a single, interactive terminal UI. It continuously traces the route to a target host and displays per-hop statistics — round-trip time, packet loss, jitter, and more — updating in real time. It is a significant step up from both classic traceroute and mtr, with a richer TUI, more tracing protocols, and better configurability.

Features

• Real-time TUI — a continuously updating display showing every hop, its RTT history, packet loss percentage, and jitter
• Multiple tracing protocols — supports ICMP, UDP, and TCP for both IPv4 and IPv6, making it useful in environments where ICMP is blocked
• Multiple tracing strategies — Paris, Dublin, and Classic tracing strategies to avoid ECMP load balancing issues that confuse traditional traceroute
• DNS resolution — resolves hostnames for each hop, with reverse-DNS lookup and configurable TTL caching
• GeoIP — optionally annotates hops with their geographic location using a MaxMind GeoLite2 database
• MPLS — displays MPLS label information where available
• Hop details — expand any hop to see the full list of responding addresses (useful when a hop load-balances across multiple paths)
• Tui themes — configurable colour themes
• Export — export trace results as JSON, CSV, or pretty-printed text for reporting

Installation

cargo install trippy --locked

Or via your system package manager:

# macOS
brew install trippy

# Arch Linux
pacman -S trippy

# Debian / Ubuntu
apt install trippy

# Fedora
dnf install trippy

# Nix
nix-env -iA nixpkgs.trippy

Pre-built binaries for Linux, macOS, and Windows are available on the releases page.

Usage

Trippy requires elevated privileges to send raw packets. On Linux you can grant the binary the required capability instead of running as root:

sudo setcap CAP_NET_RAW+p $(which trip)

# Trace to a host (ICMP by default)
trip example.com

# Trace using UDP
trip --protocol udp example.com

# Trace using TCP on port 443
trip --protocol tcp --target-port 443 example.com

# Trace IPv6
trip --addr-family ipv6 example.com

# Set the tracing strategy (Paris avoids ECMP issues)
trip --multipath-strategy paris example.com

# Limit to a maximum of 20 hops
trip --max-ttl 20 example.com

# Set packet send interval (default 1s)
trip --min-round-duration 200ms example.com

# Export results as JSON after 10 rounds and exit
trip --mode json --report-cycles 10 example.com

# Export as a pretty table and exit
trip --mode table --report-cycles 5 example.com

TUI Keybindings

Tracing Strategies

Classic traceroute sends probes with a fixed source/destination port, which means ECMP (Equal-Cost Multi-Path) routing can send all probes down the same path — giving you a misleading picture of the actual route your traffic takes.

Trippy supports alternative strategies:

• paris — varies the IP ID and checksum to probe multiple paths while keeping the flow consistent; the standard choice for accurate ECMP tracing
• dublin — varies the IP ID similarly to Paris but with different encoding; useful for some network configurations where Paris gives inconsistent results
• classic — the traditional approach; fine for simple networks without ECMP

GeoIP Integration

To annotate hops with geographic location data:

1. Download the free MaxMind GeoLite2-City database
2. Pass the path to Trippy:

trip --geoip-mmdb-file /path/to/GeoLite2-City.mmdb example.com

Each hop will then show its country, city, and coordinates in the detail view.

Configuration

Trippy reads from ~/.config/trippy/trippy.toml:

[trippy]
protocol          = "icmp"
addr-family       = "ipv4"
multipath-strategy = "paris"
min-round-duration = "1s"
max-ttl           = 64
dns-resolve-all   = false

[tui]
theme-colors = [
  "bg-color=black",
  "text-color=white",
  "selected-bg-color=blue",
]

Why Trippy over mtr?

mtr is the classic interactive traceroute tool, but it has limitations: it only supports ICMP and UDP, has no support for alternative multipath strategies, and its TUI is fairly minimal. Trippy adds TCP tracing (useful for diagnosing firewalls), Paris/Dublin multipath strategies for ECMP networks, GeoIP annotation, exportable reports, and a more polished and configurable interface — all from a modern Rust codebase.