Microsoft Is Rewriting TypeScript in Go: 10x Faster Performance

Hello HaWkers, one of the most impactful news of late 2025 came directly from the TypeScript team at Microsoft. The company announced that it is completely rewriting the TypeScript compiler and language service in Go, promising performance improvements of up to 10x compared to the current version.

Have you ever waited minutes for your TypeScript project to compile? Have you felt the frustration of watching VS Code freeze while trying to provide autocomplete in a large file? Well, Microsoft heard those complaints.

What Is Happening

The news came through an official post on the TypeScript blog in December 2025, revealing the significant progress the team has made on the compiler rewrite. The project, internally called TypeScript 7, represents the biggest architectural change in the language's history.

Why Go?

The choice of Go as the target language was not random. The Microsoft team evaluated several options and chose Go for the following reasons:

Advantages of Go for TypeScript:

Native compilation to efficient binaries
Optimized and predictable garbage collector
Excellent concurrency support with goroutines
Easy distribution (single binary)
Performance close to C/C++ with high productivity

The current version of TypeScript is written in TypeScript (self-hosted), which means the compiler depends on Node.js to run. This brings performance overhead that the new version completely eliminates.

The Numbers That Impress

According to the benchmarks released by Microsoft, TypeScript 7 shows drastic improvements:

Performance Comparison

Full build (medium project ~100k lines):

TypeScript 6.0: ~45 seconds
TypeScript 7.0: ~4.5 seconds
Improvement: 10x faster

Incremental build:

TypeScript 6.0: ~8 seconds
TypeScript 7.0: ~800ms
Improvement: 10x faster

Language service (autocomplete):

TypeScript 6.0: ~200ms
TypeScript 7.0: ~25ms
Improvement: 8x faster

Multi-Threaded Builds

One of the major new features is support for parallel builds. TypeScript 7 can now build multiple projects simultaneously:

Monorepo with 50 projects:

TypeScript 6.0: ~12 minutes (sequential)
TypeScript 7.0: ~90 seconds (parallel)
Improvement: 8x faster

What This Means For Developers

The change brings important implications for the ecosystem:

1. Improved Development Experience

With the language service 8x faster, your IDE will respond instantly. Autocomplete, go-to-definition, and refactoring will work without perceptible lag, even in huge projects.

2. Faster CI/CD

Build pipelines that took minutes will now complete in seconds. For companies with hundreds of builds per day, this represents significant savings in time and computing resources.

3. Full Compatibility

Microsoft guaranteed that the new version maintains 100% compatibility with existing TypeScript code. You won't need to modify anything in your projects to take advantage of the improvements.

How Distribution Will Work

An important practical change is in the distribution method:

Today (TypeScript 6.x):

Installed via npm as a Node.js package
Requires Node.js to run
Interpreted execution

Future (TypeScript 7.x):

Available as a native binary
Also available via npm (wrapper)
Native compiled execution

Microsoft plans to maintain compatibility with the current workflow. You'll still be able to use npm install typescript, but internally the package will run the native binary.

Timeline and Availability

According to the released roadmap:

First half of 2026:

Public preview of TypeScript 7
Focus on early adopters and feedback

Second half of 2026:

Release candidate
Extensive compatibility testing

2027:

Stable release
Gradual deprecation of TypeScript 6.x

Community Reaction

The news divided opinions in the developer community:

Positive arguments:

Performance was a frequent complaint
Large projects will benefit enormously
Go is a solid and pragmatic choice

Concerns raised:

Community contributions may decrease (fewer devs know Go)
Plugins and extensions will need to be rewritten
Learning curve for those who want to contribute

Microsoft responded that they will maintain tools and documentation to facilitate contributions, and that most users will never need to interact directly with the Go code.

Impact on the Ecosystem

Tools that depend on the TypeScript API will need to adapt:

Affected tools:

ESLint with typescript-eslint
Prettier
Bundlers (webpack, rollup, vite)
IDEs and editors

Microsoft is working with maintainers of these tools to ensure a smooth transition. The new version will expose compatible APIs that minimize migration work.

Comparison with Other Initiatives

This is not the first time languages have been rewritten for better performance:

Project	Original Language	New Language	Improvement
TypeScript 7	TypeScript	Go	10x
Rome/Biome	JavaScript	Rust	100x
esbuild	N/A	Go	Reference
SWC	N/A	Rust	20x vs Babel

The trend of rewriting JavaScript tools in compiled languages is consolidating.

What To Do Now

While TypeScript 7 hasn't arrived, you can:

1. Optimize Your Current Projects

Take advantage of features like project references and incremental builds that already exist in the current TypeScript to improve performance.

2. Follow the Development

The TypeScript repository on GitHub will have regular updates on progress. It's worth following to prepare yourself.

3. Test Alternative Tools

Tools like esbuild and SWC already offer fast compilation. You can use them together with tsc for type-checking.

Conclusion

The rewriting of TypeScript in Go represents an important milestone in the language's evolution. Microsoft is making a significant bet on performance, recognizing that compilation speed has become a real bottleneck in modern projects.

For developers, this means a smoother development experience, faster builds, and less time waiting for the compiler. The promised compatibility suggests that the transition will be smooth for most projects.

If you want to prepare for these changes, I recommend checking out another article: Node.js With Native TypeScript Support where you'll discover how the JavaScript ecosystem is evolving to embrace TypeScript more deeply.