Program Translation Models

• Program translation models are systems that automatically convert code between programming languages while preserving both syntax and semantics.
• They integrate machine translation, programming language theory, and software engineering to address challenges like code migration, cross-platform integration, and validation using metrics such as BLEU and CodeBLEU.
• Modern methods leverage deep learning, Transformers, and hybrid neuro-symbolic pipelines along with execution-based tests to ensure accurate and reliable translations.

Program translation models are systems designed to automatically transform code written in one programming language into functionally equivalent code in another. These models address the increasing need for software modernization, interoperability, and cross-platform development by facilitating the migration and integration of code across diverse programming ecosystems. The design and evaluation of program translation models combine principles from machine translation, programming language theory, and software engineering, and the field has rapidly advanced through classical rule-based approaches, statistical models, and more recently, deep learning and LLMs.

1. Core Principles and Evaluation Metrics

Effective program translation demands both syntactic fidelity and semantic preservation. Two principal metrics are widely adopted to quantitatively evaluate translation quality:

• BLEU (Bilingual Evaluation Understudy): Measures surface-level n-gram overlap between the candidate translation and one or more reference translations, factoring in a brevity penalty to prevent excessively short outputs. BLEU is formally defined as:

$$\text{BLEU} = BP \cdot \exp\left( \sum_{n=1}^N w_n \cdot \log p_n \right)$$

where $p_n$ is the precision of matched n-grams, $w_n$ are typically uniform weights, and $BP$ is the brevity penalty controlled by candidate and reference length (Aljagthami et al., 16 Sep 2025).

• CodeBLEU: Extends BLEU to code-specific properties by augmenting n-gram overlap with weighted token similarity, syntax-aware (AST-based) matching, and data-flow graph overlap. The metric is:

$$\text{CodeBLEU} = \alpha\cdot\mathrm{Sim}_{\text{ngram}} + \beta\cdot\mathrm{Sim}_{\text{weighted}} + \gamma\cdot\mathrm{Sim}_{\text{syntax}} + \delta\cdot\mathrm{Sim}_{\text{dataflow}}$$

Typical default weights are $\alpha=\beta=\gamma=\delta=0.25$ (Aljagthami et al., 16 Sep 2025).

While BLEU primarily assesses syntactic similarity, CodeBLEU provides a more comprehensive reflection of structural and semantic correctness. Many studies now complement these metrics with execution-based tests, such as pass rates on unit test suites ("Computational Accuracy" or CA), to assess true behavioral equivalence (Chen et al., 1 Oct 2025, Yuan et al., 2024).

2. Model Architectures and Translation Paradigms

Sequence-to-Sequence (Seq2Seq) and Transformer Baselines

Initial program translation networks leveraged architectures derivative of neural machine translation, such as multi-layer LSTM-based seq2seq encoders and decoders with attention (Kim et al., 2019). Modern approaches predominantly use Transformer models, sometimes augmented for syntax or dataflow awareness (Liu et al., 2023, Du et al., 2024).

Structure-Aware and Grammar-Constrained Models

Tree-based models exploit the recursive syntactic structure of code. Notably, Tree-to-Tree architectures propagate representations over binarized ASTs, using attention over subtrees to align translation (Chen et al., 2018). Grammar-constrained tree decoders further restrict generation to valid productions of the target language grammar, guaranteeing only syntactically valid outputs (Drissi et al., 2018).

Disentanglement and Multilingual Modeling

Disentanglement-based architectures, such as VIM-PT, introduce latent variables to separately represent language-shared semantics and language-specific syntax. This enables effective cross-lingual transfer, addresses semantic distribution shifts, and dramatically reduces model count for $N$ languages from $O(N^2)$ to $O(N)$ (Du et al., 2024).

Pipeline and Modular Systems

Recent high-performance translation systems orchestrate translation in stages, often combining symbolic (static analysis, program decomposition) and neural (LLM-based synthesis) techniques. These include:

• Skeleton-based approaches: Extract language-agnostic program skeletons with holes for code fragments, then synthesize or repair these fragments using LLMs or synthesizers to achieve global correctness (Wang et al., 10 Apr 2025).
• Multi-agent and neuro-symbolic frameworks: Decompose translation into sub-tasks such as code generation, syntax repair, block alignment, and semantic repair, often assigning each to a specialized agent or module (Yuan et al., 2024, Ibrahimzada et al., 2024).
• Intermediate Representations/Pivots: Translate code via a language-agnostic IR or pivot, constructed through aggressive AST pruning and normalization, then regenerate target code from IR (Huang et al., 2023).

The table summarizes representative architectures and characteristics:

Model/System	Structural Bias	Pipeline Granularity	Guarantees/Scope
Tree2Tree (Chen et al., 2018)	AST-to-AST, subtree attention	Function-level	Syntactic, some semantic
Grammar-driven (Drissi et al., 2018)	Target language grammar enforced	Function-level	Syntactic correctness
CoDist (Huang et al., 2023)	IR-based, code distillation	Function-level	Data-driven, scalable
VIM-PT (Du et al., 2024)	Disentanglement (latent vars)	Snippet/program	Unified multilingual
Skel (Wang et al., 10 Apr 2025)	Skeleton + fragment synthesis	Program-level	Sound-by-construction
AlphaTrans (Ibrahimzada et al., 2024)	Neuro-symbolic, call-graph	Repository-level	Multi-level validation
C2RustXW (Yan et al., 30 Mar 2026)	CFG/DDG-guided, LLM-prompted	Function/file/project	Dependency-aware
TransAGENT (Yuan et al., 2024)	Multi-agent error repair	Function-level	Iterative correctness

3. Prompt Design, Language, and Semantic Abstraction

Prompt Specification

Empirical evaluation demonstrates that prompt formulation significantly influences translation fidelity in LLM-based models. Detailed, bullet-point prompts incorporating explicit instructions on variable preservation, control flow, comment handling, function signatures, and imports yield consistent BLEU/CodeBLEU gains over minimal or ambiguous prompts (ΔBLEU = 3–8, ΔCodeBLEU = 2–6 across directions) (Aljagthami et al., 16 Sep 2025).

Prompt Language

LLMs pretrained with predominantly English corpora exhibit a strong performance bias, with prompts in English outperforming those in Arabic by 13–15% in CodeBLEU and BLEU (Aljagthami et al., 16 Sep 2025). This reflects both pretraining data imbalances and induced misalignment in non-English instruction encodings.

Semantic Intermediate Representations

Translating via semantic abstraction—such as through pseudocode or self-generated natural language explanations—increases zero-shot accuracy, especially on more challenging tasks or flexible→rigid language pairs (e.g., Python→Rust: +13.6 pp pass@10 with the hybrid approach) (Chen et al., 1 Oct 2025, Tang et al., 2023). However, effectiveness depends on the fidelity of the intermediate abstraction; low-quality pseudocode or explanations can degrade performance.

4. Error Diagnosis, Validation, and Repair Methodologies

Syntax and Semantic Error Repair

Contemporary systems address inevitable translation errors using modular debugging strategies:

• Syntax Error Fixers: Iteratively diagnose and patch compilation or parse errors using LLMs guided by compiler output and error localization (Yuan et al., 2024, Yan et al., 30 Mar 2026).
• Semantic Error Fixers: Leverage dynamic instrumentation to trace variable values and control flow, map execution blocks between source and translation, and use LLMs to repair misaligned or divergent program regions (Yuan et al., 2024, Yan et al., 30 Mar 2026).
• Automated Property-Based Testing: Property-driven test harnesses express and enforce both syntactic and semantic postconditions, automatically searching for model settings that yield property-compliant translations (Eniser et al., 2023).

Evaluation Harnesses and Syntactic Unit Testing

Standard metrics fail to reveal persistent elementary syntax errors. Syntactic Unit Test (SUT) suites provide fine-grained, interpretable checks for individual grammar elements across languages, uncovering deficiencies even in top LLMs (e.g., ChatGPT passes only ≈66% of SUTs despite >90% CA in contest-style tests) (Qi et al., 2023).

Multi-Level and Execution-Based Validation

AlphaTrans and C2RustXW implement multi-stage validation: each program fragment is checked for syntactic correctness, in-situ runtime behavior (by replacing Java methods with Python implementations and executing Java tests, or by differential testing on test suites), and functional correctness after translation. Such layered validation approaches provide empirical correctness guarantees even for large, multi-file or repository-scale translation tasks (Ibrahimzada et al., 2024, Yan et al., 30 Mar 2026).

5. Current Limitations and Future Research Directions

Dataset Coverage and Generalization

Many empirical studies are limited by small test sets, language coverage, and the lack of real-world, API-heavy, multi-file program translations. Expanding datasets to include more languages (e.g., Rust, Go) and scaling to realistic codebases remain key pursuits (Aljagthami et al., 16 Sep 2025, Ibrahimzada et al., 2024).

Non-English and Low-Resource Scenarios

Translation quality degrades with non-English prompts due to LLM pretraining biases, and translating into low-resource or emergent languages (e.g., Rust) often exposes limitations in existing models. Approaches that explicitly incorporate semantic abstraction, multitask learning, or collaborative direct/pseudocode strategies show promise for compensating in these regimes (Chen et al., 1 Oct 2025).

Semantic and Behavioral Guarantees

No purely neural system yet provides full semantic or functional correctness guarantees at scale. Hybrid skeleton/fragments frameworks and property-guided search offer partial solutions but rely on comprehensive unit tests and dynamic analysis to ensure behavioral equivalence (Wang et al., 10 Apr 2025, Eniser et al., 2023).

Automated Repair and Human-in-the-Loop

Though LLM-based error repair systems reduce manual effort, challenging failures (e.g., library/API mismatches, structural misalignments) often remain. Interactive workflows that expose error localization and facilitate human review, as in AlphaTrans, reduce the time required to patch residual bugs (Ibrahimzada et al., 2024).

Directions for Improvement

• Integration of richer test-suite–driven losses in training and evaluation.
• Automated mining of parallel or semi-parallel corpora to improve low-resource translation.
• Refinement of IRs and skeleton-based representations to handle larger dependency graphs and multi-module scope.
• Extension of property-based and SUT-based evaluation to support advanced syntactic constructs and additional languages.
• Joint fine-tuning of LLMs on multi-hop or explanation-augmented workflows (Tang et al., 2023, Macedo et al., 2024).

6. Comparative Model Performance and Best Practices

Comparative evaluations consistently show that:

• Detailed and language-matched prompts significantly boost performance.
• Hybrid and modular approaches (skeleton + fragment synthesis, neuro-symbolic, multi-agent repair) outperform monolithic neural generation, especially at scale.
• Translation difficulty is direction-dependent (e.g., Java→C# and Python→C++ are especially challenging due to type systems and control structure idioms) (Aljagthami et al., 16 Sep 2025).
• Execution-based and property-guided validation is essential for production use.

Summary recommendations:

• Use detailed, structured prompts in English whenever feasible.
• Evaluate both surface form (BLEU, CodeBLEU) and executional behavior.
• Prefer modular, structure-aware pipelines for large or complex codebases.
• Employ hybrid direct/pseudocode and intermediate translation strategies to exploit complementary model strengths (Chen et al., 1 Oct 2025, Macedo et al., 2024).
• Augment LLM-based translation with dynamic error localization and automated syntactic/semantic repair.

7. Impact and Outlook

Program translation models are now integral to cross-language interoperability, codebase migration, and software maintenance in heterogeneous environments. The evolution from statistical and purely neural approaches to modular, structure-guided, and property-driven translation marks significant progress in both capabilities and practical applicability. Nevertheless, further advances in robust handling of syntactic and semantic nuances, automated repair, and scalable multi-language modeling are necessary for fully reliable and general program translation systems. Ongoing research is systematically addressing these challenges through deeper integration of static analysis, symbolic reasoning, test-guided repair, and richer intermediate abstractions (Aljagthami et al., 16 Sep 2025, Chen et al., 1 Oct 2025, Ibrahimzada et al., 2024, Du et al., 2024, Yan et al., 30 Mar 2026, Huang et al., 2023, Wang et al., 10 Apr 2025, Qi et al., 2023).