Field Guide · technology

Also known as: liquid-dsp, liquid

liquid-dsp is a portable, dependency-light C library of digital-signal-processing primitives aimed at software-defined radio: filters, modulators and demodulators, resamplers, forward error correction, and synchronization loops, all exposed through a plain C API.1 Its goal is to give radio developers a toolbox of proven, self-contained components so they can build a modem or a decoder without reimplementing the same FIR filter, symbol synchronizer, or Reed-Solomon coder from scratch. It compiles almost anywhere with a C compiler and has no mandatory external dependencies.

resampler(msresamp) FIR filter(firfilt) symsync(timing) demod(modemcf) FEC decode→ bytes a receiver assembled from liquid-dsp objects
liquid-dsp provides the reusable pieces of a receiver — resampling, filtering, timing recovery, demodulation, and error correction — each a small self-contained C object.

How it works

liquid-dsp is structured as modules, each a family of objects created, run, and destroyed through a consistent C interface (_create, an execute call, _destroy). A program instantiates the pieces it needs and feeds samples through them. The catalogue spans the whole receive and transmit path:

  • Filtering — FIR and IIR filters, arbitrary-rate resamplers, polyphase filter banks, and pulse-shaping filters including the root-raised-cosine used by most digital radios.
  • Modems — linear modulators/demodulators (PSK, QAM, ASK, APSK) plus continuous-phase and analog schemes, all sharing one modem object interface.
  • Synchronization — symbol-timing recovery, carrier phase/frequency loops, frame detectors, and equalizers, the components that let a receiver lock onto a real signal.
  • Coding — forward error correction (convolutional, Reed-Solomon, Hamming), interleaving, CRCs, and scramblers.
  • Math and utilities — windowing, FFT (using FFTW when available, an internal transform otherwise), complex-number helpers, and a fixed-point option.

The design emphasizes portability and independence: the core builds with just a C toolchain, and FFTW is an optional accelerator rather than a requirement. Because the objects are small and orthogonal, developers compose them freely — the library supplies the DSP primitives and leaves the protocol logic to the application.

Relevance to SDR

liquid-dsp is a common foundation for custom SDR modems and decoders where pulling in a full framework would be too heavy. It powers homebrew data links, experimental waveforms, and the DSP cores of applications that want C-level control without writing every filter by hand. It also appears inside larger ecosystems — for example as the basis of a GNU Radio out-of-tree module — so a GNU Radio flowgraph can call liquid’s synchronizers and coders. Its niche is complementary to a SIMD kernel library like VOLK: liquid-dsp supplies whole DSP objects (a symbol synchronizer, a Reed-Solomon coder), while VOLK optimizes the vector math those objects run on.

GopherTrunk does not link liquid-dsp. Being a pure-Go project, GopherTrunk implements its resamplers, matched filters, timing and carrier recovery, and FEC in Go so the whole decoder stays a single static binary with no C dependency. liquid-dsp is nonetheless the closest open-source analogue to what GopherTrunk’s DSP layer is — a curated set of software-radio primitives — and it is a valuable reference when validating a Go implementation against a well-established C one, or when prototyping a receiver structure before porting it.

Sources

  1. liquidsdr.org — the liquid-dsp project site and API documentation, describing the module catalogue (filters, resamplers, modems, synchronizers, FEC), the object lifecycle, and the optional FFTW dependency. ↩

See also