Microsoft recently announced an exciting development in the world of programming languages: the TypeScript compiler and language service are being ported to native code, specifically the Go programming language. This transition aims to achieve a remarkable 10x speed boost in build times and improve editor responsiveness, a game-changer for developers working with large codebases.
A brief intro of TypeScript
Designed by Microsoft, TypeScript is a programming language based on JavaScript with static type addition. This allows developers to identify errors early in the process, making it easier to maintain large applications. The core components of TypeScript include its compiler, which translates TypeScript code into JavaScript, and its language service, which provides features like autocompletion and error checking in development environments.
The Need for Speed
As projects grow larger, the performance of the TypeScript compiler becomes crucial. Developers often face long load times and sluggish performance when working with extensive codebases. The current version of the TypeScript compiler (tsc) is written in TypeScript itself and runs on Node.js, which can lead to inefficiencies when handling large amounts of data.
Anders Hejlsberg, the lead architect of TypeScript, highlighted these challenges in a recent announcement, stating that many developers have had to choose between quick editor startup times or comprehensive project views. To address these issues, Microsoft has embarked on a project dubbed “Corsa,” which aims to rewrite the TypeScript compiler in Go.
Why Go?
Go, also known as Golang, is a statically typed programming language designed for efficiency and performance. Its strengths lie in memory management, concurrency features, and the ability to compile directly into binary executables that run on operating systems without needing additional runtime environments. This makes Go an ideal choice for improving the TypeScript compiler’s performance.
By moving to Go, Microsoft anticipates not only a significant reduction in build times but also lower memory usage during compilation processes. Hejlsberg noted that initial tests showed promising results: for instance, loading the Visual Studio Code codebase went from approximately 9.6 seconds down to about 1.2 seconds with the native implementation—an impressive 8x improvement.
Anticipated Performance Improvements
Early benchmarks from the native Go-based implementation demonstrate substantial enhancements. For instance, compiling the Visual Studio Code codebase, which consists of approximately 1.5 million lines of code, currently takes about 77.8 seconds with the existing compiler. The new Go-based compiler accomplishes the same task in just 7.5 seconds, reflecting a 10.4x speed improvement.
Similar performance gains have been observed across other sizable projects, indicating a consistent trend of reduced build times.
VS Code: With 1,505,000 LOC, the compilation time has reduced from 77.8 seconds to 7.5 seconds, achieving a 10.4x speedup.
Playwright: With 356,000 LOC, the build time improved from 11.1 seconds to 1.1 seconds, showing a 10.1x speedup.
TypeORM: A codebase with 270,000 LOC saw a reduction in compilation time from 17.5 seconds to 1.3 seconds, marking a 13.5x improvement.
date-fns: For 104,000 LOC, the build time dropped from 6.5 seconds to 0.7 seconds, achieving a 9.5x speedup.
tRPC (server + client): With a smaller 18,000 LOC, the compilation time improved from 5.5 seconds to 0.6 seconds, a 9.1x speedup.
rxjs (observable): The smallest codebase in the list, with 2,100 LOC, saw a decrease in compilation time from 1.1 seconds to 0.1 seconds, resulting in an 11.0x speedup.
Why Some Prefer Rust Over Go
Despite the advantages of Go, many developers argue that Rust could have been a superior choice for several reasons:
Performance: Rust is recognized for its exceptional performance and memory safety without garbage collection overhead. In various benchmarks, optimized Rust code has been shown to outperform Go by significant margins—sometimes by over 30% in speed. This makes Rust particularly appealing for performance-critical applications.
Memory Safety: Rust’s strict compile-time checks prevent common runtime errors related to memory management. This function is especially valuable in complex systems where stability is paramount. Developers appreciate that Rust enforces safe coding practices, reducing the likelihood of bugs that can arise from shared mutable state.
Control Over Resources: Rust provides fine-grained control over system resources and thread behavior, making it an excellent choice for low-level programming tasks where efficiency is crucial.
Insights from the Community
In discussions surrounding the decision to use Go over Rust, various developers have shared their perspectives on social media platforms and blogs. Some noted that while Rust excels in raw performance, Go’s ergonomics and faster development cycles make it more suitable for projects like TypeScript, where rapid iteration is essential.
For example, one developer who attempted to rewrite the TypeScript compiler in Rust reported achieving impressive performance gains—62 times faster type checking compared to the existing tsc—but ultimately decided against continuing due to the complexities involved with Rust’s ownership model. This sentiment reflects a broader consensus that while Rust may offer superior performance under certain conditions, Go’s balance of speed and ease of use aligns better with TypeScript’s goals.
Project Timeline and Expectations
The Corsa project is currently in its early stages, but Microsoft plans to preview a native implementation capable of command-line type checking by mid-2025. By the end of 2025, they expect a fully functional solution for project builds and a complete language service.
This transition will not only enhance performance but also pave the way for new features that were previously too resource-intensive to implement. For example, developers will benefit from instant error listings across entire projects and more advanced refactoring capabilities.
Impact on Development Experience
The implications of this transition extend beyond just faster compilation times. With improved performance, developers will experience enhanced responsiveness within their editors. This is particularly important as many modern development environments rely heavily on real-time feedback from language services.
Moreover, as more tools integrate with TypeScript’s language service—like popular code editors such as Visual Studio Code—users across various platforms will enjoy these performance enhancements. The expected improvements in memory usage mean that even developers working on resource-constrained machines can benefit from a smoother coding experience.
The Future of TypeScript
Microsoft’s decision to port TypeScript to Go reflects a broader trend in software development: the need for tools that can scale effectively as projects grow larger and more complex. As software development increasingly incorporates artificial intelligence (AI) tools, having a robust and efficient foundation like this new native implementation will be crucial for future advancements.
Hejlsberg expressed excitement about the opportunities this project creates, stating that it will enable deeper insights into codebases that were previously too costly to compute. This could lead to innovative tools that learn from developer interactions and adapt over time.
Microsoft’s announcement marks a significant milestone in enhancing TypeScript’s capabilities. By leveraging Go’s strengths to improve speed and efficiency, they are setting the stage for a more powerful development experience that meets the demands of modern software engineering. As we look forward to further updates on Project Corsa throughout 2025, it’s clear that this initiative could redefine how developers interact with TypeScript and their coding environments overall.