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

• :video_game: Simulation

• :signal_strength: Signal Processing

• :chart_with_upwards_trend: Characterization

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)

• Ubuntu 24.04 (x86-64 and ARM64)

• Ubuntu 26.04 (x86-64 and ARM64)

• Generic Linux (x86-64 or ARM64)

• MacOS

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

| | 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:

| Example | v12.5.0 CPU | v12.5.0 GPU | v12.6.1 CPU | v12.6.1 GPU | v15.5.0 CPU | v15.5.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 |

_{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

• ### Radar Cross Section (RCS) Analysis

• ### Signal Processing & Detection

• ### System Performance & Characterization

• ### LiDAR Simulation

Build

Check Build Instructions

Documentation

Full documentation lives at radarsimx.github.io/radarsimpy.

Getting started

• Overview — what RadarSimPy can model, simulate and process
• Dependencies and Installation

• 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

• 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

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.