RadarSimPy
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.
Key Features
- :satellite: Radar Modeling
- Transceiver modeling
- Arbitrary waveform (CW, FMCW, PMCW, Pulse, ...)
- Phase noise
- Phase/amplitude modulation (CDM, FDM, DDM, TDM, ...)
- Fast-time/slow-time modulation
- :video_game: Simulation
- Baseband data from point targets & 3D models
- Interference simulation
- Target RCS simulation
- LiDAR point cloud simulation
- :signal_strength: Signal Processing
- Range/Doppler processing
- DoA estimation (MUSIC, Root-MUSIC, ESPRIT, IAA)
- Beamforming (Capon, Bartlett)
- CFAR (CA-CFAR, OS-CFAR)
- :chart_with_upwards_trend: Characterization
- Radar detection characteristics (Swerling’s models)
Dependencies
- Python >= 3.10
- NumPy >= 2.0
- SciPy
- One of PyMeshLab, PyVista, trimesh or meshio, for 3D model support (
trimesh is installed by default)
- pygltflib, only for keyframed glTF 2.0 / GLB targets (
radarsimpy.animation_kit)
pip install -r requirements.txt
Full detail, including platform and hardware requirements, is on the Dependencies page.
Platform-specific requirements:
- Windows
- Ubuntu 22.04 (x86-64 and ARM64)
- GCC 11 (default)
- GPU execution (CUDA13) – requires a GPU with Compute Capability 7.5 (Turing) or higher and a recent driver; see Minimum Required Driver Versions. Without one, the same module runs on the CPU; no CUDA toolkit is needed
- Ubuntu 24.04 (x86-64 and ARM64)
- GCC 13 (default)
- GPU execution (CUDA13) – requires a GPU with Compute Capability 7.5 (Turing) or higher and a recent driver; see Minimum Required Driver Versions. Without one, the same module runs on the CPU; no CUDA toolkit is needed
- Ubuntu 26.04 (x86-64 and ARM64)
- GCC 15 (default)
- GPU execution (CUDA13) – requires a GPU with Compute Capability 7.5 (Turing) or higher and a recent driver; see Minimum Required Driver Versions. Without one, the same module runs on the CPU; no CUDA toolkit is needed
- Generic Linux (x86-64 or ARM64)
- MacOS
- Intel: use default Clang (no extra dependency)
- Apple Silicon: use default Clang (no extra dependency)
Installation
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
Acceleration
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; see Dependencies for the GPU and driver requirements
The Windows and Linux modules are a single CUDA-enabled build: they use the GPU when a usable one is present and otherwise run on the CPU with OpenMP, at about the same speed as a CPU-only build. MacOS modules are CPU-only.
| CPU (x86-64) | CPU (ARM64) | GPU (CUDA) |
|---|
| Windows | ✔️ | ❌️ | ✔️ |
| Linux | ✔️ | ✔️ | ✔️ |
| MacOS | ✔️ | ✔️ | ❌️ |
On Linux, the GPU (CUDA) module is available for both x86-64 and ARM64.
Selecting a device
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 a RuntimeWarning when no GPU is usable, so a timing taken from that run is a CPU timing.CUDA_VISIBLE_DEVICES=-1 hides the GPU, which makes "auto" run on the CPU.
Performance
Execution time in seconds for examples from the radarsimnb repository, across releases:
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.
Coordinate Systems
Everything lives in a single right-handed, z-up frame. Angles are in degrees, distances in metres.
Global frame
- 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
Radar-centric angles
- 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
Orientation
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.
Usage Examples
Find more usage examples at radarsimx.com. Source files are available in the radarsimnb repository.
-
Radar Systems & Waveforms
-
MIMO & Multi-Channel Systems
-
3D Scene Simulation & Ray Tracing
Build
Check Build Instructions
Documentation
Full documentation lives at radarsimx.github.io/radarsimpy.
Getting started
Concepts and conventions
Configuring a simulation
API reference — complete class and function documentation
Contributing
Contributions, issues, and feature requests are welcome! Please open an issue or submit a pull request on GitHub.
License
This project is licensed under the terms of the LICENSE file.
