The TypeScript team has spent years optimizing its compiler, but as projects grow in complexity, JavaScript’s runtime limitations have become increasingly apparent. Out-of-memory issues, slow batch compilations, and limited concurrency support have driven the need for a more efficient approach. The solution? Moving to Go, a language built for performance, parallelism, and scalability to enhance TypeScript’s compilation process. Still, what does this all mean and what changes does it imply? That’s what we’ll discover at Unimedia, where we’ve been working to support our clients in all types of programming language transitions to stay ahead. Today, we explore the reasons behind Microsoft’s move from TypeScript to Go, what it means for developers, how it could reshape the software development landscape and answer the question “Is Go a functional programming language?”.
Why transition to Go?
The primary motivation behind this transition is to improve the performance and scalability of the TypeScript compiler. The current JavaScript-based compiler, while functional, struggles with large-scale projects due to memory limitations and execution speed. Go provides a more efficient compilation process, allowing TypeScript to benefit from a faster and more reliable compiler.
Why a port instead of a rewrite? What’s the difference?
The TypeScript team decided to port the existing compiler rather than rewrite it from scratch. This approach ensures continuity, maintains compatibility with existing projects, and accelerates the transition without disrupting the ecosystem. A rewrite could introduce significant inconsistencies and require developers to relearn critical aspects of the compiler, whereas a direct port retains the familiar architecture while leveraging Go’s efficiency.
Performance and efficiency
JavaScript, the original language of the TypeScript compiler, is optimized for UI and browser usage rather than compute-intensive workloads. Over time, this has led to challenges like high memory consumption and slower compilation speeds. That’s why moving to Go is a way to address these issues by offering native performance benefits, better memory management, and more efficient concurrency handling.
One of the primary performance drawbacks of the JavaScript-based compiler is its reliance on Just-In-Time (JIT) compilation. JIT introduces an overhead that affects start-up times and runtime performance. Since Go is compiled ahead of time, it eliminates this bottleneck, which allows the TypeScript compiler to start and execute much faster.
For developers wondering, why use Go programming language for this transition, the answer lies in its ability to handle concurrent tasks efficiently while maintaining simplicity. Unlike languages that require complex memory management techniques, Go automates these processes and makes development more streamlined and reliable.
Compatibility and incremental adoption
A full rewrite could introduce breaking changes and compatibility issues. When porting TypeScript’s compiler to Go, the team ensures that existing projects will still work with minimal modifications. Incremental adoption is part of the strategy, and this allows developers to migrate at their own pace while still having support for TypeScript 6.x.
Another major advantage of a port is that all core functionalities remain intact. The behavior of TypeScript’s type-checking system, inference mechanisms, and error reporting will be replicated in the Go-based compiler. This means developers won’t need to change how they write or debug TypeScript code—only the underlying engine processing will be different.
Is Go a functional programming language? Open source and community support
The Go-based compiler project, codenamed “Corsa,” remains open source and follows the same licensing model as the original TypeScript compiler. Developers can contribute, review code, and adapt the new compiler to their specific needs. As with previous versions, the project will be hosted on GitHub to encourage collaboration and transparency.
The TypeScript team has emphasized that while Go brings significant benefits, it’s not intended to fundamentally change the developer experience. Instead, it is designed to enhance performance while maintaining the robust features TypeScript users rely on.
Evaluating other languages
Before selecting Go, the TypeScript team considered alternatives such as Rust, C, and C++. While these languages offer high performance, Go was chosen for its balance of speed, memory management, concurrency support, and cross-platform compatibility.
- C and C++ provide low-level control but introduce complexity in memory management, which makes them harder to maintain.
- Rust offers memory safety without a garbage collector, but its strict borrowing rules make it less flexible for certain workflows.
- Go provides automatic memory management, concurrency primitives, and cross-platform support, making it the ideal choice.
Again, for those asking, is Go a functional programming language? The answer is no in a strict sense, as it follows an imperative approach. However, it does support higher-order functions, closures, and immutability, which are commonly found in functional programming.
Current and upcoming releases
Let’s see what’s coming in the latest and upcoming releases.
TypeScript 5.8 and 5.9
The latest releases of TypeScript continue to enhance the JavaScript-based compiler. TypeScript 5.8 introduces performance improvements, while TypeScript 5.9 prepares the ecosystem for upcoming changes, including the transition to the Go-based compiler.
TypeScript 6.0 and the native transition
TypeScript 6.0 will introduce deprecations and breaking changes, setting the foundation for a smoother migration to TypeScript 7.0. This release will focus on compatibility while preparing for the native transition.
Developers using TypeScript 6 will be encouraged to start testing the new Go-based compiler early, which will allow them to assess performance improvements and report any inconsistencies before the official launch of TypeScript 7.0.
TypeScript 7.0: the Go-based compiler
The Go-based compiler will be released as TypeScript 7.0 once it achieves feature parity with the JavaScript-based version. This transition marks a significant shift in performance and scalability, benefiting enterprise applications and large-scale development environments.
Benchmarks from early testing indicate that compiling a 1.5 million-line TypeScript project with the Go-based compiler takes just five seconds—more than 10 times faster than the JavaScript-based version. This means faster feedback loops, quicker deployments, and improved developer productivity.
Naming conventions and codenames
- TypeScript 6.x: JavaScript-based compiler, maintained alongside the native version.
- TypeScript 7.0: the Go-based native compiler.
- Codename “Strada” refers to the original JavaScript-based TypeScript compiler.
- Codename “Corsa” represents the new native port effort.
Coexistence and long-term support plan
Both TypeScript 6 (JavaScript) and TypeScript 7 (Go) will coexist for some time to allow developers to transition at their own pace. Companies with existing dependencies on the JavaScript-based compiler can continue using TypeScript 6 while evaluating the benefits of TypeScript 7.
The long-term goal is to maintain alignment between the two versions, ensuring that developers have a choice based on their project requirements. Whether they prioritize stability or performance, they can select the appropriate compiler version without disrupting workflows.
For those still questioning, why use Go programming language for this effort, the answer is its ability to scale efficiently while simplifying code maintenance. Go’s focus on concurrency and memory management ensures that it outperforms JavaScript in large-scale applications.
Powering the future of software development
The move to Go represents a new era for TypeScript, addressing long-standing performance limitations while maintaining compatibility. As TypeScript 7.0 nears release, developers should prepare for a transition that promises significant speed improvements, better memory management, and enhanced concurrency support.
At this point, we hope to have answered our question “Is Go a functional programming language?” While exploring this topic, it’s clear that adapting to new technologies is key to staying competitive. At Unimedia, we are committed to helping your business navigate these technological shifts with expert consulting and development services. Contact us today to learn how we can enhance your software projects and ensure a seamless transition to the next generation of TypeScript compilation.
