💻 computer science

Documentation-Guided Agentic Codebase Migration from C to Rust

RustPrint is een door documentatie geleid agentiek framework dat schaalbare migratie op repository-niveau van C naar Rust mogelijk maakt door broncode om te zetten in architecturale blauwdrukken die iteratieve agentplanning, verificatie en reparatie sturen, en zo een superieure compilatiesucces en behoud van functionaliteit bereikt in vergelijking met bestaande op LLM gebaseerde vertalers.

Oorspronkelijke auteurs: Minh Le-Anh, Anh Nguyen Hoang, Bach Le, Nghi D. Q. Bui

Gepubliceerd 2026-05-15

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Minh Le-Anh, Anh Nguyen Hoang, Bach Le, Nghi D. Q. Bui

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je een enorme, oude bibliotheek voor die is geschreven in een taal genaamd C. Het is de fundering van veel kritieke systemen (zoals besturingssystemen en netwerktools), maar is gebouwd op wankel grond. De "stenen" (geheugenbeheer) zijn los, en als je niet extreem voorzichtig bent, kan de hele structuur instorten of gemakkelijk worden binnengebroken door indringers (beveiligingshacks).

Je wilt deze hele bibliotheek herbouwen met een nieuwe, moderne taal genaamd Rust. Rust is als een fort: het heeft automatische veiligheidsvergrendelingen die voorkomen dat het gebouw instort. Maar hier is het probleem: het vertalen van een hele bibliotheek, steen voor steen, is ongelooflijk moeilijk. Als je gewoon één kamer per keer vertaalt, verlies je vaak de blauwdrukken, vergeet je hoe de kamers met elkaar verbonden zijn, of eindig je met een gebouw dat eruitziet als Rust, maar zich gedraagt als een gebroken C-gebouw.

RustPrint is een nieuw "architect en bouwteam" (een AI-agentensysteem) dat is ontworpen om dit op te lossen. In plaats van alleen code regel voor regel te vertalen, gebruikt het een slimme drie-stappenstrategie om ervoor te zorgen dat het nieuwe gebouw veilig, functioneel en trouw aan het oorspronkelijke ontwerp is.

Hier is hoe RustPrint werkt, met behulp van eenvoudige analogieën:

1. De "Blauwdruk"-fase (Documentatie Eerst)

De meeste vertaaltools proberen een zin te vertalen, dan de volgende zin, dan de volgende. RustPrint stopt en zegt: "Wacht, laten we eerst het hele boek lezen."

Wat het doet: Het leest de volledige oude C-codebase en schrijft een enorme, gedetailleerde instructiehandleiding (documentatie) die beschrijft hoe het systeem werkt, hoe de onderdelen met elkaar verbonden zijn, en waarom het zo is gebouwd.
De Analogie: Stel je voor dat je een oud kasteel renoveert. In plaats van gewoon de stenen te vervangen, huur je eerst een expert in om een perfecte, gedetailleerde kaart te tekenen van de plattegrond van het kasteel, geheime gangen en structurele logica. Deze kaart wordt de "blauwdruk" voor de nieuwe bouw.
Waarom dit belangrijk is: Dit zorgt ervoor dat de AI de intentie van de code begrijpt, niet alleen de syntaxis. Het voorkomt dat de AI vergeet hoe twee verschillende kamers met elkaar moeten communiceren.

2. De "Bouw"-fase (Agentische Vertaling)

Zodra de blauwdruk klaar is, stuurt RustPrint een team van gespecialiseerde AI-werkers om de nieuwe Rust-versie te bouwen.

De Planner: Kijkt naar de blauwdruk en zegt: "We moeten hier de keuken bouwen, daar de bibliotheek, en zorgen dat de leidingen aansluiten." Het maakt een stap-voor-stap bouwplan.
De Bouwer: Bouwt de kamers (codemodules) één voor één.
De Inspecteur: Nadat elke kamer is gebouwd, voert de Inspecteur een "veiligheidscontrole" uit (compilatie). Als een muur scheef staat of een pijp lekt (codefouten), repareert de Bouwer dit direct voordat hij verder gaat.
De Veiligheidsfunctionaris: Controleert specifiek op "onveilige" shortcuts. Rust staat onveilige code alleen toe als het absoluut noodzakelijk is, maar deze functionaris probeert ze te elimineren, zodat het uiteindelijke gebouw een fort is.

3. De "Kwaliteitscontrole"-fase (De Dubbelcontrole)

Hier wordt RustPrint echt slim. Het vertrouwt niet zomaar dat het gebouw klaar is; het verifieert het tegen het origineel.

De "Spiegel"-controle: Nadat het nieuwe Rust-gebouw is gebouwd, schrijft de AI een nieuwe instructiehandleiding voor de Rust-versie. Vervolgens vergelijkt het deze nieuwe handleiding met de originele C-handleiding.
- Als de nieuwe handleiding een sectie mist (bijvoorbeeld "De geheime tunnel"), weet de AI dat het een functie heeft gemist en gaat het terug om het te repareren.
De "Stress-test": De AI neemt de originele tests (zoals stress-tests voor de kasteelmuren) en voert ze uit op het nieuwe Rust-gebouw. Als een muur barst tijdens de test, repareert de AI het niet zomaar; het zoekt uit waarom de muur barstte en repareert het onderliggende ontwerpdefect.

De Resultaten: Heeft het gewerkt?

De onderzoekers testten RustPrint op 8 real-world, grootschalige C-projecten (variërend van kleine bibliotheken tot enorme systemen met meer dan 80.000 regels code).

De Concurrentie: Andere tools (zoals C2Rust of eenvoudige AI-vertalers) probeerden dit, maar faalden. Ze konden de bouw niet afmaken (de code wilde niet compileren) of ze bouwden een structuur die eruitzag als Rust, maar vol gaten zat.
Het Succes van RustPrint:
- Het heeft de klus afgerond: RustPrint bouwde succesvol een werkende, compileerbare versie van elk enkel project.
- Het behield de functies: Het behield 93% tot 97% van de originele functies (afhankelijk van het gebruikte AI-model), terwijl andere methoden slechts ongeveer 50% behielden.
- Het slaagde de tests: Toen ze de originele tests op de nieuwe code uitvoerden, slaagde RustPrint voor 95% tot 98% ervan. Andere methoden faalden aanzienlijk vaker.
- Het was veilig: De resulterende code was bijna volledig vrij van "onveilige" shortcuts, waardoor het veel veiliger is dan eerdere pogingen.

De Conclusie

RustPrint bewijst dat je om een massaal, complex softwaresysteem te migreren, niet zomaar een vertaler kunt zijn; je moet een architect zijn. Door de AI te dwingen eerst een "blauwdruk" te schrijven, de plannen te vergelijken en stress-tests uit te voeren, kan RustPrint succesvol legacy C-code verplaatsen naar de veilige, moderne wereld van Rust, zonder de ziel van het oorspronkelijke systeem te verliezen.

Opmerking: Het artikel richt zich strikt op de technische migratie van code. Het claimt niet dat deze methode klaar is voor direct gebruik in levenskritieke medische apparaten of dat het alle softwareproblemen oplost, maar eerder dat het een zeer effectief hulpmiddel is voor de specifieke taak van het vertalen van grote C-codebases naar Rust.

Technische Samenvatting: RustPrint – Documentatie-gestuurde Agentische Codebase-migratie van C naar Rust

Probleemstelling

De migratie van legacy C-repositories naar Rust is cruciaal voor het aanpakken van geheugenveiligheidskwetsbaarheden die inherent zijn aan het pointermodel van C, maar het blijft een aanzienlijke technische uitdaging. Bestaande vertaalgereedschappen (bijv. C2Rust) werken vaak op bestands- of functieniveau, behouden C-achtige structuren en resulteren in een zwaar gebruik van unsafe-blokken, of ze slagen er niet in de architecturale intentie, de dataflow en het ontwerprationale van het oorspronkelijke systeem vast te leggen. Bovendien worstelen huidige Large Language Model (LLM)-gebaseerde benaderingen vaak met repository-schaaltaken en falen ze om compileerbare output te produceren voor grote codebases (11K–84K regels code) vanwege een gebrek aan holistisch begrip en coördinatie tussen modules. Het kernprobleem is dat migratie fundamenteel een taak is van het begrijpen van een codebase, waarbij een mentaal model van gedeelde datastructuren, modulegrenzen en cross-file invarianten vereist is, wat geïsoleerde vertaalstrategieën niet kunnen herstellen.

Methodologie: Het RustPrint Framework

RustPrint is een multi-agent framework ontworpen voor migratie van C naar Rust op repository-niveau. Het introduceert een documentatie-gedreven paradigma waarbij automatisch gegenereerde documentatie dient als een intermediaire representatie (IR) om planning, vertaling en verfijning te sturen. Het framework werkt via een pijplijn van vijf fasen:

1. Documentatie-gestuurde Codevertaling

In plaats van code eenheid per eenheid te vertalen, genereert RustPrint eerst holistische documentatie van de bron-C-codebase met behulp van een dedicated DocGen-module.

Proces: De bronrepository wordt op bestandsniveau geklusterd en vervolgens omhooggehaald naar hogere niveau component-abstrcties. De DocGen-module produceert gestructureerde documentatie ( $S_{doc}$ ) die abstracte kenmerken, module-interacties en ontwerprationale vastlegt, in plaats van alleen syntactische beschrijvingen.
Agents:
- Planner: Zet $S_{doc}$ om in een implementatieplan op crate-niveau (IMPLEMENTATION_PLAN.md), lost architecturale details op en definieert verantwoordelijkheden van componenten.
- Translator: Implementeert elke geplande crate, iteratief met cargo_check om compileerbaarheid te waarborgen en detect_unsafe om unsafe-blokken te minimaliseren.
- Synthesizer: Voert integratie op repository-niveau uit, lost cross-crate afhankelijkheden op en genereert een uniforme README.md.

2. Requirement-gedreven Codeverfijning

Om semantische volledigheid te waarborgen, hanteert RustPrint een iteratief verfijningsmechanisme dat de documentatie van de gegenereerde Rust-codebase ( $T_{doc}$ ) vergelijkt met de brondocumentatie ( $S_{doc}$ ).

Mechanisme: Het systeem benadert functionele behoud via documentatie-equivalentie: $CodeEquiv(S, T) \approx DocEquiv(S_{doc}, T_{doc})$ .
Agent: De RequirementRefiner identificeert gaten waar $T_{doc}$ niet overeenkomt met $S_{doc}$ (bijv. weggelaten functies, niet-overeenkomende API's). Het bewerkt de vertaalde code met str_replace_editor, controleert de compilatie en repareert iteratief ontbrekende of niet-overeenkomende functionaliteit.

3. Uitvoeringsbewuste Codeherziening

Omdat documentatievergelijking niet alle runtime-fouten kan blootleggen, voegt het framework een feedbacklus op basis van tests toe.

Proces: De bron-testset wordt naar Rust vertaald door de TestTranslator.
Agent: De ExecutionRevisor analyseert mislukte tests met cargo_single_test. Het update uitsluitend de vertaalde productcode (niet de tests) om gedragsinconsistenties te verhelpen, zoals randgevallen, state-updates of protocolmismatches die statische uitlijning overleven maar falen onder concrete uitvoering.

Belangrijkste Bijdragen

Documentatie-gedreven Migratieparadigma: Het artikel stelt het gebruik van automatisch gegenereerde codebase-documentatie voor als een intermediaire representatie voor vertaling op repository-niveau. Deze benadering encodeert begrip van de hele codebase voordat vertaling plaatsvindt, waardoor het genereren van idiomatische Rust mogelijk wordt die architecturale intentie behoudt in plaats van alleen syntactische structuur te repliceren.
Documentatie-gestuurde Iteratieve Verfijning: Een mechanisme dat gegenereerde Rust-code beoordeelt en verbetert door deze documentatie te vergelijken met de bron, systematisch dekkingstekorten identificeert en structurele uitlijning bevordert.
Uitvoeringsbewuste Herziening: De integratie van feedback op basis van tests stelt het systeem in staat om gedragsinconsistenties iteratief te corrigeren via dynamische testuitvoering, waardoor functionele correctiviteit wordt bereikt die verder gaat dan wat statische vertaling garandeert.
Evaluatie op Grote Schaal: Het framework is geëvalueerd op acht real-world C-repositories variërend van 11K tot 84K LoC, waarmee de beperking van eerdere werken wordt aangepakt die zich richtten op kleine benchmarks.

Experimentele Resultaten

De evaluatie werd uitgevoerd op acht repositories met twee modelruggengraten: een open-weight model (Kimi-K2-Instruct) en een closed-weight model (GPT-5.4). Baselines omvatten traditionele tools (C2Rust) en LLM-gebaseerde agents (Self-Repair, EvoC2Rust, en een agentische Claude Code-baseline).

Projectcompileerbaarheid: RustPrint slaagde erin om elke doelrepository te compileren onder beide modelruggengraten. In tegenstelling hiermee faalden baseline LLM-vertalers (Self-Repair, EvoC2Rust) om end-to-end compileerbare repositories te produceren op deze schaal. C2Rust compileerde maar behield een zwaar gebruik van unsafe.
Behoud van Functies: Gemeten via de CodeWikiBench-score, presteerde RustPrint aanzienlijk beter dan de Claude Code-baseline.
- Met Kimi-K2-Instruct: RustPrint behaalde 93,26% versus 52,52% voor Claude Code.
- Met GPT-5.4: RustPrint behaalde 97,76% versus 48,87% voor Claude Code.
Functionele Correctheid: Met behulp van een cross-evaluatieprotocol (het testen van RustPrint's output met Claude Code's tests en omgekeerd), toonde RustPrint superieure robuustheid.
- Kimi-K2-Instruct: 95,17% Test Pass Rate (TPR) versus 79,85% voor Claude Code.
- GPT-5.4: 98,70% TPR versus 79,85% voor Claude Code.
Veiligheid: RustPrint behaalde hoge veiligheidspercentages en minimaliseerde unsafe-blokken. Met GPT-5.4 bereikte het 99,41% API-niveau en 98,47% file-niveau veilige rates, waarmee het andere methoden overtrof.

Betekenis en Claims

Het artikel beweert dat documentatie-gestuurde coördinatie een haalbare en effectieve richting is voor schaalbare codebase-migratie. De resultaten suggereren dat het behandelen van migratie als een coördinatieprobleem over bestanden, interfaces en herstelstappen – in plaats van een ruwe code-generatietaken – essentieel is voor succes op repository-niveau.

De auteurs benadrukken dat:

Planning en verfijning belangrijker zijn dan één-shot vertaling: De iteratieve lus van het genereren van documentatie, het vergelijken daarvan met de bron en het verfijnen op basis van uitvoeringsfeedback is cruciaal voor het hanteren van complexe cross-module afhankelijkheden.
Documentatie fungeert als operationele leidraad: Het is niet slechts achtergrondcontext maar een functioneel blauwdruk dat het herstel van ontbrekende requirements en structurele uitlijning drijft.
Gedragscorrectheid bereikbaar is: De cross-suite testresultaten geven aan dat de winst niet alleen documentair is; de vertaalde repositories behouden het daadwerkelijke runtime-gedrag.

Het artikel concludeert dat hoewel de huidige studie een sterk eerste resultaat vertegenwoordigt op realistische repositories, de aanpak duidelijke paden voor toekomstige verbetering laat, zoals het hanteren van mixed-language repositories, diepere externe afhankelijkheden en minder gestandaardiseerde buildsystemen. De auteurs positioneren RustPrint als een praktische methode om LLM-gebaseerde vertaling te schalen van geïsoleerde bestanden naar volledige engineeringtaken op repository-niveau.