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 (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
  • 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

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.

Execution time in seconds for examples from the radarsimnb repository, across releases:

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.

• Radar Systems & Waveforms

  • FMCW radar
  • Pulsed Radar
  • Doppler radar
  • PMCW radar
  • Interferometric Radar
  • Arbitrary waveform

• MIMO & Multi-Channel Systems

  • TDM MIMO FMCW radar
  • Imaging radar
  • DoA estimation

• 3D Scene Simulation & Ray Tracing

  • FMCW radar with a car
  • FMCW radar with a plate
  • FMCW radar with a corner reflector
  • Multi-path effect
  • Micro-Doppler
  • Doppler of a turbine

• Radar Cross Section (RCS) Analysis

  • Cross-Polarization and Co-Polarization RCS
  • Car RCS
  • Plate RCS
  • Corner reflector RCS

• Signal Processing & Detection

  • CFAR
  • CFAR with corner reflector

• System Performance & Characterization

  • FMCW Radar Link Budget - Ideal Point Target
  • Phase noise
  • Receiver operating characteristic (ROC)
  • Interference

• LiDAR Simulation

  • LIDAR point cloud

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, Receiver and Radar fit 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.