Recently, Microsoft made a groundbreaking announcement: they have rewritten the TypeScript compiler in Go, resulting in up to 10x faster performance compared to the original implementation in TypeScript/JavaScript. This shift is turning heads across the developer community and promises to reshape how TypeScript projects are compiled and built.
In this blog, we’ll dive into why Microsoft decided to rewrite TypeScript in Go, what benefits this brings, and how it impacts developers working with TypeScript.
Why Rewrite TypeScript in Go?
TypeScript is a superset of JavaScript that adds static typing, enabling safer and more maintainable codebases. Its compiler (tsc) is traditionally written in TypeScript/JavaScript and runs on Node.js.
While the TypeScript compiler is robust and widely adopted, as projects grow larger, compilation speed becomes a bottleneck – affecting developer productivity and CI/CD pipelines.
Microsoft chose Go for the rewrite because:
- Go is compiled and fast: Go binaries run directly on the OS without a virtual machine, which cuts down execution time significantly.
- Strong concurrency model: Go’s goroutines enable efficient parallel processing, which is beneficial for compiling many files concurrently.
- Static typing and simplicity: Go’s syntax and type safety help maintain a clean, maintainable codebase.
- Cross-platform and easy deployment: Go binaries can be compiled for multiple platforms easily and packaged as standalone executables.
What Does the Go-based TypeScript Compiler Change?
The new compiler, often referred to as tsc-go or similar, offers:
- Blazing fast compile times: Benchmarks show up to 10x improvement in compilation speed, dramatically reducing wait times during development.
- Lower resource consumption: The Go binary uses less memory compared to Node.js, making it lighter on machines.
- Smaller binary size: Unlike Node.js dependencies, the compiled Go binary is standalone, making distribution and integration easier.
- Improved incremental builds: Thanks to Go’s concurrency, incremental builds are faster and more efficient.
- Better support for large monorepos: Faster build times scale well with very large TypeScript projects common in enterprises.
What This Means for Developers
If you’re a TypeScript developer, here’s why this change matters:
- Improved Developer Experience: Faster builds mean less time waiting and quicker feedback loops.
- Better CI/CD Efficiency: Reduced build times speed up automated testing and deployment.
- Simplified Tooling: The standalone Go binary reduces dependency management headaches.
- Future Ecosystem Growth: This rewrite opens doors for integrating Go’s powerful tooling ecosystem with TypeScript development.
How to Try the New Go-based TypeScript Compiler
Microsoft is gradually rolling out this Go-based compiler. To experiment with it:
- Visit the official Microsoft or TypeScript GitHub repositories for releases.
- Download the Go binary for your platform.
- Replace or alias your current
tsccommand with the new binary. - Benchmark your projects and experience the speed improvements firsthand.
Keep in mind this is still an evolving project, so some features or plugins may not be fully supported yet.
Potential Challenges and Considerations
While the performance gains are exciting, there are a few things to consider:
- Ecosystem Compatibility: Some existing tooling tightly coupled with Node.js may need updates.
- Community Adoption: It takes time for the wider community to switch, test, and trust the new compiler.
- Debugging and Error Reporting: The user experience around error messages and stack traces might differ initially.
Microsoft is actively working on addressing these concerns to ensure a smooth transition.
Conclusion
Microsoft’s decision to rewrite the TypeScript compiler in Go is a bold move that underscores the importance of performance in modern development workflows. With up to 10x faster compile times, developers can look forward to a more efficient and enjoyable TypeScript experience.
This change highlights the power of Go beyond traditional backend services – it’s now shaping the future of frontend tooling too.
Keep an eye out for updates, try out the new compiler, and get ready to speed up your TypeScript builds like never before!