Bootstrapping Code Translation with Weighted Multilanguage Exploration

1. Problem Statement

The paper addresses two critical bottlenecks in multilingual code translation (translating code between languages like Python, Java, and C++):

1. Data Scarcity & Lack of Oracles: High-quality parallel code datasets are scarce. Even when available, they often lack executable test cases (oracles) required to verify functional correctness. Existing unsupervised methods rely on massive monolingual corpora but fail to optimize for functional equivalence, focusing instead on syntactic similarity.
2. Optimization Imbalance: In Reinforcement Learning from Verifiable Rewards (RLVR), different translation directions (e.g., Python $\to$ Java vs. Python $\to$ C++) have varying levels of difficulty. Standard uniform optimization causes the model to over-fit to "easier" directions where rewards are easily obtained, leading to performance stagnation or oscillation on "harder" directions.

2. Methodology: BootTrans

The authors propose BootTrans, a bootstrapping framework that combines multilingual exploration with language-aware weighting. The method operates without ground-truth parallel code, relying instead on a single resource-rich "pivot" language (e.g., Python) and its unit tests.

A. Bootstrapping Multilanguage Exploration

To overcome data scarcity, BootTrans uses a Dual-Pool Architecture to progressively expand the training curriculum:

• Seed Pool ($D_{seed}$): Contains the initial dataset of source code and unit tests in the pivot language (e.g., Python). The unit tests are translated to target languages using rule-based methods (leveraging the functional invariance of tests).
• Exploration Pool ($D_{explore}$): A dynamic FIFO queue that stores verified rollouts generated by the policy model.
  • Process: The model generates translations for source code from both pools. If a generated translation passes the target language's unit tests, it is added to the Exploration Pool.
  • Expansion: These verified translations then serve as new source inputs for subsequent iterations. This allows the model to learn reverse (e.g., Java $\to$ Python) and cross-lingual (e.g., Java $\to$ C++) translations that were not present in the original seed data, effectively bootstrapping a full $L \times L$ translation matrix.
• Reward Mechanism: Uses a binary reward ($R=1$ if the code compiles and passes all tests; $R=0$ otherwise), ensuring optimization is driven by functional correctness rather than surface similarity.

B. Language-Aware Weight Optimization

To solve the optimization imbalance, the authors introduce a dynamic weighting mechanism based on relative performance across sibling languages:

• Concept: For a given source code, if the model performs well on "sibling" target languages (e.g., Python $\to$ Java) but poorly on a specific target (e.g., Python $\to$ C++), the learning signal for the difficult direction should be amplified.
• Weight Calculation: The weight $w_{i,k}$ for translating to language $L_k$ is computed as:
  $$w_{i,k} = \frac{R_{i, \neg k}}{R_{i,k} + R_{i, \neg k}}$$
  Where $R_{i,k}$ is the cumulative reward for language $k$, and $R_{i, \neg k}$ is the aggregate reward for all other sibling languages.
• Effect: This forces the model to focus on "lagging" directions where the model has semantic understanding (proven by sibling success) but struggles with syntactic or idiomatic hurdles.
• Algorithm: The method employs Group Relative Policy Optimization (GRPO) with these dynamic weights to update the policy.

3. Key Contributions

1. Pivot-Based Bootstrapping: A novel method to construct a verifiable multilingual corpus using a single resource-rich pivot language and portable unit tests, eliminating the need for parallel code.
2. Dual-Pool Exploration: An architecture that enables the model to self-generate and verify training data, unlocking reverse and cross-lingual translation capabilities beyond the initial seed.
3. Language-Aware Weighting: A dynamic optimization strategy that mitigates performance imbalance by prioritizing difficult translation directions based on relative sibling performance.
4. Comprehensive Evaluation: Extensive experiments demonstrating state-of-the-art performance across multiple model families and benchmarks.

4. Experimental Results

The method was evaluated on HumanEval-X and TransCoder-Test benchmarks across Python, Java, and C++.

• Performance Gains: BootTrans consistently outperformed its base models.
  • On HumanEval-X, it achieved up to 26.82% improvement (e.g., Qwen3-1.7B base vs. BootTrans).
  • On TransCoder-Test, it achieved up to 7.46% improvement.
  • It outperformed large-scale baselines (e.g., 70B parameter models) despite using smaller models (1.7B - 8B).
• Ablation Studies:
  • Removing the Exploration Pool caused a ~4% average drop, proving the necessity of bootstrapping reverse/cross-lingual data.
  • Removing Weighting caused a ~2.5% drop, confirming its role in balancing optimization across difficult directions.
• Pivot Language Sensitivity: While Python yielded the best results (due to richer pre-training data and seed availability), the method remained effective when using Java or C++ as the pivot.
• Generalization: The method successfully generalized to unseen languages (Go) and low-resource languages (Dlang, Racket), showing significant improvements over base models.
• Compatibility: BootTrans serves as a strong foundation for inference-time strategies (e.g., InterTrans, UniTrans), further boosting performance when combined.

5. Significance

BootTrans represents a paradigm shift in code translation by moving away from the dependency on scarce, high-quality parallel corpora. By leveraging functional invariance (tests work across languages) and RLVR, it creates a self-improving loop that expands the model's capabilities to all language pairs. The language-aware weighting mechanism specifically addresses a common failure mode in multilingual RL, ensuring balanced proficiency. This approach makes high-quality, functionally correct code translation accessible even for language pairs with limited data, offering a scalable solution for legacy system modernization and cross-platform interoperability.