IR-SIM: A Lightweight Declarative Simulator for Navigation Learning and Benchmarking

arXiv:2606.08729 · cs.RO, cs.LG · Submitted 2026-06-07 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: Today's paper: "IR-SIM: A Lightweight Declarative Simulator for Navigation Learning and Benchmarking".

Dev: IR-SIM is a lightweight skill-native navigation simulator designed for rapid scenario construction, benchmarking, and robot learning, addressing barriers in existing simulators that often require custom code or complex interfaces.

Rosa: First, who's behind it and why it matters.

Title and authors: Rosa: Welcome everyone to the show today; we're diving into something really interesting from the recent arXiv papers on simulation for robotics. We’re talking about a paper called "IR-SIM: A Lightweight Declarative Simulator for Navigation Learning and Benchmarking." I'm curious if this kind of tool actually works outside of a controlled lab setting, and how long can we realistically expect it to run complex navigation scenarios before we hit some serious performance walls?

Dev: Yeah, Rosa, that’s the million-dollar question. From an engineering standpoint, the real concern is the loop rate and any potential latency introduced by this declarative setup; if we're running fast simulations for training or benchmarking algorithms like Reciprocal Velocity Obstacle rules or ORCA baselines, every millisecond counts.

Taro: And when you talk about it running outside the lab, Dev, I wonder how much of the real-world sensor noise and unpredictable environment variability this lightweight design can actually absorb before the fidelity drops too much for meaningful autonomy research.

Rosa: That’s a good point, Taro; we’re hoping IR-SIM offers a bridge to more realistic testing without needing massive compute resources right away. I also want to ask about the core idea; how does defining everything in YAML instead of writing custom code actually simplify the creation process for people who aren't deep simulator coders?

Dev: It simplifies things because, essentially, you decouple the scenario description from the physics update and rendering, which is a big win for iteration speed. The paper describes scenarios entirely through YAML configuration files that specify everything from robot kinematics to LiDAR sensing and behavior modules like ORCA or SFM.

Taro: Decoupling sounds promising, but I want to know what happens when the world misbehaves in a complex way; if the scenario is defined so rigidly, how does the AI handle unexpected dynamic events that aren't explicitly parameterized?

Rosa: That’s where Taro’s question hits on a key area for autonomy research. The paper suggests that while scenarios are reproducible, they can be generated from text prompts using LLM-powered skills, which means we can describe complex situations in natural language and have the simulator translate that into an executable YAML artifact automatically.

Dev: That translation part is crucial; the system uses Python runners to parse those YAML files, which then instantiate the world, robots, behaviors, and sensors in a simulation loop. This whole setup allows for rapid prototyping because you’re not writing boilerplate code for every new environment.

Title and authors: Taro: I think that ability to generate scenario variants on demand is what makes this useful for training data generation; if we can describe a base scenario and have the LLM generate many variations—say, varying robot densities or obstacle layouts—that would massively speed up policy training.

Rosa: Exactly; the paper shows that these generated scenarios can be used for automated benchmarking of navigation algorithms and for generating training data for learning methods. It moves us closer to having repeatable, diverse testing conditions without spending weeks manually setting up each test case.

Dev: The paper also addresses the limitation that existing methods often tie scenario authoring to simulator-specific formats or code APIs, which forces extra translation work for natural language requests. IR-SIM aims to solve that by providing a more standardized, reproducible way to define everything using YAML.

Taro: So, if we look at the improvements they propose, I see them focusing on making the scenario authoring more accessible and less tied to simulator specifics. What about those downstream workflows they mentioned? Are there specific skills that help us compare different navigation policies fairly?

Rosa: They introduce several agent skills for downstream workflows, such as irsim-benchmark which structures fair comparisons by enforcing shared scenarios and metrics like success rate and navigation time. This is really important for social navigation benchmarking because it ensures that when we compare ORCA against a Reinforcement Learning policy, we're testing them under identical, controlled conditions.

Dev: I also see the irsim-dev skill which is geared towards IR-SIM library development, which supports researchers who want to build on top of this framework rather than just using it for a single test run. From an engineering view, having these distinct skills helps modularize the simulation pipeline itself.

Taro: And what about bridging to other simulators? I’m interested in how this lightweight 2D platform connects with things like CARLA or Isaac Sim; if we prototype something quickly in IR-SIM, can we then move that policy to a high-fidelity simulator for final validation without rewriting the core logic?

Rosa: That bridging capability is a major selling point of IR-SIM; it provides bridges to high fidelity simulators and real world deployment, allowing users to validate their algorithms in more realistic settings after prototyping without extra coding. This saves a ton of time when moving from concept to reality.

Title and authors: Dev: From the technical setup, the physics engine uses the Shapely library for fast geometric queries on planar objects like circles and polygons, which is efficient for collision checking. The LiDAR simulation also relies on casting rays and checking intersections with scene objects to model sensing accurately.

Taro: Speaking of the physics, I wonder about the fidelity of those geometric checks when dealing with complex, non-planar obstacles in a dense environment; does Shapely handle the occupancy grid cell representation well enough for detailed path planning algorithms like A* search or RRT?

Rosa: The paper mentions that map specifications can come from images, where an image is transformed into an occupancy grid map, which can then be used for path planning algorithms like A* search and Rapidly-exploring Random Trees (RRT). This gives us a way to use real-world visual data as input for planning.

Dev: And the rendering side is handled by Matplotlib for configurable 2D plotting and animation, meaning visualization options are specified through YAML configuration files. It’s a lightweight approach that keeps the overhead low while still giving us a visual feedback loop.

Taro: Looking at the overall conclusion of this paper, what do you see as the biggest practical implication for researchers in terms of how they approach navigation learning? What’s the main shift we should notice?

Rosa: The main shift is moving scenario design from being code-centric or API-dependent to being declarative and accessible through natural language prompts. This makes the creation of scenarios for learning and benchmarking much more fluid and less prone to implementation errors.

Dev: I agree; it lowers the barrier for entry significantly, especially when you think about the complexity of setting up a full simulation environment from scratch versus just describing it in a YAML file. It’s about making the infrastructure easier to use.

Taro: For me, the implication is that we can start focusing more on the policy and its performance rather than spending excessive time wrestling with simulator configuration for every new test case. That frees up cognitive load for actual autonomy problems.

Rosa: It really does simplify the iteration cycle, allowing us to rapidly generate training data and then use those same scenarios for rigorous comparison across different navigation algorithms. We’re setting up a system where rapid scenario construction and automated testing become much more standard practice.

Title and authors: Dev: And from an engineering perspective, it means we can test the scalability of our algorithms under varied conditions much faster because the simulation setup itself is being managed by this lightweight structure. The failure modes are still there, but at least the scenario definition part is robust.

Taro: I think we should watch how this evolves regarding robustness when dealing with those dynamic agents and environmental misbehavior; that’s where the real test for any autonomy system will be. It's not just about running a path; it's about surviving chaos.

Rosa: Exactly, Taro; so while IR-SIM is lightweight and excels at scenario generation, the next step is ensuring that these scenarios are sufficiently robust enough to push our autonomous systems to their limits in more realistic, messy environments.

Dev: Well, we’ve covered a lot about the structure and the workflow of this paper on IR-SIM: A Lightweight Declarative Simulator for Navigation Learning and Benchmarking. It really shows how configuration files can replace much of the simulator-specific programming needed to set up tests.

Taro: Indeed, it points toward a future where defining complex navigation tasks becomes as natural as writing a description in plain language, and we can generate massive amounts of testing material from that description. That opens up new avenues for training policies on incredibly diverse data sets.

Rosa: It’s exciting to see how this framework facilitates the transition from a quick prototype to a formally benchmarked result, all without demanding massive amounts of specialized coding knowledge. We need to keep an eye on how researchers start using these tools for social navigation and human-aware tasks.

Dev: My main concern remains the latency and loop rate when we scale up the complexity of the YAML files or introduce more intricate sensor models, but fundamentally, this is a significant step toward making simulation setup transparent and reproducible. It’s about building better tools for research efficiency.

Taro: I think we should see this framework integrated into more complex systems where the environment dynamics are less predictable, because that’s where the real challenge of autonomy lies. This paper gives us a solid foundation for creating those challenging environments systematically.

Rosa: Alright everyone, we’ve looked at the core mechanics of IR-SIM and its role in scenario creation, benchmarking, and bridging to higher fidelity simulators. It seems like a powerful tool for accelerating the research cycle in navigation learning right now. We’ll keep an eye on how this declarative approach helps shape future simulation standards.

The paper's summary: Rosa: So, to recap, IR-SIM is basically this new way of building navigation simulators where you don't write custom simulator code; instead, you define everything—the robots, the sensors, even the collision rules—using simple YAML configuration files that an AI can read and turn into a working simulation.

Dev: Exactly. Think of it as a blueprint for a world rather than writing the actual construction code for every single building component; it really shifts the focus from coding boilerplate to designing the scenario itself.

Taro: And what I find most interesting is how this declarative approach lets us generate massive amounts of training data quickly because we can feed natural language prompts into an agent, and that agent spits out dozens of varied scenarios for Reinforcement Learning algorithms.

Rosa: It’s pretty neat how it addresses the bottleneck in robotics research where setting up a clean, reproducible test environment often takes more time than actually developing the navigation policy itself.

Dev: That speed is where I get excited about the engineering aspect; we're talking about decoupling the scenario description from physics updates and rendering, which should make iteration cycles for our control algorithms much shorter.

Taro: But Rosa, I still have my reservations about how it handles things when the world throws something totally unexpected at it; if we define a perfectly structured YAML scenario, what happens when reality breaks that structure in a way the authors haven't explicitly modeled?

Rosa: That’s a valid point, Taro. The paper acknowledges its current design is focused on 2D kinematics and geometric checks using tools like Shapely for speed, which means it doesn't model full contact dynamics or photorealistic sensing yet.

Dev: Right, and that’s where the authors themselves put their limitations; they state plainly that it doesn't model those high-fidelity aspects of real physics or sensor noise, so we need to be mindful of that when using it for very advanced testing.

Taro: So the implication is that IR-SIM is excellent for rapidly prototyping and benchmarking navigation policies under controlled, reproducible conditions, but we still need a bridge to higher fidelity simulators for final validation in complex settings.

Rosa: Precisely; it serves as a fantastic starting point—a lightweight 2D platform—to quickly iterate on scenario design and get those initial policy ideas off the ground without getting bogged down in low-level simulator programming.

Dev: It’s a tool that streamlines the workflow, allowing us to move from abstract idea to testable environment much faster than traditional methods, which is a huge win for our development pipeline.

Taro: I see this having a big impact on how we approach social navigation research because it enables standardized benchmarking; if we can generate identical scenarios for two different algorithms using the same YAML seed, the comparisons become genuinely fair.

Rosa: That’s right; it moves us away from ad-hoc testing and towards systematic, reproducible comparisons of navigation policies under a wide variety of conditions.

Dev: Overall, I see this as a powerful infrastructure piece that simplifies the simulation setup process tremendously for anyone building navigation algorithms, regardless of their simulator coding experience.

Taro: It’s definitely a step toward making complex autonomy research more accessible by lowering the barrier to entry for creating diverse and varied test environments.

The paper's improvements: Rosa: So, to wrap up this part, we’re looking at how IR-SIM plans to improve itself moving forward, focusing on making the whole system more robust and useful for real research applications.

Dev: I see they’re emphasizing better automatic scenario validation; that means the AI should be able to check if a generated environment is actually testable before we waste time running it through our RL training pipelines.

Taro: That makes sense from a researcher's standpoint, because having tools that automatically verify the quality of the training data generation is crucial for building reliable navigation policies.

Rosa: They also mentioned improving sensor realism, which I think is a big deal because we’re currently stuck in 2D kinematic models, so getting closer to actual LiDAR sensing will be necessary for more realistic testing.

Dev: And from an engineering viewpoint, they want to address the performance ceiling; they recognize that while the setup is lightweight, pushing it toward higher fidelity requires better handling of latency and complex physics integration.

Taro: I'm interested in what they suggest for social navigation scenarios specifically; are there plans to make the agent skills more capable of modeling dynamic human behavior or more intricate social interactions?

Rosa: They’re focusing on making those downstream workflows, like the benchmark skill, even better at structuring fair comparisons across different navigation algorithms.

Dev: It sounds like they want to create a more modular system where we can swap out components easily—maybe switch from a simple ORCA behavior to a custom one without changing the core simulator structure.

Taro: That modularity is key for social navigation because you need flexibility to test different interaction styles, so making those behavior definitions easier to plug in would be very beneficial for our work.

Rosa: So, it seems they’re focused on evolving IR-SIM from a quick prototyping tool into a more comprehensive platform that supports deeper research into complex, dynamic behaviors.

Dev: It’s about moving beyond just running a simulation to having tools that help us systematically compare and refine the policies we are training within those simulations.

Taro: If they can really nail the sensor realism and social modeling aspect, I think this platform could become indispensable for testing autonomous systems in unstructured environments.

Conclusion: Rosa: So, to wrap up this discussion on IR-SIM: A Lightweight Declarative Simulator for Navigation Learning and Benchmarking, we've seen how defining scenarios through YAML files lets us rapidly prototype navigation tasks without getting bogged down in simulator-specific programming.

Dev: It really shows how moving the scenario definition out of the code and into a declarative format is a massive step toward making simulation setup more accessible for everyone involved in robotics research.

Taro: I think that capability to generate diverse training data from simple text prompts is what really opens up new avenues for policy development, especially in social navigation where varied testing conditions are so important.

Rosa: That’s right; the potential for automated benchmarking and generating training data based on natural language descriptions is quite significant for accelerating our research timeline.

Dev: From my end, I’m still watching how they handle the loop rate when we start feeding more complex YAML structures into the Python runner, because if that latency creeps up too much, the whole benefit of rapid iteration is lost.

Taro: I just want to keep pushing on what happens when the world misbehaves; if this system can generate scenarios that are robust enough to test against genuinely chaotic or unexpected agent behavior, then it becomes a much more powerful tool for understanding autonomy under stress.

Rosa: That’s a fair push, Taro; the current limitation is that it's focused on 2D kinematics and geometric checks, so we need to keep thinking about how those limitations impact the real-world deployment we hope to achieve later.

Dev: I agree with Rosa; the paper makes it clear that this is a lightweight starting point, and future work needs to focus heavily on bridging that gap toward more complex physics modeling.

Taro: So, even with the 2D constraint now, having a system where scenario definition is driven by natural language prompts gives us a solid foundation to build upon for those harder problems later.

Rosa: Exactly; IR-SIM gives us the means to quickly design and test navigation scenarios in a way that feels more intuitive than traditional methods, which is a big plus for field work.

Dev: We've seen how this declarative approach streamlines the whole process, making it much easier to move from concept to a reproducible test setup for our control algorithms.

Taro: It’s definitely going to help us compare navigation policies in a way that is standardized and fair, which is essential when we start looking at social navigation benchmarks.

Rosa: So, we're looking at this paper on IR-SIM: A Lightweight Declarative Simulator for Navigation Learning and Benchmarking as a powerful tool for rapidly iterating on scenario design and benchmarking.

Dev: It really underscores the idea that configuration files can replace much of the simulator-specific programming needed to set up tests, which is a huge win for our development pipeline.

Taro: The implications are clear: faster policy iteration through automated data generation and fairer comparisons in social navigation research.

Rosa: This framework is definitely shaping how we think about building simulation environments, moving toward more declarative and accessible methods. Next up on the show, we’re looking at a paper that tackles complex control challenges in power systems.

The University of Hong Kong

cs.RO, cs.LG

Submitted: 2026-06-07

Updated: 2026-09-29

Comments: project website: https://github.com/hanruihua/ir-sim

Code: https://github.com/hanruihua/ir-sim

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 80/100

The gist: IR-SIM is a lightweight skill-native navigation simulator designed for rapid scenario construction, benchmarking, and robot learning, addressing barriers in existing simulators that often require

Key concepts

IR-SIM: A lightweight skill-native navigation simulator designed for rapid scenario construction, benchmarking, and robot learning. It defines robots, sensors, and behaviors using simple YAML configuration files instead of requiring custom code.
Declarative Setup: Defining scenarios through declarative methods means specifying the desired outcome—like robot kinematics or sensor models—rather than writing the step-by-step construction code. This decouples scenario description from physics updates for faster iteration.
LLM-powered Skills: The system uses Large Language Models to translate natural language prompts into executable YAML artifacts. This allows users to describe complex situations in plain language and have the simulator automatically generate varied test scenarios for training.

Terminology

Benchmarking — 46× in this paper · explained in 3 episodes
Fidelity — 27× in this paper · explained in 2 episodes
Reinforcement Learning — 18× in this paper · explained in 4 episodes
Benchmark — 16× in this paper · explained in 2 episodes
Agent Skills — 14× in this paper · explained in 1 episode
Core — 11× in this paper · explained in 2 episodes
Gaussian Splatting — 4× in this paper · explained in 4 episodes
Rapidly-exploring Random Trees — 4× in this paper
Reciprocal Velocity Obstacle — 4× in this paper
Model Context Protocol — 3× in this paper
Decoupling — 2× in this paper · explained in 2 episodes
Embodied AI — 2× in this paper · explained in 2 episodes
Large Language Models (LLMs) — 2× in this paper · explained in 6 episodes
Proximal Policy Optimization — 2× in this paper
Social Force Model — 2× in this paper
3D Gaussian Splatting — 1× in this paper · explained in 2 episodes
Abstraction — 1× in this paper · explained in 1 episode
CVF International Conference on Computer Vision — 1× in this paper
Cognitive Load — 1× in this paper · explained in 2 episodes
Deep Reinforcement Learning — 1× in this paper · explained in 2 episodes
Failure Modes — 1× in this paper · explained in 3 episodes
Large Language Model (LLM) — 1× in this paper · explained in 3 episodes
Model Context Protocol (MCP) — 1× in this paper · explained in 8 episodes
Modularity — 1× in this paper · explained in 9 episodes
Optimal Reciprocal Collision Avoidance — 1× in this paper
Proximal Policy Optimization (PPO) — 1× in this paper · explained in 5 episodes
Robot Operating System — 1× in this paper
Robustness — 1× in this paper · explained in 5 episodes

Summary

IR-SIM is a lightweight skill-native navigation simulator designed for rapid scenario construction, benchmarking, and robot learning, addressing barriers in existing simulators that often require custom code or complex interfaces. Scenarios are entirely defined by YAML configuration files that specify mobile robot kinematics, geometric collision checking, LiDAR sensing, visualization, and behavior modules. This design makes robotic simulation fully describable and reproducible. Scenarios can be generated and modified from text prompts through the proposed IR-SIM agent skills. The resulting scenarios can be used for automated benchmarking of navigation algorithms and for automated generation of training data for learning methods. Furthermore, IR-SIM provides bridges to high fidelity simulators and real world deployment, allowing users to validate their algorithms in more realistic settings after prototyping without extra coding.

The key idea of IR-SIM is to define scenarios entirely through YAML configuration files rather than simulator-specific program logic, enabling users to generate and modify scenarios from text descriptions through the proposed LLM-powered IR-SIM skills. This design allows for reproducible and shareable scenarios with seeded randomization, which is necessary for benchmarking navigation algorithms and generating training data for reinforcement learning methods without rewriting the underlying simulator code.

IR-SIM supports core navigation components, including robot kinematics, geometric collision checking, LiDAR sensing, Matplotlib visualization, and behavior modules. The system overview shows that natural language prompts are converted into executable YAML scenario artifacts and Python runners. The Python runner then parses the YAML file and instantiates the world, robots, behaviors, and sensors in the simulation loop. This design decouples scenario description, physics update, and rendering.

IR-SIM skills are implemented as a set of task focused agent skills. The core skill for scenario construction is irsim-scenario, which authors validates and modifies YAML scenario files through the native world, robot, obstacle, and gui blocks. It covers kinematics, shapes, built-in behaviors, sensors, random distributions, and image or procedural maps. The execution boundary is handled by irsim-runner skill. Additional skills cover downstream workflows: the irsim-benchmark skill structures fair comparisons by enforcing shared scenarios and metrics such as success rate and navigation time; the irsim-dev skill is used for IR-SIM library development; and other skills support reinforcement learning oriented rollouts, social navigation benchmarking, and transitions to higher fidelity validation.

The physics engine includes collision detection implemented using the Shapely library for fast geometric queries on planar objects like circles, rectangles, polygons, linestrings, and occupancy grid cells. LiDAR sensor simulation relies on geometric queries by casting rays and checking for intersections with scene objects. Kinematic state update advances objects based on configured kinematic models such as differential drive, omnidirectional, omnidirectional angular, and Ackermann.

Rendering is implemented with Matplotlib for configurable 2D plotting and animation, with visualization options specified through YAML configuration files.

Behavior modules define motion policies configured directly through the YAML scenario. Built-in behaviors include ORCA [20], SFM [21], and a simple goal-directed behavior called dash. IR-SIM also provides a registry design for users to define custom behaviors that can be referenced in the YAML file without changing the simulator code interface.

IR-SIM supports map specifications from images, where an image is transformed into an occupancy grid map, which can be used for path planning algorithms like A∗ search and Rapidly-exploring Random Trees (RRT). This representation is also useful for interfacing with map assets from other simulators.

The paper showcases representative use cases: generating learning oriented rollouts using PPO [41] to train a multi robot collision avoidance policy; benchmarking social navigation policies using CrowdNav [17]; and bridging to high fidelity simulators and real world deployment, such as CARLA, Isaac Sim, and physical robots via ROS 2. The bridge examples demonstrate how IR-SIM preserves lightweight scenario logic while external platforms provide richer rendering, sensing, or deployment environments.

In conclusion, IR-SIM serves as a unified 2D platform for rapidly iterating on navigation scenario design, algorithm development, learning, and benchmarking by representing scenarios as executable YAML artifacts editable from natural language prompts via LLM skills. The limitations include its design as a lightweight 2D kinematic simulator that does not model full contact dynamics or photorealistic sensing. Future work will improve automatic scenario validation and sensor realism.

"The key idea of IR-SIM is to define scenarios entirely through YAML configuration files rather than simulator-specific program logic, enabling users to generate and modify scenarios from text descriptions through the proposed LLM-powered IR-SIM skills." (Page 2)

IR-SIM supports core navigation components, including robot kinematics, geometric collision checking, LiDAR sensing, Matplotlib visualization, and behavior modules. (Page 2)

The resulting scenarios can be used for automated benchmarking of navigation algorithms and for automated generation of training data for learning methods. (Page 1)

"IR-SIM provides bridges to high fidelity simulators and real world deployment, allowing users to validate their algorithms in more realistic settings after prototyping without extra coding.

Improvements for AI systems

Here are the specific improvements to AI systems that can be derived from the IR-SIM paper, focusing on making robotic navigation research faster, more scalable, and more reproducible:

Dominance of Natural Language Scenario Generation for RL/Benchmarking:
Automated Training Data Generation via LLM-Driven Simulation:
Rapid Algorithm Prototyping through Declarative Scenario Definition (YAML):
Reproducible Social Navigation Policy Benchmarking Under Controlled Conditions:
Seamless Bridging of Lightweight Prototypes to High-Fidelity Real-World Validation:

Specific improvements and capabilities of the improved AI system (IR-SIM integrated workflow):

The improved AI system, built around the IR-SIM framework, can perform the following specific tasks:

An LLM agent can translate high-level natural language instructions (e.g., Train a robot to avoid pedestrians in a crowded intersection using Reciprocal Velocity Obstacle rules) directly into an executable, reproducible YAML scenario and Python runner within minutes, bypassing extensive manual configuration of simulator APIs or code writing.
The system can automatically generate vast amounts of diverse training data for Reinforcement Learning (RL) algorithms by iterating on the LLM prompt to create numerous randomized scenario variants (e.g., varying robot densities, obstacle layouts, and goal positions) based on a single base YAML template, facilitating robust policy training under varied conditions.
Researchers can prototype novel navigation or social navigation policies instantly by defining the environment entirely through declarative YAML files specifying kinematics (Omni/Ackermann), sensor models (2D LiDAR/FMCW), geometric collision constraints (Shapely-based checks), and complex behaviors (ORCA, SFM, dash). This allows for rapid iteration on behavioral parameters without recompiling simulator code.
The system enables standardized, reproducible benchmarking of social navigation policies. By using a single seeded YAML scenario family across multiple algorithms (e.g., comparing ORCA vs. RL-RVO), the AI can consistently measure and report metrics like success rate, collision frequency, and path length under identical randomized conditions, ensuring fair and verifiable comparisons.
The system acts as a unified platform that allows researchers to rapidly transition from a lightweight 2D prototype to high-fidelity validation environments (like CARLA or Isaac Sim). A scenario authored in IR-SIM can be automatically mapped into the 3D environment of the target simulator, allowing the AI to instantly test if its learned or designed policy performs as expected in a more realistic rendering and physics context without needing to re-implement the core logic.