Pith. sign in

REVIEW 3 major objections 3 minor 80 references

IcFuzz: Fuzzing Isaac Sim with Semantic Stage Guidance and Multi-level Mutation

T0 review · 3 major / 3 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read IcFuzz claims semantic-stage guidance lets a fuzzer cover twice as much of NVIDIA Isaac Sim and find 11 real bugs.

desk verdict First fuzzer for Isaac Sim, with 9 developer-confirmed bugs; crash-oracle attribution is the one question worth asking before publication. read the letter →

arxiv 2608.06088 v1 pith:PE223QLS submitted 2026-08-06 cs.RO cs.SE

Zhixiang Chen , Zhuangbin Chen , Ruoxi Jia , Zeqin Liao , Wei Li , Jinyang Liu , Zibin Zheng This is my paper · ORCID
classification cs.ROcs.SE
keywords fuzzingIsaacSimroboticssimulatorsemanticstagesegmentationmulti-levelmutationcrashdetectionmulti-armedbanditLLM-guidedtesting
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

IcFuzz is a fuzzing pipeline for NVIDIA Isaac Sim, a robotics simulator too complex for byte-level fuzzers. The paper's central claim is that Isaac Sim programs have a recurring five-stage lifecycle, and that segmenting seeds into these semantic stages lets a fuzzer mutate objects, operations, and arguments without breaking the simulator's strict context dependencies. Guided by such stages, IcFuzz covers roughly twice the lines of its two baselines, Atheris and GzFuzz, and is the only one of the three to produce crashes. Over four months it reported 11 bugs, 9 of them confirmed or fixed by developers. If right, IcFuzz is the first effective automated testing tool for Isaac Sim and a template for fuzzing other script-driven robotics simulators.

What carries the argument

The load-bearing mechanism is the semantic-stage decomposition of a standalone Isaac Sim script into a fixed taxonomy of execution stages, produced by an LLM with a chain-of-thought prompt, paired with Table 1, a manually built mapping that says which object classes may be added or replaced at each stage. This pair converts an open-ended semantic-validity problem into a stage-constrained selection problem: mutations are only attempted with object types the table allows at the chosen stage, and an LLM is prompted to insert, replace, or delete code while checking feasibility. On top of this, mutation happens at three granularities—object-level addition, replacement, and deletion; operation-level method addition, replacement, and deletion; and argument-level deletion, nullification, and replacement on the AST—with a UCB multi-armed bandit choosing which operator to run next based on coverage gain and crash reward. The stage information is also what lets mutated seeds that increase coverage re-enter the pool with fresh annotations.

What would settle it

Instrument an IcFuzz run on an Isaac Sim release that adds a documented new object category absent from Table 1 and record whether any mutated seed instantiates it; if the new category is never sampled even though the documentation lists it as addable at a reachable stage, the fixed human-authored mapping is the limiting factor.

Watch

Extended reading notes

Core claim

The paper argues that the hard part of fuzzing Isaac Sim is not generating syntactically valid Python but respecting context-aware object semantics: a SimulationApp must exist before scene objects, an Articulation wraps existing prims, and sensors attach to already staged objects. IcFuzz's discovery is that these constraints align with a natural five-stage lifecycle, and that an LLM can segment seeds into these stages with 93.5% accuracy. With stages known, IcFuzz restricts object addition and replacement to a manually annotated table of legal object types per stage, then applies three levels of mutation—object composition, method invocations, and argument values—with an upper-confidence-bound scheduler that rewards coverage gain and crashes. The reported outcome is that this semantic-stage-guided pipeline reaches 20,771 covered lines on average, roughly 205% and 190% of Atheris and GzFuzz, detects 3.7 unique crashes per 12-hour run where the baselines find none, and produced 11 bug reports, 9 of which developers confirmed or fixed.

Load-bearing premise

The load-bearing premise is that the human-authored mapping from semantic stages to legal object types is correct and complete enough for typical Isaac Sim scripts; if it misses common legal objects or new APIs, IcFuzz's mutations get rejected or miss whole regions of the simulator.

Editorial extensions

If this is right

  • If IcFuzz's stage segmentation generalizes, other script-driven robotics simulators such as MuJoCo, Webots, and Genesis could be fuzzed with the same lifecycle-constraint recipe rather than bespoke grammars.
  • The 9 developer-confirmed fixes suggest that even a mature, industry-backed simulator has reachable bugs concentrated in newly introduced experimental classes and incompletely implemented argument paths.
  • Because argument-level mutation alone triggered bugs, fuzzing parameter values of documented methods is a valid complement to mutating whole scene objects.
  • Coverage growing steadily through roughly 600 minutes while baselines plateau near 100 minutes implies that semantic-stage guidance sustains exploration longer, not just deeper.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The manually fixed Table 1 is the main scalability risk: as Isaac Sim grows new experimental object classes, the mapping must be re-annotated by hand, so a testable extension is to auto-update the table from release notes or documentation diffs.
  • IcFuzz's oracle covers only crashes; the same stage-guided mutations could power semantic oracles, for example checking that sensor readings keep their documented shapes or that physics invariants hold after mutation.
  • Because the LLM is used for segmentation, code generation, and feasibility checks but never fine-tuned, the pipeline's cost is dominated by inference and execution; testing a smaller distilled model as a cheaper substitute would be a natural next experiment.
  • Reproducing the campaign on a newer Isaac Sim release would distinguish bugs that are already fixed in the developer branch from genuinely live defects, since two of the 11 reports were stale for exactly that reason.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 3 minor

Summary. The paper presents IcFuzz, a fuzzing framework for NVIDIA Isaac Sim that generates standalone Python simulation scripts. The central idea is to decompose seed scripts into semantic stages using an LLM, use a manually curated stage-to-object mapping to constrain object-level mutations, and apply mutations at object, operation, and argument levels. An MAB/UCB scheduler selects mutation operators based on coverage gain and crash discovery feedback. The evaluation compares IcFuzz against Atheris and GzFuzz over three 12-hour runs, reporting about 20,771 covered lines (roughly 205% and 190% of the baselines), an average of 3.7 unique crashes per run, and 11 reported bugs with 9 confirmed or fixed by developers. Ablation studies assess the contribution of context-aware object selection, each mutation level, and UCB scheduling.

Significance. If the empirical claims hold, IcFuzz is a meaningful step for testing script-driven robotics simulators: it is the first dedicated fuzzer for Isaac Sim, it introduces semantic stage segmentation as a constraint mechanism, and it provides a transferable template for other simulators. The work has notable strengths: a released replication package, three repeated runs per configuration, Welch t-tests for coverage differences, manual duplicate-crash labeling, developer-confirmed bug reports, and robustness checks across three LLMs and several UCB reward settings. The developer-confirmed bugs (e.g., Bug #280, #243, #338) provide concrete evidence that at least some detected failures are real simulator defects. The main risk is that the headline crash metric is not cleanly separated from ordinary Python-level script errors, which is essential for interpreting the baseline comparison.

major comments (3)
  1. [Section 4.1, Metrics ("Number of total/unique crashes")] The crash oracle is under-specified. The paper defines a script as invalid if it executes with "uncaught exceptions" and separately says crashes exhibit "crash detected" messages or dump files. It does not state whether a Python-level exception (e.g., TypeError or AttributeError) raised inside the mutated user script counts as a crash or as an invalid script, nor what stack-frame criteria distinguish simulator-internal faults from user-script errors. Since Table 2's headline result (7 total / 3.7 unique crashes for IcFuzz vs. 0 for baselines) depends entirely on this classification, please provide the exact rule (e.g., presence of specific log markers, dump-file generation, exception-type whitelist, or stack-frame filter) and report how many of the 7 average crashes fall into each class. Without this, the crash counts may overstate the number of genuine simulator bugs.
  2. [Section 4.1, Baselines; Table 2] The baseline comparison is potentially unfair. Atheris is described as mutating input USD files rather than Python scripts, even though Atheris is a Python fuzzer and IcFuzz's test cases are standalone Python programs. GzFuzz is adapted from Gazebo. As configured, Table 2 may demonstrate that a purpose-built script-level fuzzer beats two tools applied outside their native input domains. Please add a Python-script-mutating Atheris configuration (or an LLM-based script fuzzer) as a baseline, or justify why USD-file mutation is the appropriate native mode for Atheris in this context. The coverage comparison in Fig. 10 remains useful, but the "outperforms current SOTA baselines" claim needs a fairer control.
  3. [Section 3.2.1, Table 1] The stage-to-object mapping is a manually curated human artifact that determines the set of permissible object additions and replacements. The paper validates ambiguous entries with minimal executions, but it does not assess completeness: how many Isaac Sim object types in the crawled documentation are absent from Table 1, and how often do mutation requests target objects that the table does not list? Since object-level mutation is described as the most critical level, a completeness analysis (or at least a count of table coverage relative to the documentation database) would strengthen the external validity of the claimed coverage advantage. This is a request for evidence rather than a demonstration of an error.
minor comments (3)
  1. [Section 4.3.1, Table 2] Please report per-run crash counts (or standard deviations) in addition to averages, since the variance of crash discovery across three runs is currently invisible and the statistical significance of the crash difference is not tested.
  2. [Section 4.1, Metrics] The definition of "valid" and the definition of "crash" should be presented together, since a mutated script that raises an uncaught exception is currently ambiguous between the two categories.
  3. [Figure 4] The figure labels the final stage "5. Simulator Shutdown" while the text in Section 3.1.2 describes it as "Stage 5"; please make the numbering consistent throughout the figure and prose.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: IcFuzz's evaluation is empirical against external baselines and developer confirmation; no claim reduces to its inputs by construction.

full rationale

The paper's central claims are coverage and crash-detection results measured on the actual Isaac Sim stack and compared with Atheris and GzFuzz. The semantic stage taxonomy (Sec. 3.1.2) is derived from the official repository and lifecycle documentation, and Table 1's addable/replaceable object types are manually annotated; these are design inputs, not derived predictions. The UCB weights (w_cov=1, w_crash=5) are hand-set but swept in Table 3, so the headline numbers are not forced by a fitted parameter. The only self-citations ([5], [30]) support background statements about robot bugs and are not load-bearing for the fuzzing results. The crash oracle (Sec. 3.3) and the validity definition (Sec. 4.1) do raise a possible external validity concern: 'crashes' are identified by log symptoms such as 'crash detected' or dump files, and the paper does not fully specify how these are separated from uncaught Python exceptions in mutated scripts. However, that is a measurement and threat-to-validity issue, not a circularity: the 11 reported bugs include 9 confirmed or fixed by developers, providing independent external evidence. No equation or definition in the paper makes a predicted quantity equal to an input by construction.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The ledger is light: IcFuzz is an empirical tool, not a derivation. The main hand-chosen degrees of freedom are the UCB weights, the argument mutation probability, and the manual stage-to-object mapping. No speculative entity or force is introduced. The most load-bearing axiom is the semantic-stage lifecycle and its mapping (Table 1), because every object-level mutation is filtered through it; the UCB and coverage assumptions are secondary.

free parameters (3)
  • UCB reward weight w_crash = 5 (default; also tested at 1 and 10)
    Selected by the authors to balance coverage growth and crash detection; changing it shifts coverage from 19,879 to 20,969 lines and unique crashes from 2.0 to 4.3, showing the default is a tunable choice rather than a derived constant.
  • UCB reward weight w_cov = 1
    Fixed weight on coverage gain in the reward function (Eq. 1); not swept independently in the paper.
  • Argument mutation probability = 50%
    Each argument of a selected method is mutated with 50% probability (Section 3.2.2); chosen by hand with no sensitivity analysis.
assumptions (4)
  • domain assumption Isaac Sim standalone scripts follow a recurring semantic lifecycle: Simulator Startup, Scene Setup (with sub-stages), Interacting, Export, Simulator Shutdown.
    Section 3.1.2 derives this from the official development lifecycle [56] and manual review of official scripts. The entire mutation guidance depends on this segmentation being meaningful.
  • ad hoc to paper The stage-to-object mapping in Table 1, specifying which object types are addable or replaceable at each stage, is correct and complete.
    Section 3.2.1: three authors annotated by hand, checking ambiguous cases by executing minimal scripts. Errors here could invalidate object-level mutations and reduce the reported coverage advantage.
  • domain assumption Line coverage of the open-source Isaac Sim extensions is a valid signal for guiding fuzzing and measuring effectiveness.
    Sections 2 and 4.1 note the closed-source Omniverse foundation is not instrumented, so the paper treats extension coverage as the meaningful metric. The headline 'outperforms baselines' claim is scoped to this metric.
  • standard math The UCB bandit selection scheme (Auer et al., 2002) is a reasonable heuristic for this non-stationary reward process.
    Invoked in Algorithm 1. The theoretical regret guarantees assume stationary reward distributions; the paper uses the algorithm heuristically, which is acceptable for the empirical claim.

how reviews work

0 comments
Cite this review

Pith. "Pith review of IcFuzz: Fuzzing Isaac Sim with Semantic Stage Guidance and Multi-level Mutation." pith.science (2026). https://pith.science/paper/PE223QLS

@misc{pith2026260806088,
  author       = {Pith},
  title        = {Pith review of: IcFuzz: Fuzzing Isaac Sim with Semantic Stage Guidance and Multi-level Mutation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/PE223QLS}},
  note         = {Machine review of arXiv:2608.06088}
}
read the original abstract

Robotics simulators serve as a foundational infrastructure for embodied AI, facilitating safe and scalable robotic system development. NVIDIA Isaac Sim has emerged as one of the most popular simulators, distinguished by its GPU-accelerated physics engine and photorealistic rendering, which enable high-fidelity modeling of complex environments. However, its inherent complexity inevitably introduces software bugs that can compromise simulation reliability. Existing fuzzing approaches struggle to test Isaac Sim effectively due to challenges of context-aware object semantics, hierarchical simulation control, and a vast simulation state space. In this paper, we propose IcFuzz, the first fuzzing approach for Isaac Sim. IcFuzz first performs an LLM-based semantic stage segmentation, decomposing simulation programs into structured stages that capture context-aware object semantics. Guided by this information, IcFuzz designs multi-level mutation operators to systematically exercise the simulator across hierarchical granularities. To efficiently navigate the vast simulation state space, IcFuzz employs a multi-armed bandit algorithm to adaptively schedule mutation operators. Experimental results show that IcFuzz outperforms the baselines in terms of both code coverage and bug detection. Specifically, IcFuzz achieves approximately 190\%--205\% of the code coverage of the baselines and detects an average of 3.7 unique crashes over three rounds of 12-hour tests, while no crashes are detected by the baselines. Moreover, IcFuzz has uncovered 11 bugs over approximately four months, 9 of which have been confirmed or fixed by the developers.

Figures

Figures reproduced from arXiv: 2608.06088 by the authors.

Figure 1
Figure 1. Overview of the Isaac Sim architecture. • We propose IcFuzz, the first fuzzing approach for Isaac Sim. IcFuzz introduces semantic stage segmentation and context￾aware object selection to handle the complex object seman￾tics in simulation. It devises multi-level mutation operators to systematically exercise hierarchical simulation control across multiple granularities. Furthermore, IcFuzz utilizes an MAB algorithm to… view at source ↗
Figure 3
Figure 3. Overall Workflow of IcFuzz. 3 Methodology [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figure 4
Figure 4. An example of semantic stage segmentation for a [PITH_FULL_IMAGE:figures/full_fig_p004_4.png] view at source ↗
Figures from the paper (5 more)
Figure 5
Figure 5. Figure 5: An excerpt from the Isaac Sim documentation [ [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: Simplified prompt for object addition mutation. [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 7
Figure 7. Figure 7: A bug triggered by adding a Cylinder. in [63]. Both fuzzers are run with their default settings. Although grammar-based fuzzers and search-based test generation tools can produce structured test inputs, we do not include them as baselines. Grammar-based fuzzing [1, 74]…
Figure 9
Figure 9. Figure 9: A bug triggered by an incompletely implemented [PITH_FULL_IMAGE:figures/full_fig_p008_9.png]
Figure 10
Figure 10. Figure 10: Average code coverage over time [PITH_FULL_IMAGE:figures/full_fig_p009_10.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

80 extracted references · 53 canonical work pages

  1. [1]

    Cornelius Aschermann, Tommaso Frassetto, Thorsten Holz, Patrick Jauernig, Ahmad-Reza Sadeghi, and Daniel Teuchert. 2019. NAUTILUS: Fishing for Deep Bugs with Grammars. In26th Annual Network and Distributed System Security Symposium, NDSS 2019. The Internet Society. https://www.ndss-symposium. org/ndss-paper/nautilus-fishing-for-deep-bugs-with-grammars/

    work page 2019

  2. [2]

    Peter Auer, Nicolò Cesa-Bianchi, and Paul Fischer. 2002. Finite-time Analysis of the Multiarmed Bandit Problem.Machine Learning47, 2-3 (2002), 235–256. doi:10.1023/A:1013689704352

    doi:10.1023/a:1013689704352 2002

  3. [3]

    Roberto Bigazzi. 2025. Autonomous Embodied Agents: When Robotics Meets Deep Learning Reasoning.arXivabs/2505.00935 (2025). doi:10.48550/arXiv.2505. 00935

    work page Pith review arXiv doi:10.48550/arxiv.2505.00935 2025

  4. [4]

    Murphy, and Andrew Nelson

    Jennifer Carlson, Robin R. Murphy, and Andrew Nelson. 2004. Follow-Up Analysis of Mobile Robot Failures. InProceedings of the IEEE International Conference on Robotics and Automation (ICRA 2004). IEEE, 4987–4994. doi:10.1109/ROBOT.2004. 1302508

    work page doi:10.1109/robot.2004 2004

  5. [5]

    Zhixiang Chen, Zhuangbin Chen, Xingjie Cai, Wei Li, and Zibin Zheng. 2025. An Empirical Study of Interaction Bugs in ROS-based Software.arXivabs/2507.10235 (2025). doi:10.48550/ARXIV.2507.10235

    work page Pith review arXiv doi:10.48550/arxiv.2507.10235 2025

  6. [6]

    2026.IcFuzz

    Zhixiang Chen, Zhuangbin Chen, Ruoxi Jia, Zeqin Liao, Wei Li, Jinyang Liu, and Zibin Zheng. 2026.IcFuzz. doi:10.5281/zenodo.19244624

    work page doi:10.5281/zenodo.19244624 2026

  7. [7]

    2025.The Global Robotics Market Outlook

    George Chowdhury. 2025.The Global Robotics Market Outlook. Retrieved Jan- uary 25, 2026 from https://www.abiresearch.com/blog/global-robotics-market- outlook

    work page 2025

  8. [8]

    2025.Coverage.py

    coveragepy. 2025.Coverage.py. Retrieved January 25, 2026 from https://github. com/coveragepy/coveragepy

    work page 2025

Show all 80 references
  1. [9]

    2025.Webots User Guide: Controller Programming

    Cyberbotics. 2025.Webots User Guide: Controller Programming. Retrieved January 25, 2026 from https://cyberbotics.com/doc/guide/controller-programming?tab- language=python

    2025

  2. [10]

    2025.MuJoCo Python

    DeepMind. 2025.MuJoCo Python. Retrieved January 25, 2026 from https: //mujoco.readthedocs.io/en/stable/python.html#standalone-app

    2025

  3. [11]

    DeepSeek-AI. 2026. DeepSeek-V4: Towards Highly Efficient Million-Token Con- text Intelligence.arXivabs/2606.19348 (2026). doi:10.48550/ARXIV.2606.19348

    2026 doi

  4. [12]

    Yinlin Deng, Chunqiu Steven Xia, Haoran Peng, Chenyuan Yang, and Lingming Zhang. 2023. Large Language Models Are Zero-Shot Fuzzers: Fuzzing Deep- Learning Libraries via Large Language Models. InProceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and...

    2023

  5. [13]

    Jacob Dormuth, Ben Gelman, Jessica Moore, and David Slater. 2019. Logical Segmentation of Source Code. InThe 31st International Conference on Software Engineering and Knowledge Engineering, SEKE 2019. KSI Research Inc. and Knowl- edge Systems Institute Graduate School, 717–777...

    2019 doi

  6. [14]

    Jiafei Duan, Shuang Yu, H. L. Tan, Hongyuan Zhu, and C. Tan. 2022. A Survey of Embodied AI: From Simulators to Research Tasks.IEEE Transactions on Emerging Topics in Computational Intelligence6, 2 (2022), 230–244. doi:10.1109/TETCI.2022. 3141105

    2022 doi

  7. [15]

    Andrea Fioraldi, Dominik Christian Maier, Heiko Eißfeldt, and Marc Heuse. 2020. AFL++ : Combining Incremental Steps of Fuzzing Research. In14th USENIX Workshop on Offensive Technologies, WOOT 2020. USENIX Association. https: //www.usenix.org/conference/woot20/presentation/fioraldi

    2020

  8. [16]

    Anders Fischer-Nielsen, Zhoulai Fu, Ting Su, and Andrzej Wasowski. 2020. The forgotten case of the dependency bugs: on the example of the robot operating system. InICSE-SEIP 2020: 42nd International Conference on Software Engineering, Software Engineering in Practice, 2020. AC...

    2020

  9. [17]

    Gordon Fraser and Andrea Arcuri. 2011. EvoSuite: automatic test suite generation for object-oriented software. InProceedings of the 19th ACM SIGSOFT Sympo- sium and the 13th European Conference on Foundations of Software Engineering, ESEC/FSE 2011. ACM, 416–419. doi:10.1145/20...

    2011

  10. [18]

    2025.Hello, Genesis

    Genesis. 2025.Hello, Genesis. Retrieved January 25, 2026 from https://genesis- world.readthedocs.io/en/latest/user_guide/getting_started/hello_genesis.html

    2025

  11. [19]

    Marcus Gerhold, Lola Solovyeva, and Vadim Zaytsev. 2024. The Limits of the Identifiable: Challenges in Python Version Identification with Deep Learning. In IEEE International Conference on Software Analysis, Evolution and Reengineering, SANER 2024. IEEE, 137–146. doi:10.1109/S...

    2024

  12. [20]

    2020.Atheris: A Coverage-Guided, Native Python Fuzzer

    Google. 2020.Atheris: A Coverage-Guided, Native Python Fuzzer. Retrieved January 25, 2026 from https://github.com/google/atheris

    2020

  13. [21]

    2024.NVIDIA Isaac Sim: Photorealistic Rendering for Next-Gen Robot Development

    Gaurav Gupta. 2024.NVIDIA Isaac Sim: Photorealistic Rendering for Next-Gen Robot Development. Retrieved January 25, 2026 from https://www.blackcoffeerobotics.com/blog/isaac-sim-photorealistic-rendering- for-next-gen-robot-development

    2024

  14. [22]

    2026.SQLite

    Dwayne Richard Hipp. 2026.SQLite. Retrieved January 25, 2026 from https: //sqlite.org/

    2026

  15. [23]

    Linghan Huang, Peizhou Zhao, Lei Ma, and Huaming Chen. 2025. On the Challenges of Fuzzing Techniques via Large Language Models. In2025 IEEE International Conference on Software Services Engineering (SSE). IEEE, 162–171. doi:10.1109/SSE67621.2025.00028

    2025

  16. [24]

    2025.Isaac Sim

    isaac sim. 2025.Isaac Sim. Retrieved January 25, 2026 from https://github.com/ isaac-sim/IsaacSim

    2025

  17. [25]

    2024.Training/simulation crashing, possibly due to NaN values

    jack zeng. 2024.Training/simulation crashing, possibly due to NaN values. Re- trieved January 25, 2026 from https://forums.developer.nvidia.com/t/training- simulation-crashing-possibly-due-to-nan-values/310863

    2024

  18. [26]

    Ranim Khojah, Mazen Mohamad, Philipp Leitner, and Francisco Gomes de Oliveira Neto. 2024. Beyond Code Generation: An Observational Study of Chat- GPT Usage in Software Engineering Practice.Proceedings of the ACM on Software Engineering1, FSE (2024), 1819–1840. doi:10.1145/3660788

    2024 doi

  19. [27]

    Seulbae Kim and Taesoo Kim. 2022. RoboFuzz: fuzzing robotic systems over robot operating system (ROS) for finding correctness bugs. InProceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2...

    2022

  20. [28]

    Koenig and Andrew Howard

    Nathan P. Koenig and Andrew Howard. 2004. Design and use paradigms for Gazebo, an open-source multi-robot simulator. In2004 IEEE/RSJ International Conference on Intelligent Robots and Systems. IEEE, 2149–2154. doi:10.1109/IROS. 2004.1389727

    2004 arXiv

  21. [29]

    Maria Kyrarini, Fotios Lygerakis, Akilesh Rajavenkatanarayanan, Christos Sev- astopoulos, Harish Ram Nambiappan, Kodur Krishna Chaitanya, Ashwin Ramesh Babu, Joanne Mathew, and Fillia Makedon. 2021. A Survey of Robots in Healthcare. Technologies9, 1 (2021), 8. doi:10.3390/tech...

    2021 doi

  22. [30]

    Zeqin Liao, Zibin Zheng, Peifan Reng, Henglong Liang, Zixu Gao, Zhixiang Chen, Wei Li, and Yuhong Nan. 2025. An Empirical Study on Embodied Artificial Intelligence Robot (EAIR) Software Bugs.arXivabs/2507.18267 (2025). doi:10. 48550/arXiv.2507.18267

    2025 doi arXiv

  23. [31]

    Josip Tomo Licardo, Mihael Domjan, and Tihomir Orehovački. 2024. Intelligent Robotics—A Systematic Review of Emerging Technologies and Trends.Electronics 13, 3 (2024), 542. doi:10.3390/electronics13030542

    2024 doi

  24. [32]

    Zhe Liu, Chunyang Chen, Junjie Wang, Xing Che, Yuekai Huang, Jun Hu, and Qing Wang. 2023. Fill in the Blank: Context-aware Automated Text Input Gener- ation for Mobile GUI Testing. In45th IEEE/ACM International Conference on Soft- ware Engineering, ICSE 2023. IEEE, 1355–1367. ...

    2023

  25. [34]

    Liu, Yang and Chen, Weixing and Bai, Yongjie and Liang, Xiaodan and Li, Guanbin and Gao, Wen and Lin, Liang. 2025. Aligning Cyber Space With Physical World: A Comprehensive Survey on Embodied AI.IEEE/ASME Transactions on Mechatronics (2025), 1–22. doi:10.1109/TMECH.2025.3574943

    2025

  26. [35]

    Stephan Lukasczyk and Gordon Fraser. 2022. Pynguin: Automated Unit Test Generation for Python. In44th IEEE/ACM International Conference on Software Engineering: Companion Proceedings, ICSE Companion 2022. ACM/IEEE, 168–172. doi:10.1145/3510454.3516829

    2022

  27. [36]

    Steven Macenski, Tully Foote, Brian Gerkey, Chris Lalancette, and William Woodall. 2022. Robot Operating System 2: Design, architecture, and uses in the wild.Science Robotics7, 66 (2022), eabm6074. doi:10.1126/scirobotics.abm6074

    2022 doi

  28. [37]

    Sanoop Mallissery and Yu-Sung Wu. 2024. Demystify the Fuzzing Methods: A Comprehensive Survey.Comput. Surveys56, 3 (2024), 71. doi:10.1145/3623375

    2024 doi

  29. [38]

    Valentin J. M. Manès, HyungSeok Han, Choongwoo Han, Sang Kil Cha, Manuel Egele, Edward J. Schwartz, and Maverick Woo. 2021. The Art, Science, and Engineering of Fuzzing: A Survey.IEEE Transactions on Software Engineering47, 11 (2021), 2312–2331. doi:10.1109/TSE.2019.2946563

    2021

  30. [39]

    2022.ISAAC Sim just crashes abruptly

    mayank.ukani. 2022.ISAAC Sim just crashes abruptly. Retrieved Janu- ary 25, 2026 from https://forums.developer.nvidia.com/t/isaac-sim-just-crashes- abruptly/213444

    2022

  31. [40]

    Richard Mayer, Michael Moser, Niklas Greif, Florian Schnitzhofer, Verena Geist, and Martin Pinzger. 2024. Evaluating AI-Based Code Segmentation for ABAP Programs in an Industrial Use Case. InProduct-Focused Software Process Improve- ment. Industry-, Workshop-, and Doctoral Sym...

    2024 doi

  32. [41]

    Mayank Mittal, Calvin Yu, Qinxi Yu, Jingzhou Liu, Nikita Rudin, David Hoeller, Jia Lin Yuan, Ritvik Singh, Yunrong Guo, Hammad Mazhar, Ajay Mandlekar, Buck Babich, Gavriel State, Marco Hutter, and Animesh Garg. 2023. Orbit: A Unified Simulation Framework for Interactive Robot ...

    2023

  33. [43]

    2024.NVIDIA Robotics Adopted by Industry Leaders for Development of Tens of Millions of AI-Powered Autonomous Machines

    NVIDIA. 2024.NVIDIA Robotics Adopted by Industry Leaders for Development of Tens of Millions of AI-Powered Autonomous Machines. Retrieved January 25, 2026 from https://nvidianews.nvidia.com/news/robotics-industry-development- ai-autonomous-machines

    2024

  34. [44]

    2025.Core Experimental API

    NVIDIA. 2025.Core Experimental API. Retrieved January 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/latest/py/docs/overview/ experimental.html

    2025

  35. [45]

    2025.Isaac Sim Benchmarks

    NVIDIA. 2025.Isaac Sim Benchmarks. Retrieved January 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/5.1.0/reference_material/ benchmarks.html

    2025

  36. [46]

    2025.Isaac Sim Camera Simulation

    NVIDIA. 2025.Isaac Sim Camera Simulation. Retrieved January 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/ isaacsim.sensors.camera/docs/index.html#isaacsim.sensors.camera.Camera. get_rgba

    2025

  37. [47]

    2025.Isaac Sim Core

    NVIDIA. 2025.Isaac Sim Core. Retrieved January 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/ isaacsim.core.api/docs/index.html

    2025

  38. [48]

    2025.Isaac Sim Core API (Prims)

    NVIDIA. 2025.Isaac Sim Core API (Prims). Retrieved January 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/ isaacsim.core.prims/docs/index.html#isaacsim.core.prims.Articulation

    2025

  39. [49]

    2025.Isaac Sim Core (Objects)

    NVIDIA. 2025.Isaac Sim Core (Objects). Retrieved January 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/5.1.0/py/source/extensions/ isaacsim.core.experimental.objects/docs/index.html

    2025

  40. [50]

    2025.Isaac Sim Kit Helpers

    NVIDIA. 2025.Isaac Sim Kit Helpers. Retrieved January 25, 2026 from https: //docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/isaacsim. simulation_app/docs/index.html#isaacsim.simulation_app.SimulationApp

    2025

  41. [51]

    2025.Isaac Sim Manipulators

    NVIDIA. 2025.Isaac Sim Manipulators. Retrieved January 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/ isaacsim.robot.manipulators/docs/index.html

    2025

  42. [52]

    2025.Isaac Sim WheeledRobots

    NVIDIA. 2025.Isaac Sim WheeledRobots. Retrieved January 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/ isaacsim.robot.wheeled_robots/docs/index.html

    2025

  43. [53]

    2025.NVIDIA Isaac Sim

    NVIDIA. 2025.NVIDIA Isaac Sim. Retrieved January 25, 2026 from https: //developer.nvidia.com/isaac/sim

    2025

  44. [54]

    2025.NVIDIA Omniverse

    NVIDIA. 2025.NVIDIA Omniverse. Retrieved January 25, 2026 from https: //www.nvidia.com/en-us/omniverse/

    2025

  45. [55]

    2025.Prim

    NVIDIA. 2025.Prim. Retrieved January 25, 2026 from https://docs.omniverse. nvidia.com/usd/latest/learn-openusd/terms/prim.html

    2025

  46. [56]

    2025.Reference Architecture and Task Groupings

    NVIDIA. 2025.Reference Architecture and Task Groupings. Retrieved Janu- ary 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/5.1.0/introduction/ reference_architecture.html

    2025

  47. [57]

    2025.ROS2 Simulation Control

    NVIDIA. 2025.ROS2 Simulation Control. Retrieved January 25, 2026 from https://docs.isaacsim.omniverse.nvidia.com/5.1.0/ros2_tutorials/tutorial_ ros2_simulation_control.html

    2025

  48. [58]

    2025.Workflows

    NVIDIA. 2025.Workflows. Retrieved January 25, 2026 from https://docs.isaacsim. omniverse.nvidia.com/5.1.0/introduction/workflows.html

    2025

  49. [59]

    2025.GPT-5 mini Model

    OpenAI. 2025.GPT-5 mini Model. Retrieved January 25, 2026 from https: //platform.openai.com/docs/models/gpt-5-mini

    2025

  50. [60]

    Junyoung Park, Yunho Kim, and Insu Yun. 2025. RGFuzz: Rule-Guided Fuzzer for WebAssembly Runtimes. InIEEE Symposium on Security and Privacy, SP 2025. IEEE, 920–938. doi:10.1109/SP61157.2025.00003

    2025

  51. [61]

    Luca Pietrantoni, Marco Favilla, Federico Fraboni, Elvis Mazzoni, Sofia Morandini, Martina Benvenuti, and Marco De Angelis. 2024. Integrating Collaborative Robots in Manufacturing, Logistics, and Agriculture: Expert Perspectives on Technical, Safety, and Human Factors.Frontier...

    2024

  52. [62]

    2026.Qwen3.5: Towards Native Multimodal Agents

    Qwen Team. 2026.Qwen3.5: Towards Native Multimodal Agents. Retrieved July 14, 2026 from https://qwen.ai/blog?id=qwen3.5

    2026

  53. [63]

    Zhilei Ren, Yitao Li, Xiaochen Li, Guanxiao Qi, Jifeng Xuan, and He Jiang. 2025. Reinforcement Learning-Based Fuzz Testing for the Gazebo Robotic Simulator. Proceedings of the ACM on Software Engineering2, ISSTA (2025), 1467–1488. doi:10.1145/3728942

    2025 doi

  54. [64]

    2024.NVIDIA highlights Omniverse, Isaac adoption by robot market leaders

    The Robot Report. 2024.NVIDIA highlights Omniverse, Isaac adoption by robot market leaders. Retrieved January 25, 2026 from https://www.therobotreport. com/nvidia-highlights-omniverse-isaac-adoption-by-market-leaders

    2024

  55. [65]

    Jonan Richards and Mairieli Wessel. 2024. What You Need is what You Get: Theory of Mind for an LLM-Based Code Understanding Assistant. InIEEE International Conference on Software Maintenance and Evolution, ICSME 2024. IEEE, 666–671. doi:10.1109/ICSME58944.2024.00070

    2024

  56. [67]

    Stein and Spiros Mancoridis

    Aviel J. Stein and Spiros Mancoridis. 2023. Chaos to Clarity with Semantic Infer- encing for Python Source Code Snippets. In17th IEEE International Conference on Semantic Computing, ICSC 2023. IEEE, 161–166. doi:10.1109/ICSC56153.2023. 00034

    2023

  57. [68]

    2025.Introduction to USD

    Pixar Animation Studios. 2025.Introduction to USD. Retrieved January 25, 2026 from https://openusd.org/release/intro.html

    2025

  58. [69]

    Maolin Sun, Yibiao Yang, Yang Wang, Ming Wen, Haoxiang Jia, and Yuming Zhou

  59. [70]

    Chenyao Suo, Junjie Chen, Shuang Liu, Jiajun Jiang, Yingquan Zhao, and Jianrong Wang. 2024. Fuzzing MLIR Compiler Infrastructure via Operation Dependency Analysis. InProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, ISSTA 2024. ACM, ...

    2024 doi

  60. [71]

    Shams Tarek, Dipayan Saha, Sujan Kumar Saha, and Farimah Farahmandi. 2025. BugWhisperer: Fine-Tuning LLMs for SoC Hardware Vulnerability Detection. In 43rd IEEE VLSI Test Symposium, VTS 2025. IEEE, 1–5. doi:10.1109/VTS65138.2025. 11022958

    2025

  61. [72]

    Christopher Steven Timperley, Gijs van der Hoorn, André Santos, Harshavardhan Deshpande, and Andrzej Wasowski. 2024. ROBUST: 221 bugs in the Robot Operating System.Empirical Software Engineering29, 3 (2024), 57. doi:10.1007/ S10664-024-10440-0

    2024

  62. [73]

    Mika Viljanen. 2024. Safety by Simulation: Theorizing the Future of Robot Regulation.AI & Society39 (2024), 139–154. doi:10.1007/s00146-023-01730-0

    2024 doi

  63. [74]

    Junjie Wang, Bihuan Chen, Lei Wei, and Yang Liu. 2019. Superion: grammar-aware greybox fuzzing. InProceedings of the 41st International Conference on Software Engineering, ICSE 2019. IEEE / ACM, 724–735. doi:10.1109/ICSE.2019.00081

    2019

  64. [75]

    Pollock, and K

    Xiaoran Wang, Lori L. Pollock, and K. Vijay-Shanker. 2014. Automatic Segmen- tation of Method Code into Meaningful Blocks: Design and Evaluation.Journal of Software: Evolution and Process26, 1 (2014), 27–49. doi:10.1002/SMR.1581

    2014 doi

  65. [76]

    Zan Wang, Ming Yan, Junjie Chen, Shuang Liu, and Dongdi Zhang. 2020. Deep learning library testing via effective model generation. InESEC/FSE ’20: 28th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM, 788–799. do...

    2020

  66. [77]

    Chi, Quoc V

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou. 2022. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. InAdvances in Neural Informa- tion Processing Systems 35: Annual Conference on Neu...

    2022

  67. [78]

    Chunqiu Steven Xia, Matteo Paltenghi, Jia Le Tian, Michael Pradel, and Lingming Zhang. 2024. Fuzz4All: Universal Fuzzing with Large Language Models. In Proceedings of the 46th IEEE/ACM International Conference on Software Engineering, ICSE 2024. ACM, 126:1–126:13. doi:10.1145/...

    2024

  68. [79]

    Dongwei Xiao, Zhibo Liu, and Shuai Wang. 2023. PhyFu: Fuzzing Modern Physics Simulation Engines. In38th IEEE/ACM International Conference on Automated Software Engineering, ASE 2023. IEEE, 1579–1591. doi:10.1109/ASE56229.2023. 00054

    2023

  69. [80]

    Zhenhua Yu, Zhengqi Liu, Xuya Cong, Xiaobo Li, and Li Yin. 2024. Fuzzing: Progress, Challenges, and Perspectives.Computers, Materials and Continua78, 1 (2024), 1–29. doi:10.32604/cmc.2023.042361

    2024

  70. [81]

    Zhaowei Zhang, Hongzheng Zhang, Jinjing Zhao, and Yanfei Yin. 2023. A Survey on the Development of Network Protocol Fuzzing Techniques.Electronics12, 13 (2023), 2904. doi:10.3390/electronics12132904

    2023 doi

  71. [82]

    Yukai Zhao, Menghan Wu, Xing Hu, and Xin Xia. 2025. HFuzzer: Testing Large Language Models for Package Hallucinations via Phrase-based Fuzzing. In40th IEEE/ACM International Conference on Automated Software Engineering, ASE 2025. IEEE, 2746–2758. doi:10.1109/ASE63991.2025.00225

    2025

  72. [83]

    Zhehua Zhou, Jiayang Song, Xuan Xie, Zhan Shu, Lei Ma, Dikai Liu, Jianxiong Yin, and Simon See. 2024. Towards Building AI-CPS with NVIDIA Isaac Sim: An Industrial Benchmark and Case Study for Robotics Manipulation. InProceedings of the 46th International Conference on Software...

    2024

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.