GitHub Rewrites Copilot Runtime in Rust: 800k Lines Ported via AI

Seed story: "Migrating the GitHub Copilot runtime to Rust, using Copilot" (GitHub Blog) · search original Written from facts verified across 2 report(s) — original explainer, not a copy or translation. Sources at the end.

GitHub has completed the migration of its Copilot runtime from TypeScript to Rust, porting over 800,000 lines of production code to address critical latency and infrastructure cost challenges. The project, which spanned several months and involved 128 pull requests, notably leveraged the Copilot AI assistant itself to automate the porting process. This massive rewrite resulted in a production codebase of approximately 830,000 lines, bolstered by nearly 600,000 lines of new unit and end-to-end tests.

The Scope of the Rust Migration

The scale of this migration is immediately striking. GitHub successfully ported over 800,000 lines of production TypeScript code into Rust, transforming the Copilot runtime entirely. This massive undertaking was executed over several months, with the team merging 128 distinct porting pull requests between May and August.

By the project's conclusion, the resulting production Rust codebase reached approximately 830,000 lines. This figure highlights the complexity of the underlying infrastructure that powers the assistant. The migration was not just a language swap but a significant structural overhaul designed to handle high-volume requests efficiently.

The effort required substantial investment in code quality and verification. During the transition, the team added:

469,000 lines of Rust unit tests
Roughly 130,000 lines of end-to-end test code
Comprehensive cross-language validation suites

This volume of testing underscores the rigorous standards applied to ensure the new runtime matches the reliability of the original system.

Leveraging Copilot for Automated Porting

The GitHub team turned to its own AI assistant to handle the heavy lifting of this massive translation. By leveraging Copilot, they automated the conversion of complex TypeScript logic into idiomatic Rust, significantly accelerating the workflow. This approach allowed the team to process 128 distinct porting pull requests between May and August, demonstrating how AI tools can manage large-scale codebase transformations.

Key aspects of this automated porting included:

Translating over 800,000 lines of production code.
Maintaining consistency across the new Rust codebase.
Reducing the manual effort required for syntax and logic mapping.

For developers, this highlights a shift in refactoring workflows. Instead of writing every line by hand, engineers can now orchestrate AI-driven migrations. This method not only speeds up delivery but also ensures that the resulting codebase, which reached approximately 830,000 lines, remains robust and aligned with Rust’s strict safety standards.

Performance Drivers and Infrastructure Costs

The decision to rewrite the Copilot runtime in Rust was primarily driven by the need to optimize system performance and manage financial overhead. By moving away from the previous TypeScript implementation, GitHub aimed to significantly reduce latency in code generation responses. This shift also targets lower infrastructure costs, as Rust’s memory safety and efficiency allow for tighter resource utilization compared to garbage-collected environments.

For developers, this translates to a faster, more responsive coding experience. The technical benefits include:

Reduced processing latency for AI requests.
Lower operational costs for hosting the runtime.
Improved stability through Rust’s strict safety guarantees.

Ultimately, these performance drivers ensure that the infrastructure supporting AI-assisted development remains scalable and cost-effective, directly impacting how quickly and reliably developers can interact with their tools.

Building a Robust Testing Strategy

To validate the reliability of the ported code, the team engineered a massive safety net. This effort resulted in 469,000 lines of new Rust unit tests, ensuring that individual components behaved correctly within the new language context.

Beyond unit-level checks, the team developed a comprehensive end-to-end test suite. This added roughly 130,000 lines of test code across multiple languages, verifying that the entire runtime functioned as expected.

469,000 lines of Rust unit tests
130,000 lines of multi-language end-to-end tests
128 porting PRs merged over several months

For developers, this highlights a critical workflow shift: when using AI for large-scale refactoring, the testing infrastructure must scale equally. It is not enough to port the logic; you must simultaneously generate the verification layer to catch regressions early.

Incremental Porting Methodology

GitHub executed this massive migration over several months, prioritizing stability over speed. Rather than a risky big-bang rewrite, the team adopted a gradual approach to ensure production services remained uninterrupted throughout the transition. This methodical pacing allowed engineers to validate each component before moving to the next, significantly reducing the operational risk associated with swapping core infrastructure.

The execution relied on a steady stream of small, manageable changes. Specifically, 128 porting pull requests were merged between May and August, breaking down the 800,000-line TypeScript codebase into digestible chunks. This incremental workflow meant that:

Production traffic continued flowing through the existing system during the port.
Each merged PR could be independently tested and rolled back if necessary.
The team maintained full visibility into performance impacts at every stage.

By the end of the process, the production Rust codebase stabilized at approximately 830,000 lines, proving that large-scale refactoring can happen without halting development or service availability.

Implications for AI-Assisted Refactoring

This migration demonstrates that LLMs can handle large-scale language shifts, but only within strict guardrails. The team’s success relied on an incremental approach, merging 128 pull requests over several months. This phased strategy allowed developers to verify correctness continuously, mitigating the risk of introducing subtle bugs into a critical production system.

Key trade-offs for developers include:

Verification Over Generation: AI accelerates code translation, but human oversight remains essential for logic validation.
Test-First Mindset: The addition of 469,000 lines of unit tests highlights that robust testing is a prerequisite for safe AI refactoring.
Incremental Delivery: Breaking the 800,000-line port into manageable chunks ensures that performance gains and cost reductions are realized without disrupting service availability.

For teams considering similar migrations, this case study suggests that AI is a force multiplier for boilerplate conversion, not a replacement for architectural judgment.

FAQ

What was the final size of the Rust codebase and test suite after the migration?

By the end of the migration, the production Rust codebase consisted of approximately 830,000 lines. The team also added 469,000 lines of Rust unit tests and roughly 130,000 lines of end-to-end test code across multiple languages.