Running GopherTrunk on Linux

Key takeaways This is the payoff. Three moves get you there: install the dependencies, grant your user access to the USB SDR, and run GopherTrunk as a systemd service so it stays alive across reboots. Everything the whole path taught you — the shell, permissions, processes, SSH, and services — now goes to work getting GopherTrunk running on a Linux box or a Raspberry Pi and keeping it there.

You’ve done the groundwork. Now you point it all at one real job: a running scanner. This lesson is the map, not a line-by-line install — for the exact commands and flags, we send you to the GopherTrunk pages, because those stay current and made-up flags don’t.

The plan

The shape of the job is the same on any machine. You install the prerequisites, get GopherTrunk onto the box, plug in the SDR and grant access to it, run it to confirm it decodes, and finally make it a service so it comes back on its own. You can do every step over SSH on a headless Pi — no monitor, no keyboard, just a terminal on your laptop talking to a board by the antenna.

Install prerequisites

GopherTrunk needs a few supporting libraries and tools present on the system. Install them with your distribution’s package manager — on Raspberry Pi OS (and Debian/Ubuntu) that’s apt:

sudo apt update
sudo apt install <the packages listed on the setup page>

The setup page names exactly what to install for your platform. The point of this step is simply that supporting software is installed the ordinary Linux way, not hunted down by hand.

Get GopherTrunk

Two routes, both familiar by now:

  • Download the binary. Grab the prebuilt release for your platform from the downloads page, then make it runnable with chmod +x:

    chmod +x ./gophertrunk

  • Build from source. Clone the repository and compile it, if you’d rather track the latest code or your platform has no prebuilt binary.

Either way, the getting-started page has the exact steps — follow those rather than guessing at version numbers or paths.

Plug in the SDR & USB permissions

Your SDR is a USB device. When you plug it in, Linux exposes it as a device node under /dev, and — this trips up almost everyone — a normal user usually can’t open it yet. The kernel guards raw USB devices, so out of the box only root has access.

The clean fix is not to run the scanner as root. Instead, grant your own user access the standard way: add yourself to the group that owns the device, or install a udev rule that hands the dongle to your user when it’s plugged in. This is exactly the permissions and sudo / root thinking from earlier in the path — give the least privilege that gets the job done. After adding the rule or group, unplug and replug the SDR so the new access takes effect. The hardware page lists supported SDRs and any device-specific notes.

Run it

With the dongle accessible, run GopherTrunk straight from the shell and watch what it prints:

./gophertrunk <options from the getting-started page>

Read its output the way you’d read any long-running program’s — is it finding the control channel, is it decoding, are there errors scrolling past? This is a foreground process for now; Ctrl-C stops it. Watching the live logs is how you’ll confirm it’s healthy — see monitoring & logs. On a Pi you’re typically doing all of this over SSH, so the output is streaming to your laptop from the board across the room.

Keep it running — a systemd service

Running it by hand is fine for a first test, but a real scanner should start at boot and restart itself if it ever dies. That’s a job for systemd. Write a small unit file describing how to launch GopherTrunk — here’s the generic shape:

[Unit]
Description=GopherTrunk scanner
After=network.target

[Service]
ExecStart=/path/to/gophertrunk <your options>
Restart=on-failure
User=youruser

[Install]
WantedBy=multi-user.target

Drop that in the system’s unit directory, then enable and start it:

sudo systemctl enable --now gophertrunk.service

enable wires it to start at boot; --now starts it immediately. Check that it came up cleanly, and read its logs, with:

systemctl status gophertrunk.service
journalctl -u gophertrunk.service -f

Treat the unit above as a sketch — fill in the real binary path and options from the getting-started page.

Watch its health

A scanner that runs for months needs the occasional glance, and everything you need is on the box already. Keep an eye on disk space if GopherTrunk is writing recordings — a full disk stops a lot of things ungracefully. Watch CPU on a small Pi, since decoding is real work and a struggling board shows up as dropped or garbled audio. And when a decode misbehaves, the logs are the first place to look — journalctl for the service, plus GopherTrunk’s own output, usually tell you whether it’s a signal problem or a software one.

Where to go next

You can now run and maintain a real, always-on Linux service — which is most of what running a home server or an embedded project comes down to. A Raspberry Pi sitting at the base of the antenna is a classic GopherTrunk setup: small, quiet, low-power, and reachable over SSH from anywhere in the house. If that’s your plan, the hardware side is worth a read — start with Raspberry Pi & family.

Quick check: You want GopherTrunk to come back automatically after a reboot. What do you set up?

Recap

  • Install prerequisites with the package manager (apt on Raspberry Pi OS).
  • Get GopherTrunk — download the binary and chmod +x it, or build from source; follow the getting-started page for the exact steps.
  • Grant USB access to your user with a group or udev rule — don’t run the scanner as root.
  • Run it from the shell first and watch the logs to confirm it decodes.
  • Make it a systemd service, enable it, and check journalctl — now it survives reboots and restarts on failure.
  • Watch its health — disk space, CPU on a small Pi, and the logs.

Next up: keep the glossary handy — and if you’re setting up a Pi by the antenna, the Intro to Hardware path covers the board itself.