Announcements
Project news, milestones, and community updates.
-
Welcome to the GopherTrunk blog
A new home for project updates, release notes, deep dives on protocols and DSP, and step-by-step tutorials.
Deep dives
Technical articles on protocols, DSP, and architecture.
-
RF Front End, Part 14: Diagnostics, Metrics & the Pure-Go Payoff
The finale of RF Front End. How GopherTrunk makes the front end observable — sdr list --probe, the RTLSDR_DEBUG_USB control-transfer trace, and the iq_underruns_total metric that turned silent IQ loss into something an operator can see — and then the payoff the whole series argued for: one static binary, CGO_ENABLED=0, no librtlsdr, no libusb, cross-compiled everywhere.
-
RF Front End, Part 13: Testing Radios Without Radios
How GopherTrunk's USB driver code is tested in CI with no hardware attached — replaying captured control-transfer sequences through a scripted mock transport, pinning the pure-Go sample conversion bit-for-bit against librtlsdr with a golden-master test, and an opt-in real-hardware tier gated behind environment flags with bias-tee safety resets.
-
RF Front End, Part 12: The SDR Pool & USB Hotplug Watchdog
How GopherTrunk manages a fleet of opened dongles behind one pool — assigning control, voice, and wideband roles, running a USB watchdog that re-enumerates every 30 seconds to catch hotplug, and reacquiring a device after the kernel hands it a new bus address. Plus the re-open race that taught us to serialize retune behind stream teardown.
-
RF Front End, Part 11: HackRF One — Signed 8-Bit IQ End to End
The HackRF One driver end to end — the simplest IQ format of the three, signed 8-bit interleaved I,Q scaled to complex64; enumeration across One/Jawbreaker/Rad1o PIDs; and the open-time board-ID readback that fixed empty probe gains by establishing identity and the gain ladder before streaming.
-
RF Front End, Part 10: Airspy R2/Mini & HF+ — Real Samples to Complex Baseband
How GopherTrunk turns the Airspy R2/Mini's bare real ADC stream into complex baseband entirely on the host — a leaky DC blocker, a multiplier-free Fs/4 mix, and a stateful half-band Hilbert pair — then folds in the Airspy HF+, whose native int16 IQ needs none of it.
-
RF Front End, Part 9: RTL-SDR III — IQ Streaming & the GC-Churn Bug
Sustained IQ streaming from the RTL2832U in pure Go — 32 async USB buffers, a deep consumer channel, and a bit-identical U8-to-complex64 lookup table. Plus the headline bug: per-chunk allocations whose GC churn shed a quarter of the control channel's live IQ, and the zero-allocation reuse ring that fixed it.
-
RF Front End, Part 8: RTL-SDR II — The R82xx Tuner & the Blog V4 Deafness
GopherTrunk's pure-Go R820T/R828D tuner driver — PLL tuning, a shadow-register cache that makes read-modify-write free, and tuner auto-detection. Plus the headline bug: why the RTL-SDR Blog V4 came up deaf and mistuned by 1.8×, and how a manual override plus per-band input switching fixed it.
-
RF Front End, Part 7: RTL-SDR I — Bringing Up the RTL2832U
How GopherTrunk brings up the RTL2832U demodulator in pure Go — the order-sensitive init sequence captured verbatim from librtlsdr, the I2C bridge to the tuner, GPIO and bias-tee, and the USB register transport underneath it all.
-
RF Front End, Part 6: USB on macOS & Windows
How GopherTrunk reaches the same Transport contract through macOS IOKit (via purego, with OS-thread-pinned reader goroutines) and Windows WinUSB (with overlapped I/O), and why macOS forced us to own the calling thread.
-
RF Front End, Part 5: USB on Linux — USBDEVFS & Async URBs
How GopherTrunk's Linux USB backend hand-rolls USBDEVFS ioctl encoding, submits a ring of async URBs, and reaps them in a single goroutine for sustained IQ throughput — all in pure Go behind a safe Transport API.
-
RF Front End, Part 4: Talking to USB Without libusb
How GopherTrunk speaks to RTL-SDR hardware over raw kernel USB interfaces instead of linking libusb, and the single Transport contract that lets one driver run on three wildly different OS USB stacks.
-
Rebuilding GopherTrunk from Source: Update to the Latest Version with Git and GitHub
A copy-paste guide to rebuilding GopherTrunk from source with the Git CLI and GitHub — clone the repo, check out the latest version or a specific branch, build the pure-Go binary, verify it, and keep an existing clone up to date.
-
RF Front End, Part 3: The Driver Registry & Enumeration
How GopherTrunk's self-registering driver registry keeps the core hardware-agnostic — drivers register at init(), the binary's import set chooses the hardware, and EnumerateAll walks every backend to list attached dongles while staying resilient when one driver fails.
-
RF Front End, Part 2: The Device Contract
A method-by-method tour of GopherTrunk's Device interface — the one abstraction four very different radios hide behind — and the optional, type-asserted extension interfaces that expose RTL-SDR-only quirks without polluting the universal contract.
-
RF Front End, Part 1: Why Drive Radios in Pure Go?
The opening post of RF Front End, a 14-part deep dive into GopherTrunk's RF source layer — the pure-Go USB drivers that turn RTL-SDR, Airspy, and HackRF hardware into IQ samples without libusb, librtlsdr, or any C dependency.
-
SDR in Pure Go, Part 14: APIs, Testing & the Pure-Go Story
How GopherTrunk exposes the engine through gRPC, REST, WebSocket and a TUI, observes it with Prometheus and SQLite, and proves it works with synthesized-IQ integration tests — a ports-and-adapters finale.
-
SDR in Pure Go, Part 13: Recording, Composition & Streaming
How GopherTrunk records calls to WAV, drives a per-call demodulation chain with the composer, and streams audio to Broadcastify and RdioScanner — all from optional, config-driven subsystems.
-
SDR in Pure Go, Part 12: Voice Coding — IMBE, AMBE+2 & MBE
How GopherTrunk turns digital voice frames into audio with pure-Go IMBE and AMBE+2 vocoders sharing one MBE synthesis core, all behind a pluggable Vocoder registry.
-
SDR in Pure Go, Part 11: The Trunking Engine & Event Bus
How GopherTrunk's trunking engine turns channel grants into recorded calls, and how an in-process pub/sub event bus decouples the core from the API, storage, and streaming subsystems.
-
SDR in Pure Go, Part 10: Protocol Decoders as State Machines
How GopherTrunk decodes P25, DMR, NXDN, TETRA and a dozen more trunking protocols in pure Go — each a stateful receiver behind a uniform Grant contract, an adapter pattern that keeps the engine protocol-agnostic.
-
SDR in Pure Go, Part 9: Framing & Forward Error Correction
How GopherTrunk recovers clean data from noisy symbols using pure-Go forward error correction — Golay, BCH, Hamming, Reed-Solomon, BPTC, trellis, and Viterbi — built as deterministic, table-driven codecs.
-
SDR in Pure Go, Part 8: Equalization, Diversity & the FFT
How GopherTrunk fights simulcast distortion with adaptive equalizers, combines multiple receivers with diversity, and drives the live waterfall with a rate-limited FFT — all in pure Go.
-
SDR in Pure Go, Part 7: Symbol Timing & Sync Recovery
How GopherTrunk recovers the symbol clock from oversampled signals with a Mueller-Muller timing loop and finds frame boundaries with a sync correlator — feedback state machines implemented in pure Go.
-
SDR in Pure Go, Part 6: Demodulation — FM, C4FM, GFSK & More
How GopherTrunk turns baseband IQ into symbols with pure-Go demodulators for FM, C4FM, GFSK, FFSK, and π/4-DQPSK — each a focused, single-responsibility type composed from DSP primitives.
-
SDR in Pure Go, Part 5: Tuning & Channelization — DDC vs. Polyphase
How GopherTrunk extracts many narrowband channels from one wideband SDR capture using a digital down-converter or a polyphase channelizer, selected at runtime through a Go Strategy interface.
-
SDR in Pure Go, Part 4: DSP Foundations — Filters, NCO & AGC
The building blocks of GopherTrunk's signal chain in Go — FIR/CIC filters, a numerically-controlled oscillator, automatic gain control, and resamplers — and the zero-allocation streaming design behind them.
-
SDR in Pure Go, Part 3: The SDR Pool & Streaming Concurrency
How GopherTrunk streams IQ samples through Go channels and goroutines, manages a fleet of SDR dongles with a device pool, and fans one stream to many consumers without blocking the decode path.
-
SDR in Pure Go, Part 2: SDR Devices & the Driver Registry
How GopherTrunk talks to RTL-SDR, HackRF, and Airspy hardware in pure Go behind one Device interface, and how a self-registering driver registry keeps the core hardware-agnostic.
-
SDR in Pure Go, Part 1: What Is Software-Defined Radio?
A pure-Go tour of software-defined radio — what SDR is, the GopherTrunk signal pipeline from RF to audio, and the layered architecture behind a single static binary.
Tutorials
Step-by-step user-facing guides.
-
Signal Lab, Part 10: The Demod Bench — siglab sweep, Regression & Export
Signal Lab's demod benchmark, gophertrunk siglab sweep, synthesizes P25 Phase 1 across an SNR ladder on both the c4fm and cqpsk/lsm demod paths, decodes through the production pipeline, and prints measured demod quality against a theoretical symbol-error-rate reference with CSV export.
-
RF Scope, Part 10: Advanced — Tuning Segmentation, Selective Analyzers & Pipelines
The advanced rfscope guide — run a subset of analyzers with dependencies auto-pulled, tune segmentation for unusual bands, emit machine formats (json/jsonl/yaml/csv) for pipelines, and close the reverse-engineering loop from -frames-out into cryptolab, with a note on how rfscope's downconverter relates to GopherTrunk's DSP paths.
-
Crypto Lab, Part 10: The Subject Framework, alias & the Mercury Reveal
Crypto Lab's pluggable subject framework and its alias tool recover length-seeded, keyless byte obfuscators through four incremental, resumable modes — gauge, structure, cells, and fromseed — and finally reveal that the Mercury signal was never encryption at all, graded BROKEN, with the moral that obfuscation is not encryption.
-
Signal Lab, Part 9: Dissecting P25 — TSBK PDUs, Receiver States & the Sync Landscape
Signal Lab's deepest P25 view — collect_pdus surfaces every TSBK signaling block (decoded and CRC-failed) as a field-level dissection with a csv-pdus export, plus the C4FM and CQPSK receiver-state series, the soft-eye verdict, and the sync-landscape heatmap.
-
RF Scope, Part 9: The Scene Cockpit — Live TUI & Web Console
rfscope cockpit is a full-screen Bubbletea terminal dashboard and rfscope serve is a browser console — both render the same live Scene (header, hierarchy tree, channel I/O sparklines, top talkers, conversations, severity-colored expert info) over a capture or a live SDR, with a Crypto Lab hand-off built in.
-
Crypto Lab, Part 9: The Web Console, Live-Capture Bridge & External Ciphers
Crypto Lab's serve command launches a schema-driven web console that auto-renders a form for every tool, mounts inside the daemon when built with the cryptolab tag, feeds ks and assess from a live decoder bridge, and drives operator-supplied external ciphers as CLI-only subprocesses behind a strict safety boundary.
-
Signal Lab, Part 8: Naming the Unknown — Blind Signal-ID & the Wideband Survey
Signal Lab identifies an unknown capture by ranking protocol candidates, names undecodable carriers from a blind symbol-rate and modulation estimate against an offline signal-ID reference database, and surveys a wide capture in the Wideband tab — where the Mercury signal finally gets a best guess but no lock.
-
RF Scope, Part 8: Expert Info — Anomalies & What They Mean
rfscope's expert analyzer is the RF analog of Wireshark's Expert Information — rule-based anomaly flags at note, warn, and alert severity for frequency hoppers, intermittent emitters, abnormally wide or narrow carriers, noise-like spectra, and the encrypted or obfuscated findings the entropy triage produced.
-
Crypto Lab, Part 8: Analog Voice Descrambling — Inversion, Split-Band, Rolling Code
Crypto Lab's descramble tool undoes analog voice privacy — frequency inversion, split-band inversion, and rolling-code hopping — operating on raw 16-bit PCM audio, and shows why analog scrambling is fundamentally weaker than digital encryption.
-
Signal Lab, Part 7: VSA — Lab-Grade Modulation Quality
Signal Lab's vector signal analyzer measures modulation quality like bench gear — carrier-frequency error, RMS and peak EVM split into magnitude and phase error, I/Q gain imbalance and quadrature skew, origin offset, an EVM-vs-symbol trace, and an error-vector spectrum.
-
RF Scope, Part 7: Entropy & Encryption Triage — The Crypto Lab Bridge
rfscope's entropy analyzer triages unidentified digital emitters — blind-demodulating a representative payload, running the cryptolab randomness battery and classify-auto measurements, and returning a verdict from plaintext to strong-encrypted with a recommended cryptolab command, plus a -frames-out file that hands the bytes to Crypto Lab.
-
Crypto Lab, Part 7: CRC Recovery & the Recipe Pipeline
Crypto Lab's crc recover reconstructs a protocol's CRC parameters — width, polynomial, init, reflection, and xorout — from sample frames, while recipe run chains transform and analysis operations into a CyberChef-style reusable pipeline for de-obfuscating RF payloads.
-
Signal Lab, Part 6: Synthesize — Building Ideal & Impaired References
Signal Lab's synthesis engine generates an idealized IQ capture and then injects controlled impairments — SNR, carrier offset and drift, multipath, DC, and I/Q imbalance — so you can build a clean reference or a known-bad regression fixture and overlay them in the Compare tab.
-
RF Scope, Part 6: Topology — Emitters, Frequency Hoppers & Conversations
rfscope's topology analyzer is the RF analog of Wireshark's Conversations and Endpoints — it clusters bursts into emitters by RF fingerprint, collapses a frequency hopper's scattered bursts into one logical source, links emitters into conversations, and defers to hunt's authoritative map when a trunking control channel decodes.
-
Crypto Lab, Part 6: The assess Battery — Attacking P25/DMR/TETRA
Crypto Lab's assess crypto harness runs every applicable attack against captured P25, DMR, and TETRA frames and grades each — cipher-strength, a published-weakness knowledge base, IV reuse, known-plaintext, weak/default keys against the real ciphers, and reduced-keyspace brute — landing on a RESISTANT, PARTIAL, or BROKEN verdict.
-
Signal Lab, Part 5: PSD, Spectrogram & Spectral Occupancy
Signal Lab's frequency-domain views — the power spectral density, the spectrogram/waterfall, and the spectral-occupancy metrics computed off the PSD: 99% occupied bandwidth, channel power, adjacent-channel power ratio (ACPR), and spectral flatness.
-
RF Scope, Part 5: Timing & Periodicity — Recovering the TDMA Frame
rfscope's timing analyzer builds burst-length and inter-arrival histograms per channel and recovers a TDMA or frame period by autocorrelating each channel's occupancy series, keeping only peaks above a minimum confidence — the time-domain counterpart to cryptolab's byte-period detection.
-
Crypto Lab, Part 5: Keystream Reuse — Many-Time-Pad & Crib-Dragging
Crypto Lab's ks tool exploits keystream reuse — the core real-world break against additive stream ciphers like P25 DES-OFB, ADP/RC4, and TETRA AIE — detecting IV/MI collisions with ks reuse and recovering plaintext with ks mtp via known-plaintext or crib-dragging, no key recovery required.
-
Signal Lab, Part 4: Constellations & Eye Diagrams — Seeing Modulation Quality
Signal Lab's constellation, eye diagram, and symbol scope — how to read clean versus noisy C4FM (four rails) and CQPSK modulation, what opening and closing eyes mean, and how these plots make EVM and SNR visible.
-
RF Scope, Part 4: The I/O Graph — Per-Channel Activity Over Time
rfscope's timeline analyzer is the RF analog of Wireshark's I/O Graphs — it groups bursts by frequency into channels and fills each with a 100-bin occupancy and power series plus duty cycle, occupancy percentage, burst rate, dominant class, and the sparkline the cockpit renders.
-
Crypto Lab, Part 4: Classical Ciphers — Brute XOR, Caesar, Vigenère, Substitution
Crypto Lab's brute tool recovers classical ciphers — repeating XOR, Caesar shift, Vigenère, and monoalphabetic substitution — using an embedded English trigram language model and optional cribs, with lfsr recovering the keystream of a linear scrambler.
-
Signal Lab, Part 3: The Browser Console — siglab serve and Live Decode
Signal Lab's browser console, gophertrunk siglab serve — a fully offline web app at 127.0.0.1:8099 with Captures, Synthesize, Identify, Wideband, and Compare tabs, upload-configure-run workflow, and a live SSE decode event stream.
-
RF Scope, Part 3: Protocol Hierarchy — What's on the Air
rfscope's hierarchy analyzer is the RF analog of Wireshark's Protocol Hierarchy — it groups bursts by modulation class, then occupied-bandwidth bucket, then names the protocol of the longest digital burst with siglab, attaching burst counts, airtime, spectrum share, and symbol volume to every node.
-
Crypto Lab, Part 3: Randomness — NIST SP 800-22 & the LFSR Signature
Crypto Lab's randomness battery runs a NIST SP 800-22 subset over a keystream bitstream — monobit, block frequency, runs, longest run, binary-matrix rank, spectral DFT, approximate entropy, serial, cumulative sums, and linear complexity — to tell strong keyed encryption from an exploitable LFSR scrambler.
-
Signal Lab, Part 2: Reading the Dashboard — Symbols, Baud, Lock & the 2% Rule
Signal Lab's terminal dashboard, field by field — protocol, symbols, effective baud versus expected, lock status and latency, symbol histogram, IQ imbalance, decode-error rate, EVM, and SNR — plus the ~2% baud-deviation rule that catches a wrong sample rate.
-
RF Scope, Part 2: From IQ to Bursts — The Segmentation Pre-Pass
rfscope's segmentation pre-pass turns a wideband IQ span into bursts — discovering carriers with a wideband FFT, estimating a robust noise floor, downconverting each carrier to a narrow baseband, and slicing onset→offset bursts with per-burst spectral metrics and a blind modulation class.
-
Crypto Lab, Part 2: First Triage — classify auto and stats scan
Crypto Lab's classify auto emits a ranked verdict for an unknown RF payload — plaintext, substitution, repeating-XOR, periodic scrambler, LFSR, or strong-encrypted — each with the exact next command, backed by the stats scan and stats period statistical triage.
-
Signal Lab, Part 1: Your First Capture — No Radio Required
Signal Lab is GopherTrunk's offline signal-analysis workbench — replay, identify, synthesize, and grade recorded IQ captures through the exact production decode pipeline with no SDR, no daemon, and no network attached.
-
RF Scope, Part 1: Wireshark for the RF Physical Layer
rfscope is GopherTrunk's protocol-agnostic RF network analyzer — point it at any band, recorded IQ or a live SDR, with no prior knowledge of the technology, modulation, framing, or encryption, and get a structured Scene of what is on the air and how it behaves.
-
Crypto Lab, Part 1: Breaking It Is the Test
Crypto Lab is GopherTrunk's byte-oriented cryptographic-research toolkit for security-testing RF encryption — shipped inside the binary but excluded from the default install behind a build tag, it attempts decryption by every applicable method and grades how far each one got.
-
Build in the Open, Part 14: The CLI Workflow & Claude Code as Your Daily Driver
Tie the whole idea-to-release journey into one repeatable loop using the gh CLI and Claude Code — CLAUDE.md, slash commands, hooks, MCP servers, and web sessions.
-
Build in the Open, Part 13: Advanced Git & GitHub Features
Level up beyond commit and push — interactive rebase, cherry-pick, bisect, reflog, worktrees, conflict resolution, plus Discussions, Codespaces, GHCR, and Environments.
-
Build in the Open, Part 12: Optimizing & Securing Your Repository
How to make your GitHub repo discoverable and safe — About box, badges, branch protection, secret scanning, Dependabot, SECURITY.md, and least-privilege tokens.
-
Build in the Open, Part 11: Releases — Cadence, Pre-Release vs. Release, SemVer & Changelogs
How to ship software releases the right way — Semantic Versioning, pre-releases, git tags, Keep a Changelog notes, and automated, checksummed builds.
-
Build in the Open, Part 10: Websites, Support Pages & GitHub Pages
How to give a project a free website — enabling GitHub Pages, a Jekyll static site, a custom domain via CNAME, support and sponsor pages, and a drip-released blog.
-
Build in the Open, Part 9: Documentation Done Right — What Lives Where
How to organize project documentation — README, CONTRIBUTING, SECURITY, CHANGELOG, in-repo docs — using the Diátaxis framework so docs are findable and don't rot.
-
Build in the Open, Part 8: Testing — How to Build and Write Tests
How to test software well — the testing pyramid, table-driven tests, golden files, race detection, coverage limits, and writing tests with Claude Code.
-
Build in the Open, Part 7: GitHub Actions — Which Workflows to Create and Why
Which GitHub Actions workflows most projects need — CI, security scanning, release automation, docs build, scheduled jobs — and how to gate merges with them.
-
Build in the Open, Part 6: Planning & Tracking Work — and Inviting Contributors
How to plan work with GitHub Issues, labels, milestones, and Projects, link issues to PRs, and onboard contributors with CONTRIBUTING, templates, and roles.
-
Build in the Open, Part 5: Branching & the Three Ways to Merge to Main
How to use Git branches and pick the right GitHub merge strategy — merge commit, squash & merge, or rebase & merge — with a clear "use this when" for each.
-
Build in the Open, Part 4: Git & GitHub Fundamentals (Using the Web Interface)
A beginner's Git mental model — commits, branches, remotes, the staging area — and how to create a repo, edit files, and open your first pull request entirely in the GitHub web UI.
-
Build in the Open, Part 3: Brainstorming Features with Claude & Writing the README as Your Roadmap
How to research a domain and brainstorm features with Claude Code, then write a README that doubles as a living roadmap — plus what CLAUDE.md is for.
-
Build in the Open, Part 2: Choosing Your Language, Platforms & Tech Stack
How to choose a programming language and tech stack — let your constraints (platforms, performance, distribution, team skills) decide, with GopherTrunk as a worked example.
-
Build in the Open, Part 1: Picking What to Build — How Pros Decide
How experienced developers choose what software to build — validating demand, scoping a first version, and avoiding the build-trap, with GopherTrunk as a worked example.
Subscribe via RSS.