GNU Radio Companion for Makers: Building Your First SDR Signal Processing Flowgraph

This site's RTL-SDR and Flipper Zero coverage treats GNU Radio Companion (GRC) as a name on a software list: a box in a feature table, a tool mentioned in passing when a HackRF/PortaPack build outgrows its on-device apps. That undersells it badly. GNU Radio is the actual engine behind most of the "advanced" SDR capability referenced elsewhere on this site — the thing that turns a $30 RTL-SDR dongle from a radio you listen to into a radio you can program. If you've worked through the beginner SDR guide and want to go past "tune to a frequency and listen," GNU Radio Companion is the next real step, and it's friendlier than its reputation suggests once you understand the one idea that makes it work: everything is blocks and streams.

What GNU Radio Actually Is

GNU Radio is an open-source signal processing framework. Under the hood it's a C++/Python library for building chains of digital signal processing operations — filters, mixers, demodulators, FFTs — that operate on streams of samples. GNU Radio Companion is the visual front end: instead of writing Python by hand, you drag blocks onto a canvas, wire their inputs and outputs together, and GRC generates and runs the underlying Python flowgraph for you. Each block does one job (a source pulls samples from a dongle, a filter removes energy outside a band, a demodulator converts RF to audio, a sink plays or displays the result), and the lines connecting them represent a continuous stream of complex or real samples flowing at a fixed sample rate.

This block-and-stream model is exactly how the SDR ecosystem referenced throughout this site actually works internally — rtl_433-style decoders, the PortaPack's on-device apps, and purpose-built tools like SDRTrunk and Universal Radio Hacker are all doing some version of what you're about to build by hand, just with the plumbing hidden. Learning GRC makes every other SDR tool on this site easier to reason about, because you now know what's happening between "antenna" and "demodulated signal."

Installing GNU Radio Companion

PlatformMethodNotes WindowsRadioconda installerA pre-built Conda environment maintained by the GNU Radio project; by far the least painful path on Windows, bundles GRC, drivers, and most common out-of-tree (OOT) modules. Linux (Ubuntu/Debian)apt install gnuradio or RadiocondaDistro packages are often a version or two behind; Radioconda or a PyBOMBS build gets you current GRC plus the gr-osmosdr block needed for RTL-SDR/HackRF sources. macOSRadioconda or HomebrewHomebrew's gnuradio formula works but can be slow to update; Radioconda is more consistent across OS versions.

Whichever route you take, confirm two things before building anything: that GRC itself launches, and that gr-osmosdr is present (it's the universal source block that talks to RTL-SDR, HackRF, Airspy, and SDRplay hardware through one interface). Plug in an RTL-SDR and run rtl_test first — if the dongle isn't recognized at the driver level, no amount of flowgraph building will fix it.

Your First Flowgraph: An FM Broadcast Receiver

The classic "hello world" of GNU Radio is a wideband FM receiver, because it's forgiving, immediately verifiable (you either hear music or you don't), and touches every concept you'll reuse later: sample rate, decimation, filtering, and demodulation.

1. RTL-SDR Source — drag in the "RTL-SDR Source" block (from gr-osmosdr). Set the sample rate to 2.4 MS/s and the center frequency to a strong local FM station, e.g. 101,100,000 Hz.
2. Low Pass Filter — FM broadcast channels are about 200 kHz wide. Add a low pass filter block with a cutoff around 100,000 Hz and a transition width of 10,000 Hz to isolate the station from everything else in the 2.4 MHz capture.
3. WBFM Receive — this block handles wideband FM demodulation and audio de-emphasis in one step. Set its quadrature rate to match your source sample rate and its audio decimation to bring the output down to a sane audio rate (commonly a decimation of 10, yielding 240 kHz — you'll decimate again before the audio sink).
4. Rational Resampler — most sound cards want 48,000 Hz. Add a rational resampler block between the WBFM Receive output and the audio sink to convert from whatever the WBFM block outputs down to 48,000.
5. Audio Sink — set the sample rate to 48,000 and leave the device string blank to use your system default.
6. QT GUI Frequency Sink (optional but recommended) — tap the RTL-SDR source output and feed it into a QT GUI Frequency Sink block so you get a live spectrum display while you tune. This is the single most useful debugging tool in GRC: if a flowgraph isn't working, look at the spectrum before you look at the code.

Press the green "Execute" arrow. If everything is wired correctly you'll get a waterfall/spectrum window and, within a second or two, audio. If you get silence, check sample rate math first — GRC's most common failure mode for beginners is a rate mismatch between two connected blocks, which it will often run without crashing but produce garbage or nothing.

The Concepts That Transfer Everywhere Else

ConceptWhy it matters Sample rate vs. bandwidthYour SDR captures a slice of spectrum equal to its sample rate (roughly). Everything downstream has to agree on rate at each connection, or the math falls apart. DecimationFiltering down to a narrower bandwidth lets you reduce the sample rate (and CPU load) proportionally — this is why a filter block is almost always paired with a rate change immediately after it. Complex vs. real streamsRF samples from an SDR are complex (I/Q) — they carry phase information real audio samples don't. Demodulator blocks are the boundary where complex streams become real ones. Block throttlingWhen working from a file source instead of live hardware, add a "Throttle" block or the flowgraph will run as fast as your CPU allows and can lock up your system.

Where to Go From Here

Once FM reception is solid, the natural next flowgraphs are an AM/SSB receiver (swap WBFM Receive for an AM Demod or a Weaver SSB demodulator chain), a simple OOK/ASK decoder for the kind of sub-GHz ISM-band traffic this site's Flipper Zero and RTL-SDR content frequently touches on, and a File Sink setup for capturing raw IQ to replay and analyze offline — the same raw-capture workflow that Universal Radio Hacker and rtl_433 build on internally. GNU Radio is also the development environment behind a meaningful share of the open-source SDR tooling referenced elsewhere on this site, so understanding its block model pays off even when you end up using a higher-level tool day to day.

A Note on Legality and Scope

Receiving and analyzing publicly broadcast RF signals for educational purposes is broadly legal in most jurisdictions, but transmitting is a different matter — GNU Radio flowgraphs can drive a transmit-capable SDR (HackRF, USRP, LimeSDR) just as easily as they can receive, and unlicensed transmission on licensed bands (cellular, public safety, aviation, amateur radio without a license) is a real legal exposure, not a theoretical one. Keep transmit experiments inside amateur radio bands you're licensed for, inside ISM bands explicitly allowed for low-power unlicensed use, or entirely in simulation using file-based sources rather than live RF.

GNU Radio Companion has a learning curve shaped more like a staircase than a cliff: the FM receiver above takes an afternoon, and from there each new flowgraph reuses blocks you already understand. For anyone on this site who has outgrown "point an RTL-SDR at a frequency and see what's there" and wants to actually understand what's happening to the signal, it's the most direct path from curious listener to someone who can build their own decoder.