Choose a toolbox (container images)

In RF Swift, a toolbox is a container image: a ready-made set of tools, drivers and libraries for one kind of job. You pick a toolbox, RF Swift creates a lab from it, and the tools inside already work together. This page helps you choose one, then explains how to download and manage images.

Which toolbox do I need?

Find your job in the left column. The name on the right is what you type after -i (or pick in the Workbench’s Environment / image field). To see exactly what each toolbox contains, open Included tools.

Download and use a toolbox

You don’t need a separate download step: creating a lab downloads the toolbox the first time.

rfswift container create -i sdr_light -n radio

If you prefer to download in advance, for example before you go somewhere without internet, pull it:

rfswift image pull -i sdr_light

In the Workbench, type the toolbox name in the Environment / image field of New mission; a Download image button shows the progress layer by layer.

Managing images

The rfswift image command group handles everything about images. The pre-v4 spellings (rfswift images ..., rfswift delete, rfswift download, …) still work and print a notice with the new name.

rfswift image --help

The full list of subcommands and flags is on the image reference page.

See what is published

rfswift image remote

This displays a table of available images:

  💿 Official Images
┌──────────────────────────┬──────────────────────┬─────────────────────────────────────────────────────┬──────────────┐
│ Tag                      │ Pushed Date          │ Image                                               │ Architecture │
├──────────────────────────┼──────────────────────┼─────────────────────────────────────────────────────┼──────────────┤
│ sdr_full_nvidiagpu_amd64 │ 2025-03-24T17:37:59Z │ penthertz/rfswift_resolute:sdr_full_nvidiagpu_amd64 │ amd64        │
│ hardware                 │ 2025-03-24T17:33:21Z │ penthertz/rfswift_resolute:hardware                 │ amd64        │
│ sdr_full_intelgpu_amd64  │ 2025-03-24T17:09:38Z │ penthertz/rfswift_resolute:sdr_full_intelgpu_amd64  │ amd64        │
│ sdr_full                 │ 2025-03-24T16:43:07Z │ penthertz/rfswift_resolute:sdr_full                 │ amd64        │
│ telecom_5G               │ 2025-03-24T16:36:22Z │ penthertz/rfswift_resolute:telecom_5G               │ amd64        │
...

Understanding image tags

1. Generic tags (e.g. sdr_full, bluetooth) work across supported architectures with multi-architecture builds.
2. Architecture-specific tags (e.g. sdr_light_amd64, bluetooth_arm64) target a single architecture.
3. Specialized hardware tags (e.g. sdr_full_nvidiagpu_amd64) include optimizations for specific hardware.

Short names such as sdr_full expand to penthertz/rfswift_resolute:sdr_full through the repotag setting of your configuration file.

Image categories

How images build on each other

RF Swift images are layered: specialized images build on more general base images.

graph LR;
    A[corebuild]-->B[sdrsa_devices];
    A-->C[rfid];
    A-->D[automotive];
    A-->E[reversing];
    A-->F[sdrsa_devices_antsdr];
    A-->G[sdrsa_devices_rtlsdrv4];
    B[sdrsa_devices]-->H[sdr_light];
    B[sdrsa_devices]-->I[bluetooth];
    B[sdrsa_devices]-->L[telecom_utils];
    B[sdrsa_devices]-->R[hardware];
    B[sdrsa_devices]-->S[network];
    B[sdrsa_devices]-->DT[deeptempest];
    A-->OS[osint];
    A-->AN[android];
    S[network]-->WB[wifi_basic];
    WB-->WF[wifi_full];
    S[network]-->AD[ad];
    H-->J[wifi];
    H-->G4[sdr_gnuradio4];
    H-->K[sdr_full];
    H-->H2[sdr_light_intelgpu];
    H-->H3[sdr_light_nvidiagpu];
    H2-->K2[sdr_full_intelgpu];
    H3-->K3[sdr_full_nvidiagpu];
    L-->M[telecom_2Gto3G];
    L-->N[telecom_4G_5GNSA];
    L-->O[telecom_5G];
    L-->O2[telecom_5G_bladerf];
    L-->P[telecom_4Gto5G];
    N-->P2[telecom_5G_train];

This hierarchy gives you:

• Layer reuse: less disk space when you use several images.
• Consistency: common tools are identical across related images.
• Specialization: higher-level images include more specialized tools.
• A base for customization: you can build your own images starting from any level.

All images and supported architectures

Images on your computer

rfswift image local

This shows the images you have downloaded or created, and their status:

  📦 RF Swift Images
┌──────────────────────┬─────────────────┬──────────────┬───────────────────────────┬─────────────┬────────────┐
│ Repository           │ Tag             │ Image ID     │ Created                   │ Size        │ Status     │
├──────────────────────┼─────────────────┼──────────────┼───────────────────────────┼─────────────┼────────────┤
│ myrfswift            │ latest          │ sha256:0bdb2 │ 2024-09-01T00:56:27+02:00 │ 16635.22 MB │ Custom     │
│ penthertz/rfswiftdev │ sdr_full_amd64  │ sha256:0bdb2 │ 2024-09-01T00:56:27+02:00 │ 16635.22 MB │ Up to date │
│ penthertz/rfswiftdev │ sdr_light_amd64 │ sha256:476c0 │ 2024-09-01T00:34:55+02:00 │ 9617.12 MB  │ Up to date │
│ penthertz/rfswift    │ sdr_full        │ sha256:50ce1 │ 2024-08-02T14:45:46+02:00 │ 10383.56 MB │ Custom     │
└──────────────────────┴─────────────────┴──────────────┴───────────────────────────┴─────────────┴────────────┘

• Up to date: the image matches the latest version in the repository.
• Update available: a newer version exists in the repository.
• Custom: the image was modified locally (through tagging or container commits).

Add -v to show version information, and -f to filter by name (rfswift image local -v -f sdr).

Pulling and updating

rfswift image pull -i sdr_light                  # download, or update when "Update available"
rfswift image pull -i sdr_full -t my_sdr:v1      # give it a local tag of your choice
rfswift image pull -i sdr_full -V 0.1.1          # a specific published version

Saving and loading images as files

For offline use or to move images between computers:

# Save an image to a file
rfswift image download -i sdr_light -o sdr_light.tar.gz

# Load it on the other computer
rfswift image import image -i sdr_light.tar.gz

The complete offline workflow is in Offline / air-gapped install.

Disk space

Images vary in size with the tools they include:

The sizes shown by rfswift image local are the virtual size of each image. Because images are made of shared layers, the space actually used is often much less than the sum. For example, with both sdr_light (9 GB) and sdr_full (16 GB):

• the displayed total suggests 25 GB;
• the real usage is closer to 17 GB, since both share their base layers.

This happens automatically: when you pull related images (on the same branch of the hierarchy above), you only download and store the layers that differ.

To keep disk usage low:

1. Use specialized images rather than all-inclusive ones when possible.
2. Stay on one branch of the hierarchy: related images share layers.
3. Remove images you no longer use: rfswift image rm -i IMAGE.
4. Remove old containers: rfswift container rm -c NAME (their workspace folder is kept).
5. Consider building your own image with only the tools you need.

Caches & fast delivery explains where images are stored and how a team can share them.

Next steps