ASTRA: ASV Simulator for Transferable Realistic Autonomy

Tsimafei Lazouski, Cody Sheltraw, Alan Papalia, Maani GhaffariarXiv 2026 · arXiv

TL;DR

ASTRA is an open-source simulation framework for Autonomous Surface Vehicles (ASVs) built on NVIDIA Isaac Sim. It bridges the gap between photorealistic rendering and complex marine physics, providing a 6-DOF dynamics model and native ROS 2 support that allows researchers to develop and test autonomy stacks that transfer directly to physical hardware.

What Problem Does This Paper Address?

Developing reliable autonomy for marine vehicles is notoriously difficult. Field trials are expensive, logistically exhausting, and often impossible to reproduce exactly due to changing weather and water conditions. While simulators exist to solve this, current options often force a compromise:

  • Gazebo-based tools (like VRX) have mature hydrodynamics but lack the visual fidelity needed for modern computer vision and deep learning.
  • Game-engine-based tools (like HoloOcean) offer great visuals but often lack native ROS 2 integration or specific support for surface-vehicle wave interactions.

As shown in the comparison below, ASTRA aims to fill this gap by providing a "best-of-all-worlds" environment within the NVIDIA Isaac Sim ecosystem.

Comparison of ASTRA with other popular marine simulators.

Methods

ASTRA (ASV Simulator for Transferable Realistic Autonomy) is implemented as an extension for Isaac Sim. Its architecture relies on several key technical pillars:

  • 6-DOF Dynamics: It uses a Fossen-style marine dynamics model. While many simulators simplify motion to a 2D plane, ASTRA supports full 6-degree-of-freedom motion, which is critical for understanding how waves affect sensor orientation and vehicle stability.
  • Geometry-Based Buoyancy: Instead of using a simple mathematical approximation for buoyancy, ASTRA uses a real-time solver that calculates the submerged volume of the hull's geometry. This naturally generates restoring forces (roll and pitch) and allows the vehicle to react realistically to waves.
  • Spectral Wave Synthesis: The simulator generates waves using the JONSWAP/TMA spectral models, which are industry standards for representing real-world sea states. These waves are synthesized on the GPU for high performance.
  • Digital Twin Integration: The simulator is modeled after a physical BlueBoat testbed. It replicates the boat's specific sensor suite—including GPS, IMU, LiDAR, and RGB-D cameras—and exposes them through standard ROS 2 interfaces.
The ASTRA environment features high-fidelity sensors, robotics tools integration, and realistic hydrodynamics.

Datasets

The researchers used a combination of field-collected data and simulated benchmarks:

  • Field-Test Logs: 29 "bag files" (data recordings) from a physical BlueBoat were used to identify and calibrate the vehicle's planar damping coefficients (how the water resists the boat's movement).
  • Real-World Validation: A recording from a physical pond was used to qualitatively compare the performance of semantic mapping algorithms between the real world and the simulated environment.

Key Insights and Ideas

  • Unified Force Modeling: A major "aha moment" in ASTRA's design is that it doesn't treat static buoyancy and wave disturbances as separate forces. Because the buoyancy solver is geometry-based and samples the instantaneous water surface, the wave-induced motions (heave, roll, pitch) emerge naturally from the same calculation used for basic floating.
  • Sim-to-Real Portability: By maintaining identical ROS 2 interfaces between the simulator and the physical BlueBoat, the authors demonstrated that complex modules—like the GPS-DRIFT localization filter and ConvBKI semantic mapping—could be ported from the real boat to the sim with zero code changes.
  • The Isaac Lab Path: By building on Isaac Sim, ASTRA provides a direct pipeline to Isaac Lab, opening the door for training reinforcement learning (RL) agents for marine tasks like docking or navigation in rough seas.

Key Results

  • Dynamic Accuracy: The system identification process yielded highly accurate models for planar motion, achieving an $R^2$ of 0.94 for surge and 0.96 for yaw.
  • Wave Realization: The simulator successfully reproduced target sea states. As seen in the spectral analysis, the "measured" waves in the sim closely match the theoretical JONSWAP/TMA targets.
Fig. 2. Realized vs. target JONSWAP/TMA spectrum, strong sea state.
  • Localization & Mapping: The ported GPS-DRIFT algorithm achieved a position error (RMSE) of less than 3 cm in simulation. Qualitatively, the semantic maps generated in the simulator were highly consistent with those generated from real-world pond data.
  • Performance: On an NVIDIA RTX 4090, the simulator maintains a stable 35 FPS even with a full suite of high-fidelity sensors (LiDAR, RGB-D, etc.) and the physics engine running simultaneously.
Fig. 3. On the left are the 3rd-person and RGB views of the Isaac Sim stage and the semantic map in RViz built from its localization, LiDAR, and RGB-D inputs. On the right is the same ConvBKI pipeline, with the same weights and configuration, run offline on real-world data from the physical BlueBoat.

Limitations and Future Work

While ASTRA provides a robust foundation, the authors note a few areas for growth:

  • Calibration Gaps: While planar motion (surge/yaw) was calibrated with field data, the non-planar damping (heave, roll, pitch) currently uses placeholder values and requires further field validation.
  • Propulsion Modeling: The current version lacks a fully calibrated model for the specific thrusters used on the BlueBoat.
  • RL Integration: The next major step is extending the framework into Isaac Lab to support large-scale reinforcement learning for marine robotics.

Summary updated

Abstract

Autonomy development for marine autonomous surface vehicles (ASVs) remains challenging because field testing is costly and difficult to reproduce. Existing marine simulation tools provide mature capabilities in vessel dynamics, robotics integration, and visual rendering, but these strengths are emphasized differently across platforms. This paper presents ASTRA, an ASV simulation framework built in NVIDIA Isaac Sim that combines marine vehicle dynamics, photorealistic perception, and Robot Operating System (ROS 2) autonomy interfaces within a common environment. ASTRA incorporates a Fossen-style marine dynamics model together with geometry-based buoyancy and programmable spectral wave disturbances, enabling non-planar hydrostatic and wave-induced motion. The simulator reproduces the sensor configuration of a physical BlueBoat testbed, including GPS, IMU, LiDAR, and RGB-D sensing exposed through ROS 2. This allows localization, perception, planning, and control software to be developed against interfaces consistent with the physical platform. The BlueBoat's existing ROS 2 localization and perception modules were ported directly into ASTRA, while targeted zero-propulsion experiments were used to verify the implemented wave-body coupling. The simulated roll response was consistent with the expected non-oscillatory hydrostatic behavior, and heave remained highly coherent with the generated wave field, with approximately unity gain at the dominant wave frequency in the tested sea states. ASTRA is intended as an open-source testbed for marine autonomy development, simulation-based benchmarking, and sim-to-real experimentation.
BibTeX
@misc{lazouski2026astra,
  author = {Tsimafei Lazouski and Cody Sheltraw and Alan Papalia and Maani Ghaffari},
  title = {{ASTRA: ASV Simulator for Transferable Realistic Autonomy}},
  year = {2026},
  eprint = {2611.21789},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.21789},
}
Figure