💻 computer science

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

AdaTrans is an automated framework that leverages strategy-driven retrieval, error-adaptive transformation, and multi-stage validation to successfully convert C code into safe, compilable Rust, achieving high pass rates while minimizing unsafe constructs.

Original authors: Xiaofan Liu, Zecan Li, Zhuang Zhao, Ziqi Shuai, Yanming Yang, Qi Xin, Jifeng Xuan

Published 2026-07-01

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Xiaofan Liu, Zecan Li, Zhuang Zhao, Ziqi Shuai, Yanming Yang, Qi Xin, Jifeng Xuan

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: Translating a Dangerous Language into a Safe One

Imagine you have a massive library of old books written in C, a programming language that is incredibly fast and powerful but also notoriously dangerous. In C, the author (the programmer) is the only one responsible for keeping the building safe. If they forget to lock a door (free up memory) or leave a window open (dangling pointer), the whole house can burn down (crash or get hacked).

Now, imagine you want to move all these books into a new building made of Rust. Rust is a modern language that acts like a super-strict building inspector. It won't let you write a book unless you prove, page by page, that every door is locked and every window is secure. If you try to sneak in a dangerous habit, the inspector slams the door in your face and says, "Nope, not allowed."

The Problem:
For decades, moving from C to Rust has been a nightmare.

Manual Labor: Doing it by hand takes forever.
Old Tools: Automated tools exist, but they often cheat. They write the code but hide the dangerous parts behind "unsafe" signs, effectively ignoring the building inspector.
AI Struggles: New Artificial Intelligence (LLMs) can write code, but they are like brilliant writers who don't understand the strict building codes of Rust. They write beautiful stories that the inspector immediately rejects because of a tiny safety violation.

The Solution: AdaTrans
The authors built AdaTrans, a smart system that doesn't just guess; it learns from its mistakes to translate C code into safe Rust code. Think of it as a Master Architect and a Team of Inspectors working together in a loop.

How AdaTrans Works: The Three-Step Dance

The system works in a continuous cycle of Try → Check → Fix. Here is how it handles the process:

1. The "Multi-Stage Inspection" (Phase 1)

When the AI tries to translate a piece of C code, AdaTrans immediately runs it through two tests:

The Syntax Check: Does the code even look like valid Rust? (e.g., missing semicolons).
The Safety & Logic Check: Does it compile without breaking Rust's strict safety rules? And does it actually do what the original C code did?
The Result: If it fails, the system doesn't just say "Error." It categorizes the error. Is it a typo? A safety violation? Or is the logic just wrong?

2. The "Specialized Librarian" (Phase 2: Strategy-Driven RAG)

This is the brain of the operation. Instead of just showing the AI the raw error message (which is often confusing), AdaTrans acts like a specialized librarian.

If the error is a typo (Syntax), the librarian hands the AI a "Grammar Fix" cheat sheet.
If the error is about safety (Ownership), the librarian hands over a "Rust Safety Manual" with specific examples of how to handle memory safely.
If the error is about logic (the code runs but gives the wrong answer), the librarian gives the AI a "Creative Thinking" prompt to rethink the whole algorithm.

The Analogy: Imagine you are trying to fix a car.

If the tire is flat, you don't call a mechanic to rebuild the engine; you just get a tire patch kit.
If the engine is making a weird noise, you don't just tighten a bolt; you need a deep diagnostic.
AdaTrans ensures the AI gets the right tool for the specific problem.

3. The "Adaptive Temperature" (Phase 3: ESTS)

This is the secret sauce. When the AI tries to fix the code, it has to decide how "creative" or "cautious" to be. AdaTrans controls this using a "temperature" dial:

Low Temperature (Cautious): For simple typos, the AI is told to be very precise and stick to the rules. No wild guesses.
Medium Temperature (Balanced): For safety errors, the AI is told to explore a few different ways to organize the memory, but stay within the rules.
High Temperature (Creative): If the code is logically wrong (e.g., the math is off), the AI is told to be wild and try completely new structures. It needs to break out of its current thinking pattern to find the right solution.

The "Stuck" Detector:
If the AI keeps making the same mistake over and over (like a dog chasing its tail), AdaTrans notices this "stagnation." It hits a RESET button, throws away the current attempt, and starts fresh from the original C code with a clean slate. This prevents the AI from wasting time on a dead end.

The Results: Did It Work?

The authors tested this on 104 different programming puzzles (sourced from LeetCode contests that the AI hadn't seen before).

Success Rate: AdaTrans successfully translated about 81% of the problems into Rust code that was both safe (no dangerous "unsafe" blocks) and correct (passed all tests).
Comparison:
- Old AI (Zero-shot): Without this special system, the AI only got about 25% right on the first try. Even if you let it try 100 times randomly, it only got to 70%. AdaTrans got 81% in a single, smart, iterative process.
- Old Tools: Traditional tools (like c2rust) could compile the code, but they filled it with "unsafe" blocks (cheating the safety rules). AdaTrans kept the code 99% safe.
- Other AI Tools: Other recent AI tools struggled to get past 20% success because they couldn't handle the complex logic errors.

The Takeaway

AdaTrans proves that you don't need to choose between "fast translation" and "safe code." By teaching the AI to:

Listen to the specific type of error,
Consult the right expert knowledge for that error, and
Adjust its creativity level based on the difficulty,

...it can successfully migrate dangerous old code into modern, safe code. It's like giving the AI a map, a compass, and a guide who knows exactly when to walk carefully and when to take a leap of faith.

Technical Summary: AdaTrans

Problem Statement
The automated transformation of C code to Rust remains a significant engineering challenge due to Rust's strict ownership, borrowing, and lifetime systems. While Large Language Models (LLMs) show promise in code generation, they frequently produce Rust code that violates ownership rules or relies heavily on unsafe blocks to bypass the borrow checker. Existing approaches suffer from three primary limitations: (1) general-purpose LLMs struggle to cross the semantic barrier between C's manual memory management and Rust's affine type system; (2) current methods underutilize compiler feedback for iterative repair, often treating diagnostics as superficial syntactic issues rather than structural conflicts; and (3) without targeted verification, generated code tends to circumvent safety constraints rather than satisfy them, leading to functional inequivalence or memory unsafety.

Methodology: The AdaTrans Framework
AdaTrans is an end-to-end framework designed for the file-level transformation of self-contained C modules. It operates through a closed-loop, three-phase generate-verify-repair pipeline that adapts repair strategies based on the specific type of failure signal observed.

Multi-Stage Validation (Phase 1):
The framework employs a deterministic oracle to evaluate candidate Rust code. This pipeline first invokes the Rust compiler (cargo build) to detect syntax, linking, and ownership errors. If the code compiles, it proceeds to dynamic execution against a fuzz-based test suite to verify functional equivalence (I/O consistency) with the original C program. This stage extracts diagnostic signals (compiler error codes and test failures) to guide subsequent repairs.
Strategy-Driven Retrieval-Augmented Generation (RAG) (Phase 2):
To bridge the gap between raw compiler diagnostics and structured repair context, AdaTrans utilizes a Rust Violation-Fix Graph (RVFG). This graph maps specific compiler error signatures (e.g., E0597) to semantic anchors, which include:
- Repair Templates: Role-specific meta-prompts (e.g., syntax-correction, ownership-reasoning, algorithmic-reflection).
- Knowledge Snippets: Official Rust documentation relevant to the error category.
  This mechanism ensures that the LLM receives targeted guidance rather than raw error messages, steering it away from unsafe shortcuts and toward idiomatic solutions.
Error-Stratified Transformation Strategy (ESTS) (Phase 3):
AdaTrans classifies diagnostic signals into four semantic categories and adapts the LLM's sampling behavior (temperature) accordingly:
- Syntactic-Linking (SL): Rigid errors (e.g., missing semicolons) are addressed with low-entropy sampling ( $\theta=0.1$ ) for precise, deterministic fixes.
- Memory-Semantic (MS): Ownership and lifetime conflicts are addressed with moderate-entropy sampling ( $\theta=0.5$ ) to explore alternative memory management patterns (e.g., cloning vs. borrowing).
- Logic-Behavioral (LB): Functional failures (compiles but wrong output) are addressed with high-entropy sampling ( $\theta=1.2$ ) to escape local optima and trigger significant algorithmic restructuring.
- Ambiguous-Fallback (AF): Unseen errors default to baseline exploration.
  Additionally, a Local-Loop Stagnation Escape mechanism resets the repair trajectory if the same error category persists for more than three consecutive iterations, preventing infinite loops.

Key Contributions

A Compiler-Feedback-Driven Framework: AdaTrans introduces a three-phase pipeline specifically designed for controlled file-level migration, integrating compiler diagnostics and execution feedback into a unified repair loop.
Operational Error-Stratified Repair (ESTS): The paper proposes a strategy that categorizes errors and dynamically adjusts generation diversity (temperature) to match the rigidity of the constraint, balancing exploitation for syntax fixes with exploration for algorithmic mutations.
Strategy-Driven RAG: A novel retrieval mechanism that maps error signatures to specific repair templates and domain knowledge, providing structured guidance beyond raw compiler messages.
Empirical Study of Correctness-Safety Trade-offs: The authors provide a rigorous evaluation of transformation correctness versus memory safety under a fixed LLM backbone.

Experimental Results
The framework was evaluated on a dataset of 104 algorithmic problems from LeetCode Weekly Contests (released after the LLM's knowledge cutoff to mitigate contamination). The evaluation compared AdaTrans against three existing LLM-based tools (EvoC2Rust, Tymcrat, PtrTrans), a zero-shot LLM baseline, and the traditional AST-level transpiler c2rust.

Performance: AdaTrans achieved a mean compilation pass rate of 95.51% and a mean solve rate of 81.09% across three independent runs.
Comparison: AdaTrans improved the solve rate over the strongest existing LLM-based tool (Tymcrat) by 59.94 percentage points. It also outperformed the zero-shot LLM baseline (pass@100) by 10.51 percentage points while using significantly fewer tokens (approx. 1/3 the cost).
Safety: The framework maintained a mean unsafe file rate of 1.19%, a stark contrast to c2rust, which produced unsafe code in 100% of its compilable outputs (97.94% of lines of code).
Ablation: Removing the ESTS module reduced the solve rate by ~12%, and removing the RAG module reduced it by ~10%. Removing both caused a drop of ~34%, demonstrating their synergistic effect.

Significance and Claims
The paper claims that AdaTrans demonstrates that adapting repair strategies to the semantic characteristics of compiler diagnostics can successfully reconcile transformation correctness with memory safety. By isolating the semantic core of file-level transformation, the authors show that iterative repair guided by error-stratified strategies and targeted knowledge retrieval can achieve high functional equivalence without relying on unsafe blocks. The work suggests that while general-purpose LLMs struggle with the non-local nature of Rust ownership, a structured, feedback-driven approach can effectively navigate the semantic barrier between C and Rust. The authors position this as a step toward safer, automated migration of legacy C codebases, particularly for self-contained modules where functional equivalence can be rigorously verified.