A software-defined radio system is often split in two. An antenna and a receiver stand where the signal is; the processing runs somewhere else. Between them is an IP network that loses packets, delays them and occasionally drops out.
For a stream of radio samples, how that network fails matters as much as how often. A demodulator, a correlator or a direction finder depends on the samples being continuous in time. One missing packet shifts everything after it. If the receiving side does not know that a packet is missing, the result is wrong and nothing says so.
The two usual transports each solve half of the problem. UDP is timely and never repairs anything: a lost packet is a silent hole. TCP repairs everything and has no deadline: under loss it slows down, and a live stream arrives seconds late or backs up at the sender.
We built gr-robotweax-srt to put a third option into GNU Radio: repair losses inside a fixed delay, and where that is not possible, say exactly which samples are missing. It is public on GitHub as release candidate 0.1.0-rc2. gr-robotweax-srt source.
What it is
gr-robotweax-srt is a GNU Radio out-of-tree module with two blocks. The SRT Sink ends one flowgraph and sends its sample stream; the SRT Source starts another flowgraph and delivers the stream there. Between them runs Robotweax SRT, our independently developed implementation of the Secure Reliable Transport protocol, used through its public C API.
| Property | What the module does |
|---|---|
| Sample formats | 32-bit float and complex 32-bit float (IQ) streams. |
| Gaps | In segmented mode, a discontinuity is tagged on the next sample, with its position and, where known, the exact number of missing samples. A missing tail with no following sample is reported as an event on the status port instead. Inspect status() after the run for the reliable final state; stream tags alone are not sufficient. |
| Time | Capture-time tags travel with the samples, so the receiving flowgraph can relate a sample to the moment it was taken. |
| Continuity modes | Strict ends the run at the first loss, for work that needs an unbroken stream. Segmented continues and reports each gap. |
| Buffers | Bounded on both sides. An overload is reported; it does not grow into an unbounded backlog. |
| Encryption | AES-CTR. The examples read the passphrase from an environment variable, not from a flowgraph file. |
| Operation | Status reporting from both blocks, GNU Radio Companion definitions, and headless and Companion examples. |
The rule behind all of it is short: the receiving flowgraph receives samples with explicit continuity reporting: known gaps are counted, unknown gaps and uncertain termination are reported as such. A loss that the application cannot see is treated as a defect of the module, not as a property of the network. Tags, gaps and time; block reference.
What the measurements showed
We measured the transport against plain UDP and TCP carrying the same sample stream: complex samples at 100 kS/s, about 7 Mbit/s on the wire, with SRT set to a latency of 250 ms. The figure that matters for signal processing is not the share of delivered packets but the share of 1024-sample blocks that arrive complete and on time, because that is what an FFT needs. Here, “on time” means within a 400 ms deadline, not within the 250 ms SRT latency setting. Each case ran five times for two minutes on emulated network paths.
| Emulated path | SRT | UDP | TCP |
|---|---|---|---|
| Clean | 100 % | 100 % | 100 % |
| 20 ms delay, 5 ms jitter, 0.1 % loss | 100 % | 99.1–99.4 % | 96.5–100 % |
| 40 ms delay, 10 ms jitter, 1 % loss | 99.90–99.99 % | 91.8–92.3 % | 0 % |
| Burst loss, about 6.5 % on average | 98.9–99.1 % | 84.3–85.7 % | 0 % |
The delay, jitter and random loss in these profiles apply in each direction. netem produced unusually heavy packet reordering, which contributed to TCP’s collapse: the source report cautions that the size of the advantage may be an emulation artefact. UDP's numbers look worse than its packet loss because one lost packet spoils a whole block: 1 % loss cost about 8 % of the blocks. TCP delivered part of the data in the two lossy cases at the bottom, but seconds late, so no block met the deadline. With SRT, the samples it could not recover in time were reported as missing in every run. Results against UDP and TCP; burst-loss repetitions.
SRT did not win everywhere, and the cases where it did not belong in the same table.
- It costs delay. Every sample is held for the configured latency. At 250 ms the measured sample age was 254 to 304 ms. On the clean path TCP delivered within a few milliseconds.
- At very light loss, TCP is a serious alternative. At 0.1 % loss TCP delivered everything in four of five runs, mostly within 30 ms. SRT's advantage is the bounded delay under heavier loss, and it grows with loss and round-trip time.
- A path that queues instead of dropping defeats the delay bound. When a bottleneck held packets for seconds without losing any, there was nothing to repair, and samples arrived up to 6.3 s old. Since rc2 the Source can discard such samples and report them; with a bound of 150 ms the oldest delivered sample was under 0.5 s old. The bound does not recover anything. It keeps stale samples out of the processing and counts them. Lateness bound results.
Between two machines
Emulation on one computer shares one clock between sender and receiver, which makes sample age easy to measure and leaves open whether the result holds between real machines. After the release candidate we ran the stream once between two cloud machines in two German regions, Frankfurt and Berlin, with the pass criteria published before the run.
The same 400 ms deadline applies to the two-machine results below. The two clocks are unrelated, so each case was bracketed by a two-way exchange that bounds the clock offset, here to between 5.1 and 5.7 ms. Sample ages were then judged as old as that bound allows.
| Path | Runs | Blocks complete and on time | 99th-percentile sample age |
|---|---|---|---|
| Frankfurt to Berlin as it is | 3 | 100 % | 263–264 ms |
| The same path with 20 ms delay and 1 % loss added at both ends | 2 | 100 % | 284 ms |
The real path lost nothing. With loss added, about 900 of 87,000 packets per run were lost and resent, and no block was late or incomplete. All five published criteria were met. This is one path, one direction and one day, and the added loss is still emulated loss. Two-machine results.
How it was tested
The measurements follow one rule: the criteria are written down and committed before a run, and a failed run stays in the record. One example is in the repository. At 1 MS/s the module passed 14 of 15 emulated runs; in the fifteenth, a pause of 76 ms in the receiving process ended a strict stream. The cause probably lies in the shared test machine, but that is not proven, so 1 MS/s is not listed as a supported rate.
Beyond the network measurements, a scripted relay injects outages, reconnects, lost records and a vanishing peer; the code runs under sanitizers and fuzzing; and the install guide is executed step by step in a fresh container for every release candidate. Measurement protocol.
What it is not yet
This is a release candidate, and we do not claim field readiness. It has not been run with acquisition hardware: the tests used synthetic signals, not an SDR front end. The two-machine run used the module's reference sender and receiver, not the GNU Radio blocks, and no encryption. Rates above 100 kS/s are outside the supported envelope. Nobody outside the project has installed or used it yet. Known limitations.
The module is qualified with GNU Radio 3.10.9.2 and Robotweax SRT 0.3.2 on Ubuntu 24.04, and it builds from source; there are no binary packages. Install guide; 0.1.0-rc2 pre-release.
gr-robotweax-srt is public under the GPL-3.0-or-later license, the license of GNU Radio itself. The most useful contribution right now is an independent one: follow the install guide on your own machine, run the examples, and tell us where the guide or the module let you down. Reports and questions are welcome as GitHub issues or at info@robotweax.ai.

