README.md

---
license: apache-2.0
base_model:
- Qwen/Qwen3.5-27B
library_name: transformers
pipeline_tag: text-generation
tags:
- code
- c
- rust
- code-translation
- c-to-rust
- qwen3.5
- fine-tuning
- sactor
- deepspeed
---

# C2Rust

**C2Rust** is a full-parameter BF16 fine-tune of
[Qwen/Qwen3.5-27B](https://huggingface.co/Qwen/Qwen3.5-27B) for translating C programs into
behaviorally equivalent Rust. The model is trained with a three-stage curriculum and evaluated with
an execution-based SACTOR harness that compiles each candidate and compares its behavior with the
source C program.

The accompanying technical report is titled **“Fine-Tuning Qwen3.5-27B for C-to-Rust Code
Translation: A Three-Stage Curriculum of Pretraining, Debugging-Aware SFT, and Task-Specific SFT”**
(August 2026).

## Results

### C2Rust translation success rate

Success Rate (SR) is the percentage of programs that compile and pass every end-to-end test. Scores
are arithmetic means over five random seeds under the same inference configuration.

| Model | Model size | SR |
|---|---:|---:|
| Qwen3.5-Plus | 397B total / 17B active | 77.20% |
| MiniMax-M2.5 | 230B total / 10B active | 83.90% |
| GLM-5 | 744B total / 40B active | 84.40% |
| GLM-5.2 | 744B total / 40B active | 89.90% |
| Claude Code-4.6 | undisclosed | 90.01% |
| Qwen3.5-27B base | 27B dense | 72.30% |
| **C2Rust (this model)** | **27B dense** | **87.30%** |

The curriculum improves the direct Qwen3.5-27B baseline by **15.00 percentage points** while keeping
model size and serving cost fixed. C2Rust outperforms Qwen3.5-Plus, MiniMax-M2.5, and GLM-5 on this
task, while remaining below GLM-5.2 and Claude Code-4.6.

### General coding capability

| Model | SWE-bench Verified pass@1 |
|---|---:|
| GPT-5-mini (2025-08-07) | 72.0 |
| GPT-OSS-120B | 62.0 |
| Qwen3.5-122B-A10B | 72.0 |
| Qwen3.5-27B base | 72.4 |
| **C2Rust (this model)** | **70.6** |

The 1.8-point difference from the untuned base suggests a modest specialization cost, while the model
retains strong general software-engineering performance.

## Three-stage training curriculum

| Stage | Objective | Data | Training configuration |
|---|---|---|---|
| 1. Rust continued pretraining | Strengthen Rust syntax, idioms, completion, repair, and library knowledge | 1,673,289 examples from seven Rust-focused sources | Full-parameter BF16, 1 epoch, LR `1e-6` |
| 2. Debugging-aware SFT | Learn to consume structured verifier feedback and make targeted repairs | [`microsoft/Verus_Training_Data`](https://huggingface.co/datasets/microsoft/Verus_Training_Data) | Full-parameter BF16, 2 epochs, LR `2e-7` |
| 3. C2Rust task SFT | Learn direct C-to-Rust semantic translation | C2Rust-Moxin `functions/` and `programs/` pairs | Full-parameter BF16, 2 epochs, LR `2e-7` |

Stage 1 combines Strandset-Rust, CodeFIM-Rust-Mellum, rust_instruction_dataset, humaneval-rust,
the Rust subset of Magicoder-OSS-Instruct-75K, the Rust program-synthesis and repair subsets of
xCodeEval, and the Rust subset of StarCoderData.

All three stages use a 16,384-token sequence length, DeepSpeed ZeRO Stage 3, and eight NVIDIA B300
GPUs. Training is text-only. The Qwen3.5 vision encoder remains in the released checkpoint but receives
no task input and plays no role in C-to-Rust translation.

## Model details

| Field | Value |
|---|---|
| Base model | `Qwen/Qwen3.5-27B` |
| Parameters | 27B language model (~28B including the retained vision encoder) |
| Weight format | Safetensors |
| Precision | BF16 |
| Context used in training | 16,384 tokens |
| Fine-tuning type | Full-parameter |
| Primary task | C-to-Rust program translation |
| License | Apache-2.0 |

The tokenizer, vocabulary, and architecture are unchanged from the base checkpoint; no task-specific
special tokens were added.

## Evaluation protocol

The companion benchmark contains **200 C programs**: 92 receive command-line arguments and 108
read standard input. Approximately 120 are derived from IBM Project CodeNet. A translation succeeds
only when the generated Rust program compiles and reproduces every reference output on the supplied
tests within a six-attempt translation and repair budget.

| Setting | Value |
|---|---:|
| Temperature | 0.6 |
| Top-p | 0.95 |
| Top-k | 20 |
| Maximum output length | 1,536 tokens |
| Maximum translation attempts | 6 |
| Random seeds | 5 |

The released repository's default configs evaluate SACTOR's interface-preserving, unidiomatic stage.
Generated code may therefore contain raw pointers or `unsafe` Rust. Passing the benchmark measures
agreement on the supplied test suite, not formal semantic equivalence.



## Resources

- [Benchmark, evaluation harness, and setup instructions](https://github.com/moxin-org/C2Rust)
- [Base model: Qwen/Qwen3.5-27B](https://huggingface.co/Qwen/Qwen3.5-27B)
- [SACTOR translation engine](https://github.com/qsdrqs/sactor)
- [C2Rust-Moxin training datasets](https://github.com/Bobchenyx/Moxin-C2Rust-Datasets)

## Running with the benchmark

Download the checkpoint:

```bash
hf download moxin-org/C2Rust --local-dir /path/to/C2Rust-model
```

Clone and prepare the benchmark:

```bash
git clone https://github.com/moxin-org/C2Rust.git
cd C2Rust
bash fix_paths.sh

cd engine
uv sync
./update_rust_ast_parser.sh
cargo build --release
cd ..
```

Launch the checkpoint with SGLang:

```bash
export SERVE_VENV=/path/to/sglang-venv
./scripts/launch_model.sh /path/to/C2Rust-model 0,1 30878 2
```

Run a two-program smoke test before the complete evaluation:

```bash
python3 scripts/run_eval.py configs/native_prompt.toml results/_smoke \
  --modes argv --limit 2 --workers 1
```

See the [benchmark README](https://github.com/moxin-org/C2Rust#setup-once-per-machine) and
[`SETUP.md`](https://github.com/moxin-org/C2Rust/blob/main/SETUP.md) for the complete environment,
five-seed evaluation, aggregation, and troubleshooting workflow.

## Intended use

This release is intended for research and experimentation on C-to-Rust translation. Treat every
generated program as a candidate: compile it, test it against the original implementation, and review
it for correctness, safety, and maintainability before use.

## Limitations

- Passing the supplied tests is not proof of semantic equivalence, memory safety, or security.
- The default evaluation permits `unsafe` Rust and prioritizes behavior preservation over idiomaticity.
- Stage 3 uses function- and program-level pairs, but excludes project-level training examples.
- The model scores 70.6 on SWE-bench Verified versus 72.4 for the base checkpoint, suggesting mild
  capability narrowing after full-parameter specialization.
- The report does not yet provide an ablation isolating each curriculum stage's marginal contribution.

## Citation

The supplied manuscript has not finalized its individual author list. Until citation metadata is
released, cite the software artifact:

```bibtex
@software{moxin2026c2rust,
  title  = {C2Rust: Fine-Tuned Qwen3.5-27B for C-to-Rust Translation},
  author = {{Moxin Organization}},
  year   = {2026},
  url    = {https://github.com/moxin-org/C2Rust}
}
```

## License and attribution

The checkpoint is released under Apache-2.0 and is derived from
[Qwen/Qwen3.5-27B](https://huggingface.co/Qwen/Qwen3.5-27B). The benchmark is Apache-2.0. Its
dataset includes material derived from IBM Project CodeNet under CDLA-Permissive-2.0; see the
[dataset provenance and terms](https://github.com/moxin-org/C2Rust/blob/main/CodeNet/README.md).