ForgeSDR

GPU-accelerated signals intelligence for software-defined radio.

Capture, detect, classify and alert on the whole band at once, on Linux, with NVIDIA or AMD GPUs, from a Jetson to a workstation.

C++20 core NVIDIA CUDA and AMD ROCm Python and C++ plugins SigMF recording Web UI

What it does

GPU DSP core

forged runs the radios and the signal chain on the GPU.

  • Spectrum
  • Down-conversion taps
  • Polyphase channelizer
  • Coherent multi-tuner streams
  • NVIDIA (CUDA) and AMD (ROCm) from one source

Many radios, one band

Several tuners stitch into one wide span.

  • RTL-SDR
  • KrakenSDR, phase-aligned
  • bladeRF
  • RX-888
  • Remote radios over mutual TLS
  • GPS position per node

Decoders as plugins

Separate processes that read the core's streams from shared memory.

  • FT8, BPSK31, CW
  • ADS-B
  • ISM bursts and utility meters
  • LoRa and LoRaWAN
  • BLE and Zigbee (sniffer dongle)
  • Wi-Fi (monitor-mode adapter)

Per-sample work on the GPU

Plugins get only the samples worth decoding.

  • FM and broadcast FM, with stereo and RDS
  • Mode S preamble search
  • Burst gating
  • LoRa preamble detection

Recordings that train a classifier

SigMF recordings, by channel or raw.

  • Decoders annotate them
  • A CFAR detector marks the unexplained
  • Labeled windows train a 1-D ResNet
  • Models export to ONNX

Pipelines you can see

Studio: forgemgr runs pipelines as systemd units.

  • Graph editor with typed wires
  • Live rates and health per node
  • Waterfalls and plugin output
  • Several machines in one view

Plays well with others

An rtl_tcp bridge shares the running radio.

  • gqrx, rtl_433, SDR++
  • Own frequency and rate per client
  • The core and plugins keep running

Built for Linux

Linux facilities used directly.

  • memfd rings and futex wake-ups
  • io_uring
  • systemd
  • No Python on the sample-rate path

Watch: what is on the air around you

Studio builds the pipelines; Watch is the operator's view of what they heard. No waterfalls or parameters, just the devices, where they were, and what changed.

Entities, not packets

Each device with first and last heard, how often, and its latest values, next to a live feed.

  • Water meters
  • LoRaWAN devices and Meshtastic nodes
  • Aircraft
  • FM stations
  • Bluetooth, Zigbee and Wi-Fi devices

A map that works offline

Tiles are cached on the node, so an area viewed once keeps working in the field.

  • Where each device was heard from
  • The node's own track
  • Aircraft as tracks of every reported position

Alerts with a learning period

Alerts land in an inbox and go to a webhook or a command.

  • A new device
  • A watched device heard
  • Gone silent, or back after a silence
  • A value crossing a threshold, such as a leak flag
  • A burst of new devices

Capabilities

Pipelines publish what they can watch.

  • Turning one on starts its pipeline
  • Switching hands over the radio first

From antenna to alert

  1. Radios RTL-SDR · KrakenSDR · bladeRF · RX-888 · network sources · sniffer dongles · SigMF replay
  2. forged GPU spectrum · DDC taps · channelizer · demodulation · burst gating · recorder
  3. Streams Shared-memory rings, local or over mutual TLS
  4. Plugins Decode · label · detect · classify · schedule
  5. Results Entities, maps and alerts in Watch; labeled recordings, datasets, models

A plugin in ten lines

Plugins attach to the core's streams through a control socket and get blocks as zero-copy arrays. The same plugin runs on another machine with --socket tls://node:7700.

There is a Python SDK and a C++ SDK. Only plugins you allow may retune the radio or start recordings; everything else is read-only.

from forgesdr_sdk import Plugin, run

class Peak(Plugin):
    name = "peak"
    subscribe = ["spectrum"]

    def on_block(self, stream, block):
        i = block.data.argmax()
        f = block.freqs()[i] / 1e6
        self.log(f"peak at {f:.4f} MHz")

if __name__ == "__main__":
    run(Peak)