From GNU Radio
Jump to: navigation, search

Why use conda?[edit]

Conda is a cross-platform package manager (supporting Linux, macOS, and Windows) that makes it easy to install GNU Radio, its dependencies, and out-of-tree modules in a self-contained environment. Conda lets you create independent environments with their own sets of packages, and those environments are separate from your system installation and other package managers. If you've struggled with installing GNU Radio by other methods, you want to use GNU Radio with other bleeding-edge software available through conda-forge, or you want to try out a new version without affecting your tried-and-true system installation, conda may be right for you! In addition to GNU Radio, there are also related software packages you can install that may be of interest.

Installation using conda[edit]

The conda packages for GNU Radio are unofficial and supported through volunteer effort within the conda-forge community. Conda-forge is a community-maintained collection of conda packages where anyone with interest can help improve or add packages. Please report and discuss any packaging-specific issues with the maintainers at the gnuradio feedstock. If you'd like to help or are interested in adding other related software to conda-forge (e.g. out-of-tree modules), get in touch with the maintainers through Github.

Step 1: Install conda itself[edit]

First, you will need to install a base conda distribution so that you can use the conda program to create an environment and install the GNU Radio packages. If you already have this and can run conda on a command line or use the Anaconda Navigator to install packages, skip to the next step.

If this is your first time using conda, we recommend miniforge for the base installation. This provides a minimal environment to run conda that is already set up to pull packages from conda-forge (which is where you can find GNU Radio). Download and install miniforge by following the instructions at [1]. Installers for many different platforms are available there, but the most relevant are the following:

For Linux and macOS, run the downloaded installer from a console and follow the prompts:

  • (Linux) bash
  • (macOS) bash

By default, this will install miniforge to your home directory at ~/miniforge3 and allow you to use the conda command from any console.

For Windows, double click on the downloaded installer executable and follow the prompts. By default, this will install miniforge to your user directory at C:\Users\USERNAME\miniforge3 and add a "Miniforge Prompt" entry to your start menu. Running the "Miniforge Prompt" should bring up a console window where your base conda environment is activated and you can use the conda command.

This guide provides a nice introduction to using conda generally; it may help you better understand the rest of these instructions, but it is not necessary to read.

(Optional, experts only) It may be convenient to now install mamba in your base environment and use it in place of the conda command. Mamba is a third-party alternative to conda that is written in C instead of Python, and its main benefit is faster dependency resolution when installing packages. If you do install mamba, you can simply use the mamba command in place of conda for all subsequent steps.

Step 2: Create an environment for GNU Radio[edit]

It's almost never a good idea to install additional packages to your base conda environment because their dependencies may interfere with conda's own dependencies. We recommend creating an environment specifically for GNU Radio and related packages. From a console with the base conda environment activated, run

conda create -n gnuradio

to create an empty environment called "gnuradio". Enter the environment by activating it with the command:

conda activate gnuradio

Before installing the GNU Radio packages, we need to ensure that the environment is set up to look for packages from conda-forge:

conda config --env --add channels conda-forge

conda config --env --set channel_priority strict

Now you're ready to actually install GNU Radio!

Step 3: Install GNU Radio from conda-forge[edit]

GNU Radio on conda-forge is split into a few subpackages. Most users will be happy with the full installation provided by the gnuradio metapackage. From within your activated "gnuradio" environment (previous step), run the command:

conda install gnuradio

This will install the latest available version of GNU Radio along with the latest version of Python. If you want a specific version of the gnuradio package (get a list of possibilities from conda search gnuradio), you can specify it like

conda install gnuradio=3.8.2

If you want a specific version of Python, you can install it before gnuradio or specify them together like

conda install gnuradio python=3.8

To upgrade all non-Python packages in your environment to their latest available versions, use the upgrade command

conda upgrade --all

The gnuradio metapackage installs all of the following subpackages:

  • gnuradio-core
  • gnuradio-grc
  • gnuradio-qtgui
  • gnuradio-uhd
  • gnuradio-video-sdl
  • gnuradio-zeromq

If you don't want all of those and their dependencies, you can install the ones you'd like individually like

conda install gnuradio-uhd

to get only the core package (always a dependency) and UHD support without any GUI elements.

Using GNU Radio from conda[edit]

You can use GNU Radio from a conda environment in mostly the same way that it is normally used, provided that you have activated your "gnuradio" environment (or whatever name you might give it). So from a fresh console, you'll need to run

conda activate gnuradio

and then use whatever GNU Radio scripts or programs you want, for instance


Windows users will find that GNU Radio Companion can also be launched from the Start Menu. Running it from there will first activate the appropriate environment, so all you need to do is click the icon!

GNU Radio will have access to the Python installed into the conda environment, and not any other installation. If you need specific Python packages to use with GNU Radio, just install them into the environment using conda install. As a last resort, pip or manual installation (python install) can also be used, but these will not be managed by conda and you'll have to be careful to manage your environment.

Installing related software[edit]

Beyond core GNU Radio and the in-tree modules, some out-of-tree modules and related software have also been packaged for conda. This is a non-exhaustive list of other packages that you can install using the conda install command:

  • gnuradio-osmosdr
  • gnuradio-satellites
  • gnuradio-soapy
  • gqrx
  • rtl-sdr
  • soapysdr-module-plutosdr
  • soapysdr-module-remote
  • soapysdr-module-rtlsdr
  • soapysdr-module-uhd
  • uhd
  • volk

If you have other hardware or OOT modules that you'd like to see supported, first search Anaconda Cloud to see if a package not listed above already exists on conda-forge or another channel. If it doesn't, you can create your own package recipe and submit it to conda-forge (see the documentation at [2] for details) and/or get in touch with the maintainers of the existing packages to see if they would be willing to help.

Installing pre-release versions[edit]

Sometimes, pre-release versions of GNU Radio will also be available through conda-forge (on a best effort basis!). So these don't get installed over release versions, they are provided on a separate channel label. For a release candidate ("RC" pre-release), that channel is conda-forge/label/gnuradio_rc. You can install from a special channel by using the -c flag with conda install, as in

conda install -c conda-forge/label/gnuradio_rc gnuradio

Since extra packages are unlikely to also be available and compatible with a pre-release version, we recommend creating a separate environment first and installing the pre-release there. So for example,

conda create -n grtest -c conda-forge/label/gnuradio_rc -c conda-forge gnuradio

conda activate grtest

Building GNU Radio from source within a conda environment[edit]

Take note that this is an advanced topic that is likely to be of interest to developers only. It is possible to install all of GNU Radio's dependencies into a conda environment and then build GNU Radio from source. This can be useful for development, where the source is being updated and rebuilds are frequent.

Create a development environment[edit]

Create and activate a development environment called "grdev":

conda create -n grdev

conda activate grdev

conda config --env --add channels conda-forge

conda config --env --set channel_priority strict

Install all of the dependencies (or a subset of them if you like):

  • (Linux) conda install alsa-lib boost-cpp click click-plugins cmake codec2 cppzmq fftw gtk3 gsl libblas libcblas libsndfile libusb log4cpp lxml mako mesalib mpir ninja numpy pkg-config portaudio pybind11 pyqt pygobject python pyyaml qt qwt sdl six uhd volk zeromq
  • (macOS) conda install boost-cpp click click-plugins cmake codec2 cppzmq fftw gtk3 gsl libblas libcblas libsndfile libusb log4cpp lxml mako mpir ninja numpy pkg-config pybind11 pyqt pygobject python pyyaml qt qwt six uhd volk zeromq
  • (Windows) conda install boost-cpp click click-plugins cmake codec2 cppzmq fftw gtk3 gsl libblas libcblas libsndfile libusb log4cpp lxml mako mpir ninja numpy pkg-config pybind11 pyqt pygobject python pyyaml qt qwt sdl six uhd volk zeromq

It might also be necessary or useful to install conda-forge's compiler package cxx-compiler to ensure binary compatibility with the conda-forge ecosystem.

Pass necessary arguments to CMake[edit]

With the development environment activated and from a build directory within the source directory, call cmake with the following arguments:

  • (Linux) cmake -G "Ninja" -DCMAKE_PREFIX_PATH=$CONDA_PREFIX -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX -DLIB_SUFFIX="" -DPYTHON_EXECUTABLE=python -DBoost_NO_BOOST_CMAKE=ON -DGR_PYTHON_DIR=`python -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])'` -DQWT_LIBRARIES="$CONDA_PREFIX/lib/"
  • (macOS) cmake -G "Ninja" -DCMAKE_PREFIX_PATH=$CONDA_PREFIX -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX -DLIB_SUFFIX="" -DPYTHON_EXECUTABLE=python -DBoost_NO_BOOST_CMAKE=ON -DGR_PYTHON_DIR=`python -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])'` -DQWT_LIBRARIES="$CONDA_PREFIX/lib/libqwt.dylib"
  • (Windows) cmake -G "Ninja" -DCMAKE_INSTALL_PREFIX="%CONDA_PREFIX%\Library\lib" -DCMAKE_PREFIX_PATH="%CONDA_PREFIX%\Library\lib" -DPYTHON_EXECUTABLE="%CONDA_PREFIX%\python" -DBoost_NO_BOOST_CMAKE=ON -DGR_PYTHON_DIR="%CONDA_PREFIX%\Lib\site-packages" -DLIBCODEC2_INCLUDE_DIR="%CONDA_PREFIX%\Library\include\codec2" -DLIBCODEC2_LIBRARIES="%CONDA_PREFIX%\Library\lib\libcodec2.lib" -DMPIR_LIBRARY="%CONDA_PREFIX%\Library\lib\mpir.lib" -DMPIRXX_LIBRARY="%CONDA_PREFIX%\Library\lib\mpir.lib" -DQWT_LIBRARIES="%CONDA_PREFIX%\Library\lib\qwt.lib" ..

In time, hopefully this list of argument can be trimmed down to only specifying the prefix.

Build as normal[edit]

Proceed with building and installing as normal:

cmake --build .

cmake --build . --target install


  • Why can't GNU Radio find my hardware device?

Provided you've installed the appropriate package for your hardware through conda (e.g. uhd) and the accompanying GNU Radio blocks (e.g. gnuradio-uhd), it's likely that you still need to follow extra steps to get your hardware running. Consult the documentation for your device and follow the additional steps it recommends beyond installing the basic software. For instance, with Ettus UHD-supported devices, you'll need to download the images package into the conda environment by running the script provided by uhd. Make sure your device is visible and usable outside of GNU Radio before trying to track down any GR-specific problem.