Canonical funds automated C to Rust translation research

Canonical is partnering with the University of Bristol to research automated methods for translating legacy C code into the Rust programming language. This three-year project aims to enhance software security by moving away from memory-unsafe languages while maintaining the performance and stability of existing Linux systems.

The Challenge of Legacy Code Migration

Modern operating systems like Ubuntu rely on massive amounts of C code that have been developed and refined over decades. While these codebases are high-performing and contain vital bug fixes, they are prone to memory safety vulnerabilities. Transitioning these systems to more secure languages is a priority for the industry. However, manual rewrites are notoriously expensive and carry high operational risks.

Jon Seager, the VP of Engineering at Canonical, explained that traditional rewrites often fail to deliver immediate, obvious improvements. Established codebases represent years of operational knowledge and performance tuning. Simply throwing that away to start from scratch is rarely a viable business or technical strategy. To solve this, the industry needs a way to reduce the cost of migration.

The partnership with the University of Bristol, also supported by UK Research and Innovation, focuses on this specific problem. Led by Professor Meng Wang, the team will work on a platform capable of processing hundreds of thousands of lines of code. The goal is to move beyond simple syntax swapping to create truly idiomatic and functional software in the target language.

Limitations of Current Translation Tools

Current source-to-source translators often produce code that is technically Rust but retains the structure of the original C. This leads to a final product that relies heavily on unsafe operations. Such code does not benefit from the safety guarantees that make Rust attractive in the first place. It remains difficult to maintain and does not align with how modern developers write.

Artificial intelligence and large language models offer another potential path for translation. These models are excellent at generating code that looks natural and follows modern conventions. However, they frequently fail when dealing with the massive context of a full software repository. They may struggle with complex dependencies or specific architectural patterns found in system-level software.

A significant concern with AI-generated code is the lack of verifiable accuracy. A program might look correct to a human reader but behave differently than the original source. In system-level software, even a tiny change in behavior can lead to catastrophic system failures or new security holes. This makes pure AI translation unsuitable for critical infrastructure without additional layers of verification.

A Hybrid System Architecture

The research project proposes a sophisticated four-part architecture to solve these issues. By combining machine learning with traditional program analysis, the team hopes to capture the strengths of both approaches. This system treats the language model as just one part of a larger, more disciplined pipeline. The focus remains on accuracy and behavioral equivalence.

The first stage of this architecture is scheduling. In this phase, the system breaks down a large repository into manageable chunks. These sections must contain enough context for the translator to understand data types and dependencies. Proper scheduling ensures that the translation mechanism does not lose sight of how different parts of the software interact.

The second stage involves the actual translation. This component uses models that have been trained specifically on a library of known successful C-to-Rust conversions. By using a specialized dataset, the researchers hope to produce code that is both functional and idiomatic. This step aims to bridge the gap between literal translation and modern coding standards.

Verification and Error Correction

The third component of the proposed system is validation. This is perhaps the most critical step in the entire process. The system must verify that the new Rust code behaves exactly like the original C source. Generated code is treated as untrusted until there is definitive evidence of its correctness. This verification ensures that the security benefits of Rust do not come at the cost of broken functionality.

The final stage is debugging and repair. If the validation step identifies a discrepancy or an error, this component analyzes the problem. It then attempts to correct the issue automatically. This feedback loop is designed to minimize the amount of manual intervention required from human developers during a large-scale migration.

By automating these checks, the project seeks to make the transition more reliable. The researchers want to identify exactly where automation reaches its limits. Understanding these boundaries helps developers know when human oversight is strictly necessary. This clarity can significantly lower the barrier for organizations looking to modernize their legacy software stacks.

Testing on Real-World Security Components

The research team will use two specific Ubuntu security components as case studies: AppArmor and snap-confine. These tools are essential for the security of the operating system. Using them as test subjects provides a high-stakes environment to prove the system’s effectiveness. These components are complex enough to serve as a meaningful benchmark for the translation platform.

Canonical has clarified that this project does not represent an immediate commitment to replace these specific tools with automated versions. Instead, the company is using them to evaluate the results of the research. Because Canonical has a deep interest in these software packages, they are ideal candidates for testing behavioral equivalence. Successful results here would be a strong indicator of the system’s potential.

The ultimate goal of the research is a system that can handle substantial repositories with minimal human help. Even if full automation is not achieved for every scenario, the project is likely to yield valuable side benefits. These include better methods for breaking down codebases and improved datasets for future translation tools. The insights gained will help the entire industry understand the challenges of automated migration.

The Role of Rust in Future Systems

Rust has gained significant momentum in the developer community because it provides low-level control without the common pitfalls of C. It eliminates entire classes of memory-related bugs, such as buffer overflows and use-after-free errors. For an operating system maintainer like Canonical, these features are invaluable for building resilient and secure platforms.

By investing in this research, Canonical is positioning itself at the forefront of the memory safety movement. The ability to move legacy code into a safer environment without the prohibitive costs of manual rewriting could change how software is maintained. This approach preserves the investment in existing logic while upgrading the underlying safety of the code.

As the three-year project progresses, the findings could influence how other Linux distributions and software vendors approach their own technical debt. The combination of rigorous program analysis and modern machine learning represents a new frontier in software engineering. If successful, this partnership will provide a roadmap for securing the world’s most critical digital infrastructure.