zux

zux is an mDNS-SD visualizer with force-directed graph visualization. It automatically discovers all services advertised on your local network via multicast DNS service discovery, then renders them as an interactive force-directed graph so you can see at a glance which services, instances, hosts and addresses are present and how they relate to one another.

For a list-based mDNS browser for the desktop, check out mDNS-Browser. If you prefer to browse mDNS services from a terminal, take a look at mDNS-TUI-Browser.

• Automatic discovery of every mDNS service type advertised on the network
• Force-directed graph built on vis-network, with multiple physics solvers (forceAtlas2Based, barnesHut, repulsion, hierarchicalRepulsion)
• Typed nodes distinguished by shape and color:
  • Service types (diamond)
  • Service instances (circle)
  • Hosts (square)
  • IP addresses (triangle)
• Live statistics showing the number of types, instances, hosts, addresses and links
• Offline detection: instances and their hosts grey out when a service stops being advertised and come back online once it is seen again
• Detail panel for any node showing the service type, subtype, hostname, port, addresses with their interfaces, TXT records and clickable URLs for HTTP(S) services
• Filtering of nodes by query, and toggling of whole groups via the legend
• Physics controls to tune the layout live
• SVG export of the current graph
• Auto-update on Windows, macOS and Linux (deb/rpm), plus manual update on Android
• Cross-platform: Windows (MSI/NSIS), macOS (universal DMG), Linux (deb/rpm) and Android (APK)

• zux Overview
  • Screenshots
  • Features
  • Command line options
    • include-non-link-local-ipv6
    • log-level
    • log-to-file
  • Where to find the executables?
    • GitHub Releases
    • WinGet installation
    • Arch Linux (AUR)
    • Homebrew (macOS)
    • Flatpak (FlatPark)
    • Android
  • Building
    • Building for Android
  • Attested build artifacts
  • Verifying the Windows build signature
  • Immutable releases
  • Acknowledgments

Usage: zux [OPTIONS]

Options:
  -I, --include-non-link-local-ipv6  Include non-link-local IPv6 addresses (global and ULA)
      --log-level <LOG_LEVEL>        Log level (trace, debug, info, warn, error) [default: info]
      --log-to-file                  Log to file in the OS-specific log directory
  -h, --help                         Print help
  -V, --version                      Print version

By default, only IPv4 addresses and link-local IPv6 addresses are shown in the graph. If enabled, non-link-local IPv6 addresses (global and ULA) are also included.

Filtering is enabled by default to avoid leaking your public IPv6 address.

Sets the minimum log level. Possible values are trace, debug, info, warn and error. The default is info.

If enabled, a log file will be created in a platform-specific location:

• Windows: %LOCALAPPDATA%\com.github.hrzlgnm.zux\logs
• Linux: $XDG_DATA_HOME/com.github.hrzlgnm.zux/logs or $HOME/.local/share/com.github.hrzlgnm.zux/logs
• macOS: ~/Library/Logs/com.github.hrzlgnm.zux

The log file will be named zux.log and will contain log messages with a log-level having at least the level specified by the log-level option.

You can download the latest version of the application from the GitHub Release page

To install on Windows via WinGet, run the following command:

winget install hrzlgnm.zux

To install on Arch Linux using the AUR, you can use an AUR helper like yay or paru.

The zux package builds the application from source, while zux-bin installs the prebuilt binary.

With yay:

yay -S zux

Alternatively using the -bin package:

yay -S zux-bin

With paru:

paru -S zux

Alternatively using the -bin package:

paru -S zux-bin

To install on macOS using Homebrew, you can use the custom tap:

brew install --cask hrzlgnm/tap/zux

Or add the tap first:

brew tap hrzlgnm/tap
brew install --cask zux

To install on Linux via Flatpak, use the community-maintained FlatPark repository:

flatpak remote-add --if-not-exists flatpark https://dl.flatpark.org/flatpark.flatpakrepo
flatpak install flatpark io.github.hrzlgnm.zux

The package page is available at https://flatpark.org/apps/io.github.hrzlgnm.zux.

Prebuilt APKs are attached to each GitHub Release. The app checks for updates at startup and will open the release page so you can download the latest APK. To build the APK yourself, see Building for Android.

Before you begin, make sure you meet the necessary prerequisites. You can find more details in the official Tauri Guide.

• Rust
• Node.js and pnpm (the project pins pnpm@11.20.0)
• Platform-specific system libraries, e.g. WebKitGTK on Linux

pnpm install
pnpm run tauri dev

The frontend can also be run standalone in a web browser with demo data:

pnpm run dev

pnpm install
pnpm run tauri build

The bundles are created in src-tauri/target/release/bundle/.

Building for Android requires a few additional prerequisites on top of the ones above. You can find more details on setting those up in the official Tauri Guide — Android prerequisites:

• Java (JDK 17)
• The Android SDK and NDK
• The Rust Android targets:

rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android

Generate the Android project, generate the app icons from the icon source, and build the APK:

pnpm install
pnpm run tauri android init
pnpm run tauri icon src-tauri/icons/icon.png
pnpm run tauri android build

The unsigned APK is written to src-tauri/gen/android/app/build/outputs/apk/universal/release/. It needs to be signed before it can be installed.

To run the app in development on an emulator or a connected device:

pnpm run tauri android dev

The release binaries and bundles are attested with GitHub Artifact Attestations, and a software bill of materials (SBOM) is generated for each release. The attestations for the binaries are available here. For more information and details on how to verify those, see Verifying artifact attestations with the GitHub CLI

Since release v0.7.1

The Windows MSI and NSIS bundles are signed with a self-signed code-signing certificate. The release workflow verifies the signature of every bundle before it is published. The standalone zux.exe binary is intentionally not signed.

To verify a downloaded bundle, run the following in PowerShell:

Get-AuthenticodeSignature -FilePath .\zux_1.2.0_x64-setup.exe | Format-List Status, StatusMessage, @{n='Thumbprint'; e={$_.SignerCertificate.Thumbprint}}

Because the certificate is self-signed, Status will typically be UnknownError or NotTrusted with the message certificate chain processed, but terminated in a root certificate which is not trusted by the trust provider. — this is expected and only means the certificate is not in the Windows trust store. An UnknownError status is acceptable only when StatusMessage contains trusted by the trust provider. The important thing is that the signature is cryptographically intact, i.e. Status is not HashMismatch, NotSigned, NotSupported or Incompatible.

You can additionally confirm the signer certificate matches the certificate used for releases by comparing the thumbprint:

(Get-AuthenticodeSignature -FilePath .\zux_1.2.0_x64-setup.exe).SignerCertificate.Thumbprint

It must be 4f3cc75f545c898d57c5cc4349873a3bff8d4527.

This process is established since zux v1.2.0.

The GitHub releases are now immutable: a release is first created as a draft, all its assets (binaries, checksums, attestations) are uploaded while it is still a draft, and it is only published once everything is in place. This ensures that a published release is always complete and cannot be altered afterward.

This process has been used since release v0.1.0.

This app uses the fantastic mdns-sd library to handle all mDNS functionality, and vis-network for the force-directed graph. If you find this app helpful, consider giving them a star on GitHub!