v4.0 "Nucleus" is out →

The RF companion for everyone working on radio

Hundreds of radio, hardware and security tools, ready in one command on the computer you already have. From your first FM station to a full professional assessment.

Install RF Swift New to RF? Start here

Linux · macOS · Windows · x86_64 · ARM64 · RISCV64 · Docker · Podman · Lima · Nix

rfswift — lab
$ rfswift container create -i sdr_full -n lab
› Using image penthertz/rfswift_resolute:sdr_full
✓ USB devices forwarded HydraSDR, HackRF, USRP, bladeRF, Proxmark3
✓ Audio forwarded PipeWire
✓ Display forwarded X11
✓ Workspace mounted ~/rfswift-workspace/lab
Start hacking!
root@lab:~# sdrpp
Built and used by Penthertz on its professional engagements

Presented at Black Hat Arsenal Europe 2024Spectrum 2024FOSDEM 2025CyberOnBoard 2025

Your whole assessment in one window

A desktop app for everyone who prefers clicking to typing. Create a mission for each engagement, open terminals into your labs, take notes, log findings and captures, then export a branded report.

Completely standalone

A native desktop app, not an editor add-on. No VS Code, no IDE, no plugins, no browser extension. It ships with RF Swift and runs on Linux, macOS and Windows.

Full toolboxes or lazy Nix environments

Create a mission from a container image, or pick the Nix engine and tick “Lazy tools”: nothing is installed until you run a tool, then only that tool is fetched.

Missions
One place per engagement, with its own labs and files.
Recorded terminals
Every session can be replayed later as evidence.
Notebook & findings
Write notes and rate findings as you work.
Branded reports
Turn captures and findings into a client-ready report.
Explore the Workbench Install it

A ready-made radio lab that runs next to your system, not instead of it

Radio tools are hard to install. Each one needs its own drivers, libraries and versions, and they often break each other. RF Swift ships them ready to use, in isolated environments: you pick a toolbox, plug in your radio and start working. When you're done, your computer is exactly as it was. Already on Kali, Parrot or DragonOS? Keep it: RF Swift adds to it.

  1. 1

    Install once

    One installer sets up RF Swift and the engine it needs. No manual Docker setup.

  2. 2

    Pick a toolbox

    Images are grouped by job: SDR, Wi-Fi, Bluetooth, telecom, automotive, hardware, reversing, Active Directory and more. Or stay light with a lazy Nix environment that fetches each tool the first time you use it.

  3. 3

    Plug in and listen

    Your SDR, audio and display are passed through automatically. Open SDR++, GQRX or GNU Radio and go.

Real hardware, ready to use

Plug your devices in and open the tools. The drivers and clients come built and tested in the toolbox: nothing to compile, no dependencies to chase, even on small everyday machines.

A GPD pocket laptop running SDRangel with an RTL-SDR dongle plugged in, showing an FM station at 98.5 MHz, next to two RF Swift stickers.
FM radio with an RTL-SDR A broadcast FM station at 98.5 MHz in SDRangel from the sdr_full toolbox, on a GPD pocket laptop. $ rfswift container create -i sdr_full -n fm Your first signal →
A pocket laptop running RF Swift with two terminals side by side, one driving a Proxmark5 and one a Proxmark3, both plugged in over USB, next to the Proxmark5 Iceman Edition box.
Proxmark5 and Proxmark3, side by side Both RFID tools in the same rfid lab on a pocket laptop, each on its own serial port. $ rfswift container create -i rfid -n badge Plug in devices →
A Steam Deck on a stand running the Harogic SAStudio spectrum display and an RF Swift terminal, connected to a Harogic SAE-200 spectrum analyser.
A spectrum analyser on a Steam Deck A Harogic SAE-200 real-time spectrum analyser driven by SAStudio from the sdr_light toolbox, on a Steam Deck. $ rfswift container create -i sdr_light -n spectrum Harogic setup →

Full toolboxes, or only the tools you use

RF Swift drives four engines with the same commands and the same Workbench. Use a container image for a complete, tested toolbox, or Nix to install nothing you don't use. The installer sets up the one you pick.

Docker

Linux · macOS · Windows

The most common engine. Every lab is an isolated container, with the fullest USB, serial and realtime support on Linux.

Best for: The usual setup, teams, Windows

Podman

Linux · macOS · Windows

Rootless and daemonless: labs run as you, with no admin rights and nothing running in the background.

Best for: Shared, company or air-gapped machines, small boards

Lima

macOS

Containers in a small Linux VM that receives your USB radios, with hot-plug. Optional GPU VM on Apple Silicon.

Best for: Containers with USB radios on a Mac

Nix

Linux · macOS · Windows

No containers: tools installed natively and pinned. Lazy mode fetches each tool on first use. Direct USB and native sound.

Best for: Staying light, macOS, lowest latency

Stay light with lazy Nix environments

In lazy mode nothing is installed up front. Each tool becomes a small launcher that fetches the real tool the first time you run it, then keeps it pinned for good.

Only what you run
Type sdrpp and only SDR++ is fetched. Run inspectrum next and only that is added. Standard tools come prebuilt from the binary cache.
Pinned, then instant
Your environment stays on the version you created it from, so nothing changes behind your back. Once fetched, a tool starts straight away.
In the Workbench too
Pick the Nix engine and tick “Lazy tools (build on first use)” when you create a mission.
rfswift — lazy Nix environment
$ rfswift container create --engine nix -i sdr_light -n radio --lazy
# nothing installed yet
$ sdrpp
# first run: only SDR++ is fetched, pinned and started
$ inspectrum capture.iq
# then only inspectrum is added
$ rfswift env run sdr_light sdrpp
# or run one tool without creating anything
Especially good on a Mac

With Nix, the tools run natively on macOS, with no Linux VM in between. Your USB radio opens directly, sound plays natively and OpenGL needs no setup. Add --isolate to run them inside Apple’s built-in Seatbelt sandbox. Prefer containers? Lima gives them your USB radios, and Docker Desktop or Podman cover everything else.

How lazy Nix environments workWhich engine should I pick?

Spend your time on the signal, not on the setup

Ready in minutes
Skip days of compiling and dependency hunting. Hundreds of RF and hardware security tools come already built and tested together, and one command pulls the latest ones.
One program, no Python
RF Swift itself is a single self-contained binary: no Python, no pip, no virtual environment to manage on your computer. The Workbench is a standalone desktop app.
Keeps your computer clean
No new OS, no dual boot, no reformatting. Every assessment runs in its own environment that you can throw away.
Your hardware just works
Your USB devices, sound and display are passed through for you. HydraSDR, HackRF, USRP, bladeRF, Proxmark3, Proxmark5 and many other devices work out of the box.
Same lab on every machine
Linux, macOS or Windows, on x86_64, ARM64 or RISCV64. From a workstation to a Raspberry Pi or a Steam Deck.
Stay light
Full images in Docker, Podman or Lima when you want the whole toolbox, or lazy Nix environments where each tool is fetched the first time you run it.
Covers the whole target
Radio is where it starts, not where it ends. Reversing, Active Directory, network and other assessment tools ship too, so one lab covers the entire target.
Drive a lab from anywhere
The remote agent is built into the same binary. Run it on a lab server or a small board next to the antenna, and control it from your laptop over mutual TLS.
From capture to report
The standalone Workbench keeps missions, terminal recordings, notes, findings and captures together, then exports a branded report.

Works with your distribution, not against it

Dedicated distributions and RF Swift solve different problems, and many people use both. RF Swift installs on Kali, Parrot, BlackArch or DragonOS like on any Linux and adds what they don't ship, without touching their packages. On a plain, freshly installed system, one command brings the whole tool set.

A dedicated distributionRF Swift
Getting startedEverything is there after one installOne command on the system you already use
Kernel and driversIntegrated and tested with the systemUses your computer's kernel
Hardware accessDirect, by defaultPassed through for you, or direct with Nix
EnvironmentsOne shared systemOne environment per job, easy to throw away
PlatformsMostly x86_64 LinuxLinux, macOS, Windows · x86_64, ARM64, RISC-V64
Installing toolsThe whole toolset at onceA toolbox per job, or single tools with lazy Nix
ReproducibilityDepends on local changesVersioned images, pinned Nix environments
How to use them together →
Hundredsof RF, hardware and security tools
3 OSesLinux, macOS, Windows
4 enginesDocker, Podman, Lima, Nix
3 CPUsx86_64, ARM64, RISCV64
1 commandto start a full lab

Use the parts you need

Start with the Workbench if you prefer windows and buttons, or the command line if you live in a terminal. Both manage the same labs.

Nix engineTools installed natively and pinned. In lazy mode each one is fetched the first time you run it. Excellent on macOS.Remote agentBuilt into the rfswift binary. Run it on a lab server or a small board near the antenna and drive it securely from your laptop.AI assistant (MCP)Connect a coding assistant to a Workbench mission through a local bridge, with permissions you choose.Container imagesReady-made toolboxes, one per kind of job, or your own built from a YAML recipe.

Up and running in a minute

Pick your system, paste one line. The installer sets up the CLI, the Workbench or both, plus Docker, Podman or Nix.

Every download is verified against the release SHA-256 manifest, with optional Sigstore build-provenance.

Native packagesAir-gapped installAll releases
bash
curl -fsSL "https://raw.githubusercontent.com/PentHertz/RF-Swift/refs/heads/main/get_rfswift.sh" | sh

Then run rfswift. The script installs the CLI, the Workbench or both, and sets up Docker, Podman or Nix for you.

Pick your path

Beginner

I'm new to RF

No radio or container experience needed. Follow these in order.

  1. 1Learn the key ideasToolbox, lab, workspace: 5 minutes, no jargon
  2. 2Check your computer is supportedRequirements and platforms
  3. 3Choose your engineDocker, Podman, Lima or Nix: what each is good at
  4. 4Install and open your first labQuick start
  5. 5Listen to your first signalA hands-on tutorial with an RTL-SDR
  6. 6Tour the WorkbenchThe graphical way to use RF Swift
  7. 7Pick the right toolboxWhich image for which job

Advanced

I know what I'm doing

Reference material, engines, hardening and building your own images.

Reference

All commandsContainer create optionsConfiguration fileChange a container laterKnown limits

Engines & platforms

Nix engine (lazy mode)PodmanQubesOSVPN inside containers

Build

YAML recipesHelper functionsCompile from source

Security

Hardened deploymentAgent hardeningMCP best practices

Common questions

More answers in the FAQ & troubleshooting page. Still stuck? Ask on Discord.

Do I need to know Docker or Linux?
No. The installer sets up the engine for you, and the Workbench lets you create and open labs without typing commands.
Should I use the CLI or the Workbench?
Either: they manage the same labs. The Workbench adds missions, notes, findings and reports. The command line (CLI) is best for scripting and remote machines.
Does the Workbench need VS Code or another editor?
No. The Workbench is a completely standalone desktop app: no VS Code, no IDE, no plugins, no browser extension. It installs with RF Swift and needs nothing else.
Do I have to download a whole toolbox image?
No. A Nix environment in lazy mode installs nothing up front: each tool is fetched the first time you run it, then pinned. Use --lazy on the command line or tick Lazy tools in the Workbench. To try a single tool without creating anything: rfswift env run sdr_light sdrpp.
Does it work on Windows and macOS?
Yes. On Windows, one installer sets up WSL 2, USB passthrough and the engine. On macOS, use Homebrew or the signed disk image, then pick your engine: Docker Desktop or Podman for containers, Lima when containers need your USB radio, or Nix to run the tools natively. See known limits for hardware specifics.
Does it replace Kali, Parrot or DragonOS?
No, and it isn’t meant to. RF Swift runs on the system you already use, those distributions included, and adds tools next to them without touching their packages. Each job simply gets its own environment. How they compare.
Do I need Python or other dependencies?
No. RF Swift is a single self-contained binary: no Python, pip or virtual environment to manage. The installer adds the engine you choose (Docker, Podman, Lima or Nix) and the few host tools labs need for display and sound.
Can I control a lab machine remotely?
Yes. The remote agent is built into the same binary. Run it on a lab server or a small board next to your antennas, then drive it from the Workbench on your laptop over mutual TLS. See Remote agent.
Can I use it without internet access?
Yes. Follow the air-gapped installation guide to export images and install them offline.

Join the community

Radio amateurs, researchers and security professionals sharing custom images and workflows.

Discord GitHub