# GopherTrunk > GopherTrunk is a pure-Go software-defined-radio (SDR) scanner engine that follows > and decodes digital trunked-radio voice calls (P25, DMR, TETRA, NXDN, Motorola, > EDACS, LTR, MPT 1327, dPMR, D-STAR, YSF) from RTL-SDR, HackRF, and Airspy hardware. > The site also hosts a free, structured learning path that teaches radio and SDR > fundamentals from beginner to expert. ## Learn Free, structured curricula taking a complete newcomer to a confident practitioner. Browse: https://gophertrunk.org/learn/ ### Learning paths (optional guides) Each Learning Path recommends an ordered set of modules toward competence in a broad domain. Guidance only — no module is required. - [RF Software Development](https://gophertrunk.org/learn/paths/rf-software-dev/): Write the software that turns raw radio into decoded data — the GopherTrunk skill set. - [RF Hardware](https://gophertrunk.org/learn/paths/rf-hardware/): Understand the radios, antennas, and front-ends that put signals in front of your software. - [Software Engineering Foundations](https://gophertrunk.org/learn/paths/software-engineering/): Become a well-rounded developer, from first program to shipping and licensing. - [AI Software Development](https://gophertrunk.org/learn/paths/ai-development/): Build software with — and powered by — modern AI. - [Cybersecurity](https://gophertrunk.org/learn/paths/security/): Understand systems well enough to defend them. - [Digital Trunking & Scanning](https://gophertrunk.org/learn/paths/trunked-radio/): Go from first radio wave to following live trunked voice systems. ## Learn RF & SDR (learning module) A guided path from complete newcomer to confident GopherTrunk operator. Start with what a radio wave actually is, learn how software-defined radios turn the airwaves into numbers, then follow the signal all the way to decoded digital voice — and put it to work in GopherTrunk. Start: https://gophertrunk.org/learn/rf-sdr/ ### Unit 1 — RF Fundamentals The physics every operator leans on: waves, frequency, power, antennas, and how signals travel. - [What is a radio wave?](https://gophertrunk.org/learn/rf-sdr/radio-waves/): Frequency, wavelength, amplitude, and the electromagnetic spectrum — the one idea everything else builds on. - [Frequency, bands & the spectrum](https://gophertrunk.org/learn/rf-sdr/frequency-and-spectrum/): Hz to GHz, the HF/VHF/UHF bands, and how spectrum is carved up into band plans. - [Decibels & signal power](https://gophertrunk.org/learn/rf-sdr/decibels/): dB, dBm, and dBFS demystified — gain, path loss, the noise floor, and why radio lives in logarithms. - [Noise, SNR & sensitivity](https://gophertrunk.org/learn/rf-sdr/noise-and-snr/): The noise floor, signal-to-noise ratio, and receiver sensitivity — why SNR, not raw signal strength, decides whether a signal decodes. - [Antennas 101](https://gophertrunk.org/learn/rf-sdr/antennas/): Resonance, polarization, gain, SWR, and the connectors that join your antenna to your SDR. - [How signals travel](https://gophertrunk.org/learn/rf-sdr/propagation/): Line of sight, multipath, fading, and why where you put the antenna matters more than the radio. ### Unit 2 — Signals & Modulation How information rides on a carrier — from analog AM/FM to the digital constellations GopherTrunk decodes. - [Anatomy of a signal](https://gophertrunk.org/learn/rf-sdr/signal-anatomy/): Carrier, bandwidth, and the difference between a spectrum view and a waterfall. - [Analog modulation — AM, FM, SSB](https://gophertrunk.org/learn/rf-sdr/analog-modulation/): The three classic ways to put a voice on a carrier, and where you still hear them today. - [Digital modulation & constellations](https://gophertrunk.org/learn/rf-sdr/digital-modulation/): FSK, PSK, QAM, and C4FM — how bits become symbols, and how to read a constellation and eye diagram. - [Symbols, baud & bitrate](https://gophertrunk.org/learn/rf-sdr/symbols-and-baud/): Why a 4800-baud C4FM signal carries 9600 bits per second, and what that means for capture. ### Unit 3 — Software-Defined Radio What an SDR actually is, how it samples the air into IQ data, and how to set it up without overloading it. - [What is software-defined radio?](https://gophertrunk.org/learn/rf-sdr/what-is-sdr/): The core idea — move the radio into software — and why one cheap dongle can decode dozens of systems. - [How an SDR receiver works](https://gophertrunk.org/learn/rf-sdr/sdr-receiver/): Antenna to tuner to ADC — the signal chain that turns radio waves into a stream of samples. - [IQ data & complex signals](https://gophertrunk.org/learn/rf-sdr/iq-data/): Why SDRs output pairs of numbers, what "I" and "Q" mean, and how they capture both amplitude and phase. - [Sample rate, bandwidth & Nyquist](https://gophertrunk.org/learn/rf-sdr/sample-rate-nyquist/): How much spectrum you can see at once, the Nyquist limit, and the bandwidth/CPU trade-off. - [Gain, AGC & avoiding overload](https://gophertrunk.org/learn/rf-sdr/gain-and-agc/): Set gain too low and you lose weak signals; too high and you drown in distortion. Finding the sweet spot. - [Front-end filters, LNAs & overload](https://gophertrunk.org/learn/rf-sdr/front-end-and-overload/): Preselector filters, low-noise amplifiers, and how out-of-band signals overload the front end — the intermod and reciprocal-mixing traps behind a noisy decode. - [SDR hardware — RTL-SDR, HackRF, Airspy](https://gophertrunk.org/learn/rf-sdr/sdr-hardware/): Picking a dongle for the job and how each one maps to GopherTrunk's supported hardware. ### Unit 4 — DSP Essentials The digital signal processing that lives between IQ samples and decoded bits — explained without the heavy math. - [The FFT & reading a waterfall](https://gophertrunk.org/learn/rf-sdr/fft-and-waterfall/): How the Fourier transform turns samples into a spectrum, and how to read GopherTrunk's waterfall. - [Filtering & decimation](https://gophertrunk.org/learn/rf-sdr/filtering-decimation/): Zooming in on one channel, throwing away the rest, and keeping the CPU happy. - [The demodulation pipeline](https://gophertrunk.org/learn/rf-sdr/demodulation-pipeline/): The stages every signal passes through: tune, filter, demodulate, recover symbols, decode. - [Clock recovery & symbol timing](https://gophertrunk.org/learn/rf-sdr/clock-recovery/): How a receiver finds the beat of a digital signal so it samples each symbol at the right instant. ### Unit 5 — Digital Voice & Trunked Radio From vocoded voice to control channels — the systems GopherTrunk was built to follow. - [Analog vs. digital voice](https://gophertrunk.org/learn/rf-sdr/digital-voice/): Why public-safety radio went digital, and what a vocoder gives up to fit a voice in a few kbps. - [Vocoders — IMBE & AMBE+2](https://gophertrunk.org/learn/rf-sdr/vocoders/): The speech codecs behind P25 and DMR, and how GopherTrunk turns their frames back into audio. - [What is trunked radio?](https://gophertrunk.org/learn/rf-sdr/what-is-trunking/): Control channels, voice channels, and affiliation — how a fleet shares a handful of frequencies. - [The digital protocol landscape](https://gophertrunk.org/learn/rf-sdr/protocol-landscape/): P25, DMR, NXDN, TETRA, Motorola, EDACS, and friends — who uses what, and how to tell them apart. - [Encryption & what you can decode](https://gophertrunk.org/learn/rf-sdr/encryption/): Why some talkgroups are silent, what GopherTrunk can and can't do, and how to spot encryption. - [Other signals you'll meet](https://gophertrunk.org/learn/rf-sdr/other-signals/): Paging, AIS, ADS-B, and APRS — the non-trunked signals GopherTrunk can also decode. ### Unit 6 — Putting It Together with GopherTrunk Everything you've learned, applied: from a bare antenna to decoded calls, and how to fix it when it won't lock. - [From antenna to audio](https://gophertrunk.org/learn/rf-sdr/antenna-to-audio/): The complete GopherTrunk signal path, tracing one call from RF in the air to a WAV on disk. - [Finding & identifying systems](https://gophertrunk.org/learn/rf-sdr/finding-systems/): Using Hunt and online databases to discover what's on the air near you and add it to GopherTrunk. - [Tuning for a clean lock](https://gophertrunk.org/learn/rf-sdr/tuning-with-scopes/): Reading the constellation, eye diagram, and symbol scope to dial in a marginal signal. - [Calibration & troubleshooting](https://gophertrunk.org/learn/rf-sdr/calibration-troubleshooting/): PPM and voice calibration, plus a checklist for the usual reasons a control channel won't decode. - [Legal & ethical monitoring](https://gophertrunk.org/learn/rf-sdr/legal-ethical/): Knowing what's legal to receive where you live, and the etiquette of the scanner hobby. ### Glossary - [Glossary of RF & SDR terms](https://gophertrunk.org/learn/rf-sdr/glossary/): Plain-language definitions for every term in the learning path, cross-linked to the lessons. ## Learn Git & GitHub (learning module) A guided path from your very first commit to the advanced Git and GitHub workflows professional teams use. Start with what version control actually is, build a rock-solid mental model of how Git stores your work, then learn branching, collaboration on GitHub, and the power tools — rebase, bisect, Actions — that separate confident users from the rest. Start: https://gophertrunk.org/learn/git/ ### Unit 1 — Version Control Foundations Why version control exists, how Git thinks, and the core loop — edit, stage, commit — you'll use every day. - [Why version control?](https://gophertrunk.org/learn/git/what-is-version-control/): What a version control system is, the problems it solves, and why Git won — the one idea everything else builds on. - [Installing & configuring Git](https://gophertrunk.org/learn/git/installing-git/): Getting Git on Linux, macOS, and Windows, then setting your name, email, editor, and a few sane defaults. - [How Git thinks: snapshots, not diffs](https://gophertrunk.org/learn/git/git-mental-model/): Commits, trees, blobs, and the SHA — the object model that makes Git fast, safe, and a little magic. - [Your first repository](https://gophertrunk.org/learn/git/first-repository/): init vs. clone, the working tree, and what actually lives inside the .git directory. - [The staging area & commits](https://gophertrunk.org/learn/git/staging-and-commits/): add, the index, and commit — how to compose a clean, deliberate snapshot instead of dumping everything. ### Unit 2 — Everyday Git The handful of commands you'll run dozens of times a day — reading state, history, and safely undoing mistakes. - [Reading status & diffs](https://gophertrunk.org/learn/git/status-and-diffs/): status, diff, and diff --staged — knowing exactly what has changed and what's about to be committed. - [Viewing history with log & show](https://gophertrunk.org/learn/git/viewing-history/): log, show, and blame — navigating the past, formatting output, and finding who changed what and why. - [.gitignore & tracking the right files](https://gophertrunk.org/learn/git/gitignore/): Keeping secrets, build artifacts, and noise out of your repo — patterns, precedence, and global ignores. - [Undoing changes: restore, reset & revert](https://gophertrunk.org/learn/git/undoing-changes/): The three ways to go back — and how to tell which one you need without losing work or rewriting shared history. ### Unit 3 — Branching & Merging Git's superpower — cheap branches — and how to bring lines of work back together cleanly. - [Branches explained](https://gophertrunk.org/learn/git/branches/): What a branch really is (a movable pointer), creating and switching them, and HEAD demystified. - [Merging & fast-forwards](https://gophertrunk.org/learn/git/merging/): Fast-forward vs. three-way merges, merge commits, and when each one happens. - [Resolving merge conflicts](https://gophertrunk.org/learn/git/merge-conflicts/): Why conflicts happen, how to read the markers, and a calm, repeatable process for resolving them. - [Rebasing & a linear history](https://gophertrunk.org/learn/git/rebasing/): Replaying commits onto a new base for a clean history — and the golden rule of never rebasing shared work. - [Stashing work in progress](https://gophertrunk.org/learn/git/stashing/): Parking uncommitted changes to switch context fast, then bringing them back without losing anything. ### Unit 4 — Remotes & GitHub Taking Git online — pushing to GitHub, authenticating securely, and the fork-and-pull-request workflow. - [What is GitHub?](https://gophertrunk.org/learn/git/what-is-github/): GitHub vs. Git, what a remote-hosting platform adds, and the alternatives (GitLab, Bitbucket, Codeberg). - [Remotes: clone, fetch, pull & push](https://gophertrunk.org/learn/git/remotes/): origin, tracking branches, and the difference between fetch, pull, and push — the sync model in full. - [Authentication: SSH keys & tokens](https://gophertrunk.org/learn/git/authentication/): Why HTTPS passwords are gone — setting up SSH keys or a personal access token so pushes just work. - [Forking & the fork workflow](https://gophertrunk.org/learn/git/forking/): Forks vs. clones, keeping a fork in sync with upstream, and how open-source contribution actually flows. - [Pull requests & code review](https://gophertrunk.org/learn/git/pull-requests/): Opening a PR, writing a good description, requesting review, and turning feedback into merged code. ### Unit 5 — Collaboration & GitHub Features The platform features that turn a code host into a place teams plan, automate, ship, and protect their work. - [Issues, labels & Projects](https://gophertrunk.org/learn/git/issues-and-projects/): Tracking work with issues, organizing it with labels and milestones, and planning on Projects boards. - [CI/CD with GitHub Actions](https://gophertrunk.org/learn/git/github-actions/): Workflows, jobs, and steps — automating tests, builds, and deploys that run on every push and PR. - [Tags, releases & semantic versioning](https://gophertrunk.org/learn/git/releases-and-tags/): Marking versions with tags, publishing Releases with notes and binaries, and what SemVer numbers mean. - [Pages, Gists, Discussions & wikis](https://gophertrunk.org/learn/git/github-pages-and-more/): The extras worth knowing — free static hosting, shareable snippets, community Q&A, and project wikis. - [Branch protection, reviews & CODEOWNERS](https://gophertrunk.org/learn/git/branch-protection/): Required reviews, status checks, and CODEOWNERS — the guardrails that keep a shared main branch healthy. - [The GitHub CLI, Git LFS & repo security](https://gophertrunk.org/learn/git/cli-lfs-and-security/): Three power features worth knowing — the gh command-line tool, Git LFS for large files, and GitHub's security features (Dependabot, secret scanning, advisories). ### Unit 6 — Advanced Git & Best Practices The power tools and habits that mark a confident operator — history surgery, debugging, and clean workflows. - [Rewriting history with interactive rebase](https://gophertrunk.org/learn/git/interactive-rebase/): Squash, reword, reorder, and drop commits to craft a tidy history before you share it. - [Cherry-pick, bisect & the reflog](https://gophertrunk.org/learn/git/cherry-pick-bisect-reflog/): Grab a single commit, binary-search for the commit that broke things, and recover work you thought was lost. - [Submodules, hooks & worktrees](https://gophertrunk.org/learn/git/submodules-hooks-worktrees/): Nesting repos, automating checks with hooks, and checking out multiple branches at once — the lesser-known tools. - [Branching strategies: trunk, GitHub Flow & Git Flow](https://gophertrunk.org/learn/git/workflow-strategies/): How teams organize branches — and how to pick the model that fits your team's size and release cadence. - [Commit hygiene & best practices](https://gophertrunk.org/learn/git/best-practices/): Atomic commits, good messages, small PRs, and the habits that make a repo a pleasure to work in. ### Glossary - [Glossary of Git & GitHub terms](https://gophertrunk.org/learn/git/glossary/): Plain-language definitions for every Git and GitHub term in the learning path, cross-linked to the lessons. ## Learn Linux & the Command Line (learning module) Sooner or later every developer meets a black window with a blinking cursor: a server to configure, a Raspberry Pi to set up, a build to run, a tool with no buttons. This path makes that window feel like home. Start with what Linux even is and why the command line is worth learning, then build up one small, safe command at a time — moving around the filesystem, managing files, permissions, and processes, and installing software. From there you'll learn the real superpower of the shell — pipes and text tools that snap together into custom commands — write your first scripts to automate the boring parts, and finish able to run and maintain your own services over SSH, including GopherTrunk itself on a Linux box or an SBC. No prior command-line experience required; examples use Linux (with notes for macOS and Windows/WSL). Start: https://gophertrunk.org/learn/linux-cli/ ### Unit 1 — Getting Started with Linux & the Shell What Linux is, why the command line is worth your time, and how to open a shell and run your very first commands without fear. - [What is Linux?](https://gophertrunk.org/learn/linux-cli/what-is-linux/): The kernel, the distributions, and why Linux quietly runs the servers, phones, and single-board computers the world depends on. - [Why the command line?](https://gophertrunk.org/learn/linux-cli/why-the-command-line/): What a terminal gives you that a mouse can't — speed, precision, remote control, and automation — and why it's still essential. - [The shell explained](https://gophertrunk.org/learn/linux-cli/the-shell/): What the shell actually is, the prompt, and the command-arguments-options pattern behind everything you'll type. - [Getting a shell](https://gophertrunk.org/learn/linux-cli/getting-a-shell/): Opening a terminal on Linux, macOS, and Windows (WSL), plus reaching one on a server or a Raspberry Pi. - [Your first commands](https://gophertrunk.org/learn/linux-cli/first-commands/): pwd, ls, cd, and echo — moving around and looking about — plus how to ask any command for help. ### Unit 2 — Files & the Filesystem Everything on Linux is a file in one big tree. Learn to navigate it, and to create, view, edit, and find files with confidence. - [The filesystem hierarchy](https://gophertrunk.org/learn/linux-cli/filesystem-layout/): One tree from /, the folders that matter (/home, /etc, /var), and absolute vs. relative paths. - [Navigating & listing files](https://gophertrunk.org/learn/linux-cli/navigating-and-listing/): Moving around with cd, reading ls in detail, hidden files, and seeing the shape of a directory tree. - [Creating, copying & moving files](https://gophertrunk.org/learn/linux-cli/working-with-files/): mkdir, touch, cp, mv, and rm — building and rearranging files and folders, and why rm has no undo. - [Viewing & editing files](https://gophertrunk.org/learn/linux-cli/viewing-and-editing/): cat, less, head, and tail for reading, plus a gentle first look at editing in nano and vim. - [Finding files & text](https://gophertrunk.org/learn/linux-cli/finding-things/): Locating files with find, searching inside them with grep, and finding a command with which and locate. ### Unit 3 — Permissions, Users & Processes Who can do what, and what's running right now: the multi-user model, file permissions, root, and managing live processes. - [Users, groups & root](https://gophertrunk.org/learn/linux-cli/users-and-groups/): Linux as a multi-user system — accounts, groups, and the all-powerful root user you should mostly avoid being. - [File permissions](https://gophertrunk.org/learn/linux-cli/permissions/): Read, write, execute for user, group, and other — reading ls -l, and changing access with chmod and chown. - [sudo & becoming root safely](https://gophertrunk.org/learn/linux-cli/sudo-and-root/): Why you don't log in as root — using sudo to borrow admin power for one command, and the habits that keep you safe. - [Processes & jobs](https://gophertrunk.org/learn/linux-cli/processes/): What a process is, watching them with ps and top, foreground vs. background jobs, and stopping one with signals. - [Installing software with a package manager](https://gophertrunk.org/learn/linux-cli/package-management/): apt, dnf, and pacman — how Linux installs, updates, and removes software from trusted repositories instead of downloads. ### Unit 4 — The Power of the Command Line The real superpower: small tools that snap together. Pipes, redirection, text processing, wildcards, and the environment. - [Pipes & redirection](https://gophertrunk.org/learn/linux-cli/pipes-and-redirection/): stdin, stdout, and stderr — sending one command's output into another with |, and to and from files with > and <. - [Text-processing tools](https://gophertrunk.org/learn/linux-cli/text-tools/): grep, sort, uniq, wc, cut, and a taste of sed and awk — the toolkit that turns raw text into answers. - [Wildcards, globbing & expansion](https://gophertrunk.org/learn/linux-cli/wildcards-and-expansion/): How the shell expands *, ?, and {…} before a command runs, and why quoting sometimes matters. - [Environment variables & PATH](https://gophertrunk.org/learn/linux-cli/environment-variables/): What environment variables are, why PATH decides which programs you can run, and how to set them for a session or for good. - [History, tab completion & shortcuts](https://gophertrunk.org/learn/linux-cli/history-and-shortcuts/): Command history, reverse-search, tab completion, and the keyboard shortcuts that make the shell fast. ### Unit 5 — Scripting & Automation Turn a sequence of commands into a reusable program: your first scripts, variables and input, control flow, and scheduling. - [Your first shell script](https://gophertrunk.org/learn/linux-cli/first-shell-script/): The shebang line, making a file executable, and running a saved sequence of commands as a program. - [Variables, arguments & input](https://gophertrunk.org/learn/linux-cli/variables-and-input/): Storing values, reading script arguments, and taking input — the pieces that make a script flexible. - [Conditionals & loops](https://gophertrunk.org/learn/linux-cli/conditionals-and-loops/): if, for, and while with the test command — making a script decide and repeat instead of running blindly. - [Functions, exit codes & error handling](https://gophertrunk.org/learn/linux-cli/functions-and-exit-codes/): Reusable functions, the exit codes every command returns, and writing scripts that fail loudly instead of silently. - [Scheduling with cron & timers](https://gophertrunk.org/learn/linux-cli/scheduling-with-cron/): Running a job every night or every minute — cron syntax, systemd timers, and where scheduled output goes. ### Unit 6 — Living on Linux: Servers, SBCs & GopherTrunk Everything applied: reach a machine over SSH, run software as a managed service, watch its health, and put GopherTrunk on a Linux box. - [SSH & working remotely](https://gophertrunk.org/learn/linux-cli/ssh-and-remote/): Logging into another machine over the network with SSH, key-based login, and copying files with scp. - [Services & systemd](https://gophertrunk.org/learn/linux-cli/services-and-systemd/): How Linux runs background services — systemctl to start and enable them, and journalctl to read their logs. - [Monitoring, disk & logs](https://gophertrunk.org/learn/linux-cli/monitoring-and-logs/): Checking disk with df and du, memory and load with free and htop, and finding out what went wrong in the logs. - [Running GopherTrunk on Linux](https://gophertrunk.org/learn/linux-cli/running-gophertrunk-on-linux/): Putting it all together — installing GopherTrunk, running it, and keeping it alive as a service on a Linux box or a Raspberry Pi. ### Glossary - [Glossary of Linux & command-line terms](https://gophertrunk.org/learn/linux-cli/glossary/): Plain-language definitions for every term in the path — shell, kernel, path, permission, process, pipe, PATH, script, cron, SSH, systemd, and more — cross-linked to the lessons. ## Learn Networking & the Internet (learning module) Every program that talks to another machine — a browser, an app, a server, a scanner streaming audio across the house — leans on the same handful of networking ideas. This path demystifies them. Start with what a network even is and follow one web request end to end, then learn the addressing that makes it work — IP, DNS, and ports — and the protocols that carry it — TCP, UDP, HTTP, and TLS. From there you'll cover the pieces that connect and protect real systems (firewalls, NAT, VPNs, proxies), pick up the command-line tools to inspect and debug a connection, and finish able to put your own service on the network safely, including reaching GopherTrunk across your home network or the internet. No prior networking knowledge required; the Linux & the Command Line path pairs well for the hands-on parts. Start: https://gophertrunk.org/learn/networking/ ### Unit 1 — How Networks & the Internet Work The big picture: what a network is, how data is chopped into packets and routed, the layered model behind it, and one web request traced end to end. - [What is a network?](https://gophertrunk.org/learn/networking/what-is-a-network/): Nodes, links, and the leap from a home LAN to the internet — a network of networks — the one idea everything else builds on. - [Packets & switching](https://gophertrunk.org/learn/networking/packets-and-switching/): Why data is chopped into packets, how switches and routers pass them along, and what "best-effort" delivery really means. - [Protocols & layers](https://gophertrunk.org/learn/networking/protocols-and-layers/): The layered model — link, internet, transport, application — and why splitting networking into layers makes the whole thing work. - [Clients, servers & peers](https://gophertrunk.org/learn/networking/clients-and-servers/): The request-response model most of the internet runs on, and the peer-to-peer alternative — who asks and who answers. - [How a web request works, end to end](https://gophertrunk.org/learn/networking/how-a-web-request-works/): Type a URL and press Enter — DNS, TCP, TLS, HTTP, and back — the whole journey in one trace that the rest of the path unpacks. ### Unit 2 — Addressing: IP, DNS & Ports How machines find each other: IP addresses and subnets, the DNS name system, ports and sockets, and how home networks share one public address. - [IP addresses & subnets](https://gophertrunk.org/learn/networking/ip-addresses/): IPv4 and IPv6, public vs. private addresses, and what a subnet (and CIDR /24) actually means — gently. - [DNS — names to addresses](https://gophertrunk.org/learn/networking/dns/): How a name like example.com becomes an IP address — resolvers, records (A, AAAA, CNAME, MX, TXT), and caching. - [Ports & sockets](https://gophertrunk.org/learn/networking/ports-and-sockets/): How one machine runs many services at once — ports, well-known port numbers, and the socket that ties an address to a program. - [NAT & private networks](https://gophertrunk.org/learn/networking/nat-and-private-networks/): Why every device in your home shares one public IP — network address translation, private ranges, and what it hides. - [DHCP & joining a local network](https://gophertrunk.org/learn/networking/dhcp-and-local-networks/): How a device gets an address the moment it connects — DHCP, the default gateway, and what your router is doing. ### Unit 3 — The Transport & Web Protocols The protocols you'll actually build on: TCP vs. UDP, HTTP and its methods and status codes, TLS/HTTPS, web APIs, and real-time connections. - [TCP vs. UDP](https://gophertrunk.org/learn/networking/tcp-and-udp/): Reliable-and-ordered vs. fast-and-lossy — the handshake, what each is for, and why voice and video often pick UDP. - [HTTP — the web's protocol](https://gophertrunk.org/learn/networking/http/): Requests and responses, methods (GET/POST/…), status codes, and headers — the language nearly every API and site speaks. - [TLS & HTTPS](https://gophertrunk.org/learn/networking/tls-and-https/): How HTTPS encrypts traffic and proves a server is who it claims — certificates, the handshake, and why the padlock matters. - [Web APIs & REST](https://gophertrunk.org/learn/networking/web-apis-and-rest/): Programs talking over HTTP — REST, JSON, endpoints, and how an app, a server, and a browser exchange data. - [WebSockets & real-time connections](https://gophertrunk.org/learn/networking/websockets-and-realtime/): When request-response isn't enough — long-lived, two-way connections for live updates, streaming, and push. ### Unit 4 — Connecting & Securing Networks The infrastructure that connects and protects real systems: firewalls, port forwarding, VPNs, proxies and load balancers, and the security basics. - [Firewalls & controlling access](https://gophertrunk.org/learn/networking/firewalls/): Deciding what traffic is allowed — default-deny, open vs. closed ports, and where a firewall sits in the path. - [Port forwarding & dynamic DNS](https://gophertrunk.org/learn/networking/port-forwarding-and-dynamic-dns/): Reaching a service behind your home router from outside — port forwarding, dynamic DNS, and the risks of opening a door. - [VPNs & tunnels](https://gophertrunk.org/learn/networking/vpns/): What a VPN actually does — an encrypted tunnel — what it hides and what it doesn't, and when to reach for one. - [Proxies, reverse proxies & load balancers](https://gophertrunk.org/learn/networking/proxies-and-load-balancers/): The middlemen of the web — forward and reverse proxies, load balancers, and CDNs — and what each is for. - [Network security basics](https://gophertrunk.org/learn/networking/network-security-basics/): The everyday threats — interception, spoofing, and floods — and the defenses that counter them, from encryption to least exposure. ### Unit 5 — Networking from the Command Line The tools that turn 'it won't connect' into an answer: inspecting your own network, testing connectivity, making requests, tunneling, and capturing packets. - [Inspecting your network](https://gophertrunk.org/learn/networking/inspecting-your-network/): What's my address and what's listening — ip, ss, and friends for seeing your own machine's network state. - [Testing connectivity](https://gophertrunk.org/learn/networking/testing-connectivity/): A repeatable way to diagnose "it won't connect" — ping, traceroute, and dig, from the machine outward. - [Making requests with curl](https://gophertrunk.org/learn/networking/curl-and-http-tools/): curl and wget — sending HTTP requests, reading headers and status codes, and testing an API or a site from the shell. - [SSH tunnels & transfers](https://gophertrunk.org/learn/networking/ssh-tunnels-and-transfers/): Reaching a remote service securely — SSH port forwarding (local and remote tunnels) and copying files with scp and rsync. - [Packet capture basics](https://gophertrunk.org/learn/networking/packet-capture-basics/): Watching the actual traffic — tcpdump and Wireshark — to see what's really on the wire when something misbehaves. ### Unit 6 — Putting a Service on the Network Everything applied: run a server and understand what it's bound to, expose it safely, self-host on a home network, and reach GopherTrunk across the network. - [Running a server — binding & reachability](https://gophertrunk.org/learn/networking/running-a-server/): localhost vs. 0.0.0.0, binding to a port, and the difference between a service running and a service you can actually reach. - [Exposing a service safely](https://gophertrunk.org/learn/networking/exposing-a-service-safely/): Putting a service online without regret — a reverse proxy, TLS, a firewall, and authentication in front of it. - [Self-hosting on a home network](https://gophertrunk.org/learn/networking/self-hosting-at-home/): Running your own services on your own connection — the practical setup, the pitfalls, and when to keep it on the LAN. - [GopherTrunk on the network](https://gophertrunk.org/learn/networking/gophertrunk-on-the-network/): Putting it together — reaching GopherTrunk's web interface across your LAN or the internet, and streaming to other tools, securely. ### Glossary - [Glossary of networking terms](https://gophertrunk.org/learn/networking/glossary/): Plain-language definitions for every term in the path — packet, protocol, IP, subnet, DNS, port, NAT, TCP, UDP, HTTP, TLS, firewall, VPN, proxy, and more — cross-linked to the lessons. ## Learn Cybersecurity Fundamentals (learning module) Security isn't a bolt-on; it's a way of thinking about every system you build or run. This path teaches that mindset from the ground up, entirely from the defender's side. Start with the core goals — confidentiality, integrity, availability — and the vocabulary of threats, vulnerabilities, and risk, then build a working understanding of the cryptography that underpins modern security. From there you'll cover identity and access, the common attacks every developer should recognise (explained so you can defend against them, not carry them out), and the layered defenses that stop them — hardening systems, writing secure code, and protecting data. The path closes with security in practice, including personal safety online and the wireless-and-RF security world a scanner like GopherTrunk lives in, where the law and ethics matter as much as the technology. No security background required; the Linux and Networking paths pair well. Start: https://gophertrunk.org/learn/cybersecurity/ ### Unit 1 — Security Foundations The mindset and vocabulary of security: what it protects, the goals it aims for, how threats and risk are described, who attacks, and how a defender thinks. - [What is cybersecurity?](https://gophertrunk.org/learn/cybersecurity/what-is-cybersecurity/): What security actually protects, why every system needs it, and the defender's job — the one idea everything else builds on. - [The CIA triad](https://gophertrunk.org/learn/cybersecurity/cia-triad/): Confidentiality, integrity, and availability — the three goals that define what "secure" even means. - [Threats, vulnerabilities & risk](https://gophertrunk.org/learn/cybersecurity/threats-vulnerabilities-risk/): The words security people actually use — threat, vulnerability, exploit, risk, and attack surface — and how they fit together. - [Who attacks, and why](https://gophertrunk.org/learn/cybersecurity/threat-actors/): From opportunists and criminals to insiders and nation-states — the actors, their motives, and what that means for your defenses. - [The security mindset](https://gophertrunk.org/learn/cybersecurity/security-mindset/): Thinking like an attacker to defend like a pro — assume breach, least privilege, and defense in depth as habits, not slogans. ### Unit 2 — Cryptography Essentials The math-free version of the cryptography that underpins everything secure: encryption, keys, hashing, signatures, and where each shows up in real life. - [What is cryptography?](https://gophertrunk.org/learn/cybersecurity/what-is-cryptography/): Plaintext, ciphertext, and keys — what encryption does, what it doesn't, and why you never roll your own. - [Symmetric & public-key encryption](https://gophertrunk.org/learn/cybersecurity/symmetric-and-asymmetric/): One shared secret versus a public/private key pair — the two families of encryption and what each is good for. - [Hashing & integrity](https://gophertrunk.org/learn/cybersecurity/hashing-and-integrity/): One-way hashes, checksums, and how they detect tampering and store passwords safely — and why hashing isn't encryption. - [Digital signatures & certificates](https://gophertrunk.org/learn/cybersecurity/signatures-and-certificates/): Proving who sent something and that it wasn't changed — signatures, public-key infrastructure, and the certificates behind HTTPS. - [Cryptography in practice](https://gophertrunk.org/learn/cybersecurity/crypto-in-practice/): Where the theory shows up — TLS, SSH, disk and end-to-end encryption — and how the encryption on a radio system fits the same ideas. ### Unit 3 — Identity, Authentication & Access Proving who you are and controlling what you can do: authentication, passwords and MFA, authorization, managing secrets, and the human layer attackers love. - [Authentication basics](https://gophertrunk.org/learn/cybersecurity/authentication-basics/): The three factors — something you know, have, and are — and how a system decides you are who you claim to be. - [Passwords, MFA & passkeys](https://gophertrunk.org/learn/cybersecurity/passwords-and-mfa/): Why passwords fail, how they should be stored, and how multi-factor authentication and passkeys close the gap. - [Authorization & access control](https://gophertrunk.org/learn/cybersecurity/authorization-and-access/): The difference between who you are and what you're allowed to do — least privilege, roles, and access models. - [Managing secrets & keys](https://gophertrunk.org/learn/cybersecurity/secrets-management/): API keys, tokens, and passwords in software — keeping them out of code, rotating them, and using a secrets manager. - [Social engineering & the human layer](https://gophertrunk.org/learn/cybersecurity/social-engineering/): Phishing, pretexting, and why the easiest way past strong technology is often a person — and how to defend against it. ### Unit 4 — Attacks & Defenses The attacks every developer should recognise — explained so you can defend against them — and the layered defenses that stop them. - [Common attacks, in plain terms](https://gophertrunk.org/learn/cybersecurity/common-attacks/): A field guide to the attacks you'll hear about — malware, phishing, credential attacks, and denial of service — and what each targets. - [Web application attacks](https://gophertrunk.org/learn/cybersecurity/web-application-attacks/): How injection, cross-site scripting, and CSRF work at a high level, why they happen, and the coding habits that prevent them. - [Network attacks](https://gophertrunk.org/learn/cybersecurity/network-attacks/): Interception, spoofing, and floods — the network-layer attacks from the networking path, seen through a defender's eyes. - [Malware & endpoint security](https://gophertrunk.org/learn/cybersecurity/malware-and-endpoints/): Viruses, worms, ransomware, and trojans — how malware spreads, what it does, and how endpoints are defended. - [Defense in depth](https://gophertrunk.org/learn/cybersecurity/defense-in-depth/): Why no single control is enough — layering prevention, detection, and response so one failure isn't a breach. ### Unit 5 — Securing Systems & Software Applying the defenses: hardening a machine, writing secure code, protecting networks and services, watching for trouble, and safeguarding data. - [Hardening systems](https://gophertrunk.org/learn/cybersecurity/hardening-systems/): Shrinking the attack surface — least privilege, disabling what you don't need, patching, and the config that keeps a box safe. - [Secure coding](https://gophertrunk.org/learn/cybersecurity/secure-coding/): The handful of habits that stop most software vulnerabilities — validate input, avoid injection, handle errors, and watch dependencies. - [Securing networks & services](https://gophertrunk.org/learn/cybersecurity/securing-networks-and-services/): Putting network security to work — firewalls, encryption in transit, segmentation, and exposing a service without regret. - [Monitoring & incident response](https://gophertrunk.org/learn/cybersecurity/monitoring-and-incident-response/): You can't stop everything, so you plan to notice and recover — logging, detection, a basic incident-response flow, and backups. - [Privacy & data protection](https://gophertrunk.org/learn/cybersecurity/privacy-and-data-protection/): Security serves privacy — classifying data, minimizing what you collect, protecting personal information, and the rules around it. ### Unit 6 — Security in Practice Everything applied: a developer's security checklist, staying safe as an individual, the wireless-and-RF security world, and where to keep learning. - [Security for developers](https://gophertrunk.org/learn/cybersecurity/security-for-developers/): A practical, repeatable checklist for building security into what you ship — a secure development lifecycle without the jargon. - [Staying safe online](https://gophertrunk.org/learn/cybersecurity/staying-safe-online/): The personal security that actually matters — updates, a password manager, MFA, backups, and a healthy suspicion. - [Wireless & RF security](https://gophertrunk.org/learn/cybersecurity/rf-and-radio-security/): Security on the airwaves — Wi-Fi and radio encryption, jamming and replay, what monitoring can and can't reveal, and the law and ethics that govern it. - [Where to go next](https://gophertrunk.org/learn/cybersecurity/keep-learning-security/): Turning fundamentals into skill — CTFs, certifications, responsible disclosure, and how to keep up with a field that never sits still. ### Glossary - [Glossary of cybersecurity terms](https://gophertrunk.org/learn/cybersecurity/glossary/): Plain-language definitions for every term in the path — CIA triad, threat, vulnerability, encryption, hash, MFA, least privilege, phishing, injection, malware, and more — cross-linked to the lessons. ## Learn Intro to Software Dev (learning module) A guided path from "what even is software?" to shipping your own program. Start with the story of how computing got here — the hardware, the languages, and the people — then build a working model of how modern languages differ and what they're good (and bad) at. Learn the principles and patterns that separate code that lasts from code that rots, the systems teams use to ship, how to choose the right language for a job, and finally how to assemble your own solo development stack, workflow, and distribution strategy. Examples lean on real-time and radio software — the kind of streaming, signal-crunching code behind GopherTrunk. Start: https://gophertrunk.org/learn/intro-software-dev/ ### Unit 1 — A Brief History of Software Where software came from: the hardware, the first languages, the pioneers, and the cheap compute that put a radio receiver inside a program. - [What is software?](https://gophertrunk.org/learn/intro-software-dev/what-is-software/): Hardware vs. software, the stored-program idea, and what "code" really is — the one idea everything else builds on. - [From looms to microprocessors](https://gophertrunk.org/learn/intro-software-dev/computing-hardware-story/): The hardware story — Babbage and Lovelace, ENIAC, the transistor, and the microchip that put a computer on every desk. - [From machine code to high-level languages](https://gophertrunk.org/learn/intro-software-dev/birth-of-languages/): Why we stopped writing 1s and 0s — assembly, FORTRAN, COBOL, LISP, and C, and what each one made possible. - [The people who built programming](https://gophertrunk.org/learn/intro-software-dev/the-pioneers/): Lovelace, Turing, Hopper, Ritchie, Kay, and the engineers whose ideas you still use every day. - [PCs, the internet & the age of cheap compute](https://gophertrunk.org/learn/intro-software-dev/internet-to-edge/): From mainframes to the cloud and the edge — and how falling compute costs made software-defined radio possible. ### Unit 2 — Modern Programming Languages The families languages fall into, how they run, and the capabilities, trade-offs, and security properties that set them apart. - [Paradigms & language families](https://gophertrunk.org/learn/intro-software-dev/language-families/): Imperative, object-oriented, functional, and declarative — the big families and how a language can belong to several. - [Compiled, interpreted & JIT](https://gophertrunk.org/learn/intro-software-dev/compiled-vs-interpreted/): How source code becomes something a computer runs — and why the answer shapes speed, portability, and tooling. - [Type systems & safety](https://gophertrunk.org/learn/intro-software-dev/type-systems/): Static vs. dynamic, strong vs. weak — what types catch, what they cost, and why it matters for reliable code. - [Memory — manual, GC & ownership](https://gophertrunk.org/learn/intro-software-dev/memory-management/): Stacks, heaps, garbage collection, and Rust-style ownership — and why memory model is the deepest language difference. - [Concurrency & parallelism](https://gophertrunk.org/learn/intro-software-dev/concurrency-models/): Threads, async, goroutines, and actors — doing many things at once, the way streaming radio data demands. - [Language-level security](https://gophertrunk.org/learn/intro-software-dev/language-security/): Memory safety, undefined behaviour, and the software supply chain — how your language choice changes your attack surface. ### Unit 3 — Software Development Principles The timeless, language-agnostic ideas that make code readable, changeable, and robust instead of a tangle nobody dares touch. - [Writing readable code](https://gophertrunk.org/learn/intro-software-dev/clean-code/): Naming, small functions, and comments that earn their place — code is read far more often than it's written. - [DRY, KISS, YAGNI & separation of concerns](https://gophertrunk.org/learn/intro-software-dev/dry-kiss-yagni/): The four maxims that fight complexity — repeat yourself less, keep it simple, and don't build what you don't need yet. - [SOLID & object-oriented design](https://gophertrunk.org/learn/intro-software-dev/solid/): The five principles that keep object-oriented code flexible — explained with plain examples, not jargon. - [Abstraction, coupling & cohesion](https://gophertrunk.org/learn/intro-software-dev/abstraction-coupling/): Good fences make good modules — hiding detail behind interfaces so parts of a program can change independently. - [Errors, edge cases & defensive programming](https://gophertrunk.org/learn/intro-software-dev/robustness-and-errors/): Handling failure on purpose — because real-world inputs, like a noisy radio channel, never behave. - [Data structures & algorithms, briefly](https://gophertrunk.org/learn/intro-software-dev/data-structures-algorithms/): The handful of data structures every developer leans on, how to pick the right one, and what Big-O notation actually tells you about speed. ### Unit 4 — Software Design Patterns Named, reusable solutions to problems that come up again and again — including the streaming and plugin shapes signal software lives on. - [What is a design pattern?](https://gophertrunk.org/learn/intro-software-dev/what-are-patterns/): Where patterns came from, how to read one, and the anti-patterns that signal trouble. - [Creational patterns: factory, builder, singleton](https://gophertrunk.org/learn/intro-software-dev/creational-patterns/): Patterns for making objects — flexibly, step by step, or exactly once. - [Structural patterns: adapter, facade, decorator](https://gophertrunk.org/learn/intro-software-dev/structural-patterns/): Patterns for composing objects — wrapping, simplifying, and extending without rewriting. - [Behavioral patterns: observer, strategy, state](https://gophertrunk.org/learn/intro-software-dev/behavioral-patterns/): Patterns for how objects talk and decide — swapping algorithms and reacting to change. - [Concurrency & streaming patterns](https://gophertrunk.org/learn/intro-software-dev/concurrency-and-pipelines/): Pipelines, producer/consumer, and pub-sub — the patterns a real-time DSP chain is built from. - [Architecture patterns: layered, event-driven & plugins](https://gophertrunk.org/learn/intro-software-dev/architectural-patterns/): The big-picture shapes — including the plugin architecture that lets a scanner add a new decoder without a rewrite. ### Unit 5 — Development Systems & Strategies How software actually gets built and kept alive: life cycles, version control, testing, automation, and fighting technical debt. - [The software life cycle — Waterfall to Agile](https://gophertrunk.org/learn/intro-software-dev/sdlc-and-methodologies/): The stages every project moves through, and the methodologies — Waterfall, Agile, Scrum, Kanban — teams use to manage them. - [Version control & collaboration](https://gophertrunk.org/learn/intro-software-dev/version-control-collab/): Why every project lives in version control, how teams work together without stepping on each other, and where to go deeper. - [Testing — unit, integration & beyond](https://gophertrunk.org/learn/intro-software-dev/testing/): The kinds of tests, what each is for, and why signal-processing code needs them most of all. - [Build systems, CI/CD & automation](https://gophertrunk.org/learn/intro-software-dev/build-and-ci-cd/): Turning source into a shippable artifact automatically — and catching problems the moment they're introduced. - [Storing data — files & databases](https://gophertrunk.org/learn/intro-software-dev/databases-and-persistence/): How programs remember things after they exit — files, relational vs. NoSQL databases, and how to choose where your data should live. - [APIs & talking to other software](https://gophertrunk.org/learn/intro-software-dev/apis-and-integration/): How programs talk to each other — APIs, HTTP and REST, and the integration glue that connects your software to the rest of the world. - [Documentation, tech debt & maintenance](https://gophertrunk.org/learn/intro-software-dev/docs-and-maintenance/): The unglamorous work that decides whether software survives — writing it down and paying down debt. ### Unit 6 — Choosing the Right Language A full toolkit for the question every project starts with: which language? Driven by requirements, trade-offs, and the domain you're in. - [Why language choice matters (and when it doesn't)](https://gophertrunk.org/learn/intro-software-dev/why-language-choice-matters/): What the language decision actually buys you, what it locks in, and the cases where it barely matters. - [Start with requirements](https://gophertrunk.org/learn/intro-software-dev/from-requirements/): Turning needs — performance, safety, ecosystem, team, timeline — into the criteria that pick a language for you. - [The performance ↔ productivity trade-off](https://gophertrunk.org/learn/intro-software-dev/performance-vs-productivity/): Fast to run vs. fast to write — the central tension, and how to find the right point on the curve for your project. - [A tour of today's major languages](https://gophertrunk.org/learn/intro-software-dev/language-tour/): C, C++, Rust, Go, Python, JavaScript/TypeScript, Java, and friends — strengths, drawbacks, and sweet spots. - [Matching language to domain](https://gophertrunk.org/learn/intro-software-dev/language-for-the-domain/): Web, systems, data, mobile, embedded, and DSP/RF — the languages each field reaches for, and why. - [A practical decision framework](https://gophertrunk.org/learn/intro-software-dev/decision-framework/): A repeatable way to choose, worked through real cases — including why a pure-Go engine fits a software-defined-radio scanner. ### Unit 7 — Build Your Solo Developer Stack Putting it all together as a team of one: pick your stack, set up your workflow, and ship and distribute software you build alone. - [The solo developer — wearing every hat](https://gophertrunk.org/learn/intro-software-dev/solo-developer-mindset/): What changes when you're designer, coder, tester, and release manager at once, and how to use your speed without drowning. - [Choosing your stack](https://gophertrunk.org/learn/intro-software-dev/choosing-your-stack/): Picking a language, frameworks, and tools you can be productive and happy in for the long haul — solo edition. - [Your environment & daily workflow](https://gophertrunk.org/learn/intro-software-dev/dev-environment-workflow/): Editor, terminal, version control, and the loop you'll run a hundred times a day — set up once, benefit forever. - [From idea to project](https://gophertrunk.org/learn/intro-software-dev/scoping-a-project/): Scoping a v1 you can actually finish, structuring the repo, and resisting the urge to build everything at once. - [Keeping quality high alone](https://gophertrunk.org/learn/intro-software-dev/quality-when-solo/): Tests, linters, and CI as the teammate you don't have — guardrails that review your work when no one else can. - [Packaging & distributing your software](https://gophertrunk.org/learn/intro-software-dev/packaging-and-distribution/): Cross-platform binaries, releases, and versioning — how a solo project like GopherTrunk reaches users on every OS. - [Shipping v1 & maintaining solo](https://gophertrunk.org/learn/intro-software-dev/shipping-and-maintaining/): Cutting the first release, gathering feedback, and sustaining a project — and yourself — over the long run. ### Glossary - [Glossary of software development terms](https://gophertrunk.org/learn/intro-software-dev/glossary/): Plain-language definitions for every term in the learning path, cross-linked to the lessons. ## Learn Digital & Trunked Radio (learning module) Public-safety and commercial radio quietly went through two revolutions: trunking, which lets a whole fleet share a handful of frequencies, and the jump from analog to digital voice. This path tells that story from the start, then walks the digital signal end to end — vocoder, modulation, framing, control channel — before taking each trunking system in turn: P25, DMR, TETRA, NXDN, Motorola, EDACS, LTR, MPT-1327 and friends. You finish able to recognise a system on the waterfall and follow it in GopherTrunk. New to radio? Skim the RF & SDR path first; this one assumes only the basics. Start: https://gophertrunk.org/learn/digital-trunking/ ### Unit 1 — A Brief History of Trunked & Digital Radio How we got here: from one-frequency-per-fleet, to shared trunked channels, to the digital standards that run public safety today. - [Why radio went digital](https://gophertrunk.org/learn/digital-trunking/why-radio-went-digital/): The analog two-way era, the problems it ran into — congestion, privacy, capacity — and the pressures that pushed radio toward digital. - [The birth of trunking: sharing channels](https://gophertrunk.org/learn/digital-trunking/birth-of-trunking/): How automatic channel-sharing replaced fixed frequencies, and why one control channel changed everything about scanning. - [The analog trunking era: SmartNet, EDACS, LTR & MPT-1327](https://gophertrunk.org/learn/digital-trunking/analog-trunking-era/): The first big trunked systems were analog voice with digital control — the architectures that still shape digital trunking today. - [The digital leap: P25, TETRA & DMR are born](https://gophertrunk.org/learn/digital-trunking/the-digital-leap/): How three regions answered the same question differently, giving us the digital trunking standards in use across the world. - [Standards & who sets them: APCO, ETSI, TIA & the DMRA](https://gophertrunk.org/learn/digital-trunking/standards-and-bodies/): Why open standards matter for interoperability, who writes them, and how to read a spec number when you meet one. ### Unit 2 — Digital Radio End-to-End The complete digital chain: turning a voice into bits, putting bits on a carrier, protecting them from errors, and packing many calls onto one channel. - [Analog vs. digital voice](https://gophertrunk.org/learn/digital-trunking/analog-vs-digital-voice/): What actually changes when voice goes digital — the trade of graceful static for a clean signal that drops off a cliff. - [From voice to bits: vocoders](https://gophertrunk.org/learn/digital-trunking/voice-to-bits-vocoders/): How IMBE and AMBE+2 squeeze speech into a few kbps, why every digital system needs one, and what that means for decoding. - [Digital modulation for trunking: C4FM, π/4-DQPSK & CQPSK](https://gophertrunk.org/learn/digital-trunking/digital-modulation-for-trunking/): The handful of modulations digital trunking actually uses, how to spot each on a constellation, and why P25 picked two of them. - [Framing, error correction & interleaving](https://gophertrunk.org/learn/digital-trunking/framing-fec-interleaving/): Why raw bits are never sent bare — how frames, FEC, and interleaving let a decoder rebuild a message through fading and noise. - [TDMA vs. FDMA: fitting more calls on a channel](https://gophertrunk.org/learn/digital-trunking/tdma-vs-fdma/): Time slots vs. separate frequencies — the capacity trick behind P25 Phase 2 and DMR, and how it changes what you decode. - [The control channel: the system's heartbeat](https://gophertrunk.org/learn/digital-trunking/the-control-channel/): A frequency that carries only data — what it broadcasts, why it never stops, and why decoding it is the whole game. ### Unit 3 — How Trunking Works The mechanics every trunked system shares: talkgroups, affiliation, the request-grant-release dance, multi-site coverage, and encryption. - [Conventional vs. trunked radio](https://gophertrunk.org/learn/digital-trunking/conventional-vs-trunked/): Fixed frequencies vs. channels assigned on demand — the core difference, and why a trunked system can't be scanned the old way. - [Talkgroups, radio IDs & affiliation](https://gophertrunk.org/learn/digital-trunking/talkgroups-ids-affiliation/): The virtual channels you actually follow, the unit IDs behind them, and how radios register with the system over the air. - [Anatomy of a trunked call: request, grant, release](https://gophertrunk.org/learn/digital-trunking/anatomy-of-a-call/): One call from keyup to hang-time, step by step — the exact sequence a control-channel decoder watches unfold. - [Control-channel signaling: what the data says](https://gophertrunk.org/learn/digital-trunking/control-channel-signaling/): Inside the message stream — grants, updates, registrations, and system parameters — and how a tracker turns it into a live map. - [Trunking flavors: dedicated vs. distributed, message vs. transmission](https://gophertrunk.org/learn/digital-trunking/trunking-flavors/): The design choices that distinguish systems — where the control data lives and how long a channel stays assigned. - [Sites, simulcast & roaming: multi-site systems](https://gophertrunk.org/learn/digital-trunking/sites-simulcast-roaming/): How a system covers a whole region with many sites, what simulcast is, and why both matter when you pick a control channel. - [Encryption & authentication](https://gophertrunk.org/learn/digital-trunking/encryption-and-authentication/): Why some talkgroups go silent, how encryption is signaled, what GopherTrunk can and can't do, and how radios prove who they are. - [OTAR & key management](https://gophertrunk.org/learn/digital-trunking/otar-key-management/): How encrypted systems distribute and rotate keys over the air — key IDs, OTAR, and what a scanner can and can't see when the keys change. - [Data services — GPS, text & registration](https://gophertrunk.org/learn/digital-trunking/data-services/): Trunked systems carry more than voice — location updates, short data, and registration traffic riding the control and data channels. ### Unit 4 — P25 & DMR: The Dominant Systems The two digital trunking standards you'll meet most — examined in depth, from frame structure to the way GopherTrunk follows them. - [P25 Phase 1](https://gophertrunk.org/learn/digital-trunking/p25-phase-1/): The North American public-safety standard — C4FM, 9600 bps, IMBE voice, and the control-channel messages that drive it. - [P25 Phase 2: TDMA](https://gophertrunk.org/learn/digital-trunking/p25-phase-2/): Doubling capacity with two-slot TDMA and the AMBE+2 vocoder — how Phase 2 differs from Phase 1 on the air and in the decoder. - [DMR: Tier II & Tier III](https://gophertrunk.org/learn/digital-trunking/dmr-tier-2-3/): The ETSI two-slot TDMA standard — conventional repeaters vs. full Tier III trunking, and what GopherTrunk reads from each. ### Unit 5 — Other Digital Systems You'll Meet The rest of the landscape GopherTrunk decodes — from European TETRA to legacy LTR, and the amateur digital voice modes in between. - [TETRA](https://gophertrunk.org/learn/digital-trunking/tetra/): Europe's public-safety standard — four-slot TDMA, π/4-DQPSK, and why it sounds and looks unlike anything in North America. - [NXDN](https://gophertrunk.org/learn/digital-trunking/nxdn/): The narrow 4FSK system from Icom and Kenwood — NXDN48/96, its control channel, and where you'll run into it. - [Motorola SmartNet / SmartZone & Type II](https://gophertrunk.org/learn/digital-trunking/motorola-smartnet/): The analog-trunking giant — Type II fleet/subfleet IDs, SmartZone multi-site, and why so much of it is still on the air. - [EDACS, LTR & MPT-1327](https://gophertrunk.org/learn/digital-trunking/edacs-ltr-mpt1327/): Three legacy trunking families — sub-audible LTR, GE/Ericsson EDACS, and the British MPT-1327 standard — and how to recognise them. - [dPMR, D-STAR & System Fusion](https://gophertrunk.org/learn/digital-trunking/dpmr-dstar-ysf/): The lighter digital modes — dPMR's NXDN cousin, plus the amateur-radio voice standards D-STAR and Yaesu System Fusion. ### Unit 6 — Decoding Digital Trunking with GopherTrunk Everything applied: spot a system on the waterfall, find its control channel, follow every call, and fix it when the lock won't hold. - [Identifying what you're hearing](https://gophertrunk.org/learn/digital-trunking/identifying-the-system/): Reading bandwidth, symbol rate, and the waterfall to tell P25 from DMR from NXDN — before you ever decode a bit. - [Finding the control channel](https://gophertrunk.org/learn/digital-trunking/finding-the-control-channel/): Using Hunt, online databases, and the data burst's telltale signature to lock the one frequency that maps the whole system. - [Following a system end to end](https://gophertrunk.org/learn/digital-trunking/following-a-system-end-to-end/): The full GopherTrunk path for a trunked call — control channel in, talkgroup grant, voice channel tuned, audio out. - [Multi-site & simulcast in practice](https://gophertrunk.org/learn/digital-trunking/multisite-and-simulcast-in-practice/): Choosing the right site, surviving simulcast distortion, and what to do when the system spans more than you can hear. - [Troubleshooting a digital decode](https://gophertrunk.org/learn/digital-trunking/troubleshooting-a-decode/): A checklist for the usual culprits — gain, PPM, the wrong control channel, encryption, simulcast — when a system won't decode. ### Glossary - [Glossary of digital & trunked radio terms](https://gophertrunk.org/learn/digital-trunking/glossary/): Plain-language definitions for every term in the learning path, cross-linked to the lessons. ## Learn Intro to Hardware (learning module) Every project runs on something. This path is a guided tour of the hardware a developer chooses between — from a few dollars of shared web hosting up through VPSes, dedicated and home servers, the desktops and laptops you build on, the phones and tablets you ship to, and down to single-board computers and the tiny microcontrollers like the Arduino and ESP32. For each one you'll learn what it's for, the programming languages it runs, and its real strengths and drawbacks. The final module turns all of that into a practical way to decide which platform — often several working together — is right for your project. Examples lean on GopherTrunk, the kind of software-defined-radio software that can live on anything from a laptop to a Raspberry Pi by the antenna. Start: https://gophertrunk.org/learn/intro-hardware/ ### Unit 1 — Hardware Foundations The ideas every later module leans on: what hardware is, the parts inside every computer, the spectrum from cloud to microcontroller, and the trade-offs that drive every choice. - [What is computer hardware?](https://gophertrunk.org/learn/intro-hardware/what-is-hardware/): Hardware vs. software, what counts as a computer, and why the same job can run on a server or a chip the size of a stamp — the one idea everything else builds on. - [CPU, memory, storage & I/O](https://gophertrunk.org/learn/intro-hardware/building-blocks/): The four building blocks inside every computer, from a data center to a microcontroller, and how their size and speed define what a device can do. - [Beyond the CPU — GPUs, FPGAs & accelerators](https://gophertrunk.org/learn/intro-hardware/specialized-compute/): When a general-purpose CPU isn't the right tool — graphics cards, FPGAs, DSPs, and AI accelerators, what each is for, and where SDR and DSP work lean on them. - [The hardware spectrum — cloud to microcontroller](https://gophertrunk.org/learn/intro-hardware/hardware-spectrum/): A single map of every platform in this path, ordered by power, cost, and how much of it you control, so the rest of the path has a frame to hang on. - [Programming languages & where they run](https://gophertrunk.org/learn/intro-hardware/languages-and-hardware/): Why a web host runs PHP and Python while a microcontroller runs C — how hardware shapes which languages are practical, and what "runs on" really means. - [Cost, power & performance trade-offs](https://gophertrunk.org/learn/intro-hardware/cost-power-performance/): The handful of trade-offs — money, electricity, performance, control, and effort — that recur in every hardware decision you'll make. ### Unit 2 — Servers & Hosting Where software runs for other people: the ladder from cheap shared web hosting, through VPSes and dedicated servers, to a server humming in your own home. - [Web & shared hosting](https://gophertrunk.org/learn/intro-hardware/web-hosting/): The cheapest way to put something online — what shared hosting gives you, what it hides, the languages it runs, and where it stops being enough. - [Virtual private servers (VPS)](https://gophertrunk.org/learn/intro-hardware/vps/): Your own slice of a server with root access — how virtualization carves one machine into many, what you can run, and the responsibility that comes with it. - [Dedicated servers](https://gophertrunk.org/learn/intro-hardware/dedicated-servers/): A whole physical machine that's yours alone — when raw, uncontended performance is worth the price, and what changes when nothing is shared. - [Home servers & self-hosting](https://gophertrunk.org/learn/intro-hardware/home-servers/): Running your own server on your own internet — the freedom, the costs nobody mentions, and why a Raspberry Pi or old PC can be a perfect first server. ### Unit 3 — Personal Computers The machines you build software on: the trade between a fixed, powerful desktop and a portable laptop, and how to choose the one you'll work on every day. - [Desktop computers](https://gophertrunk.org/learn/intro-hardware/desktop-computers/): The most power per dollar, endlessly upgradable, and going nowhere — what desktops are for, what they run, and where they shine for a developer. - [Laptops](https://gophertrunk.org/learn/intro-hardware/laptops/): A whole computer you can carry — the portability-for-power trade, battery and thermal limits, and why most developers work on one anyway. - [Choosing your development machine](https://gophertrunk.org/learn/intro-hardware/choosing-a-dev-machine/): Desktop, laptop, or both — matching your machine to how and where you work, and the specs that actually matter for writing software. ### Unit 4 — Mobile Devices The computers in everyone's pocket and bag: what smartphones and tablets are good at, what they're not, and what it takes to build software for them. - [Smartphones](https://gophertrunk.org/learn/intro-hardware/smartphones/): The most widespread computer on earth — its sensors and constraints, the platforms and languages behind apps, and why it's a target, not a dev machine. - [Tablets](https://gophertrunk.org/learn/intro-hardware/tablets/): The big-screen cousin of the phone — where the extra size pays off, where tablets sit between phone and laptop, and what runs on them. - [Developing for mobile devices](https://gophertrunk.org/learn/intro-hardware/developing-for-mobile/): Native, cross-platform, or web — the ways to build a mobile app, the languages and toolchains each uses, and the trade-offs between them. ### Unit 5 — Single-Board Computers A complete computer on one small board: what an SBC like the Raspberry Pi is, what it's brilliant at, how you program it, and where its limits begin. - [What is a single-board computer?](https://gophertrunk.org/learn/intro-hardware/what-is-an-sbc/): A real, Linux-running computer the size of a credit card — how an SBC differs from both a PC and a microcontroller, and why GPIO pins change everything. - [The Raspberry Pi & its alternatives](https://gophertrunk.org/learn/intro-hardware/raspberry-pi-and-family/): The board that defined the category, plus the rivals worth knowing — Pi Zero to Pi 5, Jetson, Rock, and BeagleBone — and how to tell them apart. - [Programming & running software on an SBC](https://gophertrunk.org/learn/intro-hardware/programming-an-sbc/): It's just Linux — Python, C, Go, and the same tools you use on a PC, plus talking to the physical world through the GPIO header. - [SBC use cases, strengths & drawbacks](https://gophertrunk.org/learn/intro-hardware/sbc-use-cases-and-limits/): Home labs, media servers, robots, and edge sensors — where SBCs win, and the heat, power, storage, and reliability limits that decide when to reach for something else. ### Unit 6 — Microcontrollers The tiny chips that run the physical world: what a microcontroller is, the Arduino that made them approachable, the wireless ESP32, and how you program them. - [What is a microcontroller?](https://gophertrunk.org/learn/intro-hardware/what-is-a-microcontroller/): A whole computer on one cheap, low-power chip with no operating system — how it differs from an SBC, and why it boots in milliseconds and runs for years. - [Arduino & the maker ecosystem](https://gophertrunk.org/learn/intro-hardware/arduino/): The board and language that made microcontrollers approachable — what Arduino is, the sketch model, and the enormous ecosystem that grew around it. - [ESP32 & wireless microcontrollers](https://gophertrunk.org/learn/intro-hardware/esp32/): A microcontroller with Wi-Fi and Bluetooth built in for a couple of dollars — why it powers most DIY smart-home gadgets and the Internet of Things. - [Programming microcontrollers: languages, use cases & limits](https://gophertrunk.org/learn/intro-hardware/mcu-programming-and-tradeoffs/): C/C++, MicroPython, and Rust on bare metal — the use cases microcontrollers own, and the tight memory, power, and tooling limits you design around. ### Unit 7 — Choosing the Right Hardware Everything applied: turn a project's needs into the platform — or, more often, the combination of platforms — that fits it best, with a repeatable framework and worked examples. - [Start with your requirements](https://gophertrunk.org/learn/intro-hardware/start-with-requirements/): Before you pick a board or a host, pin down what the project actually needs — performance, connectivity, power, budget, and where it has to live. - [Matching hardware to the project type](https://gophertrunk.org/learn/intro-hardware/matching-hardware-to-project/): Websites, apps, data crunching, automation, sensors, and robots — the platforms each kind of project tends to reach for, and why. - [Combining tiers: device, server & cloud](https://gophertrunk.org/learn/intro-hardware/combining-tiers/): Real systems rarely live on one platform — how a microcontroller, an SBC, and a server team up, and where to draw the line between them. - [A practical decision framework](https://gophertrunk.org/learn/intro-hardware/decision-framework/): A repeatable checklist for turning requirements into a hardware choice, including the questions that quickly rule platforms in or out. - [Worked examples: picking hardware for real projects](https://gophertrunk.org/learn/intro-hardware/worked-examples/): The framework applied end to end to several projects — a blog, a smart-home sensor, a home media server, and a GopherTrunk scanner — to make it concrete. ### Glossary - [Glossary of hardware terms](https://gophertrunk.org/learn/intro-hardware/glossary/): Plain-language definitions for every hardware term in the learning path, cross-linked to the lessons. ## Learn AI in Software Dev (learning module) AI has gone from novelty to a daily tool for writing software, and this path is a guided, hype-free tour of how to use it well. Start under the hood — how large language models are trained, how they actually decide what to write next, and how the context window that feeds them really works — then map the landscape: which providers and models are used for coding, their strengths and trade-offs, the interfaces you reach them through, and how usage limits and cost work. From there you'll compare the ways people code with AI — the provider's app, an IDE integration, an agentic CLI, or a blend — and the whole spectrum from line-by-line completion to full "vibe coding". You'll learn to steer a model with prompts, skills, and AI config files, and to weigh one model against a combination of several. The path ends by helping you choose your own model, provider, and method and put AI to work in a real project. No coding background required, though the Intro to Software Development path pairs well; examples lean on real software, including the kind of signal-crunching code behind GopherTrunk. Start: https://gophertrunk.org/learn/ai-software-dev/ ### Unit 1 — How AI Models Actually Work Under the hood before the hype: what an AI model is, how it's trained, how it decides what to write, how context works, and which kinds of models write code. - [What is AI, for a developer?](https://gophertrunk.org/learn/ai-software-dev/what-is-ai-for-coding/): LLMs, "narrow" vs "general", and why today's coding AI is next-token prediction rather than understanding — the one idea everything else builds on. - [How AI models are trained](https://gophertrunk.org/learn/ai-software-dev/how-models-are-trained/): Pretraining on oceans of text, fine-tuning, and RLHF — and why training explains knowledge cutoffs, bias, and the confident wrong answer. - [How a model decides: tokens & prediction](https://gophertrunk.org/learn/ai-software-dev/how-models-decide/): Tokenization, next-token prediction, temperature and sampling, and why the same prompt can give different code — and sometimes invents an API that doesn't exist. - [The context window, in detail](https://gophertrunk.org/learn/ai-software-dev/context-windows/): What "context" really is, why it's measured in tokens, the window's hard limits, attention and "lost in the middle", and why context is both your biggest lever and a cost driver. - [The types of AI models](https://gophertrunk.org/learn/ai-software-dev/types-of-models/): LLMs, reasoning models, embeddings, multimodal, image and speech models — which ones write and plan code, and which power the embedded-AI features a later path will build on. ### Unit 2 — Providers, Models & What They Cost The market you're choosing from: the major providers and models for coding, their strengths and weaknesses, the interfaces you reach them through, and how limits and cost work. - [The provider & model landscape](https://gophertrunk.org/learn/ai-software-dev/the-provider-landscape/): The major AI providers, proprietary vs open-weight models, and a durable way to think about a field that ships a new leading model every few months. - [Coding models compared](https://gophertrunk.org/learn/ai-software-dev/coding-models-compared/): The strengths and weaknesses that actually distinguish coding models — capability, context size, speed, autonomy, and cost — framed to outlive this month's leaderboard. - [Interfaces: app, API, CLI & IDE](https://gophertrunk.org/learn/ai-software-dev/interfaces-and-access/): The handful of ways a model reaches you — web chat, raw API, command-line tools, and editor plugins — and what each interface is and isn't for. - [Usage limits & tiers](https://gophertrunk.org/learn/ai-software-dev/usage-limits-and-tiers/): How rate limits and caps actually work — messages, tokens per minute, usage tiers — the difference between subscription and API metering, and how to design around them. - [Understanding the cost](https://gophertrunk.org/learn/ai-software-dev/understanding-cost/): Token pricing for input and output, subscriptions vs pay-as-you-go, prompt caching, the real cost drivers, and how to estimate what a workflow will spend. ### Unit 3 — Ways to Use AI in Your Workflow Where the AI actually lives while you work: the provider's app, your IDE, an agent in the terminal, or a deliberate blend — with the honest pluses and drawbacks of each. - [Using the provider's app](https://gophertrunk.org/learn/ai-software-dev/the-provider-app/): The chat window in your browser — the simplest on-ramp, what it's great at, and the copy-paste friction that eventually pushes people elsewhere. - [AI inside your editor](https://gophertrunk.org/learn/ai-software-dev/ide-integration/): Autocomplete plugins and AI-native editors that see your code as you type — the productivity jump, and the new failure modes that come with it. - [Agentic & command-line tools](https://gophertrunk.org/learn/ai-software-dev/agentic-cli-tools/): Tools that read your repo, run commands, and edit files on their own — what an agent can do, and the guardrails you need before you let it. - [Running local & open models](https://gophertrunk.org/learn/ai-software-dev/local-and-open-models/): Open-weight models on your own hardware — Ollama, llama.cpp, and GPU limits — when running a model locally makes sense for coding and when it doesn't. - [App, IDE, agent — or all three?](https://gophertrunk.org/learn/ai-software-dev/app-vs-ide-vs-both/): There's no single right answer — how to match the integration method to the task, and why most people end up using more than one. ### Unit 4 — Modes of AI-Assisted Coding The full spectrum, from a model finishing your line to a model building a feature unattended — what each mode is good for, and where it bites. - [Code & "sentence" completion](https://gophertrunk.org/learn/ai-software-dev/code-completion/): The inline grey-text suggestions that finish your line or block — how they work, where they shine, and why they rarely lead you far astray. - [Chat-assisted coding](https://gophertrunk.org/learn/ai-software-dev/chat-assisted-coding/): Conversation as the interface — generate, explain, refactor, and debug with a human in the loop reviewing every step. - [Agentic coding & "vibe coding"](https://gophertrunk.org/learn/ai-software-dev/agentic-and-vibe-coding/): Handing the model the wheel — autonomous plan-and-act loops and full "vibe coding", the productivity ceiling they raise, and the risks of trusting output you never read. - [Choosing where on the spectrum to work](https://gophertrunk.org/learn/ai-software-dev/the-spectrum/): Completion, chat, agent, vibe — a single spectrum of how much you delegate, how to pick per task, and why every mode still ends in verification. ### Unit 5 — Directing How the Model Writes Code Going from random results to reliable ones: prompting well, steering behavior with skills and config files, feeding the right context, and deciding between one model and many. - [Prompting for code](https://gophertrunk.org/learn/ai-software-dev/prompting-for-code/): What separates a vague request from one that gets the code you wanted — context, constraints, examples, and iterating instead of restarting. - [Skills & AI config files](https://gophertrunk.org/learn/ai-software-dev/skills-and-config-files/): Standing instructions that steer a model every time — skills, rules, and config files like CLAUDE.md and AGENTS.md — so you stop repeating yourself and get consistent code. - [Feeding the model the right context](https://gophertrunk.org/learn/ai-software-dev/providing-context/): The model only knows what it can see — open files, repo retrieval and RAG, and tool/MCP connections — and how managing context decides the quality of the answer. - [One model, or a combination?](https://gophertrunk.org/learn/ai-software-dev/one-model-vs-many/): Standardizing on a single model versus routing each task to the best tool — the case for each, and how multi-model setups actually work in practice. ### Unit 6 — Putting AI to Work in Your Projects Everything applied: choose your model and provider, pick your method, keep the output trustworthy and safe, and start using AI in a real project today. - [Choosing your model & provider](https://gophertrunk.org/learn/ai-software-dev/choosing-model-and-provider/): A repeatable framework for picking a model and provider — or a deliberate combination — driven by your work, budget, and constraints rather than the hype cycle. - [Choosing your method](https://gophertrunk.org/learn/ai-software-dev/choosing-your-method/): App, IDE, agent, or a blend — matching how you reach the model to how you actually work, and assembling a setup you'll stick with. - [Verifying AI-written code](https://gophertrunk.org/learn/ai-software-dev/verification-and-trust/): AI writes plausible code, not always correct code — reviewing it, leaning on tests, catching hallucinations, and the discipline that keeps speed from costing you quality. - [Security, privacy & ethics](https://gophertrunk.org/learn/ai-software-dev/security-privacy-ethics/): Where your code and prompts go, the licensing and IP questions, leaking secrets, the security of AI-written code, and using these tools responsibly. - [Getting started today](https://gophertrunk.org/learn/ai-software-dev/getting-started-today/): Turning the whole path into action — concrete first steps for a real project, a worked example, and a look ahead to building AI into the software you ship. ### Glossary - [Glossary of AI-for-development terms](https://gophertrunk.org/learn/ai-software-dev/glossary/): Plain-language definitions for every term in the learning path — token, context window, RLHF, embedding, RAG, MCP, agent, vibe coding, and more — cross-linked to the lessons. ## Learn Building AI Into Software (learning module) The AI in Software Dev path taught you to *use* AI to write code. This one teaches you to *build* AI into the software you ship — to call a model from your own program and turn it into a feature. Start with what changes when a language model becomes a component in your architecture, make your first API call, and learn to treat the model as a powerful but unreliable dependency. From there you'll write prompts as code, get reliable structured output, give the model tools, ground it in your own data with retrieval (RAG), let it act as an agent, and — crucially — evaluate, secure, and operate all of it in production. Examples lean on real software, including AI features you might add to a project like GopherTrunk. Pairs with the AI in Software Dev path; no AI background beyond it required. Start: https://gophertrunk.org/learn/building-ai/ ### Unit 1 — From Using AI to Building With It The shift from chatting with AI to calling it from your own code: what an AI feature is, the model as a component, how the API works, your first call, and the cost it carries. - [What it means to build AI into software](https://gophertrunk.org/learn/building-ai/building-vs-using-ai/): The jump from using an AI tool to shipping an AI feature — what changes when the model runs inside your program instead of a chat window. - [The model as a probabilistic component](https://gophertrunk.org/learn/building-ai/llm-as-a-component/): Designing around a dependency that is powerful, non-deterministic, and occasionally wrong — the mindset shift everything else builds on. - [How a model API call works](https://gophertrunk.org/learn/building-ai/how-a-model-api-works/): Messages, roles, tokens, and the request/response cycle — what actually goes over the wire when your code talks to a model. - [Your first API call](https://gophertrunk.org/learn/building-ai/your-first-api-call/): API keys, SDKs, and a first request in code — the smallest end-to-end example of software calling a model. - [Cost, latency & rate limits by design](https://gophertrunk.org/learn/building-ai/cost-latency-and-limits/): Every call costs tokens and time — why cost, latency, and rate limits are design constraints you plan for, not afterthoughts. ### Unit 2 — Prompting in Code Turning prompts from throwaway chat messages into reliable, versioned parts of your program that produce output consistent enough to build on. - [Prompts as code — system prompts & templates](https://gophertrunk.org/learn/building-ai/prompts-as-code/): Treating prompts as first-class, version-controlled artifacts — system vs. user roles, templating, and separating instructions from data. - [Feeding the model context & user input](https://gophertrunk.org/learn/building-ai/context-and-user-input/): Assembling the right context safely — injecting your data and user input into a prompt without letting it hijack your instructions. - [Few-shot examples & steering output](https://gophertrunk.org/learn/building-ai/few-shot-and-steering/): Showing the model what "good" looks like — examples, constraints, and the levers that make output consistent enough to rely on. - [Getting usable output back](https://gophertrunk.org/learn/building-ai/parsing-and-validating-output/): The model returns text — parsing, validating, and retrying it so your program gets data it can actually trust. ### Unit 3 — Structured Output, Tools & Streaming The features that turn a text generator into a programmable component: JSON output, tool and function calling, streaming, and multimodal inputs. - [Structured output & JSON](https://gophertrunk.org/learn/building-ai/structured-output/): Getting the model to return machine-readable JSON that matches a schema — the key to wiring a model into the rest of your code. - [Tool use & function calling](https://gophertrunk.org/learn/building-ai/tool-use-and-function-calling/): Letting the model call your functions — how tool use works, and how a model that can't do math or fetch live data suddenly can. - [Streaming responses](https://gophertrunk.org/learn/building-ai/streaming/): Showing output token-by-token as it's generated — why streaming matters for user experience and how it changes your code. - [Multimodal — images, audio & documents](https://gophertrunk.org/learn/building-ai/multimodal-inputs/): Models that read more than text — sending images, audio, and documents, and the feature ideas that opens up. ### Unit 4 — Retrieval-Augmented Generation (RAG) Grounding the model in your own data so it answers from your documents and facts instead of only its training — the most common way to build a genuinely useful AI feature. - [Why retrieval — grounding the model in your data](https://gophertrunk.org/learn/building-ai/grounding-and-retrieval/): The model only knows its training data — retrieval feeds it your facts at query time, cutting hallucination and keeping answers current. - [Embeddings & vector search](https://gophertrunk.org/learn/building-ai/embeddings-and-vector-search/): Turning text into vectors so you can search by meaning, not keywords — the engine underneath retrieval. - [Building a RAG pipeline](https://gophertrunk.org/learn/building-ai/building-a-rag-pipeline/): The end-to-end shape — ingest, chunk, embed, store, retrieve, and augment the prompt — assembled into a working feature. - [Chunking & retrieval quality](https://gophertrunk.org/learn/building-ai/chunking-and-retrieval-quality/): RAG lives or dies on retrieval — chunking, metadata, re-ranking, and how to tell when retrieval is the thing that's broken. - [RAG vs. long context vs. fine-tuning](https://gophertrunk.org/learn/building-ai/rag-vs-long-context-vs-finetuning/): Three ways to give a model knowledge it didn't ship with — what each is for, what each costs, and how to choose. ### Unit 5 — Agents, Evaluation & Safety Letting the model act, then making sure it acts well: agent loops and tools, evaluating a probabilistic feature, handling failure, and defending against prompt injection. - [Agents — letting the model act in a loop](https://gophertrunk.org/learn/building-ai/what-is-an-ai-agent/): From one-shot calls to a plan-act-observe loop — what an agent is, what it can do, and where the risk goes up. - [Giving agents tools (and MCP)](https://gophertrunk.org/learn/building-ai/giving-agents-tools-and-mcp/): Tools are how an agent affects the world — designing safe tools and the Model Context Protocol (MCP) that standardizes them. - [Evaluating AI features](https://gophertrunk.org/learn/building-ai/evaluating-ai-features/): You can't unit-test a probabilistic feature the old way — evals, test sets, LLM-as-judge, and measuring quality before and after a change. - [Handling hallucinations & failure](https://gophertrunk.org/learn/building-ai/handling-hallucinations-and-failure/): The model will be confidently wrong, slow, or unavailable — grounding, guardrails, fallbacks, and failing safe when it does. - [Prompt injection & data safety](https://gophertrunk.org/learn/building-ai/prompt-injection-and-security/): Untrusted text can hijack your prompt — prompt injection, data exfiltration, the "lethal trifecta", and how to design against them. ### Unit 6 — Shipping & Operating AI Features Everything applied: choose a model, control cost and latency, protect user data, watch it in production, and ship your first AI feature end to end. - [Choosing a model for a feature](https://gophertrunk.org/learn/building-ai/choosing-a-model-for-a-feature/): Matching model to job — capability, context, speed, cost, and privacy — and why most products end up using more than one. - [Optimizing cost & latency](https://gophertrunk.org/learn/building-ai/optimizing-cost-and-latency/): Prompt caching, smaller models, batching, and streaming — the practical levers that make an AI feature affordable and fast. - [Privacy, data & compliance](https://gophertrunk.org/learn/building-ai/privacy-data-and-compliance/): Where prompts and user data go, what providers do with them, and the privacy, retention, and compliance questions to settle before you ship. - [Observability & monitoring](https://gophertrunk.org/learn/building-ai/observability-and-monitoring/): You can't fix what you can't see — logging prompts and outputs, tracing, cost and latency metrics, and catching quality drift in production. - [Shipping your first AI feature](https://gophertrunk.org/learn/building-ai/shipping-your-first-ai-feature/): Putting it all together — an end-to-end worked example that adds a real AI feature to a project like GopherTrunk, and how to keep improving it. ### Glossary - [Glossary of AI-engineering terms](https://gophertrunk.org/learn/building-ai/glossary/): Plain-language definitions for every term in the path — API, token, system prompt, structured output, tool use, embedding, RAG, agent, MCP, eval, prompt injection, and more — cross-linked to the lessons. ## Learn Software Licensing (learning module) Licensing is where software meets the law, and it decides what you and your users are actually allowed to do with code. This path is a plain-language, end-to-end tour — start with what a license is and how copyright makes software ownable, then work through every open-source license in detail (MIT, BSD, Apache, the GPL family, the weak-copyleft licenses, and public domain) with the real strengths, weaknesses, and trade-offs of each. From there you'll learn to choose and combine open-source licenses, how proprietary and commercial licensing works, how to write a custom license to sell software, and how to use open-source libraries inside a product you sell without breaking the rules. The back half teaches you to read any software agreement and understand it before you sign, covers the other agreements software needs — EULAs, terms of service, privacy policies, DPAs, SLAs, and NDAs — and ends by walking you through choosing the right license and the right set of agreements for your own software. Concepts are taught with US law as the reference point and the major differences in other jurisdictions flagged throughout, so you get the complete picture. This is educational material, not legal advice. No legal background required; examples lean on real software, including GopherTrunk's own Apache-2.0 license and dependency notices. Start: https://gophertrunk.org/learn/software-licensing/ ### Unit 1 — Licensing & IP Foundations What a software license actually is, how copyright and other IP make code ownable, license versus contract, the full spectrum of license types, and how the law differs around the world. - [What is a software license?](https://gophertrunk.org/learn/software-licensing/what-is-a-software-license/): A license is permission to use code you don't own — why software defaults to "all rights reserved", what a license grants, and why every project needs one. - [Copyright & software ownership](https://gophertrunk.org/learn/software-licensing/copyright-and-software-ownership/): How copyright attaches to code automatically, what it does and doesn't protect, and who actually owns software written by employees, contractors, and you. - [Patents, trademarks & trade secrets](https://gophertrunk.org/learn/software-licensing/other-ip-in-software/): Copyright isn't the only IP in software — how patents, trademarks, and trade secrets each touch your code, your name, and your competitive edge. - [License vs contract](https://gophertrunk.org/learn/software-licensing/license-vs-contract/): A license grants permission; a contract is a deal with obligations on both sides — why the difference matters, and how click-wrap and browse-wrap agreements bind users. - [The licensing spectrum](https://gophertrunk.org/learn/software-licensing/the-licensing-spectrum/): From locked-down proprietary to source-available to open source to public domain — the full map of how software can be licensed, and where each model fits. - [Licensing across jurisdictions](https://gophertrunk.org/learn/software-licensing/licensing-across-jurisdictions/): US copyright is the reference point, but moral rights, enforceability, warranty disclaimers, and data law differ worldwide — the complete cross-border picture. ### Unit 2 — Open Source Licenses in Depth What 'open source' really means, the permissive-versus-copyleft divide, and a detailed look at every common license — MIT, BSD, Apache, GPL, AGPL, the weak-copyleft licenses, and public domain — with the real strengths and weaknesses of each. - [What open source really means](https://gophertrunk.org/learn/software-licensing/what-is-open-source/): The OSI Open Source Definition, the FSF's four freedoms, "free vs open", and why source-available is not the same as open source. - [Permissive vs copyleft](https://gophertrunk.org/learn/software-licensing/permissive-vs-copyleft/): The single divide that organizes every open-source license — do nothing back, or share alike — and what "copyleft" really obligates. - [MIT & BSD: minimal permissive](https://gophertrunk.org/learn/software-licensing/mit-and-bsd-licenses/): The short, do-almost-anything licenses behind most of the ecosystem — what MIT and the BSD variants say, where they shine, and their few real weaknesses. - [Apache 2.0: permissive with a patent grant](https://gophertrunk.org/learn/software-licensing/apache-license/): Permissive freedom plus an explicit patent grant and NOTICE requirement — why Apache 2.0 is the corporate default, and why GopherTrunk uses it. - [The GPL: strong copyleft](https://gophertrunk.org/learn/software-licensing/gpl-strong-copyleft/): The license that started copyleft — what triggers GPLv2/v3 obligations, the source-code requirement, and the strengths and costs of "share alike". - [The AGPL: copyleft over the network](https://gophertrunk.org/learn/software-licensing/agpl-network-copyleft/): How the AGPL closes the SaaS "loophole" by triggering on network use, why it protects user freedom, and why so many companies ban it outright. - [Weak copyleft: LGPL, MPL, EPL](https://gophertrunk.org/learn/software-licensing/weak-copyleft-licenses/): The middle ground — file- and library-level copyleft that lets you link from proprietary code while keeping the open parts open; strengths and traps of each. - [Public domain, Unlicense & CC0](https://gophertrunk.org/learn/software-licensing/public-domain-and-cc0/): Giving up all rights — public-domain dedications, the Unlicense, CC0, and 0BSD — plus why "no license at all" is a trap, not a gift. ### Unit 3 — Choosing & Combining Open Source Putting the licenses to work: how they combine and where they conflict, how to pick one for your own project, contributor agreements, dual licensing, and the long-term risks of depending on open source. - [License compatibility](https://gophertrunk.org/learn/software-licensing/license-compatibility/): When code under different licenses can legally be combined, why GPL compatibility runs one way, and a mental model for the compatibility matrix. - [Choosing an open-source license](https://gophertrunk.org/learn/software-licensing/choosing-an-oss-license/): Turning strengths and weaknesses into a decision — match your goals to a license, and the tools (choosealicense.com and friends) that help. - [Contributor agreements: CLAs & DCO](https://gophertrunk.org/learn/software-licensing/contributor-agreements/): How projects take in outside contributions cleanly — CLAs, the DCO, and "inbound=outbound" — and what every contributor should understand before signing. - [Dual licensing & relicensing](https://gophertrunk.org/learn/software-licensing/dual-licensing-and-relicensing/): Offering the same code as both open source and a paid license, what makes it possible (owning the copyright), and the constraints on changing a license later. - [The risks of depending on open source](https://gophertrunk.org/learn/software-licensing/open-source-risks/): License changes and "rug pulls", abandonment, supply-chain and provenance risk, and the audit and legal exposure that come with every dependency. ### Unit 4 — Proprietary & Commercial Licensing The paid side of the spectrum: how proprietary licensing works, the commercial pricing models, source-available licenses, and how to write and price a custom license to sell your own software — plus where to get real help. - [Proprietary & closed-source licensing](https://gophertrunk.org/learn/software-licensing/proprietary-licensing/): What a proprietary license restricts and why, from "all rights reserved" to reverse-engineering and redistribution clauses — the opposite end of open source. - [Commercial license models](https://gophertrunk.org/learn/software-licensing/commercial-license-models/): Perpetual vs subscription, per-seat, per-core, usage-based, site and enterprise licenses, and OEM — the pricing structures behind software you pay for. - [Source-available & "fair source"](https://gophertrunk.org/learn/software-licensing/source-available-licenses/): BSL, SSPL, the Elastic License and "fair source" — why companies adopt them, what they actually allow, and why they are not open source. - [Writing a license to sell software](https://gophertrunk.org/learn/software-licensing/writing-a-commercial-license/): Building a custom commercial license — the grant, scope, structure, and the decisions you must make first before any clause goes on the page. - [Key clauses in a commercial license](https://gophertrunk.org/learn/software-licensing/key-commercial-clauses/): Warranty, limitation of liability, indemnity, IP ownership, termination, governing law, and audit rights — the clauses that decide who carries the risk. - [Where to get licensing help](https://gophertrunk.org/learn/software-licensing/where-to-get-licensing-help/): When you genuinely need a lawyer, the reputable template and contract sources, the standards bodies, and the generators — where to find more information. ### Unit 5 — Using Open Source in Software You Sell You can absolutely build a paid product on open source — if you follow the rules. Meeting permissive obligations, handling copyleft and the 'viral' question, and auditing your dependencies so compliance is continuous, not a fire drill. - [Can you sell software built on open source?](https://gophertrunk.org/learn/software-licensing/using-oss-in-products/): Yes — and here are the rules that make it legal. The obligations that come with every dependency, and the myths that scare people away from open source. - [Meeting permissive obligations](https://gophertrunk.org/learn/software-licensing/permissive-compliance/): The attribution, license-text, and NOTICE requirements behind MIT, BSD, and Apache — modeled on GopherTrunk's own THIRD_PARTY_LICENSES.md. - [Copyleft in products: the viral question](https://gophertrunk.org/learn/software-licensing/copyleft-in-products/): What actually triggers GPL, AGPL, and LGPL obligations in a product, where the linking and distribution boundaries fall, and the patterns that keep you safe. - [Auditing dependencies & SBOMs](https://gophertrunk.org/learn/software-licensing/auditing-dependencies/): Knowing every license you ship — dependency scanning, SBOMs, SPDX, the tooling (FOSSA, ScanCode, and friends), and building an ongoing compliance process. ### Unit 6 — Reading Agreements & Other User Agreements How to actually read a software agreement and understand it before you sign — the main clauses, the risk clauses, and the red flags — then a tour of the other agreements software needs: EULAs, terms of service, privacy policies, DPAs, SLAs, and NDAs. - [How to read a software agreement](https://gophertrunk.org/learn/software-licensing/how-to-read-an-agreement/): A repeatable method for reading any license or agreement — following defined terms, mapping the structure, and extracting what actually matters to you. - [The main clauses, decoded](https://gophertrunk.org/learn/software-licensing/main-clauses-decoded/): The clauses in nearly every software agreement — grant, scope, fees, term, confidentiality, IP — and what each one really means in plain language. - [The risk clauses: who pays when it breaks](https://gophertrunk.org/learn/software-licensing/risk-clauses/): Warranty disclaimers, limitation of liability, indemnification, and "as-is" — the quiet clauses that decide who is on the hook when software fails. - [What to check before you agree](https://gophertrunk.org/learn/software-licensing/before-you-agree/): A pre-signature checklist and the red flags — auto-renewal, price changes, data use, assignment, audit rights, and termination — to catch before you click "I agree". - [EULAs & terms of service](https://gophertrunk.org/learn/software-licensing/eula-and-tos/): The agreements your users accept — end-user license agreements and terms of service — what they cover, how they bind users, and the terms that matter most. - [Privacy policies & data agreements](https://gophertrunk.org/learn/software-licensing/privacy-and-data-agreements/): Privacy policies, data processing agreements, GDPR and CCPA basics, and sub-processors — the data-side agreements most modern software is required to have. - [SLAs & support agreements](https://gophertrunk.org/learn/software-licensing/sla-and-support-agreements/): Service level agreements, uptime guarantees and credits, and support and maintenance terms — read from both the buyer's and the seller's side. - [NDAs & the rest of the landscape](https://gophertrunk.org/learn/software-licensing/nda-and-other-agreements/): NDAs, master service agreements, acceptable-use policies, and beta/evaluation agreements — the remaining agreements software businesses run on. ### Unit 7 — Choosing Your License & Agreements Everything applied: a repeatable framework that turns your goals into a license choice, a step-by-step walkthrough to pick yours, a way to determine which other agreements your software needs, and a full worked example end to end. - [A framework for choosing](https://gophertrunk.org/learn/software-licensing/the-decision-framework/): A repeatable decision framework — goals, business model, dependencies, and risk tolerance map to a license and a set of agreements, not the other way around. - [Choosing your license, step by step](https://gophertrunk.org/learn/software-licensing/choose-your-license/): A guided walkthrough to land on your license — open source, proprietary, source-available, or dual — with the questions that decide each fork. - [Which agreements does your software need?](https://gophertrunk.org/learn/software-licensing/which-agreements-do-you-need/): Determining the full set — EULA or ToS, privacy policy, DPA, SLA — from how your software is delivered, who uses it, and what data it touches. - [Putting it all together](https://gophertrunk.org/learn/software-licensing/putting-it-all-together/): An end-to-end worked example — choosing a license and the full agreement set for a GopherTrunk-like product — plus where to go next and how to stay compliant. ### Glossary - [Glossary of software-licensing terms](https://gophertrunk.org/learn/software-licensing/glossary/): Plain-language definitions for every term in the path — copyright, copyleft, permissive, GPL/AGPL/LGPL, dual licensing, EULA, ToS, SLA, DPA, SBOM, SPDX, indemnity, and more — cross-linked to the lessons. ## Learn Programming in Go (learning module) A hands-on path into Go, the language GopherTrunk itself is built in. Start with why Go exists and your first compiled program, learn the type system, interfaces, and the concurrency model that makes Go shine, then finish by reading real code from a working SDR engine. No prior Go — or compiled language — experience assumed. Start: https://gophertrunk.org/learn/programming-go/ ### Unit 1 — Meeting Go What Go is, why it exists, and the toolchain you run every day. - [Why Go?](https://gophertrunk.org/learn/programming-go/why-go/): Where Go came from, the problems it was built to solve, and why a fast, simple, compiled language is a great fit for systems like GopherTrunk. - [Your first Go program](https://gophertrunk.org/learn/programming-go/hello-go/): Install Go, write hello world, and understand the difference between go run and go build — from source to a single static binary. - [The Go toolchain](https://gophertrunk.org/learn/programming-go/the-go-toolchain/): go build, run, test, fmt, and vet — the batteries-included tools that format, check, and build your code with zero configuration. ### Unit 2 — Language Fundamentals Values, control flow, functions, errors, pointers, structs, and interfaces — the core of Go. - [Values, variables & types](https://gophertrunk.org/learn/programming-go/values-and-types/): Go's built-in types, declarations, zero values, and static typing — why a small, strict type set makes programs easier to reason about. - [Control flow](https://gophertrunk.org/learn/programming-go/control-flow/): if, for, and switch — Go's deliberately small set of control structures, including the one loop keyword that does everything. - [Functions & error handling](https://gophertrunk.org/learn/programming-go/functions-and-errors/): Multiple return values, the error interface, and why Go returns errors instead of throwing exceptions — the pattern you'll see on every line. - [Pointers](https://gophertrunk.org/learn/programming-go/pointers/): What a pointer is, why Go has them without pointer arithmetic, and how they let functions modify values and avoid copying big structs. - [Structs & methods](https://gophertrunk.org/learn/programming-go/structs-and-methods/): Group data with structs, attach behaviour with methods, and understand pointer vs value receivers — Go's answer to objects. - [Interfaces & composition](https://gophertrunk.org/learn/programming-go/interfaces/): Small interfaces, implicit satisfaction, and composition over inheritance — the idea that makes Go code flexible without class hierarchies. ### Unit 3 — Data & Text The collections, text, files, and encodings real programs are built from. - [Slices, maps & generics](https://gophertrunk.org/learn/programming-go/slices-maps-generics/): Go's core collections — slices and maps — how they grow and alias, plus type parameters (generics) for reusable, type-safe code. - [Strings, bytes & runes](https://gophertrunk.org/learn/programming-go/strings-and-runes/): How Go handles text — immutable strings, byte slices, and runes — and why Unicode means a character isn't always one byte. - [JSON & serialization](https://gophertrunk.org/learn/programming-go/json-and-serialization/): Turning Go structs into JSON and back with encoding/json, struct tags, and the marshal/unmarshal pattern behind most APIs and config. - [Working with files & I/O](https://gophertrunk.org/learn/programming-go/working-with-files/): Reading and writing files and streams with os, io, and bufio — and the reader/writer interfaces that make it all composable. ### Unit 4 — Concurrency Goroutines, channels, coordination, and the patterns that put them to work. - [Goroutines](https://gophertrunk.org/learn/programming-go/goroutines/): Lightweight concurrency you launch with one keyword — what a goroutine is, how it differs from a thread, and why GopherTrunk runs thousands. - [Channels](https://gophertrunk.org/learn/programming-go/channels/): Typed pipes that let goroutines communicate safely — sending, receiving, buffering, and closing — Go's "share memory by communicating" model. - [select & synchronization](https://gophertrunk.org/learn/programming-go/select-and-sync/): Coordinate multiple channels with select, and use the sync package — mutexes, WaitGroups — when channels are not the right tool. - [Context & cancellation](https://gophertrunk.org/learn/programming-go/context-and-cancellation/): The context package — how a single cancel signal or timeout propagates through every goroutine in a call tree to shut work down cleanly. - [Concurrency patterns](https://gophertrunk.org/learn/programming-go/concurrency-patterns/): Worker pools, pipelines, and fan-out/fan-in — the reusable shapes for structuring concurrent work, the way a real sample pipeline does. ### Unit 5 — Packages & Quality Organizing, depending on, testing, measuring, and debugging real code. - [Packages & modules](https://gophertrunk.org/learn/programming-go/packages-and-modules/): How Go organizes code into packages and modules, how imports and go.mod work, and how visibility is controlled by capitalization. - [Dependency management](https://gophertrunk.org/learn/programming-go/dependency-management/): How go.mod and go.sum pin versions, how go get and go mod tidy manage dependencies, and why reproducible builds and few dependencies matter. - [Error-handling patterns](https://gophertrunk.org/learn/programming-go/error-handling-patterns/): Beyond if err != nil — wrapping errors with %w, sentinel errors, errors.Is and errors.As, and custom error types for real programs. - [Testing in Go](https://gophertrunk.org/learn/programming-go/testing-in-go/): The built-in testing package, table-driven tests, and why testing is a first-class part of the language, not an add-on. - [Benchmarking & profiling](https://gophertrunk.org/learn/programming-go/benchmarking-and-profiling/): Measuring performance with benchmarks and pprof — finding the hot path before optimizing it, the way real-time DSP code demands. - [Debugging Go](https://gophertrunk.org/learn/programming-go/debugging-go/): Finding bugs with print debugging, the delve debugger, the race detector, and static analysis — the toolkit for when a test goes red. - [The standard library](https://gophertrunk.org/learn/programming-go/the-standard-library/): A tour of the batteries Go ships with — io, bytes, encoding, net, and more — and why you reach for a dependency far less often than elsewhere. ### Unit 6 — Go in the Wild Logging, project layout, idioms, and reading real code — then your next steps. - [Logging with slog](https://gophertrunk.org/learn/programming-go/logging-and-slog/): Structured logging with the standard log/slog package — levels, fields, and why a running service logs in structured form, not just printed lines. - [Structuring a Go project](https://gophertrunk.org/learn/programming-go/project-structure/): The cmd, internal, and package conventions that shape real Go repositories — where code goes and why, using GopherTrunk's layout as the map. - [Writing idiomatic Go](https://gophertrunk.org/learn/programming-go/idiomatic-go/): The conventions that make Go code look and read the same everywhere — naming, accepting interfaces, handling errors, and avoiding cleverness. - [Reading a real Go codebase](https://gophertrunk.org/learn/programming-go/reading-real-go/): A guided tour of how a working SDR engine like GopherTrunk is structured in Go — packages, interfaces, and goroutines you can now recognize. - [Where to go next](https://gophertrunk.org/learn/programming-go/next-steps-in-go/): Idiomatic Go, the tooling ecosystem, the community, and a short project ladder to take you from this path to shipping your own Go programs. ### Glossary - [Glossary of Go terms](https://gophertrunk.org/learn/programming-go/glossary/): Plain-language definitions for every Go term in the path — goroutine, channel, interface, slice, struct, method, package, module, and more — cross-linked to the lessons. ## Learn Digital Signal Processing (learning module) Software-defined radio is digital signal processing wearing an antenna. This path takes the ideas the RF & SDR module introduces and shows how they become code — sampling, the Fourier transform, filters, downconversion, demodulation, and clock recovery — then maps every one of them onto the pipeline GopherTrunk runs to decode digital trunked voice. Start: https://gophertrunk.org/learn/dsp/ ### Unit 1 — Signals as Numbers How a continuous wave becomes an array your code can work on. - [What is DSP?](https://gophertrunk.org/learn/dsp/what-is-dsp/): Why we process signals with numbers instead of analog circuits, what a digital signal processor does, and where DSP sits in a software radio. - [What is a signal?](https://gophertrunk.org/learn/dsp/what-is-a-signal/): Amplitude, phase, and the sine wave that underlies everything — the vocabulary of signals before we start turning them into numbers. - [Sampling & quantization](https://gophertrunk.org/learn/dsp/sampling-and-quantization/): Turning a wave into samples — sample rate, the Nyquist limit, bit depth, and the aliasing and quantization noise that come with digitizing. - [Complex signals & I/Q](https://gophertrunk.org/learn/dsp/complex-signals-and-iq/): Why SDRs carry signals as complex I/Q pairs, what the imaginary part really means, and how negative frequency becomes a useful, everyday idea. - [Decibels & dynamic range](https://gophertrunk.org/learn/dsp/the-decibel-in-dsp/): Why signal levels are measured in decibels, how dB math turns multiplication into addition, and what dynamic range means for a sampled signal. ### Unit 2 — The Frequency Domain Seeing a signal as its component frequencies — the Fourier view. - [The Fourier transform](https://gophertrunk.org/learn/dsp/the-fourier-transform/): The single idea that any signal is a sum of sine waves — what the transform computes, and why the frequency domain makes filtering and detection easy. - [The FFT in practice](https://gophertrunk.org/learn/dsp/the-fft/): How the Fast Fourier Transform makes the DFT computable in real time, bin resolution, the time-vs-frequency tradeoff, and what a waterfall really shows. - [Windows & spectral leakage](https://gophertrunk.org/learn/dsp/windows-and-leakage/): Why chopping a signal into blocks smears energy across bins, and how window functions trade resolution for cleaner spectra. - [Spectrograms & the STFT](https://gophertrunk.org/learn/dsp/spectrograms-and-stft/): The short-time Fourier transform — sliding the FFT along a signal to see how its spectrum changes over time, the math behind a waterfall. - [The analytic signal & Hilbert transform](https://gophertrunk.org/learn/dsp/the-analytic-signal/): How a real signal becomes complex I/Q in the first place — the Hilbert transform, the analytic signal, and why it removes the negative-frequency mirror. ### Unit 3 — Filters Selecting the signal you want and throwing away the rest. - [Convolution & impulse response](https://gophertrunk.org/learn/dsp/convolution-and-impulse-response/): The operation at the heart of every filter — what an impulse response is, and how sliding-and-summing in time equals multiplying in frequency. - [Filter design basics](https://gophertrunk.org/learn/dsp/filter-design-basics/): Passband, stopband, transition width, and ripple — the specification you hand a filter designer, and how those choices trade off against each other. - [FIR filters](https://gophertrunk.org/learn/dsp/fir-filters/): Finite impulse response filters — taps, linear phase, and how to design a low-pass filter to isolate one channel from a wideband capture. - [IIR filters](https://gophertrunk.org/learn/dsp/iir-filters/): Infinite impulse response filters — feedback, poles and zeros, far fewer taps, and the stability and phase tradeoffs that come with them. - [Decimation & resampling](https://gophertrunk.org/learn/dsp/decimation-and-resampling/): Changing sample rate without aliasing — decimation, interpolation, and rational resampling — how an SDR narrows 2.4 MS/s down to a 48 kHz channel. - [Matched filters & pulse shaping](https://gophertrunk.org/learn/dsp/matched-filters-and-pulse-shaping/): Root-raised-cosine filters, the Nyquist no-ISI criterion, and why a matched filter at the receiver maximizes SNR right where symbols are decided. ### Unit 4 — From Signal to Bits Tuning, demodulating, and recovering the data hidden in the wave. - [Mixing & downconversion](https://gophertrunk.org/learn/dsp/mixing-and-downconversion/): Multiplying by a local oscillator to shift a signal to baseband — the digital downconverter (DDC) that centres a channel before it is decoded. - [Demodulation in code](https://gophertrunk.org/learn/dsp/demodulation/): Recovering the message from a carrier — AM, FM, and phase demodulation as arithmetic on I/Q samples, and how C4FM voice starts to appear. - [Clock & symbol recovery](https://gophertrunk.org/learn/dsp/clock-and-symbol-recovery/): Finding where each symbol begins when you have no shared clock — timing error detectors, interpolation, and the loop that locks onto the data rate. - [Carrier & frequency recovery](https://gophertrunk.org/learn/dsp/carrier-and-frequency-recovery/): Correcting the frequency and phase offset between transmitter and receiver — the PLL and Costas loop that lock a carrier before symbols can be read. - [Gain & automatic gain control](https://gophertrunk.org/learn/dsp/gain-and-agc/): Keeping a signal at a usable amplitude as it fades — how an AGC loop works and why the demodulator needs stable levels to decide symbols correctly. - [Constellations & symbol mapping](https://gophertrunk.org/learn/dsp/constellations-and-symbol-mapping/): Reading digital modulation as points on the I/Q plane — how PSK and QAM map bits to symbols, and what a constellation diagram tells you. - [Equalization & multipath](https://gophertrunk.org/learn/dsp/equalization/): Why reflections smear symbols together and how an equalizer undoes a channel's distortion — the filter that adapts to clean up inter-symbol interference. ### Unit 5 — Signal Quality & Coding Measuring how well a decode is working, and the coding that protects the bits. - [SNR, EVM & BER](https://gophertrunk.org/learn/dsp/snr-evm-and-ber/): The three numbers that measure a digital link's health — signal-to-noise ratio, error-vector magnitude, and bit error rate — and how they relate. - [The eye diagram](https://gophertrunk.org/learn/dsp/the-eye-diagram/): Overlaying symbol periods into an "eye" — how to read timing margin, noise, and inter-symbol interference at a glance from one picture. - [Error correction & framing](https://gophertrunk.org/learn/dsp/error-correction-and-framing/): How raw symbols become trustworthy data — sync words, framing, interleaving, and forward error correction that fix bit errors before decoding. - [Real-time processing & buffering](https://gophertrunk.org/learn/dsp/real-time-and-buffering/): Block processing, ring buffers, latency, and keeping up with the sample stream — the engineering that makes DSP run live instead of offline. ### Unit 6 — DSP in Practice Put the whole chain together the way a real decoder does. - [DSP in GopherTrunk](https://gophertrunk.org/learn/dsp/dsp-in-gophertrunk/): A walkthrough of GopherTrunk's real signal path — capture, downconvert, filter, demodulate, recover symbols — mapping each stage to the lessons you just learned. - [Testing & debugging DSP](https://gophertrunk.org/learn/dsp/testing-and-debugging-dsp/): Golden vectors, offline replay of captures, and the invariants that catch a broken signal path — how you prove a decoder actually works. - [Fixed vs floating point & performance](https://gophertrunk.org/learn/dsp/fixed-vs-floating-point/): Why real-time DSP cares about how numbers are stored, the tradeoffs of fixed vs floating point, and simple ways to keep a sample pipeline fast. ### Glossary - [Glossary of DSP terms](https://gophertrunk.org/learn/dsp/glossary/): Plain-language definitions for every DSP term in the path — sample rate, Nyquist, I/Q, FFT, FIR, IIR, decimation, mixing, AGC, symbol recovery, and more — cross-linked to the lessons. ## Learn Containers & Deployment (learning module) Writing software is only half the job; getting it running reliably somewhere other than your laptop is the other half. This path covers the modern deployment toolkit — build artifacts, containers and Docker, running services with systemd, secrets and configuration, CI/CD pipelines, and cloud hosting — and finishes by deploying a real application, GopherTrunk, end to end. Start: https://gophertrunk.org/learn/deployment/ ### Unit 1 — Foundations What deployment means, its lifecycle, and the artifacts and config it depends on. - [What is deployment?](https://gophertrunk.org/learn/deployment/what-is-deployment/): The journey from source code to a running service, what "it works on my machine" really costs, and the moving parts every deployment has to handle. - [The deployment lifecycle](https://gophertrunk.org/learn/deployment/the-deployment-lifecycle/): Build, test, release, deploy, operate — the repeating cycle every change moves through, and how the rest of this module maps onto its stages. - [Environments & configuration](https://gophertrunk.org/learn/deployment/environments-and-config/): Dev, staging, and production, why the same build must run in all of them, and how environment variables and config files keep settings out of code. - [Build artifacts & versioning](https://gophertrunk.org/learn/deployment/build-artifacts-and-versioning/): What a build produces, why a single reproducible artifact beats rebuilding everywhere, and how version tags let you ship and roll back with confidence. - [Release strategies](https://gophertrunk.org/learn/deployment/release-strategies/): Rolling, blue-green, and canary releases — the patterns for pushing a new version to users without downtime or a risky big-bang cutover. ### Unit 2 — Containers Package an app with everything it needs to run, anywhere — safely. - [What is a container?](https://gophertrunk.org/learn/deployment/what-is-a-container/): Containers vs virtual machines, the isolation the kernel provides, and why "ship the whole environment" solves the works-on-my-machine problem. - [Writing a Dockerfile](https://gophertrunk.org/learn/deployment/writing-a-dockerfile/): Build an image step by step — base images, layers, and multi-stage builds — and how GopherTrunk's own Dockerfile turns Go source into a small runtime image. - [Optimizing container images](https://gophertrunk.org/learn/deployment/container-image-optimization/): Small, fast, secure images — multi-stage builds, minimal and distroless bases, layer-cache ordering, and .dockerignore — and why GopherTrunk's image is tiny. - [Images & registries](https://gophertrunk.org/learn/deployment/images-and-registries/): How images are named, tagged, stored, and shared through registries, and how a pull-and-run makes deploying somewhere new a one-line operation. - [Multi-container apps with Compose](https://gophertrunk.org/learn/deployment/docker-compose/): Describe an app and its dependencies as one file — services, networks, and volumes — and bring the whole stack up with a single command. - [Container networking & volumes](https://gophertrunk.org/learn/deployment/container-networking-and-volumes/): How containers get an IP, talk to each other, publish ports, and persist data — the networking and storage model beneath a Compose file. - [Container security](https://gophertrunk.org/learn/deployment/container-security/): Running as non-root, dropping capabilities, read-only filesystems, and scanning images — giving a container exactly the access it needs and no more. ### Unit 3 — Running in Production Keep a service alive, reachable, observable, and configured safely. - [Services & systemd](https://gophertrunk.org/learn/deployment/services-and-systemd/): Turn a program into a managed service that starts on boot and restarts on failure, using the systemd unit GopherTrunk ships as the example. - [Reverse proxies & TLS](https://gophertrunk.org/learn/deployment/reverse-proxies-and-tls/): Putting a service behind nginx or Caddy — terminating HTTPS, routing by host, and why the proxy, not the app, usually handles certificates. - [Logging & health checks](https://gophertrunk.org/learn/deployment/logging-and-health-checks/): How a running service tells you it's healthy — structured logs, health endpoints, and the signals an orchestrator uses to restart what is broken. - [Secrets & configuration management](https://gophertrunk.org/learn/deployment/secrets-and-configuration/): Keeping API keys and passwords out of images and repos — environment injection, secret stores, and the difference between config and secrets. - [Backups & persistent data](https://gophertrunk.org/learn/deployment/backups-and-data/): Where a service's data lives, how to back it up and restore it, and why stateful data needs a plan that stateless containers don't. - [Production hardening](https://gophertrunk.org/learn/deployment/production-hardening/): Least privilege, firewalls, updates, and the systemd sandboxing GopherTrunk ships — locking a deployment down against the threats a real host faces. ### Unit 4 — Automate & Scale Ship automatically, describe infrastructure as code, and grow to meet load. - [CI/CD pipelines](https://gophertrunk.org/learn/deployment/ci-cd-pipelines/): Automating build, test, and release so every commit is shippable — what a pipeline does, and how GopherTrunk uses GitHub Actions to build and publish. - [Infrastructure as code](https://gophertrunk.org/learn/deployment/infrastructure-as-code/): Describing servers and services declaratively so environments are reproducible — the idea behind tools like Terraform and Ansible, versioned like code. - [Deploying to the cloud & VPS](https://gophertrunk.org/learn/deployment/deploying-to-cloud-and-vps/): The hosting spectrum — a VPS you manage, managed platforms, and container services — and how to choose based on control, cost, and effort. - [Container orchestration](https://gophertrunk.org/learn/deployment/container-orchestration/): What Kubernetes and its cousins actually do — scheduling, self-healing, and scaling many containers — and how to tell when you truly need one. - [Scaling & load balancing](https://gophertrunk.org/learn/deployment/scaling-and-load-balancing/): Scaling up vs out, stateless vs stateful services, and how a load balancer spreads traffic across instances — the mechanics of handling more users. - [Zero-downtime deploys](https://gophertrunk.org/learn/deployment/zero-downtime-deploys/): Health-gated rollouts, draining connections, and rollback — how to replace a running version without dropping a single request. ### Unit 5 — Operate Keep a live system healthy: monitor it, get alerted, respond, and control cost. - [Monitoring & updates](https://gophertrunk.org/learn/deployment/monitoring-and-updates/): Keeping a deployment healthy over time — metrics and alerts, rolling out new versions safely, and rolling back when a release goes wrong. - [Observability — metrics, logs & traces](https://gophertrunk.org/learn/deployment/observability/): The three pillars that let you understand a running system — metrics, logs, and traces — and how they answer "is it up?", "what happened?", and "why is it slow?". - [Alerting & on-call](https://gophertrunk.org/learn/deployment/alerting-and-oncall/): Turning metrics into pages that matter — good alert thresholds, avoiding alert fatigue, and what being on-call for a service actually means. - [Incident response & runbooks](https://gophertrunk.org/learn/deployment/incident-response/): What to do when production breaks — detecting, mitigating, and communicating during an incident, and the runbooks and postmortems that prevent the next one. - [Cost & resource management](https://gophertrunk.org/learn/deployment/cost-and-resources/): Right-sizing CPU and memory, understanding what cloud resources cost, and keeping a deployment affordable without starving it. ### Unit 6 — Applied Deploy a real application from start to finish. - [Deploying GopherTrunk end to end](https://gophertrunk.org/learn/deployment/deploying-gophertrunk/): A complete worked example — container image, docker-compose stack, and a systemd service — taking GopherTrunk from a repo to a running scanner on a server. ### Glossary - [Glossary of deployment terms](https://gophertrunk.org/learn/deployment/glossary/): Plain-language definitions for every deployment term in the path — container, image, registry, Dockerfile, Compose, systemd, CI/CD, artifact, secret, and more — cross-linked to the lessons. ## Learn Databases & Data (learning module) Almost every program you build eventually needs to remember something — a user, a setting, a log of decoded calls. A database is where that data lives: structured so you can store it reliably and get it back fast. This module starts from why plain files aren't enough, builds up the relational model and SQL — the language nearly every database speaks — then teaches you to design data well, reach beyond relational to key-value, document, time-series, and vector stores, and finally talk to a database from your own code and run one in production. Examples lean on real software, including how a project like GopherTrunk stores the calls and systems it decodes. Pairs with the Software Engineering and AI Software Development paths; no prior database experience assumed. Start: https://gophertrunk.org/learn/databases/ ### Unit 1 — Why Data Needs Structure What a database is and the ideas underneath it: persistence, the relational model, schemas and types, and the keys that tie data together. - [What a database is (and why not just files)](https://gophertrunk.org/learn/databases/what-is-a-database/): The problem databases solve — storing data so many readers and writers can query it reliably, safely, and fast, instead of hand-rolling files. - [Data, state & persistence](https://gophertrunk.org/learn/databases/data-and-persistence/): The difference between data your program holds in memory and data that outlives it — persistence, durability, and why "save it somewhere" is harder than it looks. - [The relational model — tables, rows & columns](https://gophertrunk.org/learn/databases/the-relational-model/): The idea that has run the data world for fifty years — organising data into tables of rows and columns, and why that simple shape is so powerful. - [Schemas, columns & data types](https://gophertrunk.org/learn/databases/schemas-and-types/): A schema is the shape of your data — the columns, their types, and the rules — and why deciding it up front saves you from a mess later. - [Keys & relationships](https://gophertrunk.org/learn/databases/keys-and-relationships/): Primary keys that name each row and foreign keys that link tables — how a database models the relationships between your things. ### Unit 2 — SQL, the Language of Data The query language almost every database understands: selecting, filtering, joining, aggregating, changing data, and making it all fast with indexes. - [What SQL is](https://gophertrunk.org/learn/databases/what-is-sql/): The declarative language for talking to a relational database — you describe the data you want, not how to fetch it, and the database works out the rest. - [Querying with SELECT](https://gophertrunk.org/learn/databases/querying-with-select/): The single most-used statement in all of software — SELECT — and how to ask a database for exactly the columns and rows you need. - [Filtering, sorting & limiting](https://gophertrunk.org/learn/databases/filtering-and-sorting/): WHERE, ORDER BY, and LIMIT — narrowing a result set to the rows that matter, in the order you want, without dragging back the whole table. - [Joining tables](https://gophertrunk.org/learn/databases/joins/): The heart of relational power — combining rows from two tables on a shared key, and the difference between inner and outer joins. - [Aggregation & GROUP BY](https://gophertrunk.org/learn/databases/aggregation-and-grouping/): Turning many rows into a summary — counts, sums, and averages — with GROUP BY and HAVING, the tools behind every dashboard number. - [Inserting, updating & deleting](https://gophertrunk.org/learn/databases/inserting-updating-deleting/): The write side of SQL — INSERT, UPDATE, and DELETE — and the WHERE clause you forget at your peril. - [Indexes & how queries get fast](https://gophertrunk.org/learn/databases/indexes/): Why the same query can take a millisecond or a minute — indexes, what they cost, and the mental model of a book's index that explains them. ### Unit 3 — Designing Data Well Turning a pile of columns into a sound design: normalization, modeling a real app, constraints, transactions, and evolving the schema safely over time. - [Normalization & avoiding duplication](https://gophertrunk.org/learn/databases/normalization/): Why storing the same fact in two places will eventually betray you — normalization, and the handful of normal forms worth actually knowing. - [Data modeling for a real app](https://gophertrunk.org/learn/databases/data-modeling/): Going from "what does my app do" to a set of tables and relationships — the practical craft of modeling data before you write a line of code. - [Constraints & data integrity](https://gophertrunk.org/learn/databases/constraints-and-integrity/): Letting the database enforce the rules — NOT NULL, UNIQUE, CHECK, and foreign-key constraints that keep bad data out no matter what the app does. - [Transactions & ACID](https://gophertrunk.org/learn/databases/transactions-and-acid/): All-or-nothing changes — transactions, the ACID guarantees behind them, and why moving money (or updating two tables) needs them. - [Schema migrations & evolving a database](https://gophertrunk.org/learn/databases/migrations/): Your schema is never finished — migrations are how you change a live database's shape safely, in version control, without losing data. ### Unit 4 — Beyond Relational The other database families and when they beat a table: key-value and document stores, time-series and analytics, vector search, and caching layers. - [SQL vs. NoSQL](https://gophertrunk.org/learn/databases/sql-vs-nosql/): What "NoSQL" actually means, the tradeoff it makes, and how to tell when a non-relational store fits a problem better than tables do. - [Key-value & document stores](https://gophertrunk.org/learn/databases/key-value-and-document/): Two of the most common NoSQL shapes — the dictionary-like key-value store and the JSON-document store — and the jobs each is built for. - [Time-series & analytical stores](https://gophertrunk.org/learn/databases/time-series-and-analytics/): Databases tuned for when-it-happened data and for crunching huge tables — time-series and column stores, and why your metrics live in one. - [Vector databases & similarity search](https://gophertrunk.org/learn/databases/vector-databases/): The store behind AI retrieval — embeddings as vectors, searching by meaning instead of keywords, and how RAG features lean on it. - [Caching layers](https://gophertrunk.org/learn/databases/caching-layers/): Keeping hot data in fast memory in front of the database — caches like Redis, what they buy you, and the classic hard problem of keeping them fresh. ### Unit 5 — Using a Database From Code Wiring a database into a program: connecting, pooling connections, ORMs versus raw SQL, defending against injection, and doing it all in Go. - [Connecting from your program](https://gophertrunk.org/learn/databases/connecting-from-code/): Drivers, connection strings, and credentials — how a running program actually opens a link to a database and sends it queries. - [Connection pools](https://gophertrunk.org/learn/databases/connection-pooling/): Opening a connection is expensive, so real apps reuse a pool of them — what a pool is, why you need one, and how to size it. - [ORMs vs. raw SQL](https://gophertrunk.org/learn/databases/orms-vs-raw-sql/): The perennial choice — let a library map objects to rows, or write SQL by hand — what each buys you and what each costs. - [SQL injection & querying safely](https://gophertrunk.org/learn/databases/sql-injection/): The classic, still-common vulnerability where user input becomes SQL — how it happens and why parameterised queries end it. - [Talking to a database from Go](https://gophertrunk.org/learn/databases/databases-in-go/): The Go way — database/sql, drivers, prepared statements, and querying safely — with the patterns GopherTrunk-style services use. ### Unit 6 — Running a Database in Production Everything applied: keeping data safe with backups, scaling with replication, watching performance, choosing the right database, and the data behind GopherTrunk. - [Backups & recovery](https://gophertrunk.org/learn/databases/backups-and-recovery/): The single most important operational habit — backups you have actually restored, point-in-time recovery, and testing them before you need them. - [Replication, sharding & scaling](https://gophertrunk.org/learn/databases/replication-and-scaling/): When one server isn't enough — read replicas, sharding, and the CAP tradeoffs that shape how a database scales out. - [Performance tuning & monitoring](https://gophertrunk.org/learn/databases/performance-and-monitoring/): Finding the slow query before your users do — EXPLAIN, query plans, the metrics that matter, and the usual suspects behind a sluggish database. - [Choosing a database](https://gophertrunk.org/learn/databases/choosing-a-database/): SQLite, Postgres, MySQL, a document store, a managed service like Supabase — a practical framework for picking the right one for a project. - [Data in GopherTrunk](https://gophertrunk.org/learn/databases/data-in-gophertrunk/): A worked example — how a scanner like GopherTrunk models systems, talkgroups, and decoded calls, and stores them for search and playback. ### Glossary - [Glossary of database terms](https://gophertrunk.org/learn/databases/glossary/): Plain-language definitions for every term in the module — database, schema, SQL, primary and foreign key, join, index, normalization, transaction, ACID, NoSQL, vector store, ORM, migration, replica, and more — cross-linked to the lessons. ## Learn Web Development (learning module) The web is where most software meets its users. This module is the working developer's tour of how a web app is built — not a framework tutorial, but the durable ideas that outlast any framework. Start with how the browser and the client-server web actually work, learn the front-end trio of HTML, CSS, and JavaScript and how modern component frameworks build on them, then cross to the back end: HTTP servers, REST APIs, and the database behind them. From there you'll handle the parts that separate a page from a product — auth and sessions, real-time updates, web security, caching — and finish by shipping, measuring, and operating a real web app, using GopherTrunk's own web dashboard as the worked example. Pairs with the Networking, Databases, and Deployment modules; a little programming experience helps but no web background is assumed. Start: https://gophertrunk.org/learn/web-dev/ ### Unit 1 — How the Web Works (for Building) The mental model every web developer needs: what web development is, how the browser renders a page, the client-server web, the anatomy of a web app, and static versus dynamic. - [What web development is](https://gophertrunk.org/learn/web-dev/what-is-web-development/): The lay of the land — front end, back end, and full stack — and what actually happens between typing a URL and seeing a page. - [How the browser works](https://gophertrunk.org/learn/web-dev/how-the-browser-works/): The most important program in web development — how a browser fetches, parses, and renders HTML, CSS, and JavaScript into the page you see. - [The client-server web](https://gophertrunk.org/learn/web-dev/client-server-web/): Every web interaction is a request and a response — the client-server model on the web, building on how a web request works under the hood. - [Anatomy of a modern web app](https://gophertrunk.org/learn/web-dev/anatomy-of-a-web-app/): The pieces and how they fit — front end, back end, database, and the APIs between them — the map the rest of the module fills in. - [Static vs. dynamic sites](https://gophertrunk.org/learn/web-dev/static-vs-dynamic/): A file served as-is versus a page built on the fly — the spectrum from static sites to full web apps, and why this very site is static. ### Unit 2 — The Front-End Trio The three languages of the browser and how a user interacts with them: HTML structure, CSS styling, JavaScript behaviour, the DOM, forms, and accessibility. - [HTML — structure & semantics](https://gophertrunk.org/learn/web-dev/html-structure/): The skeleton of every page — HTML elements, semantic markup, and why the right tag matters for meaning, accessibility, and search. - [CSS — styling & layout](https://gophertrunk.org/learn/web-dev/css-and-layout/): How a page goes from plain text to designed — selectors, the box model, and the flexbox and grid layout systems modern sites are built on. - [JavaScript in the browser](https://gophertrunk.org/learn/web-dev/javascript-in-the-browser/): The language that makes pages interactive — what JavaScript does in the browser, events, and where it runs versus server-side code. - [The DOM — manipulating the page](https://gophertrunk.org/learn/web-dev/the-dom/): The live tree the browser builds from your HTML — the DOM — and how JavaScript reads and changes it to update the page without a reload. - [Forms & user input](https://gophertrunk.org/learn/web-dev/forms-and-user-input/): How the web takes input — forms, validation, and safely getting what a user types from the browser to your server. - [Accessibility basics](https://gophertrunk.org/learn/web-dev/accessibility-basics/): Building for everyone — semantic HTML, keyboard use, contrast, and ARIA — the accessibility fundamentals that are also just good engineering. ### Unit 3 — The Front End at Scale How real front ends are built today: component frameworks, state, fetching data from the browser, the build toolchain, and responsive design. - [Front-end frameworks](https://gophertrunk.org/learn/web-dev/frontend-frameworks/): Why React and its peers exist — the problem of keeping a complex UI in sync with data, and what a framework does that hand-written DOM code doesn't. - [Components & state](https://gophertrunk.org/learn/web-dev/components-and-state/): The building block of modern UIs — a component — and the idea of state that drives what it shows, the core mental model of every framework. - [Fetching data from the front end](https://gophertrunk.org/learn/web-dev/fetching-data/): How a page pulls fresh data without reloading — fetch, JSON, async requests, and talking to an API from the browser. - [Build tools & bundlers](https://gophertrunk.org/learn/web-dev/build-tools-and-bundlers/): What turns your source into what the browser downloads — bundlers, transpiling, and why modern front ends have a build step at all. - [Responsive design](https://gophertrunk.org/learn/web-dev/responsive-design/): One site, every screen — fluid layouts, media queries, and the mobile-first mindset that keeps a page usable from phone to desktop. ### Unit 4 — The Back End The server side of a web app: what a back end does, HTTP servers and routing, building a REST API, the database behind it, rendering strategies, and templating. - [What a back end does](https://gophertrunk.org/learn/web-dev/what-a-backend-does/): The work that can't happen in the browser — business logic, data, auth, and secrets — and why a web app needs a server behind it. - [HTTP servers & routing](https://gophertrunk.org/learn/web-dev/http-servers-and-routing/): How a server answers the web — listening for requests, routing a URL and method to the right handler, and returning a response. - [Building a REST API](https://gophertrunk.org/learn/web-dev/building-a-rest-api/): The contract between front and back end — resources, HTTP verbs, status codes, and JSON — assembled into an API a front end can consume. - [The back end & its database](https://gophertrunk.org/learn/web-dev/backend-and-database/): Where the server meets the data layer — how a back end reads and writes a database safely, and where the boundary belongs. - [SSR vs. SPA vs. static](https://gophertrunk.org/learn/web-dev/ssr-spa-static/): Three ways to build a page — rendered on the server, in the browser, or ahead of time — what each is good at, and how to choose. - [Templating & static site generators](https://gophertrunk.org/learn/web-dev/templating-and-static-sites/): Generating HTML from templates and data — server-side templating and static generators like the Jekyll build behind this very site. ### Unit 5 — Auth, Sessions & Real-Time The features that make a web app real and safe: authentication and sessions, cookies and tokens, live updates over WebSockets, web security, and caching. - [Authentication & sessions](https://gophertrunk.org/learn/web-dev/authentication-and-sessions/): Knowing who a user is across stateless requests — logging in, sessions, and the difference between authentication and authorization on the web. - [Cookies, tokens & JWTs](https://gophertrunk.org/learn/web-dev/cookies-tokens-jwt/): How the browser remembers you between requests — cookies, bearer tokens, and JWTs — and the tradeoffs and pitfalls of each. - [WebSockets & real-time updates](https://gophertrunk.org/learn/web-dev/websockets-and-realtime/): When request-response isn't enough — pushing live data to the browser over WebSockets, the way a live scanner dashboard updates. - [Web security essentials](https://gophertrunk.org/learn/web-dev/web-security-essentials/): The vulnerabilities every web dev must know — XSS, CSRF, and CORS — how they work and the defenses that stop them. - [Caching & CDNs](https://gophertrunk.org/learn/web-dev/caching-and-cdns/): Making the web fast — browser caches, HTTP cache headers, and content delivery networks that serve your site from close to the user. ### Unit 6 — Shipping a Web App From working locally to running for users: deploying, measuring performance, monitoring, choosing a stack, and a look at GopherTrunk's own dashboard. - [Deploying a web app](https://gophertrunk.org/learn/web-dev/deploying-a-web-app/): Getting your app onto the internet — build, host, and serve the front end and back end, connecting to the deployment module's toolkit. - [Performance & Core Web Vitals](https://gophertrunk.org/learn/web-dev/performance-and-web-vitals/): What "fast" means on the web and how it's measured — load, interactivity, and layout stability — and the levers that move them. - [Monitoring & analytics](https://gophertrunk.org/learn/web-dev/monitoring-and-analytics/): Knowing what your app does in the wild — error tracking, uptime, and privacy-respecting analytics — after it ships. - [Choosing your web stack](https://gophertrunk.org/learn/web-dev/choosing-a-web-stack/): A practical framework for the endless "what should I use" question — matching front end, back end, and hosting to the project in front of you. - [The GopherTrunk web dashboard](https://gophertrunk.org/learn/web-dev/gophertrunk-web-dashboard/): A worked example — how a live dashboard for a scanner is built, from the API that serves decoded calls to the browser that shows them in real time. ### Glossary - [Glossary of web-development terms](https://gophertrunk.org/learn/web-dev/glossary/): Plain-language definitions for every term in the module — front end, back end, HTML, CSS, DOM, framework, component, state, REST API, SSR, SPA, session, cookie, JWT, WebSocket, XSS, CSRF, CORS, CDN, and more — cross-linked to the lessons. ## Learn Scanning & Monitoring (learning module) The Digital & Trunked Radio module explains how these systems work on the inside; this one is about actually listening to them. Scanning is the decades- old hobby of monitoring the radio spectrum — public safety, utilities, aviation, business — and this module is the practical craft of doing it well and legally. Start with what scanning is and what you can and can't hear today, build a real listening station out of a scanner or SDR and a decent antenna, learn to find and identify systems in the field, follow trunked calls across a system, and log, record, and share what you hear. It finishes by turning GopherTrunk into an always-on monitoring post. Pairs with the RF & SDR and Digital & Trunked Radio modules; it assumes only curiosity, and everything here stays firmly on the right side of the law. Start: https://gophertrunk.org/learn/scanning/ ### Unit 1 — The Scanning Hobby What radio scanning is and the ground rules: a short history, conventional versus trunked, what's listenable today, and the legal and ethical lines. - [What radio scanning is](https://gophertrunk.org/learn/scanning/what-is-scanning/): The hobby of monitoring live radio traffic — who's on the air, why people listen, and what a modern scanning setup actually does. - [A short history of scanners](https://gophertrunk.org/learn/scanning/history-of-scanning/): From crystal-controlled boxes to SDR — how scanners evolved alongside the radio systems they follow, and why that history still shapes the hobby. - [Conventional vs. trunked, in the field](https://gophertrunk.org/learn/scanning/conventional-vs-trunked-recap/): The one distinction that changes how you scan — a fixed channel you can park on versus a trunked system you have to follow — from the listener's chair. - [What you can (and can't) hear today](https://gophertrunk.org/learn/scanning/what-you-can-hear/): A realistic tour of the spectrum — the analog and unencrypted traffic still open, and the encrypted systems that have gone dark. - [Legal & ethical scanning](https://gophertrunk.org/learn/scanning/scanning-legal-and-ethical/): The rules that keep the hobby healthy — what's legal to receive, what's not legal to do with it, and the etiquette of responsible monitoring. ### Unit 2 — Your Listening Station The gear that puts signals in front of you: scanners versus SDR, choosing hardware, antennas and feedlines, station setup, and beating noise. - [Hardware scanners vs. SDR](https://gophertrunk.org/learn/scanning/scanners-vs-sdr/): The two roads into the hobby — a dedicated scanner you switch on versus an SDR and software like GopherTrunk — and what each is best at. - [Choosing a scanner or SDR](https://gophertrunk.org/learn/scanning/choosing-a-scanner/): Matching hardware to what you want to hear — bands, trunking support, and budget — so you buy the right receiver the first time. - [Antennas for scanning](https://gophertrunk.org/learn/scanning/antennas-for-scanning/): The single biggest upgrade to what you can hear — discones, verticals, and the difference the right antenna makes over the stock whip. - [Feedlines, connectors & grounding](https://gophertrunk.org/learn/scanning/feedlines-and-connectors/): The unglamorous parts that quietly cost you signal — coax loss, connectors, and grounding your station safely. - [Setting up your station](https://gophertrunk.org/learn/scanning/station-setup/): Putting it together — receiver, antenna, and computer — into a working monitoring setup, indoors or on a rooftop. - [Reducing noise & interference](https://gophertrunk.org/learn/scanning/reducing-interference/): Why the city is loud on the radio — where local noise comes from, how to hunt it down, and the filters and habits that cut it. ### Unit 3 — Finding What to Listen To Turning a quiet radio into a busy one: system databases, band plans, searching and discovery, identifying unknown signals, and keeping records. - [RadioReference & system databases](https://gophertrunk.org/learn/scanning/radioreference-database/): The scanning community's shared map of the airwaves — how databases like RadioReference tell you what's on the air near you. - [Band plans & where services live](https://gophertrunk.org/learn/scanning/band-plans/): The spectrum has a floor plan — the bands where public safety, business, aviation, and the rest live, so you know where to look. - [Search, scan & discovery](https://gophertrunk.org/learn/scanning/searching-and-discovery/): Finding what the databases don't list — searching a band, spotting active channels, and close-call techniques for catching nearby transmitters. - [Identifying an unknown signal](https://gophertrunk.org/learn/scanning/identifying-unknown-signals/): You found a signal — now what is it? — using the waterfall, bandwidth, and modulation to name a mystery transmission. - [Building your frequency records](https://gophertrunk.org/learn/scanning/frequency-records/): Turning what you find into a reusable log — organising frequencies, talkgroups, and notes so your setup gets smarter over time. ### Unit 4 — Following Trunked Systems The heart of modern scanning: programming a trunked system, working with talkgroups and scan lists, following a call, multisite and roaming, and troubleshooting. - [Programming a trunked system](https://gophertrunk.org/learn/scanning/programming-a-trunked-system/): Getting a scanner or SDR to follow a trunked system — the control channel, system parameters, and what you actually enter to track it. - [Talkgroups, scan lists & priorities](https://gophertrunk.org/learn/scanning/talkgroups-and-scan-lists/): Deciding what you hear — organising talkgroups into scan lists, locking out the noise, and setting priorities so you never miss the calls you care about. - [Following a call across the system](https://gophertrunk.org/learn/scanning/following-a-call/): What happens in the seconds after a radio keys up — how your setup follows a grant from the control channel to the voice channel and back. - [Multisite, simulcast & roaming](https://gophertrunk.org/learn/scanning/multisite-and-roaming/): Big systems have many sites — picking the right one to monitor, what simulcast does to your signal, and following units as they roam. - [When decoding fails](https://gophertrunk.org/learn/scanning/when-decoding-fails/): The field troubleshooting guide — no control-channel lock, garbled voice, missed calls — and how to tell a signal problem from a setup problem. ### Unit 5 — Logging, Recording & Sharing Getting value out of what you hear: logging and recording calls, tagging them, streaming feeds, alerting on what matters, and building an always-on post. - [Logging & recording calls](https://gophertrunk.org/learn/scanning/logging-and-recording/): Capturing traffic so you can review it later — call logging, per-call recording, and the storage that a busy system quickly demands. - [Metadata, tagging & searchability](https://gophertrunk.org/learn/scanning/metadata-and-tagging/): A recording is only useful if you can find it — tagging calls with talkgroup, time, and system so a month of audio stays searchable. - [Audio feeds & streaming](https://gophertrunk.org/learn/scanning/audio-feeds-and-streaming/): Sharing what you hear — how live scanner feeds like Broadcastify work, and what it takes to put one on the air responsibly. - [Alerting on the calls you care about](https://gophertrunk.org/learn/scanning/alerting-on-calls/): Letting the setup watch for you — triggers and alerts on specific talkgroups or keywords so you're notified when something happens. - [Building an always-on monitoring post](https://gophertrunk.org/learn/scanning/building-a-monitoring-post/): Going from "switch it on when I'm home" to a setup that runs unattended — the hardware, software, and reliability of a 24/7 post. ### Unit 6 — Scanning With GopherTrunk Everything applied with real software: SDR scanning tools, GopherTrunk as a scanner, a full worked setup, the community, and where to go next. - [Scanning with SDR software](https://gophertrunk.org/learn/scanning/scanning-with-sdr-software/): The software side of SDR scanning — the tools that turn a raw receiver into a trunk-tracking scanner, and where GopherTrunk fits among them. - [GopherTrunk as a scanner](https://gophertrunk.org/learn/scanning/gophertrunk-as-a-scanner/): Using GopherTrunk to follow and decode a real system — the control channel, the calls it grants, and the audio that comes out. - [A worked end-to-end monitoring setup](https://gophertrunk.org/learn/scanning/a-worked-monitoring-setup/): Start to finish — antenna, SDR, GopherTrunk, logging, and a dashboard — assembled into a complete, always-on monitoring station. - [The community & contributing data](https://gophertrunk.org/learn/scanning/contributing-and-community/): The hobby runs on shared knowledge — the forums, databases, and open-source projects, and how to give back the systems and fixes you find. - [Where to go next](https://gophertrunk.org/learn/scanning/where-to-go-next/): Where the hobby leads — decoding data modes, digging into protocols, or writing your own decoder — and the modules that take you there. ### Glossary - [Glossary of scanning terms](https://gophertrunk.org/learn/scanning/glossary/): Plain-language definitions for every term in the module — scanner, SDR, control channel, talkgroup, scan list, lockout, simulcast, multisite, roaming, feed, discone, squelch, close call, and more — cross-linked to the lessons. ## Learn Testing & Software Quality (learning module) A guided path from "why did that break?" to confident quality engineering. Understand what bugs really are and what they cost, write your first unit tests in Go, grow into integration and regression testing, master the tooling that keeps a codebase healthy, learn to debug methodically — and then apply all of it the way GopherTrunk does, where no fix lands without a test that failed first. Start: https://gophertrunk.org/learn/testing/ ### Unit 1 — Why Software Breaks Bugs, what they cost, and the mindset shift from 'it seems to work' to 'I can show it works.' - [Why does software break?](https://gophertrunk.org/learn/testing/why-software-breaks/): Software fails because people encode assumptions — complexity, change, and edge cases turn small oversights into visible failures. - [What is a bug?](https://gophertrunk.org/learn/testing/what-is-a-bug/): Mistake, defect, failure — how a wrong line of code becomes a wrong behavior, and why the distinction shapes how you hunt them. - [What does a bug cost?](https://gophertrunk.org/learn/testing/cost-of-a-bug/): The later a bug is found, the more it costs — from a red test on your laptop to a field failure, with famous disasters as waypoints. - [What is testing?](https://gophertrunk.org/learn/testing/what-is-testing/): Manual vs automated testing, verification vs validation, and the test pyramid — the map for everything this module covers. - [The testing mindset](https://gophertrunk.org/learn/testing/the-testing-mindset/): Thinking adversarially about your own code — assume it's wrong, try to break it, and turn "it seems to work" into evidence. ### Unit 2 — Unit Testing Fundamentals The smallest, fastest tests — how to write them well in Go and what coverage really tells you. - [What is a unit test?](https://gophertrunk.org/learn/testing/what-is-a-unit-test/): One small piece of code, tested in isolation, fast enough to run thousands of times a day — the foundation of the pyramid. - [Anatomy of a test](https://gophertrunk.org/learn/testing/anatomy-of-a-test/): Arrange, act, assert — the three-part shape of every good test, plus naming and the one-behavior-per-test rule. - [Your first Go test](https://gophertrunk.org/learn/testing/your-first-go-test/): Write a _test.go file, run go test, and read a failure — the complete edit-test loop with nothing but the standard library. - [Table-driven tests](https://gophertrunk.org/learn/testing/table-driven-tests/): Go's signature testing idiom — one test body, a table of cases, and subtests that name each row. - [Fakes, stubs, and mocks](https://gophertrunk.org/learn/testing/test-doubles/): Test doubles stand in for slow or unpredictable dependencies — and Go's interfaces make swapping them in natural. - [Code coverage](https://gophertrunk.org/learn/testing/code-coverage/): What coverage measures, how to read go test -cover, and why 100% is the wrong goal. ### Unit 3 — Beyond the Unit Integration, end-to-end, regression, and generative testing — proving whole systems, not just pieces. - [Integration tests](https://gophertrunk.org/learn/testing/integration-tests/): Testing real pieces wired together — databases, files, networks — and the trade of realism against speed. - [End-to-end tests](https://gophertrunk.org/learn/testing/end-to-end-tests/): Drive the whole system the way a user would — the most convincing tests, and the most expensive ones. - [Regression tests & failing first](https://gophertrunk.org/learn/testing/regression-tests/): Every bug fix ships with a test that failed before the fix — the discipline that stops bugs from coming back. - [Golden files & fixtures](https://gophertrunk.org/learn/testing/golden-files-and-fixtures/): Recorded inputs and expected outputs — how captured data turns messy real-world behavior into repeatable tests. - [Property-based testing](https://gophertrunk.org/learn/testing/property-based-testing/): Instead of hand-picking examples, state a property that must always hold and let the computer hunt for a counterexample. - [Fuzzing](https://gophertrunk.org/learn/testing/fuzzing/): Throw randomized, mutated inputs at your code until it crashes — Go's built-in fuzzer and why parsers need it most. ### Unit 4 — Quality Tooling Linters, formatters, code review, and CI — the machinery that keeps a codebase healthy between releases. - [Linters & static analysis](https://gophertrunk.org/learn/testing/linters-and-static-analysis/): Tools that read your code without running it — go vet, staticcheck, and the bug classes they catch for free. - [Formatters & style](https://gophertrunk.org/learn/testing/formatters-and-style/): gofmt ends formatting debates by making one style automatic — and why that's a quality tool, not a cosmetic one. - [Code review](https://gophertrunk.org/learn/testing/code-review/): A second pair of eyes before code merges — how to review, how to be reviewed, and what review catches that tests can't. - [Continuous integration](https://gophertrunk.org/learn/testing/continuous-integration/): Every push builds and tests automatically — pipelines, checks on pull requests, and why CI is the team's shared safety net. - [Flaky tests](https://gophertrunk.org/learn/testing/flaky-tests/): Tests that pass sometimes are worse than tests that fail always — where flakiness comes from and why "flake" is not a root cause. - [Required checks & branch protection](https://gophertrunk.org/learn/testing/required-checks/): Which CI jobs actually gate a merge — and how a green checkmark can hide a red build in a job nobody made required. ### Unit 5 — Debugging & Diagnosis When something is broken: reproduce it, read the evidence, and find the real cause. - [Reproducing a bug](https://gophertrunk.org/learn/testing/reproducing-a-bug/): A bug you can reproduce on demand is already half fixed — minimal reproductions and why "works on my machine" is a clue, not a verdict. - [Reading error messages & stack traces](https://gophertrunk.org/learn/testing/reading-error-messages/): Errors and panics are structured evidence — how to read a Go stack trace from the top and find the line that matters. - [Print debugging & logging](https://gophertrunk.org/learn/testing/print-debugging-and-logging/): The humble print statement, done well — and how structured logs turn one-off debugging into a permanent diagnostic instrument. - [Using a debugger](https://gophertrunk.org/learn/testing/using-a-debugger/): Pause a live program, inspect its state, step line by line — Delve for Go, and when a debugger beats prints. - [Bisecting history](https://gophertrunk.org/learn/testing/bisecting-history/): git bisect turns "it broke sometime this month" into the exact commit, in a dozen automatic steps. - [Root-cause analysis](https://gophertrunk.org/learn/testing/root-cause-analysis/): Keep asking why until the answer would have prevented the bug — fixing symptoms leaves the cause free to strike again. ### Unit 6 — Testing GopherTrunk Apply it all to a real codebase: replay tests, capture-gated verification, and the traps GopherTrunk learned the hard way. - [The make vet test gate](https://gophertrunk.org/learn/testing/make-vet-test/): GopherTrunk's rule that vet plus unit tests must be green before any commit — what runs, and why the gate is non-negotiable. - [Replay: testing a radio without a radio](https://gophertrunk.org/learn/testing/replay-integration-tests/): Recorded IQ captures let GopherTrunk test a whole radio decoder deterministically — the golden-file idea at system scale. - [The self-consistent synthetic trap](https://gophertrunk.org/learn/testing/the-self-consistent-synthetic-trap/): A test whose encoder and decoder share the same wrong assumption passes while the real world fails — GopherTrunk's most instructive bug pattern. - [Capture-gated verification](https://gophertrunk.org/learn/testing/capture-gated-verification/): A fix isn't verified until it works against real captured data — why GopherTrunk refuses to close a bug on a green synthetic test alone. - [Write your first regression test](https://gophertrunk.org/learn/testing/your-first-regression-test/): Walk the full failing-first loop on a real bug — reproduce, write the test that fails, fix, watch it pass, and ship both together. ### Glossary - [Glossary of testing terms](https://gophertrunk.org/learn/testing/glossary/): Plain-language definitions for every term in the module — unit test, assertion, fixture, mock, coverage, regression, CI, flaky test, fuzzing, bisect, root cause, and more — cross-linked to the lessons. ## Learn APIs & Protocols (learning module) A guided path through the interfaces that connect modern software. Start with what an API and a protocol actually are, get comfortable with HTTP and REST, move into real-time push with WebSockets, server-sent events, and webhooks, meet binary RPC with gRPC — then study a working example: the REST, event, and streaming APIs GopherTrunk's own daemon exposes, and build a client against them. Start: https://gophertrunk.org/learn/apis/ ### Unit 1 — API Foundations What APIs and protocols are, who talks to whom, and the data formats requests are made of. - [What is an API?](https://gophertrunk.org/learn/apis/what-is-an-api/): An API is a promise about how one piece of software may use another — the contract idea behind every interface in this module. - [What is a protocol?](https://gophertrunk.org/learn/apis/what-is-a-protocol/): Rules two parties agree on so bytes mean the same thing to both — from radio air interfaces to HTTP, it's the same idea. - [Clients and servers](https://gophertrunk.org/learn/apis/clients-and-servers/): Who asks and who answers — the request/response roles that shape almost every API, and where peer-to-peer differs. - [Data formats: JSON and friends](https://gophertrunk.org/learn/apis/data-formats/): JSON, YAML, and binary encodings — how structured data is serialized so it survives the trip between programs. - [API contracts](https://gophertrunk.org/learn/apis/api-contracts/): The shape of a request and response is a promise — what breaking it costs, and why contracts outlive implementations. ### Unit 2 — HTTP & REST The web's workhorse protocol and the REST conventions most APIs are built on. - [Anatomy of an HTTP request](https://gophertrunk.org/learn/apis/anatomy-of-http/): Method, path, headers, body, status line — dissect one request and one response and you've seen them all. - [REST fundamentals](https://gophertrunk.org/learn/apis/rest-fundamentals/): Resources named by URLs, manipulated with a small set of verbs — the convention that makes unfamiliar APIs feel familiar. - [Methods & status codes](https://gophertrunk.org/learn/apis/methods-and-status-codes/): GET, POST, PUT, PATCH, DELETE and the status-code families — what each one promises and when to use which. - [URLs, query strings, and bodies](https://gophertrunk.org/learn/apis/urls-queries-and-bodies/): Where data rides in a request — path segments, query parameters, and JSON bodies, and how to choose among them. - [API authentication](https://gophertrunk.org/learn/apis/authentication-basics/): API keys, tokens, and sessions — how a server knows who's calling, and why keys never belong in a URL. - [API versioning](https://gophertrunk.org/learn/apis/api-versioning/): How APIs evolve without breaking their clients — additive change, version numbers, and deprecation done politely. ### Unit 3 — Real-Time APIs When request/response isn't enough: pushing events to clients the moment they happen. - [Polling vs push](https://gophertrunk.org/learn/apis/polling-vs-push/): Asking "anything new?" every second vs being told the moment something happens — the trade at the heart of real-time design. - [WebSockets](https://gophertrunk.org/learn/apis/websockets/): One HTTP handshake upgrades to a persistent two-way pipe — the protocol behind live dashboards and chat. - [Server-sent events](https://gophertrunk.org/learn/apis/server-sent-events/): A one-way event stream over plain HTTP — simpler than WebSockets, and enough for most live-update needs. - [Webhooks](https://gophertrunk.org/learn/apis/webhooks/): The server calls you — HTTP callbacks that push events to your endpoint, and the retry and verification care they need. - [Streaming & backpressure](https://gophertrunk.org/learn/apis/streaming-and-backpressure/): What happens when the producer is faster than the consumer — buffering, dropping, and why every real stream needs a plan. ### Unit 4 — RPC & Binary Protocols Calling functions across the network, and the compact binary encodings that make it fast. - [What is RPC?](https://gophertrunk.org/learn/apis/what-is-rpc/): Make a network call look like a function call — the oldest idea in distributed computing, and its sharp edges. - [gRPC & Protocol Buffers](https://gophertrunk.org/learn/apis/grpc-and-protobuf/): Define messages and services in a .proto file, generate typed code, stream in both directions — RPC as practiced today. - [Text vs binary protocols](https://gophertrunk.org/learn/apis/text-vs-binary-protocols/): Human-readable JSON vs compact binary framing — what each costs in bytes, speed, and debuggability. - [Message framing](https://gophertrunk.org/learn/apis/message-framing/): A byte stream has no natural boundaries — length prefixes, delimiters, and what goes wrong when framing drifts. - [Schemas & code generation](https://gophertrunk.org/learn/apis/schemas-and-codegen/): Write the contract once, generate the client and server from it — schemas as the single source of truth. ### Unit 5 — Designing & Operating APIs Designing interfaces people can use, and keeping them honest in production. - [Designing a good API](https://gophertrunk.org/learn/apis/designing-a-good-api/): Consistency, predictability, and small surface area — the qualities that make an API pleasant, and how to get them. - [Error handling](https://gophertrunk.org/learn/apis/error-handling/): Errors are part of the contract — status codes, machine-readable error bodies, and messages that help instead of taunt. - [Rate limiting & quotas](https://gophertrunk.org/learn/apis/rate-limiting-and-quotas/): Protecting a server from its own clients — limits, retry-after, and backing off like a good citizen. - [API documentation](https://gophertrunk.org/learn/apis/api-documentation/): An undocumented API might as well not exist — reference docs, examples, and specs that stay true as code changes. - [API security](https://gophertrunk.org/learn/apis/api-security/): Authentication, authorization, TLS, and input validation — the checklist that keeps an exposed endpoint from becoming an incident. - [Testing an API](https://gophertrunk.org/learn/apis/testing-an-api/): Exercise endpoints with curl and Go's httptest, then pin the contract with automated tests so clients never get surprised. ### Unit 6 — GopherTrunk's APIs A working case study: the REST, event, and streaming interfaces of a real daemon — and a client of your own. - [GopherTrunk's REST API](https://gophertrunk.org/learn/apis/the-daemon-rest-api/): The daemon's HTTP API in practice — talkgroups, radio IDs, call history — and how the web console is just another client. - [Live events & webhooks](https://gophertrunk.org/learn/apis/live-events-and-webhooks/): Server-sent events and webhooks carry every call and system event out of the daemon — subscribe once, react in real time. - [Streaming audio with gRPC](https://gophertrunk.org/learn/apis/streaming-audio-with-grpc/): Live call audio rides a gRPC stream — the binary-RPC lessons of Unit 4 applied to real-time voice. - [The web console's sockets](https://gophertrunk.org/learn/apis/web-console-sockets/): Spectrum and symbol panels ride WebSockets — and GopherTrunk's own reconnect-backoff bug is a masterclass in real-time client design. - [Build your own client](https://gophertrunk.org/learn/apis/building-your-own-client/): Put the whole module to work — a small program that queries the REST API and follows the live event stream. ### Glossary - [Glossary of API & protocol terms](https://gophertrunk.org/learn/apis/glossary/): Plain-language definitions for every term in the module — API, endpoint, REST, HTTP method, status code, token, WebSocket, SSE, webhook, RPC, protobuf, framing, rate limit, and more — cross-linked to the lessons. ## Learn Embedded & Single-Board Computers (learning module) A guided path into the small computers that run the physical world. Learn what embedded systems and single-board computers are, choose and set up a board of your own, run it headless like a pro, connect it to hardware, keep it alive 24/7 — and finish by building the classic GopherTrunk project: a Raspberry Pi scanner appliance that decodes trunked radio around the clock. Start: https://gophertrunk.org/learn/embedded/ ### Unit 1 — The Small-Computer Landscape Embedded systems, single-board computers, microcontrollers, and the chips inside them. - [What is an embedded system?](https://gophertrunk.org/learn/embedded/what-is-embedded/): Computers hidden inside things — what makes a system "embedded," and why most of the computers you own don't look like computers. - [SBC vs microcontroller vs PC](https://gophertrunk.org/learn/embedded/sbc-vs-microcontroller-vs-pc/): Raspberry Pi, Arduino, and a desktop solve different problems — the capability ladder and how to pick the right rung. - [ARM and the system-on-chip](https://gophertrunk.org/learn/embedded/arm-and-socs/): One chip carrying CPU, GPU, memory controller, and I/O — why ARM SoCs power nearly every small board. - [Why the Raspberry Pi?](https://gophertrunk.org/learn/embedded/why-the-raspberry-pi/): Price, community, and software support made the Pi the default SBC — what the ecosystem gives you and where rivals win. - [Operating systems for small boards](https://gophertrunk.org/learn/embedded/operating-systems-for-sbcs/): Most boards run real Linux — what a Pi OS image contains, and how it differs from the Linux on a server or laptop. ### Unit 2 — Choosing Your Hardware Boards, storage, power, and cooling — the buying decisions that make or break a build. - [Picking a board](https://gophertrunk.org/learn/embedded/picking-a-board/): RAM, CPU cores, USB bandwidth, and connectivity — matching a board's spec sheet to the job you're actually giving it. - [Storage & SD cards](https://gophertrunk.org/learn/embedded/storage-and-sd-cards/): SD cards, USB drives, and SSDs — speed classes, endurance, and why storage is the most common weak link. - [Power supplies](https://gophertrunk.org/learn/embedded/power-supplies/): Undervoltage is the classic mystery failure — amps, volts, cable quality, and powering a board that also powers peripherals. - [Cases & cooling](https://gophertrunk.org/learn/embedded/cases-and-cooling/): Heatsinks, fans, and airflow — keeping a small board cool enough to run at full speed in a closed box. - [When you need more than a Pi](https://gophertrunk.org/learn/embedded/when-you-need-more/): Signs your project has outgrown an SBC — and the step up to mini PCs and small servers when it has. ### Unit 3 — Headless Linux on a Board No monitor, no keyboard — flash it, find it, SSH in, and run services like a server. - [Flashing an OS image](https://gophertrunk.org/learn/embedded/flashing-an-os-image/): Write an operating system onto an SD card, preconfigure Wi-Fi and SSH, and boot a board you'll never plug a monitor into. - [First boot & SSH](https://gophertrunk.org/learn/embedded/first-boot-and-ssh/): Find the board on your network and log in over SSH — the moment your SBC becomes a tiny server. - [Users, permissions & updates](https://gophertrunk.org/learn/embedded/users-and-updates/): Change default passwords, create your own user, and keep packages patched — basic hygiene for an always-on device. - [Services with systemd](https://gophertrunk.org/learn/embedded/services-with-systemd/): Turn a program into a service that starts at boot and restarts on failure — the unit file every appliance is built on. - [Networking your board](https://gophertrunk.org/learn/embedded/networking-your-board/): Static addresses, hostnames, Wi-Fi vs Ethernet, and reaching a headless board reliably from anywhere on your LAN. ### Unit 4 — Talking to the Physical World GPIO, USB, serial buses, and add-on boards — where software meets wires. - [GPIO basics](https://gophertrunk.org/learn/embedded/gpio-basics/): General-purpose pins you control from code — inputs, outputs, blinking an LED, and reading a button safely. - [USB & powered hubs](https://gophertrunk.org/learn/embedded/usb-and-powered-hubs/): USB is how most real peripherals arrive — bus power budgets, powered hubs, and why flaky USB is usually a power story. - [Serial, I2C & SPI](https://gophertrunk.org/learn/embedded/serial-i2c-spi/): The three little buses that connect chips to computers — what each is for and how to recognize them on a pinout. - [HATs & add-ons](https://gophertrunk.org/learn/embedded/hats-and-add-ons/): Stackable boards that add radios, screens, relays, and sensors — how HATs identify themselves and share the header. - [Connecting an SDR](https://gophertrunk.org/learn/embedded/connecting-an-sdr/): An RTL-SDR on a Pi is the classic pairing — drivers, USB bandwidth, and testing your dongle from the command line. ### Unit 5 — Running 24/7 Heat, storage wear, crashes, and remote access — engineering a board you never have to touch. - [Thermal throttling](https://gophertrunk.org/learn/embedded/thermal-throttling/): A hot board quietly slows itself down — how to see throttling happening and cool your way back to full speed. - [SD-card wear](https://gophertrunk.org/learn/embedded/sd-card-wear/): Flash cells wear out with every write — why logging kills cheap cards, and how to make storage last for years. - [Watchdogs & recovery](https://gophertrunk.org/learn/embedded/watchdogs-and-recovery/): Design for the crash you can't prevent — hardware watchdogs, service restarts, and boards that heal themselves. - [Remote administration](https://gophertrunk.org/learn/embedded/remote-administration/): Managing a board you can't reach — SSH keys, tmux, remote logs, and safe upgrades over the network. - [Backups & images](https://gophertrunk.org/learn/embedded/backups-and-images/): An appliance you can re-flash in ten minutes is an appliance you never fear losing — image backups and config exports. - [Monitoring your board](https://gophertrunk.org/learn/embedded/monitoring-your-board/): Temperature, load, disk, and service health — lightweight monitoring that tells you about trouble before it becomes an outage. ### Unit 6 — The GopherTrunk Appliance Put it all together: a Raspberry Pi that decodes trunked radio around the clock. - [Install GopherTrunk on a Pi](https://gophertrunk.org/learn/embedded/installing-gophertrunk-on-a-pi/): Get the ARM build running on a Raspberry Pi — install, first config, and your first decoded call on SBC hardware. - [Tuning for small CPUs](https://gophertrunk.org/learn/embedded/tuning-for-small-cpus/): Sample rates, channel counts, and decode load — fitting a real-time DSP engine inside an SBC's compute budget. - [USB SDR gotchas](https://gophertrunk.org/learn/embedded/usb-sdr-gotchas/): Dropped samples, undervoltage resets, and interference from the Pi itself — the SBC-specific SDR failure modes and their fixes. - [Appliance networking & access](https://gophertrunk.org/learn/embedded/appliance-networking/): Reach the web console from any device in the house, keep the daemon private, and expose it safely if you must. - [A complete appliance build](https://gophertrunk.org/learn/embedded/a-complete-appliance-build/): The full recipe end to end — hardware list, OS, service, monitoring, and backups for a scanner that just runs. ### Glossary - [Glossary of embedded & SBC terms](https://gophertrunk.org/learn/embedded/glossary/): Plain-language definitions for every term in the module — embedded system, SBC, microcontroller, SoC, ARM, GPIO, I2C, SPI, HAT, headless, systemd, watchdog, thermal throttling, undervoltage, and more — cross-linked to the lessons. ## Field Guide Long-form reference articles defining radio, SDR, and software-development terms, technologies, algorithms, languages, concepts, people, hardware, and organizations. Browse: https://gophertrunk.org/reference/ ### RF & SDR #### RF & signal fundamentals - [Electromagnetic spectrum](https://gophertrunk.org/reference/electromagnetic-spectrum/)- [Radio wave](https://gophertrunk.org/reference/radio-wave/)- [Frequency](https://gophertrunk.org/reference/frequency/)- [Wavelength](https://gophertrunk.org/reference/wavelength/)- [Amplitude](https://gophertrunk.org/reference/amplitude/)- [Phase](https://gophertrunk.org/reference/phase/)- [Carrier wave](https://gophertrunk.org/reference/carrier-wave/)- [Modulation](https://gophertrunk.org/reference/modulation/)- [Bandwidth](https://gophertrunk.org/reference/bandwidth/)- [Decibel (dB)](https://gophertrunk.org/reference/decibel/)- [dBm](https://gophertrunk.org/reference/dbm/)- [dBFS](https://gophertrunk.org/reference/dbfs/)- [Signal-to-noise ratio (SNR)](https://gophertrunk.org/reference/signal-to-noise-ratio/)- [Noise floor](https://gophertrunk.org/reference/noise-floor/)- [Attenuation](https://gophertrunk.org/reference/attenuation/)- [Path loss](https://gophertrunk.org/reference/path-loss/)- [Frequency bands (HF/VHF/UHF)](https://gophertrunk.org/reference/frequency-bands/)- [Impedance](https://gophertrunk.org/reference/impedance/)- [Reflection coefficient](https://gophertrunk.org/reference/reflection-coefficient/)- [Return loss](https://gophertrunk.org/reference/return-loss/)- [S-parameters](https://gophertrunk.org/reference/s-parameters/)- [Q factor](https://gophertrunk.org/reference/q-factor/)- [Resonance](https://gophertrunk.org/reference/resonance/)- [Intermodulation distortion](https://gophertrunk.org/reference/intermodulation/)- [Harmonics](https://gophertrunk.org/reference/harmonics/)- [Spurious emissions](https://gophertrunk.org/reference/spurious-emissions/)- [Duty cycle](https://gophertrunk.org/reference/duty-cycle/)- [Crest factor & PAPR](https://gophertrunk.org/reference/crest-factor-papr/)- [Group delay](https://gophertrunk.org/reference/group-delay/)- [Phase noise](https://gophertrunk.org/reference/phase-noise/)- [Frequency stability](https://gophertrunk.org/reference/frequency-stability/)- [ERP & EIRP](https://gophertrunk.org/reference/erp-eirp/)- [Link budget](https://gophertrunk.org/reference/link-budget/)- [Friis transmission equation](https://gophertrunk.org/reference/friis-transmission-equation/)- [Field strength](https://gophertrunk.org/reference/field-strength/)- [Guard band](https://gophertrunk.org/reference/guard-band/)- [Occupied bandwidth](https://gophertrunk.org/reference/occupied-bandwidth/)- [Shannon capacity](https://gophertrunk.org/reference/shannon-capacity/) #### Receiver performance & metrics - [Thermal noise](https://gophertrunk.org/reference/thermal-noise/)- [Noise figure](https://gophertrunk.org/reference/noise-figure/)- [Noise temperature](https://gophertrunk.org/reference/noise-temperature/)- [Dynamic range](https://gophertrunk.org/reference/dynamic-range/)- [Spurious-free dynamic range (SFDR)](https://gophertrunk.org/reference/spurious-free-dynamic-range/)- [Third-order intercept (IP3)](https://gophertrunk.org/reference/third-order-intercept/)- [1 dB compression point](https://gophertrunk.org/reference/1-db-compression-point/)- [Receiver sensitivity (MDS)](https://gophertrunk.org/reference/receiver-sensitivity/)- [Desensitization](https://gophertrunk.org/reference/desensitization/)- [Blocking](https://gophertrunk.org/reference/blocking-dynamic-range/)- [Reciprocal mixing](https://gophertrunk.org/reference/reciprocal-mixing/)- [Bit error rate (BER)](https://gophertrunk.org/reference/bit-error-rate/)- [Eb/N0](https://gophertrunk.org/reference/eb-n0/)- [Error vector magnitude (EVM)](https://gophertrunk.org/reference/error-vector-magnitude/)- [Modulation error ratio (MER)](https://gophertrunk.org/reference/modulation-error-ratio/)- [SINAD](https://gophertrunk.org/reference/sinad/)- [Carrier-to-noise ratio (C/N)](https://gophertrunk.org/reference/carrier-to-noise-ratio/)- [Spectral efficiency](https://gophertrunk.org/reference/spectral-efficiency/) #### Antennas - [Antenna](https://gophertrunk.org/reference/antenna/)- [Dipole antenna](https://gophertrunk.org/reference/dipole-antenna/)- [Monopole antenna](https://gophertrunk.org/reference/monopole-antenna/)- [Ground-plane antenna](https://gophertrunk.org/reference/ground-plane-antenna/)- [Whip antenna](https://gophertrunk.org/reference/whip-antenna/)- [Yagi-Uda antenna](https://gophertrunk.org/reference/yagi-uda-antenna/)- [Log-periodic antenna](https://gophertrunk.org/reference/log-periodic-antenna/)- [Discone antenna](https://gophertrunk.org/reference/discone-antenna/)- [Collinear antenna](https://gophertrunk.org/reference/collinear-antenna/)- [J-pole antenna](https://gophertrunk.org/reference/j-pole-antenna/)- [Parabolic (dish) antenna](https://gophertrunk.org/reference/parabolic-antenna/)- [Horn antenna](https://gophertrunk.org/reference/horn-antenna/)- [Patch (microstrip) antenna](https://gophertrunk.org/reference/patch-antenna/)- [Helical antenna](https://gophertrunk.org/reference/helical-antenna/)- [Loop antenna](https://gophertrunk.org/reference/loop-antenna/)- [Magnetic loop antenna](https://gophertrunk.org/reference/magnetic-loop-antenna/)- [Biconical antenna](https://gophertrunk.org/reference/biconical-antenna/)- [Phased-array antenna](https://gophertrunk.org/reference/phased-array-antenna/)- [Base scanner antenna](https://gophertrunk.org/reference/base-scanner-antenna/)- [Handheld scanner antenna](https://gophertrunk.org/reference/handheld-scanner-antenna/)- [Mobile scanner antenna](https://gophertrunk.org/reference/mobile-scanner-antenna/)- [ADS-B antenna (1090 MHz)](https://gophertrunk.org/reference/adsb-antenna/)- [MIMO](https://gophertrunk.org/reference/mimo/)- [Antenna gain](https://gophertrunk.org/reference/antenna-gain/)- [Radiation pattern](https://gophertrunk.org/reference/radiation-pattern/)- [Beamwidth](https://gophertrunk.org/reference/beamwidth/)- [Front-to-back ratio](https://gophertrunk.org/reference/front-to-back-ratio/)- [Polarization](https://gophertrunk.org/reference/polarization/)- [Feedpoint impedance](https://gophertrunk.org/reference/feedpoint-impedance/)- [Standing wave ratio (SWR)](https://gophertrunk.org/reference/standing-wave-ratio/)- [Antenna efficiency](https://gophertrunk.org/reference/antenna-efficiency/)- [Effective aperture](https://gophertrunk.org/reference/effective-aperture/)- [Antenna tuner (ATU)](https://gophertrunk.org/reference/antenna-tuner/)- [Near field & far field](https://gophertrunk.org/reference/near-field-far-field/)- [Radials & counterpoise](https://gophertrunk.org/reference/radials-counterpoise/) #### Masts, mounts & hardware - [Antenna mast](https://gophertrunk.org/reference/antenna-mast/)- [Antenna tripod mount](https://gophertrunk.org/reference/tripod-mount/)- [Eave / J-mount bracket](https://gophertrunk.org/reference/eave-mount/)- [Chimney mount kit](https://gophertrunk.org/reference/chimney-mount/)- [Antenna mounting hardware](https://gophertrunk.org/reference/mounting-hardware/)- [Antenna grounding kit](https://gophertrunk.org/reference/grounding-kit/)- [Coax lightning arrestor](https://gophertrunk.org/reference/lightning-arrestor/)- [Guy wire kit](https://gophertrunk.org/reference/guy-wire-kit/) #### Propagation - [Radio propagation](https://gophertrunk.org/reference/radio-propagation/)- [Free-space path loss](https://gophertrunk.org/reference/free-space-path-loss/)- [Radio horizon](https://gophertrunk.org/reference/radio-horizon/)- [Ground-wave propagation](https://gophertrunk.org/reference/ground-wave/)- [Sky-wave propagation](https://gophertrunk.org/reference/sky-wave/)- [Ionospheric propagation](https://gophertrunk.org/reference/ionospheric-propagation/)- [Tropospheric ducting](https://gophertrunk.org/reference/tropospheric-ducting/)- [Sporadic E](https://gophertrunk.org/reference/sporadic-e/)- [NVIS](https://gophertrunk.org/reference/nvis/)- [Meteor scatter](https://gophertrunk.org/reference/meteor-scatter/)- [Moonbounce (EME)](https://gophertrunk.org/reference/moonbounce-eme/)- [Multipath propagation](https://gophertrunk.org/reference/multipath-propagation/)- [Rayleigh fading](https://gophertrunk.org/reference/rayleigh-fading/)- [Rician fading](https://gophertrunk.org/reference/rician-fading/)- [Doppler shift](https://gophertrunk.org/reference/doppler-shift/)- [Fresnel zone](https://gophertrunk.org/reference/fresnel-zone/)- [Knife-edge diffraction](https://gophertrunk.org/reference/knife-edge-diffraction/)- [Refraction](https://gophertrunk.org/reference/refraction/)- [Scattering](https://gophertrunk.org/reference/scattering/)- [Rain fade](https://gophertrunk.org/reference/rain-fade/)- [Atmospheric absorption](https://gophertrunk.org/reference/atmospheric-absorption/)- [Fade margin](https://gophertrunk.org/reference/fade-margin/) #### Modulation - [Amplitude modulation (AM)](https://gophertrunk.org/reference/amplitude-modulation/)- [Frequency modulation (FM)](https://gophertrunk.org/reference/frequency-modulation/)- [Single sideband (SSB)](https://gophertrunk.org/reference/single-sideband/)- [Frequency-shift keying (FSK)](https://gophertrunk.org/reference/frequency-shift-keying/)- [Phase-shift keying (PSK)](https://gophertrunk.org/reference/phase-shift-keying/)- [Quadrature amplitude modulation (QAM)](https://gophertrunk.org/reference/quadrature-amplitude-modulation/)- [C4FM](https://gophertrunk.org/reference/c4fm/)- [CQPSK](https://gophertrunk.org/reference/cqpsk/)- [GMSK](https://gophertrunk.org/reference/gmsk/)- [AFSK](https://gophertrunk.org/reference/afsk/)- [FFSK](https://gophertrunk.org/reference/ffsk/)- [Symbol rate (baud)](https://gophertrunk.org/reference/symbol-rate/)- [Constellation diagram](https://gophertrunk.org/reference/constellation-diagram/)- [Eye diagram](https://gophertrunk.org/reference/eye-diagram/)- [π/4-DQPSK](https://gophertrunk.org/reference/pi-4-dqpsk/)- [GFSK](https://gophertrunk.org/reference/gfsk/)- [NRZI](https://gophertrunk.org/reference/nrzi/)- [Dibit](https://gophertrunk.org/reference/dibit/)- [Pulse shaping](https://gophertrunk.org/reference/pulse-shaping/)- [Manchester coding](https://gophertrunk.org/reference/manchester-coding/)- [DTMF](https://gophertrunk.org/reference/dtmf/)- [On-off keying (OOK)](https://gophertrunk.org/reference/on-off-keying/)- [Amplitude-shift keying (ASK)](https://gophertrunk.org/reference/amplitude-shift-keying/)- [Continuous wave (CW)](https://gophertrunk.org/reference/continuous-wave/)- [Minimum-shift keying (MSK)](https://gophertrunk.org/reference/minimum-shift-keying/)- [Continuous-phase modulation (CPM)](https://gophertrunk.org/reference/continuous-phase-modulation/)- [4FSK](https://gophertrunk.org/reference/four-fsk/)- [M-ary FSK](https://gophertrunk.org/reference/m-ary-fsk/)- [BPSK](https://gophertrunk.org/reference/bpsk/)- [QPSK](https://gophertrunk.org/reference/qpsk/)- [8PSK](https://gophertrunk.org/reference/8psk/)- [Pulse-amplitude modulation (PAM)](https://gophertrunk.org/reference/pulse-amplitude-modulation/)- [Pulse-position modulation (PPM)](https://gophertrunk.org/reference/pulse-position-modulation/)- [Pulse-code modulation (PCM)](https://gophertrunk.org/reference/pulse-code-modulation/)- [Double sideband (DSB)](https://gophertrunk.org/reference/double-sideband/)- [Vestigial sideband (VSB)](https://gophertrunk.org/reference/vestigial-sideband/)- [IQ modulation](https://gophertrunk.org/reference/iq-modulation/)- [Modulation index](https://gophertrunk.org/reference/modulation-index/)- [FM deviation](https://gophertrunk.org/reference/fm-deviation/)- [Pre-emphasis & de-emphasis](https://gophertrunk.org/reference/pre-emphasis-de-emphasis/)- [Subcarrier](https://gophertrunk.org/reference/subcarrier/)- [CTCSS](https://gophertrunk.org/reference/ctcss/)- [DCS](https://gophertrunk.org/reference/dcs/)- [Intersymbol interference (ISI)](https://gophertrunk.org/reference/intersymbol-interference/)- [Roll-off factor](https://gophertrunk.org/reference/roll-off-factor/)- [Bit rate vs baud](https://gophertrunk.org/reference/bit-rate-vs-baud/)- [Amplitude and phase-shift keying (APSK)](https://gophertrunk.org/reference/amplitude-phase-shift-keying/)- [Modulation and coding scheme (MCS)](https://gophertrunk.org/reference/modulation-and-coding-scheme/)- [P25 Phase 2 H-DQPSK](https://gophertrunk.org/reference/p25-phase-2-hdqpsk/) #### SDR & DSP - [Software-defined radio (SDR)](https://gophertrunk.org/reference/software-defined-radio/)- [IQ data](https://gophertrunk.org/reference/iq-data/)- [Analog-to-digital converter (ADC)](https://gophertrunk.org/reference/analog-to-digital-converter/)- [Sample rate](https://gophertrunk.org/reference/sample-rate/)- [Nyquist–Shannon sampling theorem](https://gophertrunk.org/reference/nyquist-theorem/)- [Aliasing](https://gophertrunk.org/reference/aliasing/)- [Superheterodyne receiver](https://gophertrunk.org/reference/superheterodyne-receiver/)- [Local oscillator](https://gophertrunk.org/reference/local-oscillator/)- [Digital down-converter (DDC)](https://gophertrunk.org/reference/digital-down-converter/)- [Decimation](https://gophertrunk.org/reference/decimation/)- [Digital filter](https://gophertrunk.org/reference/digital-filter/)- [Automatic gain control (AGC)](https://gophertrunk.org/reference/automatic-gain-control/)- [Demodulation](https://gophertrunk.org/reference/demodulation/)- [Quadrature demodulation](https://gophertrunk.org/reference/quadrature-demodulation/)- [Clock recovery](https://gophertrunk.org/reference/clock-recovery/)- [PPM frequency correction](https://gophertrunk.org/reference/ppm-frequency-correction/)- [Numerically controlled oscillator (NCO)](https://gophertrunk.org/reference/numerically-controlled-oscillator/)- [Intermediate frequency (IF)](https://gophertrunk.org/reference/intermediate-frequency/)- [Baseband](https://gophertrunk.org/reference/baseband/)- [Automatic frequency control (AFC)](https://gophertrunk.org/reference/automatic-frequency-control/)- [DC offset (DC spike)](https://gophertrunk.org/reference/dc-offset/)- [Direct-conversion receiver](https://gophertrunk.org/reference/direct-conversion-receiver/)- [Direct sampling](https://gophertrunk.org/reference/direct-sampling/)- [Zero-IF](https://gophertrunk.org/reference/zero-if/)- [Low-IF](https://gophertrunk.org/reference/low-if/)- [Bandpass (undersampling)](https://gophertrunk.org/reference/bandpass-sampling/)- [Quantization](https://gophertrunk.org/reference/quantization/)- [Dither](https://gophertrunk.org/reference/dither/)- [Effective number of bits (ENOB)](https://gophertrunk.org/reference/enob/)- [Oversampling](https://gophertrunk.org/reference/oversampling/)- [Image rejection](https://gophertrunk.org/reference/image-rejection/)- [Image frequency](https://gophertrunk.org/reference/image-frequency/)- [IQ imbalance](https://gophertrunk.org/reference/iq-imbalance/)- [Squelch](https://gophertrunk.org/reference/squelch/)- [Noise blanker](https://gophertrunk.org/reference/noise-blanker/)- [Antenna diversity](https://gophertrunk.org/reference/antenna-diversity/)- [Frame synchronization](https://gophertrunk.org/reference/frame-synchronization/)- [Preamble correlation](https://gophertrunk.org/reference/preamble-correlation/)- [Soft-decision demodulation](https://gophertrunk.org/reference/soft-decision/)- [Log-likelihood ratio (LLR)](https://gophertrunk.org/reference/log-likelihood-ratio/)- [Power spectral density (PSD)](https://gophertrunk.org/reference/power-spectral-density/)- [Spectrogram](https://gophertrunk.org/reference/spectrogram/)- [Waterfall display](https://gophertrunk.org/reference/waterfall-display/)- [TETRA receiver chain](https://gophertrunk.org/reference/tetra-receiver-chain/) #### Filtering & multirate DSP - [FIR filter](https://gophertrunk.org/reference/fir-filter/)- [IIR filter](https://gophertrunk.org/reference/iir-filter/)- [CIC filter](https://gophertrunk.org/reference/cic-filter/)- [Half-band filter](https://gophertrunk.org/reference/half-band-filter/)- [Root-raised-cosine filter](https://gophertrunk.org/reference/root-raised-cosine-filter/)- [Matched filter](https://gophertrunk.org/reference/matched-filter/)- [Polyphase filter bank](https://gophertrunk.org/reference/polyphase-filter-bank/)- [Channelizer](https://gophertrunk.org/reference/channelizer/)- [Resampler](https://gophertrunk.org/reference/resampler/)- [Fractional-delay filter](https://gophertrunk.org/reference/fractional-delay-filter/) #### Synchronization, carrier & timing - [Phase-locked loop (PLL)](https://gophertrunk.org/reference/phase-locked-loop/)- [Frequency-locked loop (FLL)](https://gophertrunk.org/reference/frequency-locked-loop/)- [Costas loop](https://gophertrunk.org/reference/costas-loop/)- [Gardner timing recovery](https://gophertrunk.org/reference/gardner-timing-recovery/)- [Mueller–Müller timing recovery](https://gophertrunk.org/reference/mueller-muller-timing-recovery/)- [Early-late gate timing recovery](https://gophertrunk.org/reference/early-late-gate/)- [Zero-crossing detection](https://gophertrunk.org/reference/zero-crossing-detection/)- [Differential decoding](https://gophertrunk.org/reference/differential-decoding/)- [DMR sync patterns](https://gophertrunk.org/reference/dmr-sync-patterns/)- [dPMR Frame Sync](https://gophertrunk.org/reference/dpmr-frame-sync/)- [NXDN Frame Sync Word](https://gophertrunk.org/reference/nxdn-fsw/)- [P25 frame sync word](https://gophertrunk.org/reference/p25-frame-sync-word/)- [P25 Phase 2 sync word](https://gophertrunk.org/reference/p25-phase-2-sync-word/)- [TETRA burst formats](https://gophertrunk.org/reference/tetra-burst-formats/)- [TETRA training sequences](https://gophertrunk.org/reference/tetra-training-sequences/) #### Equalization - [Adaptive filter](https://gophertrunk.org/reference/adaptive-filter/)- [Least mean squares (LMS)](https://gophertrunk.org/reference/lms-algorithm/)- [Recursive least squares (RLS)](https://gophertrunk.org/reference/rls-algorithm/)- [CMA equalizer](https://gophertrunk.org/reference/cma-equalizer/)- [Fractionally-spaced equalizer (FSE)](https://gophertrunk.org/reference/fractionally-spaced-equalizer/)- [Snapshot equalization](https://gophertrunk.org/reference/snapshot-equalization/)- [Zero-forcing equalizer](https://gophertrunk.org/reference/zero-forcing-equalizer/)- [MMSE equalizer](https://gophertrunk.org/reference/mmse-equalizer/)- [Decision-feedback equalizer (DFE)](https://gophertrunk.org/reference/decision-feedback-equalizer/)- [Maximum-likelihood sequence estimation (MLSE)](https://gophertrunk.org/reference/maximum-likelihood-sequence-estimation/) #### Transforms & spectral analysis - [Fourier transform](https://gophertrunk.org/reference/fourier-transform/)- [Discrete Fourier transform (DFT)](https://gophertrunk.org/reference/discrete-fourier-transform/)- [Fast Fourier transform (FFT)](https://gophertrunk.org/reference/fast-fourier-transform/)- [Goertzel algorithm](https://gophertrunk.org/reference/goertzel-algorithm/)- [Window function](https://gophertrunk.org/reference/window-function/)- [Welch's method](https://gophertrunk.org/reference/welch-method/)- [Overlap-add & overlap-save](https://gophertrunk.org/reference/overlap-add-overlap-save/)- [Hilbert transform](https://gophertrunk.org/reference/hilbert-transform/)- [CORDIC](https://gophertrunk.org/reference/cordic/) #### Error-correcting codes - [Forward error correction (FEC)](https://gophertrunk.org/reference/forward-error-correction/)- [Convolutional code](https://gophertrunk.org/reference/convolutional-code/)- [Viterbi algorithm](https://gophertrunk.org/reference/viterbi-algorithm/)- [BCJR algorithm](https://gophertrunk.org/reference/bcjr-algorithm/)- [Fano algorithm (sequential decoding)](https://gophertrunk.org/reference/fano-algorithm/)- [Trellis-coded modulation](https://gophertrunk.org/reference/trellis-coded-modulation/)- [Turbo code](https://gophertrunk.org/reference/turbo-code/)- [Low-density parity-check (LDPC) code](https://gophertrunk.org/reference/ldpc-code/)- [Polar code](https://gophertrunk.org/reference/polar-code/)- [Reed–Solomon code](https://gophertrunk.org/reference/reed-solomon-code/)- [BCH code](https://gophertrunk.org/reference/bch-code/)- [Berlekamp–Massey algorithm](https://gophertrunk.org/reference/berlekamp-massey-algorithm/)- [Chien search](https://gophertrunk.org/reference/chien-search/)- [Forney algorithm](https://gophertrunk.org/reference/forney-algorithm/)- [Golay code](https://gophertrunk.org/reference/golay-code/)- [Hamming code](https://gophertrunk.org/reference/hamming-code/)- [Reed–Muller code](https://gophertrunk.org/reference/reed-muller-code/)- [Hadamard code (Walsh–Hadamard)](https://gophertrunk.org/reference/hadamard-code/)- [Fire code](https://gophertrunk.org/reference/fire-code/)- [Cyclic redundancy check (CRC)](https://gophertrunk.org/reference/cyclic-redundancy-check/)- [BPTC](https://gophertrunk.org/reference/bptc/)- [Interleaving](https://gophertrunk.org/reference/interleaving/)- [Puncturing](https://gophertrunk.org/reference/puncturing/)- [Gray code](https://gophertrunk.org/reference/gray-code/)- [Scrambling (whitening)](https://gophertrunk.org/reference/scrambling/)- [CRC-16/CCITT](https://gophertrunk.org/reference/crc-16-ccitt/)- [DMR CSBK CRC](https://gophertrunk.org/reference/dmr-csbk-crc/)- [DMR embedded LC](https://gophertrunk.org/reference/dmr-embedded-lc/)- [DMR RS(12,9)](https://gophertrunk.org/reference/dmr-rs-12-9/)- [dPMR Channel Coding](https://gophertrunk.org/reference/dpmr-channel-coding/)- [LoRa diagonal interleaver](https://gophertrunk.org/reference/lora-diagonal-interleaver/)- [LoRa whitening](https://gophertrunk.org/reference/lora-whitening/)- [P25 Hamming(10,6,3)](https://gophertrunk.org/reference/p25-hamming-10-6/)- [P25 Phase 2 MAC interleaver](https://gophertrunk.org/reference/p25-phase-2-mac-interleaver/)- [P25 Reed-Solomon codes](https://gophertrunk.org/reference/p25-reed-solomon/)- [P25 trellis code](https://gophertrunk.org/reference/p25-trellis-code/)- [P25 TSBK interleaver](https://gophertrunk.org/reference/p25-tsbk-interleaver/)- [PN44 scrambler](https://gophertrunk.org/reference/pn44-scrambler/)- [TETRA block interleaver](https://gophertrunk.org/reference/tetra-block-interleaver/)- [TETRA RCPC code](https://gophertrunk.org/reference/tetra-rcpc-code/)- [TETRA RM(30,14)](https://gophertrunk.org/reference/tetra-rm-30-14/)- [TETRA scrambler](https://gophertrunk.org/reference/tetra-scrambler/) #### Spread spectrum & multiple access - [Direct-sequence spread spectrum (DSSS)](https://gophertrunk.org/reference/direct-sequence-spread-spectrum/)- [Frequency-hopping spread spectrum (FHSS)](https://gophertrunk.org/reference/frequency-hopping-spread-spectrum/)- [Code-division multiple access (CDMA)](https://gophertrunk.org/reference/cdma/)- [Orthogonal frequency-division multiplexing (OFDM)](https://gophertrunk.org/reference/ofdm/)- [OFDMA](https://gophertrunk.org/reference/ofdma/)- [Maximal-length sequence (m-sequence)](https://gophertrunk.org/reference/maximal-length-sequence/)- [Gold code](https://gophertrunk.org/reference/gold-code/)- [Barker code](https://gophertrunk.org/reference/barker-code/) #### Estimation, detection & array processing - [Kalman filter](https://gophertrunk.org/reference/kalman-filter/)- [Channel estimation](https://gophertrunk.org/reference/channel-estimation/)- [Coherence (normalized cross-correlation)](https://gophertrunk.org/reference/coherence/)- [Energy detection](https://gophertrunk.org/reference/energy-detection/)- [CFAR detection](https://gophertrunk.org/reference/cfar-detection/)- [Beamforming](https://gophertrunk.org/reference/beamforming/)- [Maximal-ratio combining (MRC)](https://gophertrunk.org/reference/maximal-ratio-combining/)- [Interference rejection combining (IRC)](https://gophertrunk.org/reference/interference-rejection-combining/)- [MUSIC algorithm](https://gophertrunk.org/reference/music-algorithm/)- [ESPRIT algorithm](https://gophertrunk.org/reference/esprit-algorithm/)- [Multilateration (MLAT)](https://gophertrunk.org/reference/multilateration/)- [Compact position reporting (CPR)](https://gophertrunk.org/reference/compact-position-reporting/) #### Cryptography & cryptanalysis - [Cryptography](https://gophertrunk.org/reference/cryptography/)- [Cryptanalysis](https://gophertrunk.org/reference/cryptanalysis/)- [Cipher](https://gophertrunk.org/reference/cipher/)- [Encryption](https://gophertrunk.org/reference/encryption/)- [Obfuscation](https://gophertrunk.org/reference/obfuscation/)- [Symmetric-key cryptography](https://gophertrunk.org/reference/symmetric-key-cryptography/)- [Public-key cryptography](https://gophertrunk.org/reference/public-key-cryptography/)- [Cryptographic key](https://gophertrunk.org/reference/cryptographic-key/)- [Keystream](https://gophertrunk.org/reference/keystream/)- [Kerckhoffs's principle](https://gophertrunk.org/reference/kerckhoffs-principle/)- [Stream cipher](https://gophertrunk.org/reference/stream-cipher/)- [Block cipher](https://gophertrunk.org/reference/block-cipher/)- [Feistel network](https://gophertrunk.org/reference/feistel-network/)- [Substitution-permutation network (SPN)](https://gophertrunk.org/reference/substitution-permutation-network/)- [S-box (substitution box)](https://gophertrunk.org/reference/s-box/)- [Linear-feedback shift register (LFSR)](https://gophertrunk.org/reference/linear-feedback-shift-register/)- [One-time pad (OTP)](https://gophertrunk.org/reference/one-time-pad/)- [Cryptographic hash function](https://gophertrunk.org/reference/hash-function/)- [Advanced Encryption Standard (AES)](https://gophertrunk.org/reference/advanced-encryption-standard/)- [Data Encryption Standard (DES)](https://gophertrunk.org/reference/data-encryption-standard/)- [RC4 (ARC4) cipher](https://gophertrunk.org/reference/rc4-cipher/)- [Frequency analysis](https://gophertrunk.org/reference/frequency-analysis/)- [Ciphertext-only attack](https://gophertrunk.org/reference/ciphertext-only-attack/)- [Known-plaintext attack](https://gophertrunk.org/reference/known-plaintext-attack/)- [Chosen-plaintext attack](https://gophertrunk.org/reference/chosen-plaintext-attack/)- [Brute-force attack (exhaustive key search)](https://gophertrunk.org/reference/brute-force-attack/)- [Differential cryptanalysis](https://gophertrunk.org/reference/differential-cryptanalysis/)- [Algebraic attack](https://gophertrunk.org/reference/algebraic-attack/)- [SAT/SMT solving](https://gophertrunk.org/reference/sat-smt-solving/)- [Constraint propagation](https://gophertrunk.org/reference/constraint-propagation/)- [OTAR](https://gophertrunk.org/reference/otar/)- [Key ID & ALGID](https://gophertrunk.org/reference/key-id-algid/)- [Key loader (KFD)](https://gophertrunk.org/reference/key-loader-kfd/)- [Rolling code](https://gophertrunk.org/reference/rolling-code/)- [TETRA TEA ciphers](https://gophertrunk.org/reference/tetra-tea/)- [P25 DES-XL / ADP](https://gophertrunk.org/reference/p25-des-xl/)- [DMR encryption](https://gophertrunk.org/reference/dmr-encryption/)- [LoRaWAN MIC](https://gophertrunk.org/reference/lorawan-mic/)- [Motorola talker-alias cipher](https://gophertrunk.org/reference/motorola-talker-alias-cipher/)- [NXDN Scrambler](https://gophertrunk.org/reference/nxdn-scrambler/)- [P25 Algorithm ID (ALGID)](https://gophertrunk.org/reference/p25-algorithm-id/)- [P25 Encryption Sync (ES)](https://gophertrunk.org/reference/p25-encryption-sync/)- [P25 encryption keystream generators](https://gophertrunk.org/reference/p25-encryption/) #### Trunked radio - [Trunked radio](https://gophertrunk.org/reference/trunked-radio/)- [Conventional radio](https://gophertrunk.org/reference/conventional-radio/)- [Control channel](https://gophertrunk.org/reference/control-channel/)- [Voice channel](https://gophertrunk.org/reference/voice-channel/)- [Talkgroup](https://gophertrunk.org/reference/talkgroup/)- [Affiliation](https://gophertrunk.org/reference/affiliation/)- [FDMA](https://gophertrunk.org/reference/fdma/)- [TDMA](https://gophertrunk.org/reference/tdma/)- [Channel grant](https://gophertrunk.org/reference/channel-grant/)- [Radio ID](https://gophertrunk.org/reference/radio-id/)- [TSBK](https://gophertrunk.org/reference/tsbk/)- [CSBK](https://gophertrunk.org/reference/csbk/)- [Rest channel](https://gophertrunk.org/reference/rest-channel/)- [Trunking site](https://gophertrunk.org/reference/trunking-site/)- [Simulcast](https://gophertrunk.org/reference/simulcast/)- [Multisite trunking](https://gophertrunk.org/reference/multisite-trunking/)- [Network Access Code (NAC)](https://gophertrunk.org/reference/network-access-code/)- [Color code (DMR)](https://gophertrunk.org/reference/color-code/)- [Radio Access Number (RAN)](https://gophertrunk.org/reference/ran-nxdn/)- [WACN](https://gophertrunk.org/reference/wacn/)- [System ID](https://gophertrunk.org/reference/system-id/)- [RFSS](https://gophertrunk.org/reference/rfss/)- [Group call](https://gophertrunk.org/reference/group-call/)- [Private call](https://gophertrunk.org/reference/private-call/)- [Emergency call](https://gophertrunk.org/reference/emergency-call/)- [Registration](https://gophertrunk.org/reference/registration/)- [Late entry](https://gophertrunk.org/reference/late-entry/)- [Busy/idle status](https://gophertrunk.org/reference/busy-idle/)- [Patch & multigroup](https://gophertrunk.org/reference/patch-multigroup/)- [Priority scan](https://gophertrunk.org/reference/priority-scan/)- [Failsoft](https://gophertrunk.org/reference/failsoft/)- [Roaming](https://gophertrunk.org/reference/roaming/)- [Neighbor site](https://gophertrunk.org/reference/neighbor-site/)- [DMR band plan](https://gophertrunk.org/reference/dmr-bandplan/)- [DMR burst](https://gophertrunk.org/reference/dmr-burst/)- [DMR CACH](https://gophertrunk.org/reference/dmr-cach/)- [DMR CSBK payloads](https://gophertrunk.org/reference/dmr-csbk-payloads/)- [DMR EMB](https://gophertrunk.org/reference/dmr-emb/)- [DMR Full Link Control](https://gophertrunk.org/reference/dmr-full-link-control/)- [DMR Multi-Block Control](https://gophertrunk.org/reference/dmr-mbc/)- [DMR Reverse Channel](https://gophertrunk.org/reference/dmr-reverse-channel/)- [DMR slot type](https://gophertrunk.org/reference/dmr-slot-type/)- [DMR vendor FID](https://gophertrunk.org/reference/dmr-vendor-fid/)- [DMR voice superframe](https://gophertrunk.org/reference/dmr-voice-superframe/)- [dPMR CSBK](https://gophertrunk.org/reference/dpmr-csbk/)- [EDACS Control Channel Word](https://gophertrunk.org/reference/edacs-control-channel-word/)- [LTR word format](https://gophertrunk.org/reference/ltr-word-format/)- [Motorola OSW](https://gophertrunk.org/reference/motorola-osw/)- [MPT 1327 codeword](https://gophertrunk.org/reference/mpt-1327-codeword/)- [NXDN CAC](https://gophertrunk.org/reference/nxdn-cac/)- [NXDN FACCH](https://gophertrunk.org/reference/nxdn-facch/)- [NXDN Frame Structure](https://gophertrunk.org/reference/nxdn-frame-structure/)- [NXDN LICH](https://gophertrunk.org/reference/nxdn-lich/)- [NXDN SACCH](https://gophertrunk.org/reference/nxdn-sacch/)- [P25 Header Data Unit](https://gophertrunk.org/reference/p25-header-data-unit/)- [P25 Identifier Update (IDEN_UP)](https://gophertrunk.org/reference/p25-identifier-update/)- [P25 ISCH](https://gophertrunk.org/reference/p25-isch/)- [P25 Link Control Word](https://gophertrunk.org/reference/p25-link-control-word/)- [P25 Logical Data Unit](https://gophertrunk.org/reference/p25-logical-data-unit/)- [P25 MAC PDU](https://gophertrunk.org/reference/p25-mac-pdu/)- [P25 vendor MAC opcodes](https://gophertrunk.org/reference/p25-mac-vendor/)- [P25 NID & DUID](https://gophertrunk.org/reference/p25-nid-duid/)- [P25 Packet Data Unit (PDU)](https://gophertrunk.org/reference/p25-packet-data-unit/)- [P25 Phase 2 superframe](https://gophertrunk.org/reference/p25-phase-2-superframe/)- [P25 SACCH & FACCH](https://gophertrunk.org/reference/p25-sacch-facch/)- [P25 status symbols](https://gophertrunk.org/reference/p25-status-symbols/)- [P25 talker alias (Motorola)](https://gophertrunk.org/reference/p25-talker-alias/)- [P25 Terminator Data Unit](https://gophertrunk.org/reference/p25-terminator-data-unit/)- [P25 TSBK opcodes](https://gophertrunk.org/reference/p25-tsbk-opcodes/)- [P25 TSBK vendor opcodes](https://gophertrunk.org/reference/p25-tsbk-vendor-opcodes/)- [TETRA AACH](https://gophertrunk.org/reference/tetra-aach/)- [TETRA CMCE & MLE PDUs](https://gophertrunk.org/reference/tetra-cmce-mle-pdu/)- [TETRA DMO](https://gophertrunk.org/reference/tetra-dmo/)- [TETRA extended colour code](https://gophertrunk.org/reference/tetra-extended-colour-code/)- [TETRA LLC](https://gophertrunk.org/reference/tetra-llc/)- [TETRA logical channels](https://gophertrunk.org/reference/tetra-logical-channels/)- [TETRA MAC PDU](https://gophertrunk.org/reference/tetra-mac-pdu/)- [TETRA mobile network identity (MNI)](https://gophertrunk.org/reference/tetra-mobile-network-identity/)- [TETRA SYNC PDU](https://gophertrunk.org/reference/tetra-sync-pdu/)- [TETRA traffic slot mapping](https://gophertrunk.org/reference/tetra-traffic-slot-mapping/) #### Land mobile & trunking - [Project 25 (P25)](https://gophertrunk.org/reference/project-25/)- [P25 Phase 1](https://gophertrunk.org/reference/p25-phase-1/)- [P25 Phase 2](https://gophertrunk.org/reference/p25-phase-2/)- [P25 Common Air Interface](https://gophertrunk.org/reference/p25-cai/)- [Digital Mobile Radio (DMR)](https://gophertrunk.org/reference/dmr/)- [DMR Tier I](https://gophertrunk.org/reference/dmr-tier-1/)- [DMR Tier II](https://gophertrunk.org/reference/dmr-tier-2/)- [DMR Tier III](https://gophertrunk.org/reference/dmr-tier-3/)- [Capacity Plus](https://gophertrunk.org/reference/capacity-plus/)- [Connect Plus](https://gophertrunk.org/reference/connect-plus/)- [NXDN](https://gophertrunk.org/reference/nxdn/)- [dPMR](https://gophertrunk.org/reference/dpmr/)- [TETRA](https://gophertrunk.org/reference/tetra/)- [TETRAPOL](https://gophertrunk.org/reference/tetrapol/)- [Motorola Type II](https://gophertrunk.org/reference/motorola-type-ii/)- [SmartNet / SmartZone](https://gophertrunk.org/reference/smartnet-smartzone/)- [EDACS](https://gophertrunk.org/reference/edacs/)- [LTR (Logic Trunked Radio)](https://gophertrunk.org/reference/ltr/)- [MPT 1327](https://gophertrunk.org/reference/mpt-1327/)- [iDEN](https://gophertrunk.org/reference/iden/)- [ProVoice](https://gophertrunk.org/reference/provoice/)- [Direct mode operation (DMO)](https://gophertrunk.org/reference/direct-mode-operation/) #### Cellular - [GSM](https://gophertrunk.org/reference/gsm/)- [GPRS](https://gophertrunk.org/reference/gprs/)- [EDGE](https://gophertrunk.org/reference/edge-cellular/)- [UMTS / W-CDMA](https://gophertrunk.org/reference/umts-wcdma/)- [HSPA](https://gophertrunk.org/reference/hspa/)- [CDMA2000](https://gophertrunk.org/reference/cdma2000/)- [EV-DO](https://gophertrunk.org/reference/ev-do/)- [LTE](https://gophertrunk.org/reference/lte/)- [LTE-Advanced](https://gophertrunk.org/reference/lte-advanced/)- [5G NR](https://gophertrunk.org/reference/5g-nr/)- [VoLTE](https://gophertrunk.org/reference/volte/)- [IMSI & IMEI](https://gophertrunk.org/reference/imsi-imei/)- [Handover](https://gophertrunk.org/reference/cellular-handover/)- [Base station (eNodeB / gNodeB)](https://gophertrunk.org/reference/base-station-enodeb-gnodeb/)- [Frequency-division duplex (FDD)](https://gophertrunk.org/reference/frequency-division-duplex/)- [Time-division duplex (TDD)](https://gophertrunk.org/reference/time-division-duplex/)- [Discontinuous reception (DRX)](https://gophertrunk.org/reference/discontinuous-reception/)- [International Mobile Telecommunications (IMT)](https://gophertrunk.org/reference/imt/) #### Wireless data & IoT - [Wi-Fi (802.11)](https://gophertrunk.org/reference/wifi-80211/)- [Bluetooth (RF layer)](https://gophertrunk.org/reference/bluetooth-rf/)- [Bluetooth Low Energy (BLE)](https://gophertrunk.org/reference/bluetooth-le/)- [Zigbee / 802.15.4](https://gophertrunk.org/reference/zigbee-802154/)- [Z-Wave](https://gophertrunk.org/reference/z-wave/)- [Thread](https://gophertrunk.org/reference/thread-protocol/)- [Matter](https://gophertrunk.org/reference/matter-protocol/)- [6LoWPAN](https://gophertrunk.org/reference/6lowpan/)- [ANT+](https://gophertrunk.org/reference/ant-plus/)- [LoRa](https://gophertrunk.org/reference/lora/)- [LoRaWAN](https://gophertrunk.org/reference/lorawan/)- [Sigfox](https://gophertrunk.org/reference/sigfox/)- [NB-IoT](https://gophertrunk.org/reference/nb-iot/)- [LTE-M](https://gophertrunk.org/reference/lte-m/)- [Meshtastic](https://gophertrunk.org/reference/meshtastic/)- [Wireless M-Bus](https://gophertrunk.org/reference/wireless-mbus/)- [NFC (RF layer)](https://gophertrunk.org/reference/nfc-rf/)- [RFID (RF layer)](https://gophertrunk.org/reference/rfid-rf/)- [TPMS](https://gophertrunk.org/reference/tpms/)- [Remote keyless entry](https://gophertrunk.org/reference/remote-keyless-entry/)- [APRS Mic-E](https://gophertrunk.org/reference/aprs-mic-e/)- [NMEA 0183](https://gophertrunk.org/reference/nmea-0183/) #### Satellite & GNSS - [GNSS](https://gophertrunk.org/reference/gnss/)- [GPS](https://gophertrunk.org/reference/gps-gnss/)- [GLONASS](https://gophertrunk.org/reference/glonass/)- [Galileo](https://gophertrunk.org/reference/galileo/)- [BeiDou](https://gophertrunk.org/reference/beidou/)- [Iridium](https://gophertrunk.org/reference/iridium/)- [Inmarsat](https://gophertrunk.org/reference/inmarsat/)- [Globalstar](https://gophertrunk.org/reference/globalstar/)- [Orbcomm](https://gophertrunk.org/reference/orbcomm/)- [Starlink](https://gophertrunk.org/reference/starlink/)- [NOAA APT](https://gophertrunk.org/reference/noaa-apt/)- [Meteor-M LRPT](https://gophertrunk.org/reference/meteor-lrpt/)- [GOES HRIT](https://gophertrunk.org/reference/goes-hrit/)- [COSPAS-SARSAT](https://gophertrunk.org/reference/cospas-sarsat/) #### Broadcast - [Broadcast FM](https://gophertrunk.org/reference/broadcast-fm/)- [Broadcast AM](https://gophertrunk.org/reference/broadcast-am/)- [Shortwave broadcasting](https://gophertrunk.org/reference/shortwave-broadcast/)- [RDS / RBDS](https://gophertrunk.org/reference/rds/)- [DAB / DAB+](https://gophertrunk.org/reference/dab/)- [Digital Radio Mondiale (DRM)](https://gophertrunk.org/reference/drm-broadcast/)- [HD Radio (IBOC)](https://gophertrunk.org/reference/hd-radio/)- [DVB-T / T2](https://gophertrunk.org/reference/dvb-t/)- [DVB-S / S2](https://gophertrunk.org/reference/dvb-s/)- [DVB-C](https://gophertrunk.org/reference/dvb-c/)- [ATSC 1.0](https://gophertrunk.org/reference/atsc-1/)- [ATSC 3.0 (NextGen TV)](https://gophertrunk.org/reference/atsc-3/)- [ISDB-T](https://gophertrunk.org/reference/isdb-t/)- [Single-frequency network (SFN)](https://gophertrunk.org/reference/single-frequency-network/) #### Aviation & marine - [ADS-B](https://gophertrunk.org/reference/ads-b/)- [Mode S](https://gophertrunk.org/reference/mode-s/)- [Mode A/C transponder](https://gophertrunk.org/reference/mode-ac/)- [UAT (978 MHz)](https://gophertrunk.org/reference/uat-978/)- [TIS-B](https://gophertrunk.org/reference/tis-b/)- [FIS-B](https://gophertrunk.org/reference/fis-b/)- [TCAS](https://gophertrunk.org/reference/tcas/)- [ADS-C](https://gophertrunk.org/reference/ads-c/)- [ACARS](https://gophertrunk.org/reference/acars/)- [VDL Mode 2](https://gophertrunk.org/reference/vdl-mode-2/)- [HFDL](https://gophertrunk.org/reference/hfdl/)- [CPDLC](https://gophertrunk.org/reference/cpdlc/)- [VOR](https://gophertrunk.org/reference/vor/)- [ILS](https://gophertrunk.org/reference/ils/)- [DME](https://gophertrunk.org/reference/dme/)- [TACAN](https://gophertrunk.org/reference/tacan/)- [Automatic Identification System (AIS)](https://gophertrunk.org/reference/ais/)- [Digital Selective Calling (DSC)](https://gophertrunk.org/reference/dsc/)- [NAVTEX](https://gophertrunk.org/reference/navtex/)- [EPIRB (406 MHz)](https://gophertrunk.org/reference/epirb-406/)- [Marine VHF](https://gophertrunk.org/reference/marine-vhf/)- [Identification friend or foe (IFF)](https://gophertrunk.org/reference/identification-friend-or-foe/)- [SITOR](https://gophertrunk.org/reference/sitor/)- [SOLAS](https://gophertrunk.org/reference/solas/)- [DSC message format](https://gophertrunk.org/reference/dsc-message-format/)- [Mode-S Beast protocol](https://gophertrunk.org/reference/mode-s-beast/) #### Paging & data - [POCSAG](https://gophertrunk.org/reference/pocsag/)- [FLEX](https://gophertrunk.org/reference/flex/)- [ERMES](https://gophertrunk.org/reference/ermes/)- [APRS](https://gophertrunk.org/reference/aprs/)- [AX.25](https://gophertrunk.org/reference/ax25/)- [Packet radio](https://gophertrunk.org/reference/packet-radio/)- [KISS TNC](https://gophertrunk.org/reference/kiss-tnc/)- [MDC-1200](https://gophertrunk.org/reference/mdc1200/)- [FLEX protocol coding](https://gophertrunk.org/reference/flex-protocol-coding/)- [MDC1200 frame](https://gophertrunk.org/reference/mdc1200-frame/)- [POCSAG codeword](https://gophertrunk.org/reference/pocsag-codeword/) #### Amateur digital modes - [D-STAR](https://gophertrunk.org/reference/d-star/)- [System Fusion (YSF)](https://gophertrunk.org/reference/system-fusion-ysf/)- [M17](https://gophertrunk.org/reference/m17/)- [FT8](https://gophertrunk.org/reference/ft8/)- [FT4](https://gophertrunk.org/reference/ft4/)- [WSPR](https://gophertrunk.org/reference/wspr/)- [JT65](https://gophertrunk.org/reference/jt65/)- [JT9](https://gophertrunk.org/reference/jt9/)- [JS8Call](https://gophertrunk.org/reference/js8call/)- [RTTY](https://gophertrunk.org/reference/rtty/)- [PSK31](https://gophertrunk.org/reference/psk31/)- [SSTV](https://gophertrunk.org/reference/sstv/)- [Olivia MFSK](https://gophertrunk.org/reference/olivia/)- [Contestia](https://gophertrunk.org/reference/contestia/)- [Hellschreiber](https://gophertrunk.org/reference/hellschreiber/)- [Morse code](https://gophertrunk.org/reference/morse-code/)- [Winlink](https://gophertrunk.org/reference/winlink/)- [Pactor](https://gophertrunk.org/reference/pactor/)- [VARA](https://gophertrunk.org/reference/vara/)- [D-STAR header FEC](https://gophertrunk.org/reference/dstar-header-fec/)- [M17 Link Information](https://gophertrunk.org/reference/m17-link-information/)- [YSF FICH](https://gophertrunk.org/reference/ysf-fich/) #### Voice coding - [Vocoder](https://gophertrunk.org/reference/vocoder/)- [Linear predictive coding (LPC)](https://gophertrunk.org/reference/linear-predictive-coding/)- [Code-excited linear prediction (CELP)](https://gophertrunk.org/reference/code-excited-linear-prediction/)- [Multi-band excitation (MBE)](https://gophertrunk.org/reference/multi-band-excitation/)- [MELP / MELPe](https://gophertrunk.org/reference/melp/)- [IMBE](https://gophertrunk.org/reference/imbe/)- [AMBE](https://gophertrunk.org/reference/ambe/)- [AMBE+2](https://gophertrunk.org/reference/ambe-plus-2/)- [Codec 2](https://gophertrunk.org/reference/codec2/)- [ACELP](https://gophertrunk.org/reference/acelp/)- [AMR / AMR-WB](https://gophertrunk.org/reference/amr/)- [Enhanced Voice Services (EVS)](https://gophertrunk.org/reference/evs-codec/)- [Opus](https://gophertrunk.org/reference/opus-codec/)- [G.711](https://gophertrunk.org/reference/g711/)- [G.722](https://gophertrunk.org/reference/g722/)- [G.729](https://gophertrunk.org/reference/g729/)- [Speex](https://gophertrunk.org/reference/speex/)- [SILK](https://gophertrunk.org/reference/silk-codec/)- [TWELP](https://gophertrunk.org/reference/twelp/)- [RALCWI](https://gophertrunk.org/reference/ralcwi/)- [EVRC](https://gophertrunk.org/reference/evrc/)- [GSM FR / HR / EFR](https://gophertrunk.org/reference/gsm-fr-hr-efr/)- [Advanced Audio Coding (AAC)](https://gophertrunk.org/reference/advanced-audio-coding/)- [ACELP adaptive & algebraic codebooks](https://gophertrunk.org/reference/acelp-codebooks/)- [ACELP gain quantization](https://gophertrunk.org/reference/acelp-gain-quantization/)- [ACELP LSP codebooks](https://gophertrunk.org/reference/acelp-lsp-codebooks/)- [ACELP Post_Process](https://gophertrunk.org/reference/acelp-post-process/)- [AMBE-3003 packet](https://gophertrunk.org/reference/ambe-3003-packet/)- [AMBE+2 codebooks](https://gophertrunk.org/reference/ambe-plus-2-codebooks/)- [AMBE+2 on-air FEC](https://gophertrunk.org/reference/ambe-plus-2-fec/)- [AMBE+2 tones](https://gophertrunk.org/reference/ambe-plus-2-tones/)- [G.191 basic operators](https://gophertrunk.org/reference/etsi-g191-basic-operators/)- [IMBE channel coding](https://gophertrunk.org/reference/imbe-channel-coding/)- [IMBE interleaver](https://gophertrunk.org/reference/imbe-interleaver/)- [IMBE parameter quantization](https://gophertrunk.org/reference/imbe-parameter-quantization/)- [IMBE scrambler](https://gophertrunk.org/reference/imbe-scrambler/)- [MBE adaptive smoothing](https://gophertrunk.org/reference/mbe-adaptive-smoothing/)- [MBE spectral-amplitude enhancement](https://gophertrunk.org/reference/mbe-spectral-enhancement/)- [MBE unvoiced synthesis](https://gophertrunk.org/reference/mbe-unvoiced-synthesis/)- [MBE voiced synthesis](https://gophertrunk.org/reference/mbe-voiced-synthesis/)- [TETRA TCH/S speech coding](https://gophertrunk.org/reference/tetra-tchs-speech-coding/) #### SDR devices - [RTL-SDR](https://gophertrunk.org/reference/rtl-sdr/)- [RTL2832U](https://gophertrunk.org/reference/rtl2832u/)- [R820T / R820T2 tuner](https://gophertrunk.org/reference/r820t-tuner/)- [E4000 tuner](https://gophertrunk.org/reference/e4000-tuner/)- [MSi001 tuner](https://gophertrunk.org/reference/msi001-tuner/)- [Nooelec NESDR](https://gophertrunk.org/reference/nesdr/)- [HackRF One](https://gophertrunk.org/reference/hackrf/)- [Airspy](https://gophertrunk.org/reference/airspy/)- [Airspy Mini](https://gophertrunk.org/reference/airspy-mini/)- [Airspy R2](https://gophertrunk.org/reference/airspy-r2/)- [HydraSDR RFOne](https://gophertrunk.org/reference/hydrasdr/)- [Airspy HF+](https://gophertrunk.org/reference/airspy-hf-plus/)- [Airspy HF+ Discovery](https://gophertrunk.org/reference/airspy-hf-plus-discovery/)- [SDRplay RSP1A](https://gophertrunk.org/reference/sdrplay-rsp1a/)- [SDRplay RSP1B](https://gophertrunk.org/reference/sdrplay-rsp1b/)- [SDRplay RSPdx](https://gophertrunk.org/reference/sdrplay-rspdx/)- [SDRplay RSPduo](https://gophertrunk.org/reference/sdrplay-rspduo/)- [LimeSDR](https://gophertrunk.org/reference/limesdr/)- [USRP (Ettus)](https://gophertrunk.org/reference/usrp-ettus/)- [USRP B210](https://gophertrunk.org/reference/usrp-b210/)- [ADALM-Pluto (PlutoSDR)](https://gophertrunk.org/reference/plutosdr/)- [BladeRF](https://gophertrunk.org/reference/bladerf/)- [KrakenSDR](https://gophertrunk.org/reference/krakensdr/)- [FUNcube Dongle](https://gophertrunk.org/reference/funcube-dongle/) #### Scanner hardware & receivers - [Police scanner](https://gophertrunk.org/reference/police-scanner/)- [Trunking scanner](https://gophertrunk.org/reference/trunking-scanner/)- [Uniden SDS200](https://gophertrunk.org/reference/uniden-sds200/)- [Uniden SDS100](https://gophertrunk.org/reference/uniden-sds100/)- [Uniden SDS150](https://gophertrunk.org/reference/uniden-sds150/)- [Uniden BCD536HP](https://gophertrunk.org/reference/uniden-bcd536hp/)- [Uniden BCD436HP](https://gophertrunk.org/reference/uniden-bcd436hp/)- [Uniden BCD996P2](https://gophertrunk.org/reference/uniden-bcd996p2/)- [Uniden BCD996XT](https://gophertrunk.org/reference/uniden-bcd996xt/)- [Uniden BCD325P2](https://gophertrunk.org/reference/uniden-bcd325p2/)- [Uniden HomePatrol-2](https://gophertrunk.org/reference/uniden-home-patrol-2/)- [Uniden SR30C](https://gophertrunk.org/reference/uniden-sr30c/)- [Uniden BC125AT](https://gophertrunk.org/reference/uniden-bc125at/)- [Uniden BC75XLT](https://gophertrunk.org/reference/uniden-bc75xlt/)- [Uniden BearTracker BCT15X](https://gophertrunk.org/reference/uniden-bearcat-bct15x/)- [Whistler TRX-1](https://gophertrunk.org/reference/whistler-trx-1/)- [Whistler TRX-2](https://gophertrunk.org/reference/whistler-trx-2/)- [Whistler WS1088](https://gophertrunk.org/reference/whistler-ws1088/)- [Whistler WS1065](https://gophertrunk.org/reference/whistler-ws1065/)- [Whistler WS1040](https://gophertrunk.org/reference/whistler-ws1040/) #### Ham radio transceivers - [Icom IC-7300](https://gophertrunk.org/reference/icom-ic-7300/)- [Yaesu FTDX10](https://gophertrunk.org/reference/yaesu-ftdx10/)- [Icom IC-7610](https://gophertrunk.org/reference/icom-ic-7610/)- [Yaesu FT-991A](https://gophertrunk.org/reference/yaesu-ft-991a/)- [Kenwood TS-590SG](https://gophertrunk.org/reference/kenwood-ts-590sg/)- [Icom IC-718](https://gophertrunk.org/reference/icom-ic-718/)- [Xiegu G90](https://gophertrunk.org/reference/xiegu-g90/)- [Yaesu FT-891](https://gophertrunk.org/reference/yaesu-ft-891/)- [Kenwood TS-940S](https://gophertrunk.org/reference/kenwood-ts-940s/)- [Yaesu FT-1000MP](https://gophertrunk.org/reference/yaesu-ft-1000mp/)- [Yaesu FTM-500DR](https://gophertrunk.org/reference/yaesu-ftm-500dr/)- [Yaesu FTM-300DR](https://gophertrunk.org/reference/yaesu-ftm-300dr/)- [Icom ID-5100A](https://gophertrunk.org/reference/icom-id-5100a/)- [Icom IC-2730A](https://gophertrunk.org/reference/icom-ic-2730a/)- [AnyTone AT-D578UVIII Plus](https://gophertrunk.org/reference/anytone-at-d578uviii/)- [BTECH UV-25X2](https://gophertrunk.org/reference/btech-uv-25x2/)- [QYT KT-8900D](https://gophertrunk.org/reference/qyt-kt-8900d/)- [Icom IC-706MkIIG](https://gophertrunk.org/reference/icom-ic-706mkiig/)- [Yaesu FT-857D](https://gophertrunk.org/reference/yaesu-ft-857d/)- [Kenwood TM-V71A](https://gophertrunk.org/reference/kenwood-tm-v71a/)- [Kenwood TH-D75A](https://gophertrunk.org/reference/kenwood-th-d75a/)- [Icom ID-52A](https://gophertrunk.org/reference/icom-id-52a/)- [Yaesu FT-5DR](https://gophertrunk.org/reference/yaesu-ft-5dr/)- [Yaesu FT-60R](https://gophertrunk.org/reference/yaesu-ft-60r/)- [AnyTone AT-D878UVII Plus](https://gophertrunk.org/reference/anytone-at-d878uvii-plus/)- [BTECH UV-PRO](https://gophertrunk.org/reference/btech-uv-pro/)- [Baofeng BF-F8HP](https://gophertrunk.org/reference/baofeng-bf-f8hp/)- [Baofeng UV-5R](https://gophertrunk.org/reference/baofeng-uv-5r/)- [Kenwood TH-F6A](https://gophertrunk.org/reference/kenwood-th-f6a/)- [Yaesu VX-8DR](https://gophertrunk.org/reference/yaesu-vx-8dr/) #### Consumer two-way radios (FRS, GMRS & CB) - [Rocky Talkie Mountain Radio](https://gophertrunk.org/reference/rocky-talkie-mountain-radio/)- [Rocky Talkie Expedition Radio (5 Watt)](https://gophertrunk.org/reference/rocky-talkie-5-watt/)- [Midland GXT1000VP4](https://gophertrunk.org/reference/midland-gxt1000vp4/)- [Motorola Talkabout T800](https://gophertrunk.org/reference/motorola-talkabout-t800/)- [Baofeng UV-5G Plus](https://gophertrunk.org/reference/baofeng-uv-5g-plus/)- [Baofeng GM-15 Pro](https://gophertrunk.org/reference/baofeng-gm-15-pro/)- [BTECH GMRS-PRO](https://gophertrunk.org/reference/btech-gmrs-pro/)- [Wouxun KG-935G](https://gophertrunk.org/reference/wouxun-kg-935g/)- [Garmin Rino 755t](https://gophertrunk.org/reference/garmin-rino-755t/)- [Motorola Talkabout MR350R](https://gophertrunk.org/reference/motorola-talkabout-mr350r/)- [Midland MXT575](https://gophertrunk.org/reference/midland-mxt575/)- [Midland MXT500](https://gophertrunk.org/reference/midland-mxt500/)- [Midland MXT275](https://gophertrunk.org/reference/midland-mxt275/)- [Wouxun KG-1000G Plus](https://gophertrunk.org/reference/wouxun-kg-1000g-plus/)- [Wouxun KG-XS20G Plus](https://gophertrunk.org/reference/wouxun-kg-xs20g/)- [Radioddity DB20-G](https://gophertrunk.org/reference/radioddity-db20-g/)- [BTECH GMRS-50PRO](https://gophertrunk.org/reference/btech-gmrs-50pro/)- [Midland MXT115](https://gophertrunk.org/reference/midland-mxt115/)- [Midland MXT400](https://gophertrunk.org/reference/midland-mxt400/)- [BTECH GMRS-50X1](https://gophertrunk.org/reference/btech-gmrs-50x1/)- [Cobra 29 LX](https://gophertrunk.org/reference/cobra-29-lx/)- [Cobra 29 LTD Classic](https://gophertrunk.org/reference/cobra-29-ltd-classic/)- [Uniden Bearcat 880FM](https://gophertrunk.org/reference/uniden-bearcat-880/)- [Uniden Bearcat 980SSB](https://gophertrunk.org/reference/uniden-bearcat-980ssb/)- [President McKinley II](https://gophertrunk.org/reference/president-mckinley/)- [Uniden PRO505XL](https://gophertrunk.org/reference/uniden-pro505xl/)- [Cobra 75 All Road](https://gophertrunk.org/reference/cobra-75-all-road/)- [Midland 75-822](https://gophertrunk.org/reference/midland-75-822/)- [Cobra 2000 GTL](https://gophertrunk.org/reference/cobra-2000-gtl/)- [Uniden Grant XL](https://gophertrunk.org/reference/uniden-grant-xl/) #### Shortwave & emergency radios - [Tecsun PL-990](https://gophertrunk.org/reference/tecsun-pl-990/)- [Tecsun PL-880](https://gophertrunk.org/reference/tecsun-pl-880/)- [Tecsun PL-330](https://gophertrunk.org/reference/tecsun-pl-330/)- [Sangean ATS-909X2](https://gophertrunk.org/reference/sangean-ats-909x2/)- [XHDATA D-808](https://gophertrunk.org/reference/xhdata-d-808/)- [C.Crane CC Skywave SSB 2](https://gophertrunk.org/reference/cc-skywave-ssb-2/)- [Eton Elite Executive](https://gophertrunk.org/reference/eton-elite-executive/)- [Qodosen DX-286](https://gophertrunk.org/reference/qodosen-dx-286/)- [Sony ICF-SW7600GR](https://gophertrunk.org/reference/sony-icf-sw7600gr/)- [Tecsun PL-660](https://gophertrunk.org/reference/tecsun-pl-660/)- [Midland ER310](https://gophertrunk.org/reference/midland-er310/)- [Midland ER210](https://gophertrunk.org/reference/midland-er210/)- [Kaito KA500](https://gophertrunk.org/reference/kaito-ka500/)- [Eton FRX3+](https://gophertrunk.org/reference/eton-frx3-plus/)- [Sangean MMR-88](https://gophertrunk.org/reference/sangean-mmr-88/)- [FosPower A1](https://gophertrunk.org/reference/fospower-a1/)- [RunningSnail MD-092](https://gophertrunk.org/reference/runningsnail-md-092/)- [Eton Scorpion II](https://gophertrunk.org/reference/eton-scorpion-ii/)- [Eton FR500 Solarlink](https://gophertrunk.org/reference/eton-fr500/)- [Grundig FR200](https://gophertrunk.org/reference/grundig-fr200/)- [Drake R8B](https://gophertrunk.org/reference/drake-r8b/)- [Icom IC-R75](https://gophertrunk.org/reference/icom-ic-r75/)- [AOR AR7030](https://gophertrunk.org/reference/aor-ar7030/)- [JRC NRD-545](https://gophertrunk.org/reference/jrc-nrd-545/)- [Kenwood R-5000](https://gophertrunk.org/reference/kenwood-r-5000/)- [Sony ICF-2010](https://gophertrunk.org/reference/sony-icf-2010/)- [Lowe HF-150](https://gophertrunk.org/reference/lowe-hf-150/)- [Grundig Satellit 800](https://gophertrunk.org/reference/grundig-satellit-800/)- [Icom IC-R8600](https://gophertrunk.org/reference/icom-ic-r8600/)- [Eton Elite 750](https://gophertrunk.org/reference/eton-elite-750/) #### RF front-end & components - [Low-noise amplifier (LNA)](https://gophertrunk.org/reference/low-noise-amplifier/)- [Preamplifier](https://gophertrunk.org/reference/preamplifier/)- [Power amplifier (PA)](https://gophertrunk.org/reference/power-amplifier/)- [Mixer](https://gophertrunk.org/reference/mixer-rf/)- [Attenuator](https://gophertrunk.org/reference/attenuator/)- [Circulator](https://gophertrunk.org/reference/circulator/)- [Isolator](https://gophertrunk.org/reference/isolator/)- [Directional coupler](https://gophertrunk.org/reference/directional-coupler/)- [Splitter / combiner](https://gophertrunk.org/reference/splitter-combiner/)- [Duplexer](https://gophertrunk.org/reference/duplexer/)- [Diplexer](https://gophertrunk.org/reference/diplexer/)- [RF filter](https://gophertrunk.org/reference/rf-filter/)- [FM broadcast notch filter](https://gophertrunk.org/reference/fm-broadcast-filter/)- [SAW filter](https://gophertrunk.org/reference/saw-filter/)- [Cavity filter](https://gophertrunk.org/reference/cavity-filter/)- [Helical filter](https://gophertrunk.org/reference/helical-filter/)- [Crystal filter](https://gophertrunk.org/reference/crystal-filter/)- [RF switch](https://gophertrunk.org/reference/rf-switch/)- [Bias tee](https://gophertrunk.org/reference/bias-tee/)- [Upconverter](https://gophertrunk.org/reference/upconverter/)- [Transverter](https://gophertrunk.org/reference/transverter/)- [Ferrite choke](https://gophertrunk.org/reference/ferrite-choke/)- [Balun](https://gophertrunk.org/reference/balun/)- [Unun](https://gophertrunk.org/reference/unun/)- [Dummy load](https://gophertrunk.org/reference/dummy-load/)- [Coaxial cable](https://gophertrunk.org/reference/coaxial-cable/)- [SMA connector](https://gophertrunk.org/reference/sma-connector/)- [BNC connector](https://gophertrunk.org/reference/bnc-connector/)- [N-type connector](https://gophertrunk.org/reference/n-type-connector/)- [UHF connector (PL-259)](https://gophertrunk.org/reference/uhf-connector-pl259/)- [SMA adapter kit](https://gophertrunk.org/reference/sma-adapter-kit/)- [Coax pigtail](https://gophertrunk.org/reference/coax-pigtail/)- [Coax feedline](https://gophertrunk.org/reference/coax-feedline/)- [USB extension cable](https://gophertrunk.org/reference/usb-extension-cable/)- [TCXO](https://gophertrunk.org/reference/tcxo/)- [OCXO](https://gophertrunk.org/reference/ocxo/)- [GPSDO](https://gophertrunk.org/reference/gpsdo/)- [DDS synthesizer](https://gophertrunk.org/reference/dds-synthesizer/) #### Test & measurement - [Spectrum analyzer](https://gophertrunk.org/reference/spectrum-analyzer/)- [Signal generator](https://gophertrunk.org/reference/signal-generator/)- [Vector network analyzer (VNA)](https://gophertrunk.org/reference/vector-network-analyzer/)- [NanoVNA](https://gophertrunk.org/reference/nanovna/)- [TinySA](https://gophertrunk.org/reference/tinysa/)- [RF power meter](https://gophertrunk.org/reference/rf-power-meter/)- [Frequency counter](https://gophertrunk.org/reference/frequency-counter/)- [Noise source](https://gophertrunk.org/reference/noise-source/) #### SDR software - [Zadig](https://gophertrunk.org/reference/zadig/)- [GNU Radio](https://gophertrunk.org/reference/gnuradio/)- [SDR#](https://gophertrunk.org/reference/sdr-sharp/)- [Gqrx](https://gophertrunk.org/reference/gqrx/)- [SDRangel](https://gophertrunk.org/reference/sdrangel/)- [CubicSDR](https://gophertrunk.org/reference/cubicsdr/)- [dump1090](https://gophertrunk.org/reference/dump1090/)- [DSD (Digital Speech Decoder)](https://gophertrunk.org/reference/dsd/)- [OP25](https://gophertrunk.org/reference/op25/)- [multimon-ng](https://gophertrunk.org/reference/multimon-ng/)- [Dire Wolf](https://gophertrunk.org/reference/direwolf/) #### SDR frameworks & libraries - [UHD (USRP Hardware Driver)](https://gophertrunk.org/reference/uhd/)- [GNU Radio Companion (GRC)](https://gophertrunk.org/reference/gnuradio-companion/)- [VOLK](https://gophertrunk.org/reference/volk/)- [liquid-dsp](https://gophertrunk.org/reference/liquid-dsp/)- [FFTW](https://gophertrunk.org/reference/fftw/)- [gr-osmosdr](https://gophertrunk.org/reference/gr-osmosdr/)- [libiio](https://gophertrunk.org/reference/libiio/)- [librtlsdr](https://gophertrunk.org/reference/librtlsdr/)- [libhackrf](https://gophertrunk.org/reference/libhackrf/)- [libairspy](https://gophertrunk.org/reference/libairspy/)- [libbladeRF](https://gophertrunk.org/reference/libbladerf/)- [Pothos](https://gophertrunk.org/reference/pothos/)- [REDHAWK SDR](https://gophertrunk.org/reference/redhawk-sdr/)- [csdr](https://gophertrunk.org/reference/csdr/)- [NumPy & SciPy for DSP](https://gophertrunk.org/reference/numpy-scipy-dsp/)- [SoapySDR](https://gophertrunk.org/reference/soapysdr/) #### SDR programming & DSP engineering - [Flowgraph](https://gophertrunk.org/reference/flowgraph/)- [Signal-processing block](https://gophertrunk.org/reference/signal-processing-block/)- [Block scheduler](https://gophertrunk.org/reference/block-scheduler/)- [Stream vs message passing](https://gophertrunk.org/reference/stream-vs-message-passing/)- [Stream tags](https://gophertrunk.org/reference/stream-tags/)- [Hierarchical block](https://gophertrunk.org/reference/hierarchical-block/)- [Out-of-tree module](https://gophertrunk.org/reference/out-of-tree-module/)- [Sample buffer](https://gophertrunk.org/reference/sample-buffer/)- [Ring buffer](https://gophertrunk.org/reference/ring-buffer/)- [Overruns & underruns](https://gophertrunk.org/reference/overruns-underruns/)- [Back-pressure](https://gophertrunk.org/reference/back-pressure/)- [Throttle](https://gophertrunk.org/reference/throttle-block/)- [Sample format (CS8/CS16/CF32)](https://gophertrunk.org/reference/sample-format/)- [Interleaved IQ](https://gophertrunk.org/reference/interleaved-iq/)- [Real-time DSP](https://gophertrunk.org/reference/real-time-dsp/)- [DSP latency](https://gophertrunk.org/reference/dsp-latency/)- [SIMD vectorization](https://gophertrunk.org/reference/vectorization-simd/)- [Fixed-point vs floating-point DSP](https://gophertrunk.org/reference/fixed-point-vs-floating-point/)- [Zero-copy](https://gophertrunk.org/reference/zero-copy-dsp/)- [Multithreaded DSP](https://gophertrunk.org/reference/multithreaded-dsp/)- [Numerical precision in DSP](https://gophertrunk.org/reference/numerical-precision-dsp/)- [Callback vs stream API](https://gophertrunk.org/reference/callback-vs-stream-api/) #### SDR data & streaming - [SigMF (Signal Metadata Format)](https://gophertrunk.org/reference/sigmf/)- [IQ file format](https://gophertrunk.org/reference/iq-file-format/)- [cfile format](https://gophertrunk.org/reference/cfile-format/)- [cs16 format](https://gophertrunk.org/reference/cs16-format/)- [WAV IQ recording](https://gophertrunk.org/reference/wav-iq-recording/)- [VITA 49 (VRT)](https://gophertrunk.org/reference/vita-49/)- [SpyServer protocol](https://gophertrunk.org/reference/spyserver-protocol/)- [SoapyRemote](https://gophertrunk.org/reference/soapyremote/)- [ka9q-radio](https://gophertrunk.org/reference/ka9q-radio/)- [Network IQ streaming](https://gophertrunk.org/reference/network-iq-streaming/)- [IQ recording & playback](https://gophertrunk.org/reference/iq-recording-playback/)- [ZeroMQ for SDR](https://gophertrunk.org/reference/zeromq-sdr/)- [rtl_tcp](https://gophertrunk.org/reference/rtl-tcp/) #### Building SDR applications - [Software-defined receiver](https://gophertrunk.org/reference/software-defined-receiver/)- [Receiver chain](https://gophertrunk.org/reference/receiver-chain/)- [Transmit chain](https://gophertrunk.org/reference/transmit-chain/)- [Frequency-translating FIR filter](https://gophertrunk.org/reference/frequency-xlating-fir/)- [Deframing](https://gophertrunk.org/reference/deframing/)- [Packet framing](https://gophertrunk.org/reference/packet-framing/)- [Access-code correlation](https://gophertrunk.org/reference/correlate-access-code/)- [HDLC](https://gophertrunk.org/reference/hdlc/)- [Testing DSP without hardware](https://gophertrunk.org/reference/testing-dsp-without-hardware/)- [Golden test vectors](https://gophertrunk.org/reference/golden-test-vectors/)- [File source & sink](https://gophertrunk.org/reference/file-source-sink/)- [Simulation-driven SDR development](https://gophertrunk.org/reference/simulation-driven-sdr/)- [Benchmarking DSP](https://gophertrunk.org/reference/benchmarking-dsp/)- [Waterfall rendering](https://gophertrunk.org/reference/waterfall-rendering/)- [Audio output (PortAudio/ALSA)](https://gophertrunk.org/reference/audio-output/)- [Web SDR (OpenWebRX/KiwiSDR)](https://gophertrunk.org/reference/web-sdr/)- [GPU DSP](https://gophertrunk.org/reference/gpu-dsp/)- [Embedded SDR](https://gophertrunk.org/reference/embedded-sdr/)- [RF machine learning](https://gophertrunk.org/reference/rf-machine-learning/)- [Signal classification](https://gophertrunk.org/reference/signal-classification/)- [Automatic modulation classification](https://gophertrunk.org/reference/automatic-modulation-classification/) #### People - [Heinrich Hertz](https://gophertrunk.org/reference/heinrich-hertz/)- [James Clerk Maxwell](https://gophertrunk.org/reference/james-clerk-maxwell/)- [Guglielmo Marconi](https://gophertrunk.org/reference/guglielmo-marconi/)- [Joseph Fourier](https://gophertrunk.org/reference/joseph-fourier/)- [Harry Nyquist](https://gophertrunk.org/reference/harry-nyquist/)- [Claude Shannon](https://gophertrunk.org/reference/claude-shannon/)- [Edwin Armstrong](https://gophertrunk.org/reference/edwin-armstrong/)- [Andrew Viterbi](https://gophertrunk.org/reference/andrew-viterbi/)- [Richard Hamming](https://gophertrunk.org/reference/richard-hamming/)- [Reginald Fessenden](https://gophertrunk.org/reference/reginald-fessenden/)- [John P. Costas](https://gophertrunk.org/reference/john-costas/)- [Floyd M. Gardner](https://gophertrunk.org/reference/fred-gardner/)- [Nikola Tesla](https://gophertrunk.org/reference/nikola-tesla/)- [Oliver Heaviside](https://gophertrunk.org/reference/oliver-heaviside/)- [Karl Jansky](https://gophertrunk.org/reference/karl-jansky/)- [Hedy Lamarr](https://gophertrunk.org/reference/hedy-lamarr/)- [Robert Watson-Watt](https://gophertrunk.org/reference/robert-watson-watt/)- [Irwin Jacobs](https://gophertrunk.org/reference/irwin-jacobs/)- [Phil Karn](https://gophertrunk.org/reference/phil-karn/)- [Joe Taylor (K1JT)](https://gophertrunk.org/reference/joe-taylor/)- [Gustav Kirchhoff](https://gophertrunk.org/reference/gustav-kirchhoff/)- [Oliver Lodge](https://gophertrunk.org/reference/oliver-lodge/)- [Jagadish Chandra Bose](https://gophertrunk.org/reference/jagadish-bose/)- [Alexander Popov](https://gophertrunk.org/reference/alexander-popov/)- [Hendrik Lorentz](https://gophertrunk.org/reference/hendrik-lorentz/)- [Georg Ohm](https://gophertrunk.org/reference/georg-ohm/)- [Norbert Wiener](https://gophertrunk.org/reference/norbert-wiener/)- [Rudolf Kalman](https://gophertrunk.org/reference/rudolf-kalman/)- [Robert Gallager](https://gophertrunk.org/reference/robert-gallager/)- [Irving S. Reed](https://gophertrunk.org/reference/irving-reed/)- [Gustave Solomon](https://gophertrunk.org/reference/gustave-solomon/)- [Ralph Hartley](https://gophertrunk.org/reference/ralph-hartley/)- [Dennis Gabor](https://gophertrunk.org/reference/dennis-gabor/) #### Organizations & standards bodies - [International Telecommunication Union (ITU)](https://gophertrunk.org/reference/itu/)- [Federal Communications Commission (FCC)](https://gophertrunk.org/reference/fcc/)- [ETSI](https://gophertrunk.org/reference/etsi/)- [Telecommunications Industry Association (TIA)](https://gophertrunk.org/reference/tia/)- [APCO International](https://gophertrunk.org/reference/apco-international/)- [ICAO](https://gophertrunk.org/reference/icao/)- [Digital Voice Systems (DVSI)](https://gophertrunk.org/reference/dvsi/)- [M17 Project](https://gophertrunk.org/reference/m17-project/)- [RadioReference](https://gophertrunk.org/reference/radioreference/)- [Ofcom](https://gophertrunk.org/reference/ofcom/)- [RTCA](https://gophertrunk.org/reference/rtca/)- [EUROCAE](https://gophertrunk.org/reference/eurocae/)- [3GPP](https://gophertrunk.org/reference/3gpp/)- [Wi-Fi Alliance](https://gophertrunk.org/reference/wi-fi-alliance/)- [Bluetooth SIG](https://gophertrunk.org/reference/bluetooth-sig/)- [LoRa Alliance](https://gophertrunk.org/reference/lora-alliance/)- [ARRL](https://gophertrunk.org/reference/arrl/)- [DARPA](https://gophertrunk.org/reference/darpa/)- [NIST](https://gophertrunk.org/reference/nist/)- [NASA](https://gophertrunk.org/reference/nasa/)- [ARIB](https://gophertrunk.org/reference/arib/)- [CEPT](https://gophertrunk.org/reference/cept/)- [IARU](https://gophertrunk.org/reference/iaru/)- [ITU-R](https://gophertrunk.org/reference/itu-r/)- [NTIA](https://gophertrunk.org/reference/ntia/)- [World Radiocommunication Conference (WRC)](https://gophertrunk.org/reference/wrc/)- [GSMA](https://gophertrunk.org/reference/gsma/)- [Connectivity Standards Alliance](https://gophertrunk.org/reference/connectivity-standards-alliance/)- [RSGB](https://gophertrunk.org/reference/rsgb/)- [DMR Association](https://gophertrunk.org/reference/dmr-association/)- [Federal Aviation Administration (FAA)](https://gophertrunk.org/reference/faa/)- [International Maritime Organization (IMO)](https://gophertrunk.org/reference/imo/)- [International Electrotechnical Commission (IEC)](https://gophertrunk.org/reference/iec/)- [Tucson Amateur Packet Radio (TAPR)](https://gophertrunk.org/reference/tapr/)- [National Radio Systems Committee (NRSC)](https://gophertrunk.org/reference/nrsc/)- [CCITT](https://gophertrunk.org/reference/ccitt/) ### Software Development #### Programming languages - [Go](https://gophertrunk.org/reference/go-language/)- [Python](https://gophertrunk.org/reference/python-language/)- [JavaScript](https://gophertrunk.org/reference/javascript-language/)- [TypeScript](https://gophertrunk.org/reference/typescript-language/)- [C](https://gophertrunk.org/reference/c-language/)- [C++](https://gophertrunk.org/reference/cpp-language/)- [Rust](https://gophertrunk.org/reference/rust-language/)- [Java](https://gophertrunk.org/reference/java-language/)- [C#](https://gophertrunk.org/reference/csharp-language/)- [Swift](https://gophertrunk.org/reference/swift-language/)- [Kotlin](https://gophertrunk.org/reference/kotlin-language/)- [Ruby](https://gophertrunk.org/reference/ruby-language/)- [PHP](https://gophertrunk.org/reference/php-language/)- [R](https://gophertrunk.org/reference/r-language/)- [Julia](https://gophertrunk.org/reference/julia-language/)- [MATLAB](https://gophertrunk.org/reference/matlab-language/)- [FORTRAN](https://gophertrunk.org/reference/fortran-language/)- [COBOL](https://gophertrunk.org/reference/cobol-language/)- [LISP](https://gophertrunk.org/reference/lisp-language/) #### Language internals & execution - [Compiler](https://gophertrunk.org/reference/compiler/)- [Interpreter](https://gophertrunk.org/reference/interpreter/)- [Bytecode](https://gophertrunk.org/reference/bytecode/)- [JIT vs AOT compilation](https://gophertrunk.org/reference/jit-compilation/)- [Garbage collection](https://gophertrunk.org/reference/garbage-collection/)- [Memory management](https://gophertrunk.org/reference/memory-management/)- [Type system](https://gophertrunk.org/reference/type-system/)- [Static vs dynamic typing](https://gophertrunk.org/reference/static-vs-dynamic-typing/)- [Cross-compilation](https://gophertrunk.org/reference/cross-compilation/)- [Static binary](https://gophertrunk.org/reference/static-binary/) #### Concurrency & execution models - [Concurrency vs parallelism](https://gophertrunk.org/reference/concurrency/)- [Threads](https://gophertrunk.org/reference/threads/)- [Asynchronous programming](https://gophertrunk.org/reference/async-programming/)- [Goroutines](https://gophertrunk.org/reference/goroutines/) #### Paradigms & design patterns - [Object-oriented programming](https://gophertrunk.org/reference/object-oriented-programming/)- [Functional programming](https://gophertrunk.org/reference/functional-programming/)- [Imperative programming](https://gophertrunk.org/reference/imperative-programming/)- [Declarative programming](https://gophertrunk.org/reference/declarative-programming/)- [Design patterns](https://gophertrunk.org/reference/design-patterns/)- [Creational patterns](https://gophertrunk.org/reference/creational-patterns/)- [Structural patterns](https://gophertrunk.org/reference/structural-patterns/)- [Behavioral patterns](https://gophertrunk.org/reference/behavioral-patterns/)- [Abstraction](https://gophertrunk.org/reference/abstraction/)- [Coupling & cohesion](https://gophertrunk.org/reference/coupling-and-cohesion/) #### Principles & code quality - [SOLID](https://gophertrunk.org/reference/solid/)- [DRY](https://gophertrunk.org/reference/dry-kiss-yagni/)- [Clean code](https://gophertrunk.org/reference/clean-code/)- [Refactoring](https://gophertrunk.org/reference/refactoring/)- [Error handling](https://gophertrunk.org/reference/error-handling/)- [API](https://gophertrunk.org/reference/api/) #### Testing, tooling & delivery - [Unit testing](https://gophertrunk.org/reference/unit-testing/)- [Integration testing](https://gophertrunk.org/reference/integration-testing/)- [End-to-end testing](https://gophertrunk.org/reference/end-to-end-testing/)- [Test-driven development (TDD)](https://gophertrunk.org/reference/test-driven-development/)- [Mocking](https://gophertrunk.org/reference/mocking/)- [Self-consistent test trap](https://gophertrunk.org/reference/self-consistent-test-trap/)- [Code coverage](https://gophertrunk.org/reference/code-coverage/)- [CI/CD](https://gophertrunk.org/reference/ci-cd/)- [Build systems](https://gophertrunk.org/reference/build-systems/)- [Package manager & dependency management](https://gophertrunk.org/reference/package-manager/)- [Semantic versioning](https://gophertrunk.org/reference/semantic-versioning/)- [REST](https://gophertrunk.org/reference/rest/)- [Version control](https://gophertrunk.org/reference/version-control/) ### Hardware (computers & devices) #### Hardware foundations - [Computer hardware](https://gophertrunk.org/reference/computer-hardware/)- [Central processing unit (CPU)](https://gophertrunk.org/reference/central-processing-unit/)- [Random-access memory (RAM)](https://gophertrunk.org/reference/random-access-memory/)- [Storage (SSD](https://gophertrunk.org/reference/data-storage/)- [Input/output (I/O)](https://gophertrunk.org/reference/input-output/)- [Operating system](https://gophertrunk.org/reference/operating-system/)- [The hardware spectrum](https://gophertrunk.org/reference/hardware-spectrum/)- [Motherboard](https://gophertrunk.org/reference/motherboard/)- [Graphics processing unit (GPU)](https://gophertrunk.org/reference/graphics-processing-unit/)- [Power supply unit (PSU)](https://gophertrunk.org/reference/power-supply-unit/)- [Cooling & thermals](https://gophertrunk.org/reference/cooling-and-thermals/)- [System bus](https://gophertrunk.org/reference/system-bus/)- [PCI Express (PCIe)](https://gophertrunk.org/reference/pci-express/)- [USB](https://gophertrunk.org/reference/usb/)- [Cache memory](https://gophertrunk.org/reference/cache-memory/)- [Instruction set architecture (ISA)](https://gophertrunk.org/reference/instruction-set-architecture/)- [x86](https://gophertrunk.org/reference/x86/)- [ARM architecture](https://gophertrunk.org/reference/arm-architecture/)- [RISC-V](https://gophertrunk.org/reference/risc-v/)- [Transistor](https://gophertrunk.org/reference/transistor/)- [Integrated circuit](https://gophertrunk.org/reference/integrated-circuit/)- [Semiconductor](https://gophertrunk.org/reference/semiconductor/)- [Logic gate](https://gophertrunk.org/reference/logic-gate/)- [Von Neumann architecture](https://gophertrunk.org/reference/von-neumann-architecture/)- [Moore's law](https://gophertrunk.org/reference/moores-law/)- [Bits & bytes](https://gophertrunk.org/reference/bits-and-bytes/)- [Clock speed](https://gophertrunk.org/reference/clock-speed/)- [BIOS & UEFI](https://gophertrunk.org/reference/bios-uefi/)- [Chipset](https://gophertrunk.org/reference/chipset/)- [Binary-coded decimal (BCD)](https://gophertrunk.org/reference/binary-coded-decimal/) #### Servers & hosting - [Server](https://gophertrunk.org/reference/server/)- [Web & shared hosting](https://gophertrunk.org/reference/web-hosting/)- [Virtual private server (VPS)](https://gophertrunk.org/reference/virtual-private-server/)- [Dedicated server](https://gophertrunk.org/reference/dedicated-server/)- [Home server & self-hosting](https://gophertrunk.org/reference/home-server/)- [Cloud computing](https://gophertrunk.org/reference/cloud-computing/)- [Virtualization](https://gophertrunk.org/reference/virtualization/)- [Data center](https://gophertrunk.org/reference/data-center/)- [Rack server](https://gophertrunk.org/reference/rack-server/)- [Blade server](https://gophertrunk.org/reference/blade-server/)- [Bare-metal server](https://gophertrunk.org/reference/bare-metal-server/)- [Colocation](https://gophertrunk.org/reference/colocation/)- [Managed hosting](https://gophertrunk.org/reference/managed-hosting/)- [Platform as a service (PaaS)](https://gophertrunk.org/reference/platform-as-a-service/)- [Infrastructure as a service (IaaS)](https://gophertrunk.org/reference/infrastructure-as-a-service/)- [Software as a service (SaaS)](https://gophertrunk.org/reference/software-as-a-service/)- [Serverless computing](https://gophertrunk.org/reference/serverless-computing/)- [Container](https://gophertrunk.org/reference/container/)- [Docker](https://gophertrunk.org/reference/docker/)- [Kubernetes](https://gophertrunk.org/reference/kubernetes/)- [Hypervisor](https://gophertrunk.org/reference/hypervisor/)- [Load balancer](https://gophertrunk.org/reference/load-balancer/)- [Reverse proxy](https://gophertrunk.org/reference/reverse-proxy/)- [Content delivery network (CDN)](https://gophertrunk.org/reference/content-delivery-network/)- [Network-attached storage (NAS)](https://gophertrunk.org/reference/network-attached-storage/)- [RAID](https://gophertrunk.org/reference/raid/)- [Edge computing](https://gophertrunk.org/reference/edge-computing/)- [High availability](https://gophertrunk.org/reference/high-availability/)- [Scalability](https://gophertrunk.org/reference/scalability/) #### Personal computers - [Personal computer](https://gophertrunk.org/reference/personal-computer/)- [Desktop computer](https://gophertrunk.org/reference/desktop-computer/)- [Laptop](https://gophertrunk.org/reference/laptop/)- [Workstation](https://gophertrunk.org/reference/workstation/)- [All-in-one computer](https://gophertrunk.org/reference/all-in-one-computer/)- [Mini PC](https://gophertrunk.org/reference/mini-pc/)- [Gaming PC](https://gophertrunk.org/reference/gaming-pc/)- [Chromebook](https://gophertrunk.org/reference/chromebook/)- [Thin client](https://gophertrunk.org/reference/thin-client/)- [Computer monitor](https://gophertrunk.org/reference/computer-monitor/)- [Keyboard](https://gophertrunk.org/reference/keyboard/)- [Mouse](https://gophertrunk.org/reference/mouse/)- [Peripheral](https://gophertrunk.org/reference/peripheral/)- [Computer case](https://gophertrunk.org/reference/computer-case/)- [Webcam](https://gophertrunk.org/reference/webcam/)- [Printer](https://gophertrunk.org/reference/printer/)- [Motherboard form factor](https://gophertrunk.org/reference/motherboard-form-factor/)- [Build vs buy a PC](https://gophertrunk.org/reference/build-vs-buy/) #### Mobile devices - [Smartphone](https://gophertrunk.org/reference/smartphone/)- [Tablet](https://gophertrunk.org/reference/tablet/)- [Mobile app development](https://gophertrunk.org/reference/mobile-app-development/)- [System on a chip (SoC)](https://gophertrunk.org/reference/system-on-a-chip/)- [Mobile operating system](https://gophertrunk.org/reference/mobile-operating-system/)- [Android](https://gophertrunk.org/reference/android/)- [iOS](https://gophertrunk.org/reference/ios/)- [Battery technology](https://gophertrunk.org/reference/battery-technology/)- [Touchscreen](https://gophertrunk.org/reference/touchscreen/)- [E-reader](https://gophertrunk.org/reference/e-reader/)- [Smartwatch](https://gophertrunk.org/reference/smartwatch/)- [Wearable computer](https://gophertrunk.org/reference/wearable-computer/)- [Cellular modem](https://gophertrunk.org/reference/cellular-modem/)- [GPS receiver](https://gophertrunk.org/reference/gps-receiver/)- [eSIM](https://gophertrunk.org/reference/esim/)- [Near-field communication (NFC)](https://gophertrunk.org/reference/near-field-communication/)- [Foldable phone](https://gophertrunk.org/reference/foldable-phone/) #### Single-board computers - [Single-board computer (SBC)](https://gophertrunk.org/reference/single-board-computer/)- [Raspberry Pi](https://gophertrunk.org/reference/raspberry-pi/)- [NVIDIA Jetson](https://gophertrunk.org/reference/nvidia-jetson/)- [BeagleBone](https://gophertrunk.org/reference/beaglebone/)- [GPIO](https://gophertrunk.org/reference/gpio/)- [Compute Module](https://gophertrunk.org/reference/compute-module/)- [Orange Pi](https://gophertrunk.org/reference/orange-pi/)- [ODROID](https://gophertrunk.org/reference/odroid/)- [Rock Pi (Radxa)](https://gophertrunk.org/reference/rock-pi/)- [Radxa (ROCK 5)](https://gophertrunk.org/reference/radxa/)- [Khadas (VIM)](https://gophertrunk.org/reference/khadas/)- [PINE64](https://gophertrunk.org/reference/pine64/)- [Banana Pi](https://gophertrunk.org/reference/banana-pi/)- [Google Coral](https://gophertrunk.org/reference/google-coral/)- [Libre Computer](https://gophertrunk.org/reference/libre-computer/)- [HAT add-on board](https://gophertrunk.org/reference/hat-add-on-board/)- [Edge AI](https://gophertrunk.org/reference/edge-ai/)- [Home automation](https://gophertrunk.org/reference/home-automation/)- [SBC cluster](https://gophertrunk.org/reference/sbc-cluster/) #### Microcontrollers - [Microcontroller (MCU)](https://gophertrunk.org/reference/microcontroller/)- [Arduino](https://gophertrunk.org/reference/arduino/)- [ESP32](https://gophertrunk.org/reference/esp32/)- [Firmware](https://gophertrunk.org/reference/firmware/)- [Internet of Things (IoT)](https://gophertrunk.org/reference/internet-of-things/)- [STM32](https://gophertrunk.org/reference/stm32/)- [PIC microcontroller](https://gophertrunk.org/reference/pic-microcontroller/)- [AVR / ATmega](https://gophertrunk.org/reference/avr-atmega/)- [RP2040](https://gophertrunk.org/reference/rp2040/)- [Raspberry Pi Pico](https://gophertrunk.org/reference/raspberry-pi-pico/)- [Teensy](https://gophertrunk.org/reference/teensy/)- [ARM Cortex-M](https://gophertrunk.org/reference/arm-cortex-m/)- [Real-time operating system (RTOS)](https://gophertrunk.org/reference/real-time-operating-system/)- [Bootloader](https://gophertrunk.org/reference/bootloader/)- [In-system programming](https://gophertrunk.org/reference/in-system-programming/)- [Pulse-width modulation (PWM)](https://gophertrunk.org/reference/pulse-width-modulation/)- [Digital-to-analog converter (DAC)](https://gophertrunk.org/reference/digital-to-analog-converter/)- [I²C](https://gophertrunk.org/reference/i2c/)- [SPI](https://gophertrunk.org/reference/spi/)- [UART](https://gophertrunk.org/reference/uart/)- [Interrupt](https://gophertrunk.org/reference/interrupt/)- [Embedded system](https://gophertrunk.org/reference/embedded-system/)- [Bare-metal programming](https://gophertrunk.org/reference/bare-metal-programming/)- [Watchdog timer](https://gophertrunk.org/reference/watchdog-timer/)- [Sensor](https://gophertrunk.org/reference/sensor/) #### Networking & connectivity - [Network interface card (NIC)](https://gophertrunk.org/reference/network-interface-card/)- [Router](https://gophertrunk.org/reference/router/)- [Network switch](https://gophertrunk.org/reference/network-switch/)- [Ethernet](https://gophertrunk.org/reference/ethernet/)- [Wi-Fi](https://gophertrunk.org/reference/wi-fi/)- [Bluetooth](https://gophertrunk.org/reference/bluetooth/)- [Modem](https://gophertrunk.org/reference/modem/)- [Wireless access point](https://gophertrunk.org/reference/wireless-access-point/)- [Fiber-optic](https://gophertrunk.org/reference/fiber-optic/)- [Power over Ethernet (PoE)](https://gophertrunk.org/reference/power-over-ethernet/)- [Thunderbolt](https://gophertrunk.org/reference/thunderbolt/)- [Gateway](https://gophertrunk.org/reference/gateway/)- [LAN & WAN](https://gophertrunk.org/reference/lan-and-wan/)- [IP address](https://gophertrunk.org/reference/ip-address/) #### Storage & memory - [Hard disk drive (HDD)](https://gophertrunk.org/reference/hard-disk-drive/)- [Solid-state drive (SSD)](https://gophertrunk.org/reference/solid-state-drive/)- [NVMe](https://gophertrunk.org/reference/nvme/)- [Flash memory](https://gophertrunk.org/reference/flash-memory/)- [SD card](https://gophertrunk.org/reference/sd-card/)- [eMMC](https://gophertrunk.org/reference/emmc/)- [Optical disc](https://gophertrunk.org/reference/optical-disc/)- [Magnetic tape](https://gophertrunk.org/reference/magnetic-tape/)- [Read-only memory (ROM)](https://gophertrunk.org/reference/read-only-memory/)- [Volatile vs non-volatile memory](https://gophertrunk.org/reference/volatile-memory/)- [Memory hierarchy](https://gophertrunk.org/reference/memory-hierarchy/)- [File system](https://gophertrunk.org/reference/file-system/) #### GPUs, FPGAs & accelerators - [CUDA](https://gophertrunk.org/reference/cuda/)- [GPGPU](https://gophertrunk.org/reference/gpgpu/)- [Tensor processing unit (TPU)](https://gophertrunk.org/reference/tensor-processing-unit/)- [Neural processing unit (NPU)](https://gophertrunk.org/reference/neural-processing-unit/)- [Field-programmable gate array (FPGA)](https://gophertrunk.org/reference/field-programmable-gate-array/)- [Application-specific integrated circuit (ASIC)](https://gophertrunk.org/reference/application-specific-integrated-circuit/)- [AI accelerator](https://gophertrunk.org/reference/ai-accelerator/)- [Vector processor](https://gophertrunk.org/reference/vector-processor/)- [Hardware acceleration](https://gophertrunk.org/reference/hardware-acceleration/)- [SoC vs discrete](https://gophertrunk.org/reference/soc-vs-discrete/) #### People - [Alan Turing](https://gophertrunk.org/reference/alan-turing/)- [John von Neumann](https://gophertrunk.org/reference/john-von-neumann/)- [Gordon Moore](https://gophertrunk.org/reference/gordon-moore/)- [Robert Noyce](https://gophertrunk.org/reference/robert-noyce/)- [Jack Kilby](https://gophertrunk.org/reference/jack-kilby/)- [Federico Faggin](https://gophertrunk.org/reference/federico-faggin/)- [Steve Wozniak](https://gophertrunk.org/reference/steve-wozniak/)- [Linus Torvalds](https://gophertrunk.org/reference/linus-torvalds/)- [Eben Upton](https://gophertrunk.org/reference/eben-upton/)- [Massimo Banzi](https://gophertrunk.org/reference/massimo-banzi/)- [Sophie Wilson](https://gophertrunk.org/reference/sophie-wilson/)- [Jensen Huang](https://gophertrunk.org/reference/jensen-huang/) #### Organizations & makers - [Intel](https://gophertrunk.org/reference/intel/)- [AMD](https://gophertrunk.org/reference/amd/)- [Arm Holdings](https://gophertrunk.org/reference/arm-holdings/)- [NVIDIA](https://gophertrunk.org/reference/nvidia/)- [Qualcomm](https://gophertrunk.org/reference/qualcomm/)- [Raspberry Pi Foundation](https://gophertrunk.org/reference/raspberry-pi-foundation/)- [Arduino (company)](https://gophertrunk.org/reference/arduino-company/)- [Espressif Systems](https://gophertrunk.org/reference/espressif/)- [Broadcom](https://gophertrunk.org/reference/broadcom/)- [TSMC](https://gophertrunk.org/reference/tsmc/)- [IEEE](https://gophertrunk.org/reference/ieee/)- [JEDEC](https://gophertrunk.org/reference/jedec/) ### Field Notes #### Hardware quirks - [Airspy sample-rate selection](https://gophertrunk.org/reference/airspy-rate-selection/)- [RTL-SDR USB stall recovery](https://gophertrunk.org/reference/rtlsdr-usb-recovery/)- [SDR gain & front-end overload](https://gophertrunk.org/reference/sdr-gain-overload/)- [USRP & SoapyRemote field notes](https://gophertrunk.org/reference/usrp-soapyremote-notes/) #### Configuration gotchas - [Wideband voice taps](https://gophertrunk.org/reference/wideband-voice-taps/)- [P25 demod-mode selection](https://gophertrunk.org/reference/p25-demod-mode-selection/)- [Encrypted-call handling](https://gophertrunk.org/reference/encrypted-call-handling/) #### Diagnostic signatures & playbook - [Diagnostic playbook](https://gophertrunk.org/reference/diagnostic-playbook/)- [Signal-quality signatures](https://gophertrunk.org/reference/signal-signatures/)- [Audio-pipeline tells](https://gophertrunk.org/reference/audio-pipeline-tells/)- [Carrier offset & adjacent-channel lock](https://gophertrunk.org/reference/carrier-offset-adjacent-lock/)- [AFC alias traps](https://gophertrunk.org/reference/afc-alias-traps/)- [Equalizer gotchas](https://gophertrunk.org/reference/equalizer-gotchas/)- [MRC diversity gotchas](https://gophertrunk.org/reference/mrc-diversity-gotchas/) #### Protocol facts the specs hide - [P25 site-identity semantics](https://gophertrunk.org/reference/p25-site-identity-semantics/)- [P25 on-air constants](https://gophertrunk.org/reference/p25-onair-constants/)- [DMR grant-field gotchas](https://gophertrunk.org/reference/dmr-grant-field-gotchas/)- [TETRA lock facts](https://gophertrunk.org/reference/tetra-lock-facts/)- [TETRA DMO facts](https://gophertrunk.org/reference/tetra-dmo-facts/) ## Getting started with GopherTrunk - [What is GopherTrunk?](https://gophertrunk.org/getting-started.html): conceptual overview of the scanner and its interfaces. - [Get started](https://gophertrunk.org/getting-started-setup.html): from a dongle to your first decoded call. - [Hardware](https://gophertrunk.org/hardware.html): supported SDR dongles. - [Downloads](https://gophertrunk.org/downloads.html): builds for Linux, macOS, and Windows. ## What's happening near me (sirens, lights & incident lookups) Practical, honest guides for the moment someone hears sirens or sees emergency lights and wants to know what's going on — every lookup method ranked by speed, with clear notes on coverage gaps, delays, and encryption. - [Why are there sirens near me right now?](https://gophertrunk.org/sirens-near-me/): the fastest ways to find out what's happening — scanner feeds, CAD call logs, incident apps — ranked by how quickly they answer. - [Police activity near me](https://gophertrunk.org/police-activity-near-me/): live dispatch audio, active-calls pages, crime maps, and public records, with what each one misses. - [Fire trucks on my street, but no fire](https://gophertrunk.org/fire-trucks-near-me/): why engines respond to medical calls, alarms, and gas odors, and why so many units show up at once. - [Why is a helicopter circling my neighborhood?](https://gophertrunk.org/helicopter-circling-my-neighborhood/): identify the exact aircraft in under a minute with ADS-B Exchange and read its flight pattern. - [What different siren sounds mean](https://gophertrunk.org/what-do-siren-sounds-mean/): wail, yelp, phaser, the hi-lo evacuation tone, the fire Q, and the low-frequency Rumbler. - [Why are the tornado sirens going off?](https://gophertrunk.org/tornado-sirens-going-off/): outdoor warning siren activations, test schedules, and why silence is not an all-clear. - [How to listen to police scanners online free](https://gophertrunk.org/listen-to-police-scanner-online/): Broadcastify and scanner apps, plus the honest limits — coverage, delays, encryption. - [What happened near me last night?](https://gophertrunk.org/what-happened-near-me-last-night/): reconstruct an incident after the fact from scanner archives, CAD logs, flight tracks, and records. - [Accident near me](https://gophertrunk.org/accident-near-me/): dispatch audio, 511/DOT maps, and traffic apps, and how to read crash severity from the response. - [Why is the road closed?](https://gophertrunk.org/road-closed-near-me/): finding the cause and likely duration of a closure, from crashes to wires down to planned events. - [Gunshots or fireworks?](https://gophertrunk.org/gunshots-or-fireworks/): the honest by-ear guidance, when to call 911, and how to hear what responding officers actually found. - [What's burning near me?](https://gophertrunk.org/whats-burning-near-me/): smoke-investigation dispatch calls, wildfire and air-quality maps, and prescribed-burn schedules. - [Power outage near me](https://gophertrunk.org/power-outage-near-me/): outage maps, the radio traffic that names the cause, and staying informed when the Wi-Fi is down. - [That loud phone alert](https://gophertrunk.org/emergency-alert-just-went-off/): Wireless Emergency Alerts explained — types, recovering a dismissed alert, and the detail the message leaves out. - [What was that loud boom?](https://gophertrunk.org/loud-boom-near-me/): transformers, sonic booms, blasting, frost quakes — and the dispatch "area check" that settles it. - [Ambulance at a neighbor's house](https://gophertrunk.org/ambulance-at-neighbors-house/): what the response pattern means, what stays private and why, and what a good neighbor does. - [SWAT in my neighborhood](https://gophertrunk.org/swat-team-in-my-neighborhood/): warrant services vs standoffs, what to do while it's active, and the honest limits of what a scanner can hear. - [Drone flying over my house](https://gophertrunk.org/drone-flying-over-my-house/): identify any drone with free Remote ID apps, police drone programs, and the legal lines in both directions. - [Military jets flying over](https://gophertrunk.org/military-jets-flying-over-my-house/): training routes, refueling orbits, and why fighters don't show on flight trackers. - [Why train horns keep blowing](https://gophertrunk.org/train-horns-blowing/): the required horn pattern, stuck crossing gates and the blue-sign number, and quiet zones. - [Why is the school on lockdown?](https://gophertrunk.org/school-lockdown-near-me/): lockdown vs secure vs hold, why not to drive to the school, and reunification. - [Water main breaks](https://gophertrunk.org/water-main-break-near-me/): sudden pressure loss, boil-water advisories, brown water, and hydrant flushing false alarms. - [Did we just have an earthquake?](https://gophertrunk.org/did-we-just-have-an-earthquake/): the 30-second USGS check, the impostor list, and the drop-cover-hold drill. - [Police checkpoint or roadblock](https://gophertrunk.org/police-checkpoint-near-me/): DUI checkpoints vs manhunt perimeters vs closures, and what each expects of a driver. - [Why did police knock on my door?](https://gophertrunk.org/police-knocked-on-my-door/): canvassing, welfare checks, wrong addresses — and how to verify a knock is real. - [Missing-person search near me](https://gophertrunk.org/missing-person-search-near-me/): how searches work, and the three neighbor actions that actually find people. ## Police scanner buyer's guides & hardware Consumer scanner hardware (Uniden, Whistler) compared honestly against a free SDR + GopherTrunk. - [Best police scanners](https://gophertrunk.org/best-police-scanners/): buyer's guide to every scanner worth owning, with an honest SDR comparison. - [Police scanner vs GopherTrunk (SDR)](https://gophertrunk.org/police-scanner-vs-sdr/): where dedicated hardware wins and where free software wins. - [How police scanners work](https://gophertrunk.org/how-police-scanners-work/): trunking, talkgroups, P25/DMR/NXDN in plain language. - [Police scanner encryption explained](https://gophertrunk.org/police-scanner-encryption/): why no scanner (or SDR) can decode AES, and what stays open. - [Is a police scanner legal?](https://gophertrunk.org/police-scanner-legal/): federal and state law on owning and using a scanner. - [Scanner frequencies by service](https://gophertrunk.org/scanner-frequencies/): police, fire, EMS, aviation, marine, and railroad band plans. - [How to program a police scanner](https://gophertrunk.org/how-to-program-a-police-scanner/): zip-code, manual, and software programming. - [Best scanner antennas](https://gophertrunk.org/best-scanner-antenna/): indoor, outdoor, and mobile antennas that fix weak reception. - [Digital vs analog scanners](https://gophertrunk.org/digital-vs-analog-scanner/): what you can still hear on an analog radio in 2026. - [P25 scanners](https://gophertrunk.org/p25-scanner/): what Phase I/II and simulcast mean for buyers. ## Ham radio buyer's guides Amateur radio transceivers ranked with an honest rubric — no star ratings — plus classic used-market picks. Transmitting requires an FCC amateur license; listening does not. - [Best ham radio base stations](https://gophertrunk.org/best-ham-radio-base-stations/): the 10 best HF base stations ranked, from the Xiegu G90 to the Icom IC-7610, including classic used rigs. - [Best mobile ham radios](https://gophertrunk.org/best-mobile-ham-radios/): the 10 best vehicle-mount rigs ranked, from budget dual-banders to the Yaesu FTM-500DR, including discontinued do-everything classics. - [Best handheld ham radios](https://gophertrunk.org/best-handheld-ham-radios/): the 10 best HTs ranked, from the Baofeng UV-5R to the Kenwood TH-D75A, including used-market classics. ## Consumer two-way radio buyer's guides FRS/GMRS walkie-talkies, GMRS mobile rigs, and CB radios ranked with the same honest rubric — no star ratings. GMRS takes a $35 no-test FCC license; FRS and CB are license-free. - [Best walkie-talkies](https://gophertrunk.org/best-walkie-talkies/): the 10 best FRS and GMRS handhelds ranked, from the Baofeng GM-15 Pro to the Rocky Talkie 5 Watt, including discontinued classics. - [Best GMRS mobile radios](https://gophertrunk.org/best-gmrs-mobile-radios/): the 10 best GMRS mobile and base rigs ranked, from the Radioddity DB20-G to the Midland MXT575 and Wouxun KG-1000G Plus. - [Best CB radios](https://gophertrunk.org/best-cb-radios/): the 10 best CB radios ranked, from the Uniden PRO505XL to the Bearcat 880 and President McKinley, including collector classics. ## Shortwave & emergency radio buyer's guides Portable and desktop shortwave receivers plus emergency crank/solar radios, ranked with the same honest rubric — all listen-only, no license ever. - [Best shortwave radios](https://gophertrunk.org/best-shortwave-radios/): the 10 best portable shortwave receivers ranked, from the Tecsun PL-330 to the PL-990 and Sangean ATS-909X2, including discontinued classics. - [Best emergency radios](https://gophertrunk.org/best-emergency-radios/): the 10 best crank/solar emergency radios ranked, with honest notes on tone alerts vs NOAA SAME and real crank runtimes. - [Best desktop shortwave receivers](https://gophertrunk.org/best-desktop-shortwave-receivers/): the classic tabletop receivers worth buying used — Drake R8B, Icom IC-R75 — plus the few still made new. ## SDR hardware for GopherTrunk (buyer's guides) The receivers, antennas, cables, and accessories to run GopherTrunk, with honest picks and Amazon links. - [Best SDR for GopherTrunk](https://gophertrunk.org/best-sdr-for-gophertrunk/): RTL-SDR, NESDR, Airspy, and HackRF compared for P25/DMR/NXDN decoding. - [What hardware do I need to run GopherTrunk?](https://gophertrunk.org/what-do-i-need-for-gophertrunk/): the complete dongle + antenna + adapter + computer checklist. - [Best RTL-SDR for scanning](https://gophertrunk.org/best-rtl-sdr/): which RTL-SDR dongle to buy (and why the V4 is end-of-line). - [Airspy vs RTL-SDR vs HackRF](https://gophertrunk.org/airspy-vs-rtl-sdr-vs-hackrf/): choosing a receiver by use case. - [Best SDR antenna](https://gophertrunk.org/best-sdr-antenna/): dipole kits, discones, and mounting for better reception. - [SDR cables & connectors](https://gophertrunk.org/sdr-cables-and-connectors/): SMA/BNC/N/F/UHF adapters and coax. - [Best LNA for SDR](https://gophertrunk.org/best-sdr-lna/) and [SDR filters](https://gophertrunk.org/sdr-filters/): fixing weak signals and overload. - [Best SDR for HF](https://gophertrunk.org/best-hf-sdr/): Airspy HF+ and upconverters for shortwave/ham. - [Run GopherTrunk on a Raspberry Pi](https://gophertrunk.org/raspberry-pi-sdr-scanner/): 24/7 headless decoding. - [Best SDR for P25 trunking](https://gophertrunk.org/best-sdr-for-p25-trunking/) and [multi-dongle setups](https://gophertrunk.org/multi-dongle-sdr-setup/): single-site vs wideband multi-site. - [Cheapest way to scan digital radio](https://gophertrunk.org/cheap-sdr-scanner/): a $30 SDR beats a $380 digital scanner. - [Best single-board computer for GopherTrunk](https://gophertrunk.org/best-single-board-computer-for-gophertrunk/): Raspberry Pi 5/4/Zero 2 W, Orange Pi 5, Radxa Rock 5B, ODROID, and Le Potato compared as GopherTrunk hosts. ## Technical docs - [Architecture](https://gophertrunk.org/architecture.html): how the engine is built. - [Vocoders](https://gophertrunk.org/vocoders.html): IMBE and AMBE+2 voice decoding. - [Status](https://gophertrunk.org/status.html): protocol and decoder coverage. ## More - [Full site map](https://gophertrunk.org/sitemap/): a browsable index of every page on the site. - [Blog](https://gophertrunk.org/blog/): release notes, deep dives, and build-in-the-open posts.