Mostly Automatic Translation of Language Interpreters from C to Safe Rust

• URL: http://arxiv.org/abs/2606.27122v1
• Date: Thu, 25 Jun 2026 14:59:08 GMT
• Title: Mostly Automatic Translation of Language Interpreters from C to Safe Rust
• Abstract summary: We present Reboot, a technique that translates real-world interpreter programs from C to safe Rust.<n>We have translated six interpreters ranging from 6k to 23k lines of C code to safe Rust, with each translation requiring only 1 to 11 brief user interventions.<n>All translations pass 100% of the provided test suites, and achieve 62%--92% pass rates on separately created validation tests.
• Score: 9.34230791716657
• License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
• Abstract: Translating C programs to safe Rust is challenging owing to significant differences in typing constraints, ownership, and borrowing rules. Interpreter programs are particularly important targets for such translation, as they often handle untrusted inputs and suffer from memory-related vulnerabilities. We present Reboot, a mostly-automatic technique that translates real-world interpreter programs from C to safe Rust. Using Reboot, we have translated six interpreters ranging from 6k to 23k lines of C code to safe Rust, with each translation requiring only 1 to 11 brief user interventions. All translations pass 100% of the provided test suites, and achieve 62%--92% pass rates on separately created validation tests that were never exposed to the system. A security case study on mujs shows that memory vulnerabilities such as heap buffer overflows and use-after-free present in C are eliminated in the safe Rust translation. Two ideas underpin Reboot. First, feature reduction decomposes the translation by program features, creating a sequence of milestones where each is a complete, testable program; the translation starts from the simplest version and incrementally restores features, with each milestone validated before proceeding. Second, a multi-agent architecture orchestrates inherently unreliable coding agents through automated validation and feedback, keeping long-running translation workflows on track with minimal human involvement. An ablation study confirms that feature reduction improves translation correctness compared to using multi-agent translation alone, with 6%--20% improvements in pass rates on validation test suites.

Related papers

• Defending Jailbreak Attacks on Large Language Models via Manifold Trajectory Kinetics [50.36375380196006]
  Jailbreak prompts can bypass alignment guardrails in large language models.<n>Prior detection approaches largely rely on a fixed metric space.<n>We show this assumption breaks under (i) pseudo-malicious prompts that are benign by intent but contain safety-related keywords.<n>We present Manifold Trajectory Kinetics (MTK), which treats an LLM as a kinetic system transforming inputs into outputs.
  arXiv  Detail & Related papers  (2026-06-05T14:49:26Z)
• Finding a Crab in the C: Assured Translation via Comparative Symbolic Execution [0.0]
  cozy is a comparative binary analysis tool that analyzes a binary compiled from "unsafe" source code and a binary compiled from a translation of the source code to a memory safe language.<n> cozy walks the developer through differences in the behavior of the two binaries, presenting each difference and asking the user to assess whether the difference is intentional (good) or erroneous.<n> cozy has applications to automated translation, bug correction, code reviews, operation authorization, and automatic translation.
  arXiv  Detail & Related papers  (2026-05-12T20:33:33Z)
• Translating Large-Scale C Repositories to Idiomatic Rust [12.221834497939897]
  Existing C to Rust translation techniques fail to balance quality and scalability.<n>This paper proposes Rustine, a fully automated pipeline for effective and efficient repository-level C to idiomatic safe Rust translation.
  arXiv  Detail & Related papers  (2025-11-25T18:42:46Z)
• EffiReasonTrans: RL-Optimized Reasoning for Code Translation [48.862761776440635]
  EffiReasonTrans is a training framework designed to improve translation accuracy while balancing inference latency.<n>EffiReasonTrans consistently improves translation accuracy (up to +49.2% CA and +27.8% CodeBLEU compared to the base model) while reducing the number of generated tokens.
  arXiv  Detail & Related papers  (2025-10-21T17:55:39Z)
• Adversarial Agent Collaboration for C to Rust Translation [13.65848262530917]
  ACToR translates all of the 63 real-world command line utilities considered in our benchmarks.<n>It achieves over 90% test pass rate with zero human intervention.<n>It is the first such system that reliably translates C programs of this scale.
  arXiv  Detail & Related papers  (2025-10-04T17:08:36Z)
• SafeTrans: LLM-assisted Transpilation from C to Rust [5.6274106543826585]
  Rust is a strong contender for a memory-safe alternative to C as a "systems" programming language.<n>In this paper, we evaluate the potential of large language models (LLMs) to automate the transpilation of C code to Rust.<n>We present the design and implementation of SafeTrans, a framework that uses LLMs to i) transpile C code into Rust and ii) iteratively fix any compilation and runtime errors.
  arXiv  Detail & Related papers  (2025-05-15T21:05:33Z)
• CRUST-Bench: A Comprehensive Benchmark for C-to-safe-Rust Transpilation [51.18863297461463]
  CRUST-Bench is a dataset of 100 C repositories, each paired with manually-written interfaces in safe Rust as well as test cases.<n>We evaluate state-of-the-art large language models (LLMs) on this task and find that safe and idiomatic Rust generation is still a challenging problem.<n>The best performing model, OpenAI o1, is able to solve only 15 tasks in a single-shot setting.
  arXiv  Detail & Related papers  (2025-04-21T17:33:33Z)
• LLM-Driven Multi-step Translation from C to Rust using Static Analysis [27.122409727034192]
  Translating software written in legacy languages to modern languages, such as C to Rust, has significant benefits in improving memory safety.<n>We propose SACTOR, an LLM-driven C-to-Rust zero-shot translation tool using a two-step translation methodology.<n>SACTOR produces more natural and Rust-compliant translations compared to existing methods.
  arXiv  Detail & Related papers  (2025-03-16T14:05:26Z)
• RustRepoTrans: Repository-level Code Translation Benchmark Targeting Rust [50.65321080814249]
  RustRepoTrans is the first repository-level context code translation benchmark targeting incremental translation.<n>We evaluate seven representative LLMs, analyzing their errors to assess limitations in complex translation scenarios.
  arXiv  Detail & Related papers  (2024-11-21T10:00:52Z)
• Mitigating Hallucinations and Off-target Machine Translation with Source-Contrastive and Language-Contrastive Decoding [53.84948040596055]
  We introduce two related methods to mitigate failure cases with a modified decoding objective. Experiments on the massively multilingual models M2M-100 (418M) and SMaLL-100 show that these methods suppress hallucinations and off-target translations.
  arXiv  Detail & Related papers  (2023-09-13T17:15:27Z)
• Zero-Shot Cross-lingual Semantic Parsing [56.95036511882921]
  We study cross-lingual semantic parsing as a zero-shot problem without parallel data for 7 test languages. We propose a multi-task encoder-decoder model to transfer parsing knowledge to additional languages using only English-Logical form paired data. Our system frames zero-shot parsing as a latent-space alignment problem and finds that pre-trained models can be improved to generate logical forms with minimal cross-lingual transfer penalty.
  arXiv  Detail & Related papers  (2021-04-15T16:08:43Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.