EVOC2RUST: A Skeleton-guided Framework for Project-Level C-to-Rust Translation

2025-08-06

AI Summary

Addressing three key challenges in full-project-level automated C-to-Rust translation—scalable adaptation, poor semantic equivalence, and insufficient memory safety—this paper proposes a skeleton-guided, three-stage evolutionary framework. The method leverages static analysis and feature-mapping-enhanced large language models (LLMs) for modular decomposition and incremental translation, integrated with type checking, stub generation, and compiler-error repair techniques. Crucially, it innovatively combines rule-based systems with LLMs for collaborative reasoning, thereby enhancing memory safety guarantees without compromising syntactic or semantic fidelity. Evaluated on industrial-scale projects, the approach achieves a 92.25% compilation success rate and an 89.53% test pass rate. It improves syntactic and semantic accuracy by 17.24% and 14.32%, respectively, and boosts memory safety compliance by 96.79% over baseline methods.

Technology Category

• Natural Language Processing: Safety and Robustness
• Machine Learning: Large Multimodal Models (LMMs)
• Planning, Routing, and Scheduling: Planning with Language Models

Application Category

• Semantics and Knowledge: Methods to enhance, augment, integrate or synergize semantic models such as knowledge graphs and LLMs
• Search and Retrieval-Augmented AI: Retrieval-Augmented Generation (RAG) and multi-modal RAG
• Economics, Online Markets and Human Computation: Cost models of using LLMs in production systems

Abstract

Rust's compile-time safety guarantees make it ideal for safety-critical systems, creating demand for translating legacy C codebases to Rust. While various approaches have emerged for this task, they face inherent trade-offs: rule-based solutions face challenges in meeting code safety and idiomaticity requirements, while LLM-based solutions often fail to generate semantically equivalent Rust code, due to the heavy dependencies of modules across the entire codebase. Recent studies have revealed that both solutions are limited to small-scale programs. In this paper, we propose EvoC2Rust, an automated framework for converting entire C projects to equivalent Rust ones. EvoC2Rust employs a skeleton-guided translation strategy for project-level translation. The pipeline consists of three evolutionary stages: 1) it first decomposes the C project into functional modules, employs a feature-mapping-enhanced LLM to transform definitions and macros and generates type-checked function stubs, which form a compilable Rust skeleton; 2) it then incrementally translates the function, replacing the corresponding stub placeholder; 3) finally, it repairs compilation errors by integrating LLM and static analysis. Through evolutionary augmentation, EvoC2Rust combines the advantages of both rule-based and LLM-based solutions. Our evaluation on open-source benchmarks and six industrial projects demonstrates EvoC2Rust's superior performance in project-level C-to-Rust translation. On average, it achieves 17.24% and 14.32% improvements in syntax and semantic accuracy over the LLM-based approaches, along with a 96.79% higher code safety rate than the rule-based tools. At the module level, EvoC2Rust reaches 92.25% compilation and 89.53% test pass rates on industrial projects, even for complex codebases and long functions.

Problem

• Automated translation of entire C projects to Rust
• Ensuring semantic equivalence and code safety in translation
• Overcoming limitations of rule-based and LLM-based solutions

Innovation

• Skeleton-guided translation for project-level conversion
• Feature-mapping-enhanced LLM for type-checked stubs
• Evolutionary augmentation combining LLM and static analysis