💻 computer science

Documentation-Guided Agentic Codebase Migration from C to Rust

RustPrint ist ein dokumentationsgestütztes Agenten-Framework, das eine skalierbare Migration auf Repository-Ebene von C nach Rust ermöglicht, indem es Quellcode in architektonische Baupläne umwandelt, um die iterative Planung, Verifikation und Reparatur durch Agenten zu steuern, und dabei im Vergleich zu bestehenden auf LLM basierenden Übersetzern eine überlegene Kompilierungserfolgsrate und Erhaltung von Funktionen erzielt.

Ursprüngliche Autoren: Minh Le-Anh, Anh Nguyen Hoang, Bach Le, Nghi D. Q. Bui

Veröffentlicht 2026-05-15

📖 5 Min. Lesezeit🧠 Tiefgang

CC BY 4.0

Ursprüngliche Autoren: Minh Le-Anh, Anh Nguyen Hoang, Bach Le, Nghi D. Q. Bui

Originalarbeit lizenziert unter CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dies ist eine KI-generierte Erklärung des untenstehenden Papers. Sie wurde nicht von den Autoren verfasst oder gebilligt. Für technische Genauigkeit konsultieren Sie das Originalpaper. Vollständigen Haftungsausschluss lesen

Stellen Sie sich vor, Sie haben eine riesige, alte Bibliothek, die in einer Sprache namens C geschrieben ist. Sie ist das Fundament vieler kritischer Systeme (wie Betriebssysteme und Netzwerktools), wurde jedoch auf wackeligem Grund errichtet. Die „Ziegelsteine" (Speicherverwaltung) sind lose, und wenn Sie nicht extrem vorsichtig sind, kann die gesamte Struktur einstürzen oder leicht von Eindringlingen (Sicherheitsangriffen) aufgebrochen werden.

Sie möchten diese gesamte Bibliothek mit einer neuen, modernen Sprache namens Rust neu aufbauen. Rust ist wie eine Festung: Sie verfügt über automatische Sicherheitsverriegelungen, die verhindern, dass das Gebäude einstürzt. Doch hier liegt das Problem: Eine ganze Bibliothek, Ziegelstein für Ziegelstein, zu übersetzen, ist unglaublich schwierig. Wenn Sie einfach Raum für Raum übersetzen, verlieren Sie oft die Baupläne, vergessen, wie die Räume verbunden sind, oder landen bei einem Gebäude, das zwar wie Rust aussieht, sich aber wie ein kaputtes C-Gebäude verhält.

RustPrint ist ein neues „Architekt- und Bauteam" (ein KI-Agentensystem), das entwickelt wurde, um dieses Problem zu lösen. Anstatt Code einfach zeilenweise zu übersetzen, verwendet es eine clevere Dreistufen-Strategie, um sicherzustellen, dass das neue Gebäude sicher, funktional und dem ursprünglichen Entwurf treu ist.

So funktioniert RustPrint, unter Verwendung einfacher Analogien:

1. Die „Bauplan"-Phase (Dokumentation zuerst)

Die meisten Übersetzungswerkzeuge versuchen, einen Satz zu übersetzen, dann den nächsten, dann den folgenden. RustPrint hält inne und sagt: „Warten Sie, lassen Sie uns zuerst das ganze Buch lesen."

Was es tut: Es liest die gesamte alte C-Codebasis und schreibt ein massives, detailliertes Bedienhandbuch (Dokumentation), das beschreibt, wie das System funktioniert, wie die Teile verbunden sind und warum es so gebaut wurde.
Die Analogie: Stellen Sie sich vor, Sie renovieren eine alte Burg. Anstatt einfach nur die Steine auszutauschen, beauftragen Sie zuerst einen Experten, eine perfekte, detaillierte Karte des Burggrundrisses, der Geheimgänge und der strukturellen Logik zu zeichnen. Diese Karte wird zum „Bauplan" für den Neubau.
Warum es wichtig ist: Dies stellt sicher, dass die KI die Absicht des Codes versteht, nicht nur die Syntax. Es verhindert, dass die KI vergisst, wie zwei verschiedene Räume miteinander kommunizieren müssen.

2. Die „Baustelle"-Phase (Agentische Übersetzung)

Sobald der Bauplan fertig ist, schickt RustPrint ein Team spezialisierter KI-Arbeiter, um die neue Rust-Version zu bauen.

Der Planer: Schaut sich den Bauplan an und sagt: „Wir müssen hier die Küche bauen, dort die Bibliothek, und sicherstellen, dass die Rohrleitungen verbunden sind." Er erstellt einen schrittweisen Bauplan.
Der Baumeister: Baut die Räume (Code-Module) einzeln.
Der Inspektor: Nachdem jeder Raum gebaut wurde, führt der Inspektor einen „Sicherheitscheck" (Kompilierung) durch. Wenn eine Wand krumm ist oder ein Rohr undicht (Codefehler), repariert der Baumeister dies sofort, bevor er weitermacht.
Der Sicherheitsbeauftragte: Überprüft speziell auf „unsichere" Abkürzungen. Rust erlaubt unsicheren Code nur, wenn er absolut notwendig ist, aber dieser Beamte versucht, diese zu eliminieren, um sicherzustellen, dass das endgültige Gebäude eine Festung ist.

3. Die „Qualitätskontrolle"-Phase (Die Doppelprüfung)

Hier wird RustPrint wirklich intelligent. Es vertraut nicht einfach darauf, dass das Gebäude fertig ist; es verifiziert es gegenüber dem Original.

Der „Spiegel"-Check: Nachdem das neue Rust-Gebäude errichtet wurde, schreibt die KI ein neues Bedienhandbuch für die Rust-Version. Anschließend vergleicht sie dieses neue Handbuch mit dem ursprünglichen C-Handbuch.
- Wenn dem neuen Handbuch ein Abschnitt fehlt (z. B. „Der Geheimgang"), weiß die KI, dass sie eine Funktion übersehen hat, und kehrt zurück, um es zu reparieren.
Der „Stresstest": Die KI nimmt die ursprünglichen Tests (wie Stresstests für die Burgmauern) und führt sie am neuen Rust-Gebäude aus. Wenn eine Wand während des Tests reißt, repariert die KI sie nicht nur; sie ermittelt, warum die Wand gerissen ist, und behebt den zugrunde liegenden Konstruktionsfehler.

Die Ergebnisse: Hat es funktioniert?

Die Forscher testeten RustPrint an 8 realen, großskaligen C-Projekten (von kleinen Bibliotheken bis hin zu massiven Systemen mit über 80.000 Codezeilen).

Der Wettbewerb: Andere Werkzeuge (wie C2Rust oder einfache KI-Übersetzer) versuchten dies, scheiterten jedoch. Entweder konnten sie den Bau nicht fertigstellen (der Code ließ sich nicht kompilieren), oder sie bauten eine Struktur, die wie Rust aussah, aber voller Löcher war.
Der Erfolg von RustPrint:
- Es hat die Arbeit beendet: RustPrint baute erfolgreich eine funktionierende, kompilierbare Version von jedem einzelnen Projekt.
- Es behielt die Funktionen: Es bewahrte 93 % bis 97 % der ursprünglichen Funktionen (abhängig vom verwendeten KI-Modell), wohingegen andere Methoden nur etwa 50 % bewahrten.
- Es bestand die Tests: Als sie die ursprünglichen Tests auf dem neuen Code ausführten, bestand RustPrint 95 % bis 98 % davon. Andere Methoden scheiterten signifikant häufiger.
- Es war sicher: Der resultierende Code war fast vollständig frei von „unsicheren" Abkürzungen, was ihn viel sicherer machte als frühere Versuche.

Das Fazit

RustPrint beweist, dass man bei der Migration eines massiven, komplexen Softwaresystems nicht nur ein Übersetzer sein kann; man muss ein Architekt sein. Indem es die KI zwingt, zuerst einen „Bauplan" zu schreiben, die Pläne zu vergleichen und Stresstests durchzuführen, kann RustPrint erfolgreich veralteten C-Code in die sichere, moderne Welt von Rust überführen, ohne die Seele des ursprünglichen Systems zu verlieren.

Hinweis: Die Studie konzentriert sich streng auf die technische Migration von Code. Sie behauptet nicht, dass diese Methode sofort für lebenskritische medizinische Geräte einsatzbereit ist oder dass sie alle Softwareprobleme löst, sondern vielmehr, dass sie ein hochwirksames Werkzeug für die spezifische Aufgabe der Übersetzung großer C-Codebasen nach Rust ist.

Technische Zusammenfassung: RustPrint – Dokumentationsgestützte agentenbasierte Migration von Codebasen von C nach Rust

Problemstellung

Die Migration veralteter C-Repositorys zu Rust ist entscheidend, um die in Cs Zeigermodell inhärenten Sicherheitslücken bezüglich Speichersicherheit zu adressieren, stellt jedoch weiterhin eine erhebliche ingenieurtechnische Herausforderung dar. Bestehende Übersetzungstools (z. B. C2Rust) arbeiten häufig auf Datei- oder Funktionsebene, bewahren C-ähnliche Strukturen bei und führen zu einer starken Verwendung von unsafe-Blöcken, oder sie erfassen nicht die architektonische Absicht, den Datenfluss und das Design-Rationale des ursprünglichen Systems. Darüber hinaus haben aktuelle Ansätze auf Basis von Large Language Models (LLMs) häufig Schwierigkeiten mit repositoryweiten Aufgaben und scheitern daran, für große Codebasen (11.000–84.000 Codezeilen) kompilierbare Ausgaben zu produzieren, da ihnen ein ganzheitliches Verständnis und eine Koordination über Module hinweg fehlen. Das Kernproblem besteht darin, dass Migration im Wesentlichen eine Aufgabe des Codebase-Verständnisses ist, die ein mentales Modell gemeinsamer Datenstrukturen, Modulgrenzen und übergreifender Invarianten erfordert, das isolierte Übersetzungsstrategien nicht wiederherstellen können.

Methodik: Das RustPrint-Framework

RustPrint ist ein Multi-Agenten-Framework, das für die Migration von C nach Rust auf Repository-Ebene entwickelt wurde. Es führt ein dokumentationsgestütztes Paradigma ein, bei dem automatisch generierte Dokumentation als Zwischenrepräsentation (IR) dient, um Planung, Übersetzung und Verfeinerung zu steuern. Das Framework arbeitet durch eine Pipeline aus fünf Stufen:

1. Dokumentationsgestützte Code-Übersetzung

Anstatt Code Einheiten für Einheiten zu übersetzen, generiert RustPrint zunächst eine ganzheitliche Dokumentation des Quell-C-Codebases mit Hilfe eines dedizierten DocGen-Moduls.

Prozess: Das Quell-Repository wird auf Dateiebene clustert und dann in höhere Komponentenabstraktionen gehoben. Das DocGen-Modul erstellt strukturierte Dokumentation ( $S_{doc}$ ), die abstrakte Merkmale, Modulinteraktionen und Design-Rationale erfasst, anstatt nur syntaktische Beschreibungen.
Agenten:
- Planner: Wandelt $S_{doc}$ in einen Implementierungsplan auf Crate-Ebene (IMPLEMENTATION_PLAN.md) um, löst architektonische Details auf und definiert Komponentenverantwortlichkeiten.
- Translator: Implementiert jede geplante Crate, iteriert mit cargo_check, um Kompilierbarkeit sicherzustellen, und nutzt detect_unsafe, um unsafe-Blöcke zu minimieren.
- Synthesizer: Führt die Integration auf Repository-Ebene durch, löst Abhängigkeiten zwischen Crates auf und generiert eine einheitliche README.md.

2. Anforderungsgesteuerte Code-Verfeinerung

Um semantische Vollständigkeit sicherzustellen, setzt RustPrint einen iterativen Verfeinerungsmechanismus ein, der die Dokumentation des generierten Rust-Codebases ( $T_{doc}$ ) mit der Quelldokumentation ( $S_{doc}$ ) vergleicht.

Mechanismus: Das System approximiert die funktionale Erhaltung durch Dokumentationsäquivalenz: $CodeEquiv(S, T) \approx DocEquiv(S_{doc}, T_{doc})$ .
Agent: Der RequirementRefiner identifiziert Lücken, in denen $T_{doc}$ nicht mit $S_{doc}$ übereinstimmt (z. B. ausgelassene Funktionen, nicht übereinstimmende APIs). Er bearbeitet den übersetzten Code mit str_replace_editor, prüft die Kompilierung und repariert iterativ fehlende oder nicht ausgerichtete Funktionalität.

3. Ausführungsbewusste Code-Revision

In Anerkennung dessen, dass ein Dokumentationsvergleich nicht alle Laufzeitfehler aufdecken kann, fügt das Framework einen testgetriebenen Feedback-Loop hinzu.

Prozess: Der Quell-Test-Suite wird vom TestTranslator nach Rust übersetzt.
Agent: Der ExecutionRevisor analysiert fehlschlagende Tests mit cargo_single_test. Er aktualisiert nur den übersetzten Produktionscode (nicht die Tests), um Verhaltensinkonsistenzen wie Randfälle, Zustandsaktualisierungen oder Protokollmismatches zu beheben, die eine statische Ausrichtung überdauern, aber unter konkreter Ausführung scheitern.

Hauptbeiträge

Dokumentationsgestütztes Migrationsparadigma: Die Arbeit schlägt vor, automatisch generierte Codebase-Dokumentation als Zwischenrepräsentation für die Übersetzung auf Repository-Ebene zu verwenden. Dieser Ansatz kodiert ein ganzheitliches Codebase-Verständnis vor der Übersetzung und ermöglicht die Generierung von idiomatischem Rust, das die architektonische Absicht bewahrt, anstatt lediglich die syntaktische Struktur zu replizieren.
Dokumentationsgestützte iterative Verfeinerung: Ein Mechanismus, der generierten Rust-Code bewertet und verbessert, indem er dessen Dokumentation mit der Quelle vergleicht, systematisch Abdeckungslücken identifiziert und strukturelle Ausrichtung fördert.
Ausführungsbewusste Revision: Die Integration von testgetriebenem Feedback ermöglicht dem System, Verhaltensinkonsistenzen durch dynamische Testausführung iterativ zu korrigieren und funktionale Korrektheit zu erreichen, die über das hinausgeht, was statische Übersetzungen garantieren.
Evaluation im großen Maßstab: Das Framework wurde an acht realen C-Repositorys im Bereich von 11.000 bis 84.000 Codezeilen evaluiert und adressiert damit die Einschränkung früherer Arbeiten, die sich auf kleine Benchmarks konzentrierten.

Experimentelle Ergebnisse

Die Evaluation wurde an acht Repositorys mit zwei Modell-Backbones durchgeführt: einem Open-Weight-Modell (Kimi-K2-Instruct) und einem Closed-Weight-Modell (GPT-5.4). Als Baselines dienten traditionelle Tools (C2Rust) und LLM-basierte Agenten (Self-Repair, EvoC2Rust sowie eine agentenbasierte Claude Code-Baseline).

Projekt-Kompilierbarkeit: RustPrint kompilierte jedes Ziel-Repository unter beiden Modell-Backbones erfolgreich. Im Gegensatz dazu scheiterten Baseline-LLM-Übersetzer (Self-Repair, EvoC2Rust) daran, in diesem Maßstab End-to-End-kompilierbare Repositorys zu produzieren. C2Rust kompilierte zwar, behielt jedoch eine starke Verwendung von unsafe bei.
Funktions-Erhaltung: Gemessen am CodeWikiBench-Score übertraf RustPrint die Claude Code-Baseline signifikant.
- Mit Kimi-K2-Instruct: RustPrint erreichte 93,26 % gegenüber 52,52 % für Claude Code.
- Mit GPT-5.4: RustPrint erreichte 97,76 % gegenüber 48,87 % für Claude Code.
Funktionale Korrektheit: Unter Verwendung eines Cross-Evaluation-Protokolls (Testen von RustPrints Ausgabe mit den Tests von Claude Code und umgekehrt) zeigte RustPrint überlegene Robustheit.
- Kimi-K2-Instruct: 95,17 % Test-Pass-Rate (TPR) gegenüber 79,85 % für Claude Code.
- GPT-5.4: 98,70 % TPR gegenüber 79,85 % für Claude Code.
Sicherheit: RustPrint erreichte hohe Sicherheitsraten und minimierte unsafe-Blöcke. Mit GPT-5.4 wurden 99,41 % auf API-Ebene und 98,47 % auf Dateiebene als sicher erreicht, was andere Methoden übertrifft.

Bedeutung und Behauptungen

Die Arbeit behauptet, dass dokumentationsgesteuerte Koordination eine gangbare und effektive Richtung für skalierbare Codebase-Migration ist. Die Ergebnisse deuten darauf hin, dass die Behandlung von Migration als Koordinationsproblem über Dateien, Schnittstellen und Reparatur-Schritte hinweg – und nicht als reine Code-Generierungsaufgabe – für den Erfolg auf Repository-Ebene unerlässlich ist.

Die Autoren betonen, dass:

Planung und Verfeinerung wichtiger sind als Ein-Schuss-Übersetzung: Der iterative Loop aus Generierung von Dokumentation, Vergleich mit der Quelle und Verfeinerung basierend auf Ausführungsfeedback ist entscheidend für den Umgang mit komplexen modulübergreifenden Abhängigkeiten.
Dokumentation als operative Anleitung fungiert: Sie ist nicht nur Hintergrundkontext, sondern ein funktionaler Bauplan, der die Wiederherstellung fehlender Anforderungen und strukturelle Ausrichtung vorantreibt.
Verhaltenskorrektheit erreichbar ist: Die Cross-Suite-Ergebnisse zeigen, dass die Gewinne nicht nur dokumentarischer Natur sind; die übersetzten Repositorys bewahren das tatsächliche Laufzeitverhalten.

Die Arbeit schließt damit, dass die aktuelle Studie zwar ein starkes erstes Ergebnis an realistischen Repositorys darstellt, der Ansatz jedoch klare Wege für zukünftige Verbesserungen lässt, wie z. B. den Umgang mit Repositories gemischter Sprachen, tieferen externen Abhängigkeiten und weniger standardisierten Build-Systemen. Die Autoren positionieren RustPrint als eine praktische Methode, um LLM-basierte Übersetzung von isolierten Dateien auf ingenieurtechnische Aufgaben auf Repository-Ebene im großen Maßstab zu skalieren.