An Async SDR Runtime for Heterogeneous Architectures

Related tags



An experimental asynchronous SDR runtime for heterogeneous architectures that is:

  • Extensible: custom buffers (supporting accelerators like GPUs and FPGAs) and custom schedulers (optimized for your application).

  • Asynchronous: solving long-standing issues around IO, blocking, and timers.

  • Portable: Linux, Windows, Mac, WASM, Android, and prime support for embedded platforms through a REST API and web-based GUIs.

  • Fast: SDR go brrr! Apache 2.0 licensed Build Status

Website | Guides | API Docs | Chat


FutureSDR supports Blocks with synchronous or asynchronous implementations for stream-based or message-based data processing. Blocks can be combined to a Flowgraph and launched on a Runtime that is driven by a Scheduler.

  • Single and multi-threaded schedulers, including examples for application-specific implementations.
  • Portable GPU acceleration using the Vulkan API (supports Linux, Windows, Android, ...).
  • User space DMA driver for Xilinx Zynq to interface FPGAs.


Since FutureSDR is in an early state of development, it is likely that SDR applications will require changes to the runtime. We, therefore, do not recommend to add it as a dependency in a separate project but to clone the repository and implement the application as binary, example, or sub-crate.


An example flowgraph with a periodic message source, sending five messages to a sink:

use anyhow::Result;
use std::time::Duration;

use futuresdr::blocks::MessageSink;
use futuresdr::blocks::MessageSource;
use futuresdr::runtime::Flowgraph;
use futuresdr::runtime::Pmt;
use futuresdr::runtime::Runtime;

fn main() -> Result<()> {
    let mut fg = Flowgraph::new();

    let src = fg.add_block(MessageSource::new(Pmt::Null, Duration::from_secs(1), Some(5)));
    let snk = fg.add_block(MessageSink::new());

    fg.connect_message(src, "out", snk, "in")?;




Contributions are very welcome. Please see the (work-in-progress) contributing guide for more information. If you develop larger features or work on major changes with the main intention to submit them upstream, it would be great, if you could announce them in advance.


The FutureSDR project adheres to the Rust Code of Conduct. It describes the minimum behavior expected from all contributors.


This project is licensed under the Apache 2.0 license.

Using this license is in contrast to the large majority of Open Source SDR applications and frameworks, which are mostly AGLP, LGPL, or GPL. In a nutshell, this means that there is no money to be made from relicensing the project for commercial use, since this is already allowed by Apache 2.0. Furthermore, companies can use (parts of) the project and integrate (adapted) versions in commercial products without releasing the source or contributing back to the project.

The main motivation for this license is that

  • it better fits the Rust ecosystem
  • it eases adoption; one can use (parts of) the code with close to no strings attached
  • using Open Source and not contributing back (for the time being) seems better than not using Open Source at all


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in FutureSDR, shall be licensed as Apache 2.0, without any additional terms or conditions.

  • Add pedantic clippy lints

    Add pedantic clippy lints

    Fix some pedantic options for clippy lints


    No issues with code, just ran padantic clippy over the project to get to understand the code a bit better.

    Cool project, excited to play around with this!

    opened by wcampbell0x2a 3
  • ZeroMQ PubSink & SubSource

    ZeroMQ PubSink & SubSource

    Why ZeroMQ? ZeroMQ is by default in GNU Radio Companion.

    ZMQSubSource & ZMQPubSink as blocks I would like to have blocks to publish stream & receive stream from other systems.

    Underlying ZMQ rust lib? I have done an experiment with zmq library which is blocking one. Should we consider using async-zmq (non blocking) or the more idiomatic libzmq (but unmaintained).

    Additional context Having those would enable tests where only part of a chain is migrated to FutureSDR. For instance, it could enable to split a chain between GNU Radio and FutureSDR until FutureSDR had all the mandatory blocks of the overall chain.

    opened by loic-fejoz 2
  • feature/ZeroMQ


    Add ZMQSubSource and SMQPubSink for streaming over ZeroMQ protocol which is also by default in GNU Radio. I think I have made it as a feature activated by default. It also come with two binaries (one receiver, one emitter) that can talk to each other and/or with GNU Radio.

    Apparently the topics is not settable in GNU Radio thus I have not provided way to set it. Maybe I should?

    Close #3

    opened by loic-fejoz 2
  • feature/constblock



    Because GNU Radio tutorials are using basic blocks applying some constant operation (AddConst, MulConst), we should add this feature. See also the discussion 6.


    • Shared code for operations requiring 1 constant.
    • Implementation for Addition and Multiplication based on closure.
    opened by loic-fejoz 2
  • clippy: ptr_as_ptr

    clippy: ptr_as_ptr


    Change casts that don't change mut to .cast<T>().

    opened by wcampbell0x2a 1
  • Feature/soapysdr args

    Feature/soapysdr args


    SoapySDR inputs are hardcoded and should be user defined.


    Add custom freq/sample_rate/gain SoapySdr Block

    Add freq/sample_rate/gain to the SoapySdrBuilder. This allows the freq/gain/sample_rate to be set in the init() function once the soapySDR library has the context of the device.

    This was tested on a HackRF One device.

    Enable soapysdr logging

    This changes the following output:

    [INFO] Opening HackRF One #0 57b068dc214b4c63...

    into the following:

    FutureSDR: INFO - Opening HackRF One #0 57b068dc214b4c63...
    opened by wcampbell0x2a 1
  • Feature/soapysdr filter

    Feature/soapysdr filter


    Add filter for choosing sdr at startup of flowgraph.


    Add SoapySdrBuilder::filter()

    opened by wcampbell0x2a 1
  • FM Receiver example

    FM Receiver example


    See how FutureSDR can be applied on simple example such as an FM Receiver. Also testing the AudioSink as stated in #4


    While we add discussion on Discord and other alternatives implementation, we come up with the idea that an Apply block with a mutable closure would be sufficient.

    opened by loic-fejoz 0
  • AudioSource & AudioSink

    AudioSource & AudioSink

    AudioSource & AudioSink The AudioSource & AudioSink blocks are one of the basic blocks of a lot of tutorial.

    underlying library? cpal could be a candidate as the underlying library. Being a newbie in Rust, I do not know much about the state of such audio crates. NB: I have tried to provide such a block but I am stuck with some requirement from cpal of having 'static callbacks.

    opened by loic-fejoz 2
An Async SDR Runtime for Heterogeneous Architectures
GlueSQL is a SQL database library written in Rust

GlueSQL is a SQL database library written in Rust. It provides a parser (sqlparser-rs), execution layer, and optional storage (sled) packaged into a single library.

GlueSQL 893 Sep 14, 2021
The official MongoDB Rust Driver

MongoDB Rust Driver This repository contains the officially supported MongoDB Rust driver, a client side library that can be used to interact with Mon

mongodb 814 Sep 14, 2021

Transistor A Rust Crux Client crate/lib. For now, this crate intends to support 2 ways to interact with Crux: Via Docker with a crux-standalone versio

Julia Naomi 27 Aug 31, 2021
Official Skytable client driver for Rust

Skytable client Introduction This library is the official client for the free and open-source NoSQL database Skytable. First, go ahead and install Sky

Skytable 7 Aug 24, 2021
Cassandra DB native client written in Rust language. Find 1.x versions on Looking for an async version? - Check WIP

CDRS CDRS is looking for maintainers CDRS is Apache Cassandra driver written in pure Rust. ?? Looking for an async version? async-std https://github.c

Alex Pikalov 327 Sep 11, 2021
TDS 7.2+ (mssql / Microsoft SQL Server) async driver for rust

Tiberius A native Microsoft SQL Server (TDS) client for Rust. Supported SQL Server versions Version Support level Notes 2019 Tested on CI 2017 Tested

Prisma 115 Sep 8, 2021
Redis library for rust

redis-rs Redis-rs is a high level redis library for Rust. It provides convenient access to all Redis functionality through a very flexible but low-lev

Armin Ronacher 2.1k Sep 11, 2021
Official Rust client for Central Dogma

centraldogma-rs Official Rust Client for Central Dogma. Full documentation is available at Getting started Installing Add

LINE 39 Aug 12, 2021
Immutable Ordered Key-Value Database Engine

PumpkinDB Build status (Linux) Build status (Windows) Project status Usable, between alpha and beta Production-readiness Depends on your risk toleranc

null 1.3k Sep 14, 2021
An async executor based on the Win32 thread pool API

wae An async executor based on the Win32 thread pool API use futures::channel::oneshot; #[wae::main] async fn main() { let (tx, rx) = oneshot::ch

Raphaël Thériault 12 Apr 29, 2021
RedisLess is a fast, lightweight, embedded and scalable in-memory Key/Value store library compatible with the Redis API.

RedisLess is a fast, lightweight, embedded and scalable in-memory Key/Value store library compatible with the Redis API.

Qovery 132 Aug 31, 2021
Asyncronous Rust Mysql driver based on Tokio.

mysql-async Tokio based asynchronous MySql client library for rust programming language. Installation Library hosted on [dependencies] mysq

Anatoly I 231 Sep 14, 2021
A easy-use client to influxdb

InfluxDBClient-rs A easy-use client to influxdb Overview This is an InfluxDB driver for Rust. Status This project has been able to run properly, PR is

漂流 69 Sep 14, 2021
UnQLite wrapper 1.0 is avaliable for Rust

unqlite A high-level UnQLite database engine wrapper. NOTE: Some of the documents is stolen from UnQLite Official Website. What is UnQLite? UnQLite is

Huo Linhe 83 Aug 19, 2021
Simple, async embedded Rust

Cntrlr - Simple, asynchronous embedded Cntrlr is an all-in-one embedded platform for writing simple asynchronous applications on top of common hobbyis

Branan Riley 11 Jun 3, 2021
Async positioned I/O with io_uring.

uring-positioned-io Fully asynchronized positioned I/O with io_uring. Basic Usage let files = vec![File::open("test.txt").unwrap()]; let context = Uri

Alex Chi 24 Sep 11, 2021
Rust implementation of Hyperswarm, a networking stack for connecting peers

hyperswarm-rs Peer to peer networking stack API Docs | Contributing NOTE: This is still in early stages. See the roadmap below. Please feel free to op

Franz Heinzmann 17 May 16, 2021
Engula empowers engineers to build reliable and cost-effective databases.

Engula is a storage engine that empowers engineers to build reliable and cost-effective databases with less effort and more confidence. Engula is in t

Engula 208 Sep 12, 2021
Skytable rust client support library for the bb8 connection pool

bb8-skytable Skytable rust client support library for the bb8 connection pool. Heavily based on bb8-redis Basic usage example use bb8_skytable::{

null 3 Sep 18, 2021