Why Rust for SDR?

Making the Case to C/C++ Developers

The Elephant in the Room

“We’ve been doing SDR in C/C++ for decades. Why change?”

This presentation addresses: 1. The problems we’re actually solving 2. What Rust brings that C/C++ doesn’t 3. Performance comparisons (real numbers) 4. Migration strategies 5. The things Rust is NOT good at

What We’re Solving

Memory Safety Bugs in SDR Codebases

Real impact: Hours/days of debugging, sanitizer runs, code review.

The C/C++ Response

“We use AddressSanitizer”

• Catches bugs at runtime
• Slows execution 2x
• Doesn’t catch everything
• You still have to hit the bug

“We have code review”

• Humans miss things
• Review fatigue is real
• Not all reviewers understand all code

“We’ve been careful for years”

• Staff turnover
• Deadline pressure
• “It worked before”

What Rust Actually Does

Compile-Time Prevention

// This doesn't compile:
let data = vec![1, 2, 3];
let reference = &data[0];
data.push(4);  // ERROR: cannot borrow `data` as mutable
               // because it is also borrowed as immutable
println!("{}", reference);

The compiler catches: - Buffer overflows - Use-after-free - Data races - Null pointer dereference

Real DSP Code Comparison

Rust

pub fn apply_fir_filter(samples: &mut [IQSample], coeffs: &[f64]) {
    for i in coeffs.len()..samples.len() {
        samples[i] = coeffs.iter()
            .enumerate()
            .map(|(j, &c)| samples[i - j] * c)
            .sum();
    }
}  // Bounds checked at compile time

C

void apply_fir_filter(complex_t* samples, size_t n,
                      double* coeffs, size_t m) {
    for (size_t i = m; i < n; i++) {
        samples[i] = 0;
        for (size_t j = 0; j < m; j++) {
            samples[i] += samples[i - j] * coeffs[j];  // Hope indices are valid!
        }
    }
}

“But Performance?”

Common Misconception

“Memory safety checks must cost performance.”

Reality

Rust’s safety is compile-time, not runtime.

• No bounds checking in release builds (when optimizable)
• Same LLVM backend as Clang
• No garbage collector
• Zero-cost abstractions

Benchmark: R4W vs GNU Radio

Why faster? - rustfft optimized for Rust memory model - Zero-copy lock-free buffers - No Python/SWIG overhead

Real-Time Validation

Same RT primitives as C: mlockall, SCHED_FIFO, CPU affinity.

“I Can’t Abandon My C Libraries”

FFI is Zero-Cost

// Calling C from Rust
extern "C" {
    fn fftw_plan_dft_1d(n: c_int, in_: *mut c_double,
                        out: *mut c_double, sign: c_int,
                        flags: c_uint) -> *mut fftw_plan;
}

Exposing Rust to C

// r4w.h (generated by cbindgen)
typedef struct r4w_waveform_t r4w_waveform_t;
r4w_waveform_t* r4w_waveform_bpsk(double sample_rate, double symbol_rate);
size_t r4w_modulate(r4w_waveform_t* wf, const bool* bits, size_t len, float* out);

Migration Strategies

Phase 1: Use Rust as a Library

Keep existing C/C++ application, call R4W for specific functions.

#include <r4w.hpp>
auto lora = r4w::Waveform::lora(7, 125000.0);
auto samples = lora.modulate(bits);

Phase 2: Port Pure Functions

Start with stateless DSP functions: - Filters - FFT wrappers - Modulation algorithms

Phase 3: New Development in Rust

Legacy maintenance in C++, new features in Rust.

What Rust is NOT Good At

Learning Curve

• Borrow checker takes time to internalize
• Different mental model than C++
• 2-4 weeks to productivity

Ecosystem Gaps

• Fewer SDR libraries than C++
• Some hardware SDKs are C-only
• Smaller community (growing)

When NOT to use Rust

• Tiny microcontrollers (< 32KB RAM)
• Quick prototypes
• When team refuses to learn

The R4W Value Proposition

What You Get

What You Give Up

• Familiarity (temporarily)
• Some C++ libraries (need wrappers)

R4W Code Metrics

• 38+ waveforms implemented
• 6,324 lines of formal proofs
• 1 test per 126 lines of Rust

Try It Yourself

# Clone and build
git clone https://github.com/joemooney/r4w
cd r4w && cargo build --release

# Run benchmarks
cargo bench

# Run 527 tests
cargo test

# Explore the code
cargo doc --open

Resources for C/C++ Developers

Books

• “The Rust Programming Language” (free online)
• “Rust for Rustaceans” (intermediate)

Tutorials

• Rustlings exercises
• Rust by Example

SDR-Specific

• R4W Workshop Materials
• crates/r4w-ffi/examples/

Questions?

Common Follow-ups

• “What about SIMD?” → Rust has std::simd and external crates
• “Embedded targets?” → Rust supports ARM, RISC-V, etc.
• “Build systems?” → Cargo + CMake integration available
• “Debugging?” → GDB/LLDB work fine, rust-gdb wrapper available

Summary

The question isn’t “Why Rust?”

It’s “Why are we still debugging buffer overflows?”