Fine-Tuning Qwen3-27B for C-to-Rust Code Translation: A Three-Stage Curriculum of Pretraining, Debugging-Aware SFT, and Task-Specific SFT

Pu Zhao; Changdi Yang; Yixiao Chen; Yi Gao; Yifan Cao; Haochen Zeng; Yanzhi Wang

cs.SEAug 13, 2026

Fine-Tuning Qwen3-27B for C-to-Rust Code Translation: A Three-Stage Curriculum of Pretraining, Debugging-Aware SFT, and Task-Specific SFT

Authors: Pu Zhao, Changdi Yang, Yixiao Chen, Yi Gao, Yifan Cao, Haochen Zeng, Yanzhi Wang

Organizations: Northeastern University · EmbodyX Inc · Aibao LLC

Abstract

Translating C code into safe, idiomatic Rust is a longstanding software-engineering goal because it can eliminate entire classes of memory-safety vulnerabilities while preserving the functional behavior of legacy systems. Large language models (LLMs) have shown promise for this task but typically underperform when applied off-the-shelf, since general-purpose pretraining rarely emphasizes idiomatic Rust generation, cross-language semantic equivalence, or the ability to reason about and repair compiler/runtime feedback. In this report we describe a three-stage fine-tuning curriculum applied to Qwen3-27B that is designed to progressively specialize the model for the C-to-Rust (C2Rust) translation task: (1) continued pretraining on Rust-centric corpora to strengthen the model's prior over idiomatic Rust syntax and standard-library usage; (2) supervised fine-tuning (SFT) on the microsoft/Verus_Training_Data dataset to instill debugging and self-repair behavior over Rust code; and (3) task-specific SFT on paired C/Rust solutions derived from LeetCode problems to teach direct semantic translation. We evaluate the resulting model using the agentic, static-analysis-guided verification framework of SACTOR, which performs structure-aware, two-phase (unidiomatic to idiomatic) translation with foreign-function-interface (FFI)-based end-to-end (E2E) testing. We report success rate, idiomaticity (Clippy lint counts, unsafe-code fraction), and failure-mode analyses, and compare our fine-tuned model against baseline Qwen3-27B and other LLMs evaluated under the same framework.

Figures & tables

Property	Value
Parameters (language model)	27B ( $\sim$ 28B including the vision encoder)
Hidden dimension	5,120
Number of layers	64
Layer layout	16 $\times$ [ 3 $\times$ (Gated DeltaNet $\to$ FFN) $\to$ 1 $\times$ (Gated Attention $\to$ FFN) ]
Gated DeltaNet heads	48 (value), 16 (query/key)
Gated DeltaNet head dimension	128

Table 1: Qwen3.5-27B language-model architecture (as released).

Setting	Value
ZeRO stage	3
Precision	bf16.enabled = auto (BF16 training)
zero_allow_untested_optimizer	true
overlap_comm	false
contiguous_gradients	true
sub_group_size	$1\times 10^{9}$

Table 2: DeepSpeed ZeRO Stage 3 configuration used for all three fine-tuning stages.

Stage	Objective	Data Source	Training Type
1	Rust language proficiency	Rust code from various Rust datasets	Continued pretraining
2	Debugging / self-repair	microsoft/Verus_Training_Data	Instruction SFT
3	C2Rust task translation	LeetCode C/Rust paired solutions	Instruction SFT

Table 3: Overview of the three-stage training curriculum.

Name	Hugging Face Source	Examples
Strandset-Rust	Fortytwo-Network/Strandset-Rust-v1	191,008
CodeFIM-Rust-Mellum	Etherll/CodeFIM-Rust-Mellum	56,920
rust_instruction_dataset	ysr/rust_instruction_dataset	524
humaneval-rust	diversoailab/humaneval-rust	164
Magicoder-OSS-Instruct-75K-rust	ise-uiuc/Magicoder-OSS-Instruct-75K	4,695 (Rust subset)
xCodeEval-rust	NTU-NLP-sg/xCodeEval	39,510

Table 4: Stage 1 pretraining corpus composition, by Hugging Face source dataset.

Data Type	Concatenation Pattern	Representative Source
FIM / code completion	prefix + middle / completion + suffix	CodeFIM-Rust-Mellum
Instruction + code	instruction + code	rust_instruction_dataset
Context + code	code_context + code	Several Strandset-Rust-v1 categories
Code + explanation	code_context + code + explanation / summary	Strandset-Rust-v1 (e.g., documentation-oriented categories)
Before/after (repair-style)	code_context + code_before + rationale / comment + code_after	Strandset-Rust-v1 (e.g., code-review categories)
Full source	prompt + declaration + solution + test	humaneval-rust

Table 5: Concatenation patterns used to build Stage 1 pretraining text, by data type.

Setting	Value
LLaMA-Factory stage	pt (continued pretraining)
Fine-tuning type	full (full-parameter)
Distributed backend	DeepSpeed ZeRO Stage 3 (§ 3 )
Precision	BF16
max_samples	$10^{8}$ (effectively unlimited – the full corpus is used)
Sequence length ( cutoff_len )	16,384 tokens

Table 6: Stage 1 (continued pretraining) training configuration, from the LLaMA-Factory recipe.

Part	Subtype	Approx. Count
Part 1 (self-/tutorial-synthesis)	Direct-generation (program + spec + proof)	5.7M
Part 1 (self-/tutorial-synthesis)	Debugging (unverified $\to$ verified pair + error report)	1.2M
Part 2 (agent trajectories, Sonnet 4.5)	Long direct-generation CoT	871
Part 2 (agent trajectories, Sonnet 4.5)	Single-step debugging CoT	3,686
Total		$\sim$ 6.9M + 4,557

Table 7: Composition of microsoft/Verus_Training_Data (VeruSyn dataset), as reported in [ 4 ] .

Setting	Value
LLaMA-Factory stage	sft
Fine-tuning type	full (full-parameter)
Initialized from	Stage 1 checkpoint
Distributed backend	DeepSpeed ZeRO Stage 3 (§ 3 )
Precision	BF16
max_samples	$10^{8}$ (effectively unlimited – the full configured dataset is used)

Table 8: Stage 2 (Verus debugging SFT) training configuration, from the LLaMA-Factory recipe.

Setting	Value
LLaMA-Factory stage	sft
Fine-tuning type	full (full-parameter)
Initialized from	Stage 2 checkpoint
Distributed backend	DeepSpeed ZeRO Stage 3 (§ 3 )
Precision	BF16
max_samples	$10^{8}$ (effectively unlimited – the full configured dataset is used)

Table 9: Stage 3 (C2Rust task-specific SFT) training configuration, from the LLaMA-Factory recipe.

Configuration	Value
Temperature	0.6
Top-p	0.95
Top-k	20
Maximum output length	1,536
Maximum translation attempts	6

Table 10: Inference configuration used in evaluation.

Model	Model Size	SR
Qwen3.5-Plus	397B (17B active)	77.20%
MiniMax-M2.5	230B (10B active)	83.90%
GLM-5	744B (40B active)	84.40%
GLM-5.2	744B (40B active)	89.90%
Claude Code-4.6	–	90.01%
Qwen3.5-27B (base, no fine-tuning)	27B (dense)	72.30%

Table 11: Overall SR on the C2Rust translation evaluation, by model.

Model	SWE-bench Verified
GPT-5-mini (2025-08-07)	72.0
GPT-OSS-120B	62.0
Qwen3.5-122B-A10B	72.0
Qwen3.5-27B (base, no fine-tuning)	72.4
Ours (Qwen3.5-27B + Stages 1–3)	70.6

Table 12: SWE-bench Verified pass@1, by model.

Code Translation

Code translation converts programs between languages, frameworks, and representations while aiming to preserve behavior and sometimes improve safety or performance.

See all 41 papers

ENCRUST: Encapsulated Substitution and Agentic Refinement on a Live Scaffold for Safe C-to-Rust Translation
Apr 6, 2026Hohyun Sim, Hyeonjoong Cho, Ali Shokri +2Code Translation LLM-Based Program Synthesis
Korea University, South Korea · University of Houston, United States · State University of New York Korea, South Korea +1
Mostly Automatic Translation of Language Interpreters from C to Safe Rust
Jun 25, 2026Bo Wang, Brandon Paulsen, Joey Dodds +3Code Translation
National University of Singapore, Singapore · Amazon, USA
Where Does the Performance Go? Understanding and Recovering Performance Regressions in C-to-Rust Translation
Oct 16, 2026Zhiqiang Yuan, Chong Wang, Zhenhao Zhou +2Code Translation Code Optimization
Department of Computer Science, Fudan University, China · Nanyang Technological University, Singapore

Apr 6, 2026J/K move · Enter open · S save

ENCRUST: Encapsulated Substitution and Agentic Refinement on a Live Scaffold for Safe C-to-Rust Translation

Hohyun Sim, Hyeonjoong Cho, Ali Shokri, Zhoulai Fu+1

Korea University, South Korea · University of Houston, United States · State University of New York Korea, South Korea+1

Code Translation LLM-Based Program Synthesis

Open paper AskPDF arXiv

We present Encapsulated Substitution and Agentic Refinement on a Live Scaffold for Safe C-to-Rust Translation, a two-phase pipeline for translating real-world C projects to safe Rust. Existing approaches either produce unsafe output without memory-safety guarantees or translate functions in isolation, failing to detect cross-unit type mismatches or handle unsafe constructs requiring whole-program reasoning. Furthermore, function-level LLM pipelines require coordinated caller updates when type signatures change, while project-scale systems often fail to produce compilable output under real-world dependency complexity. Encrust addresses these limitations by decoupling boundary adaptation from function logic via an Application Binary Interface (ABI)-preserving wrapper pattern and validating each intermediate state against the integrated codebase. Phase 1 (Encapsulated Substitution) translates each function using an ABI-preserving wrapper that splits it into two components: a caller-transparent shim retaining the original raw-pointer signature, and a safe inner function targeted by the LLM with a clean, scope-limited prompt. This enables independent per-function type changes with automatic rollback on failure, without coordinated caller updates. A deterministic, type-directed wrapper elimination pass then removes wrappers after successful translation. Phase 2 (Agentic Refinement) resolves unsafe constructs beyond per-function scope, including static mut globals, skipped wrapper pairs, and failed translations, using an LLM agent operating on the whole codebase under a baseline-aware verification gate. We evaluate Encrust on 7 GNU Coreutils programs and 8 libraries from the Laertes benchmark, showing substantial unsafe-construct reduction across all 15 programs while maintaining full test-vector correctness.

Abstract

Code Translation

Explore similar work

ENCRUST: Encapsulated Substitution and Agentic Refinement on a Live Scaffold for Safe C-to-Rust Translation

Mostly Automatic Translation of Language Interpreters from C to Safe Rust

Where Does the Performance Go? Understanding and Recovering Performance Regressions in C-to-Rust Translation