pith. sign in

arxiv: 2606.31706 · v1 · pith:ZJG3ST63new · submitted 2026-06-30 · 💻 cs.SE

AdaTrans: Automated C to Rust Transformation via Error-Adaptive Repair

Xiaofan Liu , Zecan Li , Zhuang Zhao , Ziqi Shuai , Yanming Yang , Qi Xin , Jifeng Xuan This is my paper

Pith reviewed 2026-07-01 04:22 UTC · model grok-4.3

classification 💻 cs.SE
keywords C to Rust transformationautomated code migrationerror-adaptive repairretrieval-augmented generationRust ownership semanticsLLM code generationcompiler error fixingunsafe code minimization
0
0 comments X

The pith

AdaTrans converts C code to Rust using error-adaptive strategies that reach 95.51 percent compilation success.

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

The paper introduces AdaTrans as a framework that turns C programs into Rust by mapping compiler errors to targeted fixes. It relies on retrieval-augmented generation for repairs, a strategy that shifts its approach according to the error category, and repeated validation steps that check both compilation and matching behavior. Tested on 104 algorithmic problems, the system produces code that compiles in most cases, solves the original tasks at high rates, and uses unsafe Rust constructs in only a small fraction of files. A reader would care because rewriting C into Rust by hand is slow and risks introducing bugs, while this method aims to automate the move to a memory-safe language.

Core claim

AdaTrans employs a Strategy-Driven Retrieval-Augmented Generation mechanism to map compiler errors to specific repairs, an Error-Stratified Transformation Strategy that adapts its behavior based on error types, and a multi-stage validation pipeline to ensure both compilability and functional equivalence. On a dataset of 104 algorithmic problems this produces a mean compilation pass rate of 95.51 percent and a mean solve rate of 81.09 percent while keeping the unsafe file rate at 1.19 percent, outperforming prior tools.

What carries the argument

The Error-Stratified Transformation Strategy (ESTS) that adapts its behavior based on error types identified during compilation attempts.

If this is right

  • Large numbers of existing C algorithmic implementations can be moved to Rust with minimal manual review.
  • The fraction of output files that require unsafe blocks stays near one percent across many problems.
  • Compilation failures become rare enough that the translation process can run in a largely automated loop.
  • Functional correctness can be checked without executing the original C code after the initial validation.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same error-mapping approach might apply to other strict language pairs such as C to Go or Java to Rust.
  • Extending the validation to cover performance or concurrency properties would require new test oracles.
  • Handling of larger codebases with multiple files and external libraries would need additional dependency tracking.
  • The reported rates may drop on code that uses heavy pointer arithmetic or platform-specific features.

Load-bearing premise

The multi-stage validation pipeline correctly confirms both compilability and functional equivalence between the original C code and the generated Rust code.

What would settle it

A case where the generated Rust code passes all validation tests and compiles cleanly yet produces different results from the C source on an input outside the test set.

Figures

Figures reproduced from arXiv: 2606.31706 by Jifeng Xuan, Qi Xin, Xiaofan Liu, Yanming Yang, Zecan Li, Zhuang Zhao, Ziqi Shuai.

Figure 1
Figure 1. Figure 1: Typical C pattern for string collection. [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: LLM-generated Rust code triggering E0597. [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Overall architecture and inter-phase dependencies of the AdaTrans framework. [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: A hidden runtime panic captured by the validation pipeline during a transformation task. [PITH_FULL_IMAGE:figures/full_fig_p009_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Execution flow of the Strategy-Driven RAG mapping mechanism. The central panel depicts the Rust Violation-Fix Graph [PITH_FULL_IMAGE:figures/full_fig_p010_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Example of an MS error (E0597) triggering RAG injection. [PITH_FULL_IMAGE:figures/full_fig_p011_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: High-entropy mutation escaping local optima by refactoring the parsing logic. [PITH_FULL_IMAGE:figures/full_fig_p013_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Example fuzzing script for test case generation. [PITH_FULL_IMAGE:figures/full_fig_p015_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Sweet-spot analysis of the Local-Loop threshold from AdaTrans repair logs (434 observations across error-category iterations). [PITH_FULL_IMAGE:figures/full_fig_p024_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: Error category distribution across repair iterations (1–19) for all 104 problems. At each iteration, each problem is either Solved [PITH_FULL_IMAGE:figures/full_fig_p026_10.png] view at source ↗
read the original abstract

The automated transformation of C code to Rust is challenging due to Rust's strict ownership and borrowing semantics. While Large Language Models (LLMs) show promise, they often produce code that violates these rules or relies on unsafe constructs. We propose AdaTrans, a framework that addresses these issues through three core mechanisms: a Strategy-Driven Retrieval-Augmented Generation (RAG) mechanism to map compiler errors to specific repairs, an Error-Stratified Transformation Strategy (ESTS) that adapts its behavior based on error types, and a multi-stage validation pipeline to ensure both compilability and functional equivalence. Evaluating on a dataset of 104 algorithmic problems, AdaTrans achieves a mean compilation pass rate of 95.51% and a mean solve rate of 81.09%, significantly outperforming existing tools while maintaining an unsafe file rate of only 1.19%.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 1 minor

Summary. The manuscript proposes AdaTrans, a framework for automated C-to-Rust transformation that combines Strategy-Driven Retrieval-Augmented Generation (RAG) to map compiler errors to repairs, an Error-Stratified Transformation Strategy (ESTS) that adapts based on error types, and a multi-stage validation pipeline to ensure compilability and functional equivalence. On a dataset of 104 algorithmic problems, it reports a mean compilation pass rate of 95.51%, a mean solve rate of 81.09%, and an unsafe file rate of 1.19%, claiming to significantly outperform existing tools.

Significance. If the validation pipeline is shown to correctly establish functional equivalence, the work would represent a concrete advance in LLM-based code migration by reducing reliance on unsafe constructs while achieving high compilability and solve rates on algorithmic problems. The direct experimental measurement on a held-out dataset of 104 problems supplies falsifiable numeric outcomes that can be compared to future work; the error-adaptive mechanisms (RAG + ESTS) are a plausible direction for handling Rust's ownership rules.

major comments (2)
  1. [Abstract] Abstract: the solve-rate claim of 81.09% is defined via the multi-stage validation pipeline's confirmation of functional equivalence, yet the abstract supplies no concrete mechanism (test-case execution, output comparison, oracle construction, or handling of UB/memory/I/O), which is load-bearing for the metric.
  2. [Abstract] Abstract / Evaluation section: the claim of 'significantly outperforming existing tools' is presented without naming the baseline tools, the exact definition of solve rate, dataset construction details, or any statistical significance test, preventing verification of the headline numeric results.
minor comments (1)
  1. [Abstract] Abstract: clarify whether the reported means are computed over problems or over multiple runs per problem.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for these comments on the abstract. Both points identify areas where the abstract can be made more self-contained without altering the underlying claims or results. We will revise the abstract in the next version.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the solve-rate claim of 81.09% is defined via the multi-stage validation pipeline's confirmation of functional equivalence, yet the abstract supplies no concrete mechanism (test-case execution, output comparison, oracle construction, or handling of UB/memory/I/O), which is load-bearing for the metric.

    Authors: We agree the abstract should briefly indicate how functional equivalence is established. The manuscript describes the multi-stage validation pipeline (test-case execution against reference outputs, with explicit handling for undefined behavior via sanitizers and memory safety checks) in Section 4. We will add a short clause to the abstract summarizing these mechanisms while remaining within length limits. revision: yes

  2. Referee: [Abstract] Abstract / Evaluation section: the claim of 'significantly outperforming existing tools' is presented without naming the baseline tools, the exact definition of solve rate, dataset construction details, or any statistical significance test, preventing verification of the headline numeric results.

    Authors: The evaluation section (Section 5) names the baselines (C2Rust, rustc-transpile, and LLM-only prompting), defines solve rate as the fraction of problems passing both compilation and all test cases, and details the 104-problem algorithmic dataset. No statistical significance test was conducted. We will revise the abstract to name the primary baselines and restate the dataset size; the solve-rate definition will be referenced via the validation clause added in response to the first comment. revision: yes

Circularity Check

0 steps flagged

No circularity: results are direct empirical measurements

full rationale

The paper presents an empirical evaluation of AdaTrans on a held-out dataset of 104 algorithmic problems, reporting measured compilation pass rate (95.51%) and solve rate (81.09%). No derivation chain, equations, fitted parameters renamed as predictions, or self-citation load-bearing premises appear in the provided text. The central claims rest on experimental outcomes rather than any reduction to inputs by construction, self-definition, or ansatz smuggling. The validation pipeline is an implementation detail whose correctness is an external assumption, not a circular step within a derivation.

Axiom & Free-Parameter Ledger

0 free parameters · 2 axioms · 0 invented entities

The approach rests on the assumption that compiler error messages provide sufficient signal for targeted repair retrieval and that the 104 algorithmic problems form a representative test set; no free parameters or invented entities are described.

axioms (2)
  • domain assumption Compiler error messages can be reliably mapped to effective repair strategies via retrieval-augmented generation.
    This underpins the Strategy-Driven RAG component.
  • domain assumption Functional equivalence can be verified through a multi-stage pipeline on algorithmic problems.
    This supports the reported solve rate and validation claims.

pith-pipeline@v0.9.1-grok · 5687 in / 1294 out tokens · 46817 ms · 2026-07-01T04:22:03.014855+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

57 extracted references · 43 canonical work pages · 3 internal anchors

  1. [1]

    Wasi Ahmad, Saikat Chakraborty, Baishakhi Ray, and Kai-Wei Chang. 2021. Unified Pre-training for Program Understanding and Genera- tion. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Kristina Toutanova, Anna Rumshisky, Luke Zettlemoyer, Dilek Hakkani-Tur, ...

    work page doi:10.18653/v1/2021.naacl-main.211 2021

  2. [2]

    Xuemeng Cai, Jiakun Liu, Xiping Huang, Yijun Yu, Haitao Wu, Chunmiao Li, Bo Wang, Imam Nur Bani Yusuf, and Lingxiao Jiang. 2025. RustMap: Towards Project-Scale C-to-Rust Migration via Program Analysis and LLM. In Engineering of Complex Computer Systems: 29th International Conference, ICECCS 2025, Hangzhou, China, July 2–4, 2025, Proceedings (Hangzhou, Chi...

    2025

  3. [3]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian...

    work page internal anchor Pith review Pith/arXiv arXiv 2021

  4. [4]

    James R. Cordy. 2006. The TXL source transformation language. Science of Computer Programming 61, 3 (2006), 190–210. doi:10.1016/j.scico.2006. 04.002 Special Issue on The Fourth Workshop on Language Descriptions, Tools, and Applications (LDTA ’04)

    work page doi:10.1016/j.scico.2006 2006

  5. [5]

    Mohan Cui, Shuran Sun, Hui Xu, and Yangfan Zhou. 2024. Is unsafe an Achilles’ Heel? A Comprehensive Study of Safety Requirements in Unsafe Rust Programming. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (Lisbon, Portugal) (ICSE ’24). Association for Computing Machinery, New York, NY, USA, Article 106, 13 pages. doi:1...

    work page doi:10.1145/3597503.3639136 2024

  6. [6]

    Sébastien Doeraene. 2013. Scala.js: Type-Directed Interoperability with Dynamically Typed Languages. https://infoscience.epfl.ch/handle/20.500. 14299/97425

    2013

  7. [7]

    Mehmet Emre, Peter Boyland, Aesha Parekh, Ryan Schroeder, Kyle Dewey, and Ben Hardekopf. 2023. Aliasing Limits on Translating C to Safe Rust. Proc. ACM Program. Lang. 7, OOPSLA1, Article 94 (April 2023), 29 pages. doi:10.1145/3586046

    work page doi:10.1145/3586046 2023

  8. [8]

    Mehmet Emre, Ryan Schroeder, Kyle Dewey, and Ben Hardekopf. 2021. Translating C to safer Rust. Proc. ACM Program. Lang. 5, OOPSLA, Article 121 (Oct. 2021), 29 pages. doi:10.1145/3485498

    work page doi:10.1145/3485498 2021

  9. [9]

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. CodeBERT: A Pre-Trained Model for Programming and Natural Languages. In Findings of the Association for Computational Linguistics: EMNLP 2020, Trevor Cohn, Yulan He, and Yang Liu (Eds.). Association for Computational ...

    work page doi:10.18653/v1/2020.findings- 2020

  10. [10]

    Daniel Fried, Armen Aghajanyan, Jessy Lin, Sida Wang, Eric Wallace, Freda Shi, Ruiqi Zhong, Scott Yih, Luke Zettlemoyer, and Mike Lewis. 2023. InCoder: A Generative Model for Code Infilling and Synthesis. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net, Kigali, Rwanda, 26 pages...

    2023

  11. [11]

    Yongfeng Gu, Jifeng Xuan, Hongyu Zhang, Lanxin Zhang, Qingna Fan, Xiaoyuan Xie, and Tieyun Qian. 2019. Does the fault reside in a stack trace? Assisting crash localization by predicting crashing fault residence. Journal of Systems and Software 148 (2019), 88–104. doi:10.1016/j.jss.2018.11.004

    work page doi:10.1016/j.jss.2018.11.004 2019

  12. [12]

    A comparison of index-based

    Mark Harman, S. Afshin Mansouri, and Yuanyuan Zhang. 2012. Search-based software engineering: Trends, techniques and applications. ACM Comput. Surv. 45, 1, Article 11 (Dec. 2012), 61 pages. doi:10.1145/2379776.2379787

    work page doi:10.1145/2379776.2379787 2012

  13. [13]

    Jaemin Hong and Sukyoung Ryu. 2025. Type-migrating C-to-Rust translation using a large language model. Empir. Softw. Eng. 30, 1 (2025), 3. doi:10.1007/S10664-024-10573-2

    work page doi:10.1007/s10664-024-10573-2 2025

  14. [14]

    and Galois, Inc

    Immunant, Inc. and Galois, Inc. 2018. C2Rust: Migrating C Code to Rust. https://github.com/immunant/c2rust. Open-source transpiler. Accessed: 2025. Manuscript submitted to ACM AdaTrans: Automated C-to-Rust Transformation via Error-Adaptive Repair 35

    2018

  15. [15]

    Juyong Jiang, Fan Wang, Jiasi Shen, Sungju Kim, and Sung Hun Kim. 2026. A Survey on Large Language Models for Code Generation. ACM Trans. Softw. Eng. Methodol. 35, 2 (2026), 58:1–58:72. doi:10.1145/3747588

    work page doi:10.1145/3747588 2026

  16. [16]

    Mingsheng Jiao, Tingrui Yu, Xuan Li, Guanjie Qiu, Xiaodong Gu, and Beijun Shen. 2024. On the Evaluation of Neural Code Translation: Taxonomy and Benchmark. In Proceedings of the 38th IEEE/ACM International Conference on Automated Software Engineering (Echternach, Luxembourg) (ASE ’23). IEEE Press, Piscataway, NJ, USA, 1529–1541. doi:10.1109/ASE56229.2023.00114

    work page doi:10.1109/ase56229.2023.00114 2024

  17. [17]

    Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, and Derek Dreyer. 2017. RustBelt: securing the foundations of the Rust programming language. Proc. ACM Program. Lang. 2, POPL, Article 66 (Dec. 2017), 34 pages. doi:10.1145/3158154

    work page doi:10.1145/3158154 2017

  18. [18]

    Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-augmented generation for knowledge-intensive NLP tasks. In Proceedings of the 34th International Conference on Neural Information Processing Systems (V...

    2020

  19. [19]

    Hongyu Li, Liwei Guo, Yexuan Yang, Shangguang Wang, and Mengwei Xu. 2024. An empirical study of rust-for-Linux: the success, dissatisfaction, and compromise. InProceedings of the 2024 USENIX Conference on Usenix Annual Technical Conference (Santa Clara, CA, USA)(USENIX ATC’24). USENIX Association, USA, Article 27, 19 pages

    2024

  20. [20]

    Ruishi Li, Bo Wang, Tianyu Li, Prateek Saxena, and Ashish Kundu. 2025. Translating C To Rust: Lessons from a User Study. In32nd Annual Network and Distributed System Security Symposium, NDSS 2025, San Diego, California, USA, February 24-28, 2025. The Internet Society, Reston, VA, USA, 18 pages. https://www.ndss-symposium.org/ndss-paper/translating-c-to-ru...

    2025

  21. [21]

    Cordy, and Ahmed E

    Michael Ling, Yijun Yu, Haitao Wu, Yuan Wang, James R. Cordy, and Ahmed E. Hassan. 2022. In rust we trust: a transpiler from unsafe C to safer rust. In Proceedings of the ACM/IEEE 44th International Conference on Software Engineering: Companion Proceedings (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 354–3...

    work page doi:10.1145/3510454.3528640 2022

  22. [22]

    Fang Liu, Jia Li, and Li Zhang. 2023. Syntax and Domain Aware Model for Unsupervised Program Translation. InProceedings of the 45th International Conference on Software Engineering (Melbourne, Victoria, Australia) (ICSE ’23). IEEE Press, Piscataway, NJ, USA, 755–767. doi:10.1109/ICSE48619. 2023.00072

    work page doi:10.1109/icse48619 2023

  23. [23]

    Jiaqi Liu, Fengming Zhang, Xin Zhang, Zhiwen Yu, Liang Wang, Yao Zhang, and Bin Guo. 2024. hmCodeTrans: Human–Machine Interactive Code Translation. IEEE Trans. Softw. Eng. 50, 5 (May 2024), 1163–1181. doi:10.1109/TSE.2024.3379583

    work page doi:10.1109/tse.2024.3379583 2024

  24. [24]

    Shaoting Liu, Haiyan Xu, Qi Xin, and Jifeng Xuan. 2026. Exceptions Can Be Nested: An Exploratory Study on Nested Exceptions in Java Crashes. Journal of Software: Evolution and Process 38, 4 (2026), e70099. arXiv:https://onlinelibrary.wiley.com/doi/pdf/10.1002/smr.70099 doi:10.1002/smr. 70099

    work page doi:10.1002/smr.70099 2026

  25. [25]

    Xiaofan Liu, Zecan Li, Zhuang Zhao, Ziqi Shuai, and Jifeng Xuan. 2025. AdaTrans Replication Package. https://github.com/SlainTroyard/adatrans_dev. Source code, prompts, knowledge base, and experimental data

    2025

  26. [26]

    Feng Luo, Kexing Ji, Cuiyun Gao, Shuzheng Gao, Jia Feng, Kui Liu, Xin Xia, and Michael R. Lyu. 2025. Integrating Rules and Semantics for LLM-Based C-to-Rust Translation . In2025 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE Computer Society, Los Alamitos, CA, USA, 685–696. doi:10.1109/ICSME64153.2025.00069

    work page doi:10.1109/icsme64153.2025.00069 2025

  27. [27]

    Marcos Macedo, Yuan Tian, Filipe Cogo, and Bram Adams. 2024. Exploring the Impact of the Output Format on the Evaluation of Large Language Models for Code Translation. InProceedings of the 2024 IEEE/ACM First International Conference on AI Foundation Models and Software Engineering (Lisbon, Portugal) (FORGE ’24). Association for Computing Machinery, New Y...

    work page doi:10.1145/3650105.3652301 2024

  28. [28]

    Aniketh Malyala, Katelyn Zhou, Baishakhi Ray, and Saikat Chakraborty. 2023. On ML-Based Program Translation: Perils and Promises. InProceedings of the 45th International Conference on Software Engineering: New Ideas and Emerging Results (Melbourne, Australia)(ICSE-NIER ’23). IEEE Press, Piscataway, NJ, USA, 60–65. doi:10.1109/ICSE-NIER58687.2023.00017

    work page doi:10.1109/icse-nier58687.2023.00017 2023

  29. [29]

    Matsakis and Felix S

    Nicholas D. Matsakis and Felix S. Klock. 2014. The rust language. In Proceedings of the 2014 ACM SIGAda Annual Conference on High Integrity Language Technology (Portland, Oregon, USA) (HILT ’14). Association for Computing Machinery, New York, NY, USA, 103–104. doi:10.1145/ 2663171.2663188

    work page arXiv 2014

  30. [30]

    Matsakis and Felix S

    Nicholas D. Matsakis and Felix S. Klock. 2014. The rust language. Ada Lett. 34, 3 (Oct. 2014), 103–104. doi:10.1145/2692956.2663188

    work page doi:10.1145/2692956.2663188 2014

  31. [31]

    McKeeman

    William M. McKeeman. 1998. Differential Testing for Software. Digital Technical Journal 10, 1 (1998), 100–107

    1998

  32. [32]

    OpenAI. 2024. Models - GPT-4o-mini. https://platform.openai.com/docs/models/gpt-4o-mini. Accessed: 2026-06-08

    2024

  33. [33]

    OpenAI, Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, Red Avila, Igor Babuschkin, Suchir Balaji, Valerie Balcom, Paul Baltescu, Haiming Bao, Mohammad Bavarian, Jeff Belgum, Irwan Bello, Jake Berdine, Gabriel Bernadett-Shapiro, Christopher Berner...

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  34. [34]

    Pendyala and Neha Bais Thakur

    Vishnu S. Pendyala and Neha Bais Thakur. 2026. Rosetta-XAI: An automated evaluation and explainability framework for code translation models. Software Impacts 27 (2026), 100811. doi:10.1016/j.simpa.2026.100811

    work page doi:10.1016/j.simpa.2026.100811 2026

  35. [35]

    Boqin Qin, Yilun Chen, Zeming Yu, Linhai Song, and Yiying Zhang. 2020. Understanding memory and thread safety practices and issues in real-world Rust programs. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (London, UK) (PLDI 2020). Association for Computing Machinery, New York, NY, USA, 763–779. doi:10...

    work page doi:10.1145/3385412.3386036 2020

  36. [36]

    Baptiste Roziere, Marie-Anne Lachaux, Lowik Chanussot, and Guillaume Lample. 2020. Unsupervised translation of programming languages. In Proceedings of the 34th International Conference on Neural Information Processing Systems (Vancouver, BC, Canada)(NIPS ’20). Curran Associates Inc., Red Hook, NY, USA, Article 1730, 11 pages

    2020

  37. [37]

    Baptiste Rozière, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, Jérémy Rapin, Artyom Kozhevnikov, Ivan Evtimov, Joanna Bitton, Manish Bhatt, Cristian Canton Ferrer, Aaron Grattafiori, Wenhan Xiong, Alexandre Défossez, Jade Copet, Faisal Azhar, Hugo Touvron, Louis Martin, Nico...

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  38. [38]

    Freda Shi, Daniel Fried, Marjan Ghazvininejad, Luke Zettlemoyer, and Sida I. Wang. 2022. Natural Language to Code Translation with Execution. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, Yoav Goldberg, Zornitsa Kozareva, and Yue Zhang (Eds.). Association for Computational Linguistics, Abu Dhabi, United Arab Em...

    work page doi:10.18653/v1/2022.emnlp-main.231 2022

  39. [39]

    Weisong Sun, Chunrong Fang, Yuchen Chen, Guanhong Tao, Tingxu Han, and Quanjun Zhang. 2022. Code search based on context-aware code translation. In Proceedings of the 44th International Conference on Software Engineering (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 388–400. doi:10.1145/3510003.3510140

    work page doi:10.1145/3510003.3510140 2022

  40. [40]

    Bo Wang, Aashish Kolluri, Ivica Nikolić, Teodora Baluta, and Prateek Saxena. 2023. User-Customizable Transpilation of Scripting Languages. Proc. ACM Program. Lang. 7, OOPSLA1, Article 82 (April 2023), 29 pages. doi:10.1145/3586034

    work page doi:10.1145/3586034 2023

  41. [41]

    Bo Wang, Ruishi Li, Mingkai Li, and Prateek Saxena. 2023. TransMap: Pinpointing Mistakes in Neural Code Translation. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (San Francisco, CA, USA) (ESEC/FSE 2023). Association for Computing Machinery, New York, NY, USA, 999–101...

    work page doi:10.1145/3611643.3616322 2023

  42. [42]

    Chaofan Wang, Tingrui Yu, Chen Xie, Jie Wang, Dong Chen, Wenrui Zhang, Yuling Shi, Xiaodong Gu, and Beijun Shen. 2026. EvoC2Rust: A Skeleton-guided Framework for Project-Level C-to-Rust Translation. 12 pages. https://arxiv.org/abs/2508.04295

    work page arXiv 2026

  43. [43]

    Le, Ed H

    Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc V. Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2023. Self-Consistency Improves Chain of Thought Reasoning in Language Models. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net, Amherst, MA, USA, 24 pages. https:...

    2023

  44. [44]

    Yue Wang, Weishi Wang, Shafiq Joty, and Steven C.H. Hoi. 2021. CodeT5: Identifier-aware Unified Pre-trained Encoder-Decoder Models for Code Understanding and Generation. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, Marie-Francine Moens, Xuanjing Huang, Lucia Specia, and Scott Wen-tau Yih (Eds.). Association fo...

    work page doi:10.18653/v1/2021.emnlp-main.685 2021

  45. [45]

    Weisz, Michael Muller, Stephanie Houde, John Richards, Steven I

    Justin D. Weisz, Michael Muller, Stephanie Houde, John Richards, Steven I. Ross, Fernando Martinez, Mayank Agarwal, and Kartik Talamadupula

  46. [46]

    InProceedings of the 26th International Conference on Intelligent User Interfaces (College Station, TX, USA) (IUI ’21)

    Perfection Not Required? Human-AI Partnerships in Code Translation. InProceedings of the 26th International Conference on Intelligent User Interfaces (College Station, TX, USA) (IUI ’21). Association for Computing Machinery, New York, NY, USA, 402–412. doi:10.1145/3397481.3450656 Manuscript submitted to ACM AdaTrans: Automated C-to-Rust Transformation via...

    work page doi:10.1145/3397481.3450656

  47. [47]

    Chunqiu Steven Xia, Yuxiang Wei, and Lingming Zhang. 2023. Automated Program Repair in the Era of Large Pre-Trained Language Models. In Proceedings of the 45th International Conference on Software Engineering (Melbourne, Victoria, Australia) (ICSE ’23). IEEE Press, Piscataway, NJ, USA, 1482–1494. doi:10.1109/ICSE48619.2023.00129

    work page doi:10.1109/icse48619.2023.00129 2023

  48. [48]

    Yingfei Xiong, Jie Wang, Runfa Yan, Jiachen Zhang, Shi Han, Gang Huang, and Lu Zhang. 2017. Precise condition synthesis for program repair. In Proceedings of the 39th International Conference on Software Engineering (Buenos Aires, Argentina) (ICSE ’17). IEEE Press, Piscataway, NJ, USA, 416–426. doi:10.1109/ICSE.2017.45

    work page doi:10.1109/icse.2017.45 2017

  49. [49]

    Jifeng Xuan, He Jiang, Yan Hu, Zhilei Ren, Weiqin Zou, Zhongxuan Luo, and Xindong Wu. 2015. Towards Effective Bug Triage with Software Data Reduction Techniques. IEEE Trans. Knowl. Data Eng. 27, 1 (2015), 264–280. doi:10.1109/TKDE.2014.2324590

    work page doi:10.1109/tkde.2014.2324590 2015

  50. [50]

    Jifeng Xuan, He Jiang, Zhilei Ren, and Zhongxuan Luo. 2012. Solving the Large Scale Next Release Problem with a Backbone-Based Multilevel Algorithm. IEEE Trans. Software Eng. 38, 5 (2012), 1195–1212. doi:10.1109/TSE.2011.92

    work page doi:10.1109/tse.2011.92 2012

  51. [51]

    Jifeng Xuan, Matias Martinez, Favio DeMarco, Maxime Clément, Sebastian Lamelas Marcote, Thomas Durieux, Daniel Le Berre, and Martin Monperrus. 2017. Nopol: Automatic Repair of Conditional Statement Bugs in Java Programs. IEEE Transactions on Software Engineering 43, 1 (2017), 34–55. doi:10.1109/TSE.2016.2560811

    work page doi:10.1109/tse.2016.2560811 2017

  52. [52]

    Jifeng Xuan and Martin Monperrus. 2014. Test case purification for improving fault localization. In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (Hong Kong, China) (FSE 2014). Association for Computing Machinery, New York, NY, USA, 52–63. doi:10.1145/2635868.2635906

    work page doi:10.1145/2635868.2635906 2014

  53. [53]

    Xuejun Yang, Yang Chen, Eric Eide, and John Regehr. 2011. Finding and understanding bugs in C compilers. SIGPLAN Not. 46, 6 (June 2011), 283–294. doi:10.1145/1993316.1993532

    work page doi:10.1145/1993316.1993532 2011

  54. [54]

    Xuejun Yang, Yang Chen, Eric Eide, and John Regehr. 2011. Finding and understanding bugs in C compilers. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (San Jose, California, USA) (PLDI ’11). Association for Computing Machinery, New York, NY, USA, 283–294. doi:10.1145/1993498.1993532

    work page doi:10.1145/1993498.1993532 2011

  55. [55]

    Zhiqiang Yuan, Wenjun Mao, Zhuo Chen, Xiyue Shang, Chong Wang, Yiling Lou, and Xin Peng. 2026. Project-Level C-to-Rust Translation via Synergistic Integration of Knowledge Graphs and Large Language Models. Proceedings of the ACM on Software Engineering 3, FSE, Article 162 (July 2026), 24 pages. Conference: ACM SIGSOFT International Symposium on the Founda...

    2026

  56. [56]

    Qihao Zhu, Qingyuan Liang, Zeyu Sun, Yingfei Xiong, Lu Zhang, and Shengyu Cheng. 2024. GrammarT5: Grammar-Integrated Pretrained Encoder- Decoder Neural Model for Code. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (Lisbon, Portugal) (ICSE ’24). Association for Computing Machinery, New York, NY, USA, Article 76, 13 pa...

    work page doi:10.1145/3597503.3639125 2024

  57. [57]

    Yuqi Zhu, Jia Li, Ge Li, Yunfei Zhao, Jia Li, Zhi Jin, and Hong Mei. 2024. Hot or Cold? Adaptive Temperature Sampling for Code Generation with Large Language Models. In Thirty-Eighth AAAI Conference on Artificial Intelligence, AAAI 2024, Thirty-Sixth Conference on Innovative Applications of Artificial Intelligence, IAAI 2024, Fourteenth Symposium on Educa...

    work page doi:10.1609/aaai.v38i1.27798 2024