A Radar Simulator for Python
RadarSimPy is a powerful and versatile Python-based Radar Simulator that models radar transceivers and simulates baseband data from point targets and 3D models. Its signal processing tools offer range/Doppler processing, direction of arrival estimation, and beamforming using various cutting-edge techniques, and you can even characterize radar detection using Swerling’s models. Whether you’re a beginner or an advanced user, RadarSimPy is the perfect tool for anyone looking to develop new radar technologies or expand their knowledge of radar systems.
- 📡 Radar Modeling
- Transceiver modeling
- Arbitrary waveform (CW, FMCW, PMCW, Pulse, ...)
- Phase noise
- Phase/amplitude modulation (CDM, FDM, DDM, TDM, ...)
- Fast-time/slow-time modulation
- 🎮 Simulation
- Baseband data from point targets & 3D models
- Interference simulation
- Target RCS simulation
- LiDAR point cloud simulation
- 📶 Signal Processing
- Range/Doppler processing
- DoA estimation (MUSIC, Root-MUSIC, ESPRIT, IAA)
- Beamforming (Capon, Bartlett)
- CFAR (CA-CFAR, OS-CFAR)
- 📈 Characterization
- Radar detection characteristics (Swerling’s models)
- Python >= 3.10
- NumPy >= 2.0
- SciPy
- One of PyMeshLab, PyVista, trimesh or meshio, for 3D model support (
trimeshis installed by default) - pygltflib, only for keyframed glTF 2.0 / GLB targets (
radarsimpy.animation_kit)
pip install -r requirements.txtFull detail, including platform and hardware requirements, is on the Dependencies page.
Platform-specific requirements:
- Windows
- Visual C++ Runtime
- GPU version (CUDA13) – requires a GPU with Compute Capability 7.5 (Turing) or higher; see Minimum Required Driver Versions
- Ubuntu 22.04
- GCC 11 (default)
- GPU version (CUDA13) – requires a GPU with Compute Capability 7.5 (Turing) or higher; see Minimum Required Driver Versions
- Ubuntu 24.04
- GCC 13 (default)
- GPU version (CUDA13) – requires a GPU with Compute Capability 7.5 (Turing) or higher; see Minimum Required Driver Versions
- Ubuntu 26.04
- GCC 15 (default)
- GPU version (CUDA13) – requires a GPU with Compute Capability 7.5 (Turing) or higher; see Minimum Required Driver Versions
- Generic Linux x86-64
- Try Ubuntu 22.04/24.04 module, or request a custom build
- MacOS
- Intel: use default Clang (no extra dependency)
- Apple Silicon: use default Clang (no extra dependency)
Download the pre-built module and place the radarsimpy folder in your project directory:
your_project.py
your_project.ipynb
radarsimpy/
├── __init__.py
├── [platform-specific binaries]
├── radar.py
├── processing.py
└── ...
Platform-specific binaries:
- Windows:
radarsimcpp.dll,simulator.xxx.pyd - Linux:
libradarsimcpp.so,simulator.xxx.so - MacOS:
libradarsimcpp.dylib,simulator.xxx.so
Simulations run in parallel on the CPU or the GPU:
- CPU: OpenMP, using all cores by default (limit it with
OMP_NUM_THREADS) - GPU: CUDA, in the GPU build of the module; see Dependencies for the GPU and driver requirements
| CPU (x86-64) | CPU (ARM64) | GPU (CUDA) | |
|---|---|---|---|
| Windows | ✔️ | ❌️ | ✔️ |
| Linux (x86-64) | ✔️ | ❌️ | ✔️ |
| MacOS | ✔️ | ✔️ | ❌️ |
sim_radar, sim_rcs and sim_lidar take a device argument:
from radarsimpy.simulator import sim_radar, gpu_available
print(gpu_available()) # True only on a GPU build with a usable CUDA device
data = sim_radar(radar, targets, device="auto") # "auto" (default), "gpu" or "cpu""auto"uses the GPU when one is usable and the CPU otherwise, without a warning."gpu"falls back to the CPU with aRuntimeWarningwhen no GPU is usable, so a timing taken from that run is a CPU timing.CUDA_VISIBLE_DEVICES=-1hides the GPU, which makes"auto"run on the CPU.
Execution time in seconds for examples from the radarsimnb repository, across releases:
| Example | v12.5.0 CPU | v12.5.0 GPU | v12.6.1 CPU | v12.6.1 GPU | v15.4.0 CPU | v15.4.0 GPU |
|---|---|---|---|---|---|---|
| FMCW imaging radar | > 7200 | 2259.91 | > 7200 | 445.48 | 854.76 | 63.59 |
| FMCW radar with a car | 909.33 | 9.72 | 373.96 | 5.17 | 8.14 | 0.75 |
| Doppler of a turbine | 2069.66 | 117.76 | 2719.24 | 126.71 | 95.54 | 63.40 |
| Multi-path | 151.64 | 4.85 | 88.40 | 4.63 | 5.62 | 1.60 |
| FMCW interference | 0.006 | 0.198 | 0.004 | 0.123 | 0.0013 | 0.0015 |
The GPU helps most on ray-traced 3D models with many channels or samples. Point-target and interference simulations are already fast on the CPU, so the GPU gains nothing there.
Measured on a laptop with an Intel Core i7-11800H (16 threads, 32 GB RAM) and an NVIDIA GeForce RTX 3050 Laptop GPU (4 GB). v15.4.0 times only the sim_radar() call, as the median of 3 runs after a warm-up for runs under 60 s and a single run otherwise; earlier releases were timed with the notebook's own timer.
Everything lives in a single right-handed, z-up frame. Angles are in degrees, distances in metres.
- axis (m):
[x, y, z]— x forward, y to the left, z up - phi (deg): azimuthal angle in the x-y plane. 0° at +x, 90° at +y
- theta (deg): polar angle from +z. 0° at zenith, 90° at the horizon, 180° at nadir
- azimuth (deg): the same angle as phi. 0° at boresight (+x), positive toward +y
- elevation (deg): angle above the x-y plane,
elevation = 90° - theta
Objects are oriented with [yaw, pitch, roll], applied in that order:
- yaw (deg): about +z. Turns +x toward +y
- pitch (deg): about -y. Turns +x toward +z
- roll (deg): about +x. Turns +y toward +z
- origin (m):
[x, y, z], the centre that rotation and translation act about. A radar's origin is always[0, 0, 0]
Note — pitch is not a right-handed rotation about +y; a right-handed one would turn +x toward -z. The composed rotation is
Rz(yaw) · Ry(-pitch) · Rx(roll), the aerospace "nose up is positive" convention. Expect a sign flip when importing orientations from a toolchain that uses the strict right-handed sense.
Conversions, the rotation order in full, and the boresight shortcut rotation = [azimuth, elevation, roll] are covered in the Coordinate Systems guide.
Find more usage examples at radarsimx.com. Source files are available in the radarsimnb repository.
Check Build Instructions
Full documentation lives at radarsimx.github.io/radarsimpy.
Getting started
- Overview — what RadarSimPy can model, simulate and process
- Dependencies and Installation
Concepts and conventions
- System model — how
Transmitter,ReceiverandRadarfit together, the virtual array, and the shape of the simulated output - Coordinate systems — frames, angles and orientation
- Doppler convention — the sign of the Doppler frequency
Configuring a simulation
- Transmitter and waveform — waveform, pulse train, modulation and the transmit array
- Receiver and baseband — sampling, baseband type, the noise budget and the range gate
- Noise — receiver thermal noise and transmitter phase noise
- Interference — mutual interference from another radar sharing the band
- Ray-tracing simulation — ray density, fidelity level and target flags for 3D meshes
- Animated targets — driving targets from keyframed glTF motion
- Long-range stretch processing — range gating for long-range FMCW
API reference — complete class and function documentation
Contributions, issues, and feature requests are welcome! Please open an issue or submit a pull request on GitHub.
This project is licensed under the terms of the LICENSE file.
