TypeScript 7 Is Here: The Native Go Port Delivers 10x Faster Builds

TypeScript 7.0 shipped today with the most significant architectural change in the language's history: a complete rewrite of the compiler in Go. The native port delivers 8-12x build speedups across real-world codebases, with some projects seeing even more dramatic improvements.

Dan Rosenwasser from Microsoft announced the release, and the numbers speak for themselves. VSCode's codebase - a substantial TypeScript project - went from 125.7 seconds to 10.6 seconds. That's an 11.9x improvement. Sentry's build dropped from 139.8 seconds to 15.7 seconds. Memory usage decreased by 6-26% across tested codebases.

But the raw build numbers only tell part of the story. The editor experience transformation is arguably more impactful for daily development. Opening an error in VSCode decreased from 17.5 seconds to under 1.3 seconds - a 13x improvement that fundamentally changes how developers interact with large TypeScript projects.

Why Go?

The decision to port to Go rather than Rust generated substantial discussion in the Hacker News thread. Several commenters noted that Go's straightforward nature made it ideal for a 1:1 port of the existing codebase.

One commenter summarized the reasoning: "Go is great because it's fast to code. It's easy to reimplement TypeScript in Go 1:1 just by looking at the code. Rust on the other hand would take a lot longer to develop. Maybe Rust is 20% faster than Go but the overall increase from TypeScript with Go is good enough to make a huge difference."

The TypeScript team specifically wanted a translation, not a rewrite. They aimed for bug-for-bug compatibility, and Go's garbage collection and simpler memory model made that goal more achievable than Rust's borrow checker would have allowed for a compiler with many circular structures.

What HN Is Saying

The thread generated significant technical discussion, with several notable perspectives:

On the type system complexity: One commenter praised the team for managing "simultaneously keeping two separate codebases alive for the most advanced type system known to mankind." Others pushed back on this characterization, noting that proof assistant languages would be more likely candidates for that title - though acknowledging TypeScript's type system is genuinely interesting and complex.

On the Jevons Paradox concern: A thoughtful thread explored whether the speed improvements would just lead to even more complex type-level programming. "Fast type inference unlocks brand new patterns that were too slow to be practical on the old checker," one commenter noted. The question of whether library authors will exploit this headroom for increasingly complex types remains open.

On types vs. dynamic languages: The release reignited the perennial static vs. dynamic typing debate. One experienced developer pushed back on the "serious people always prefer types" narrative: "I've been writing code since the 80s, professionally since the mid 90s... I would definitely argue that dynamically typed languages are superior for a large class of problems."

On WASM support: Several commenters asked about WASM builds for browser-based playgrounds and online IDEs. Jake Bailey from the TypeScript team responded that they're "hoping to start getting WASM builds out soon," noting the complexity since WASM could mean LSP for Monaco, the API in the browser, or CLI builds for platforms they couldn't otherwise target.

The Breaking Changes

TypeScript 7 is not a drop-in replacement. Several significant changes require attention:

Defaults have shifted stricter:

• strict mode enabled by default
• module defaults to esnext
• types defaults to [] (no longer auto-including @types packages)

Hard removals:

• ES5 target is gone
• downlevelIteration eliminated
• Legacy module systems (AMD, UMD, SystemJS) discontinued
• baseUrl removed - use paths instead
• Namespace module keyword prohibited

JSDoc changes hit JavaScript codebases harder:

• Values cannot substitute for types without typeof
• @enum no longer recognized
• Closure-style function syntax abandoned

The API Gap

The most significant limitation for the ecosystem: TypeScript 7 does not ship with a programmatic API. This is expected in 7.1, but for now it creates real friction.

Vue, MDX, Astro, Svelte, and Angular templates lack TypeScript 7 support because they depend on that API. The workaround is installing TypeScript 6 via npm alias alongside TypeScript 7, using tsc6 for framework tooling while tsc runs the native compiler.

This is the messiest part of the transition, and it will take time for the ecosystem to catch up.

Parallelization Controls

The new compiler exposes experimental flags for fine-tuning parallel execution:

• --checkers: Controls type-checking workers (default: 4)
• --builders: Manages parallel project reference building
• --singleThreaded: Disables parallelization for debugging

With --checkers 8, VSCode achieved a 16.7x speedup over TypeScript 6. The parallelization strategy is one of the key architectural advantages of the native port.

Watch Mode Improvements

The rebuilt --watch mode uses a Go port of Parcel's file-watcher, replacing previous polling mechanisms. This provides efficient, cross-platform file monitoring with significantly reduced resource consumption - particularly noticeable on larger projects where the old watcher could become a bottleneck.

Should You Upgrade?

For most projects, yes - but with caveats.

If you're on a pure TypeScript codebase without framework-specific tooling, the upgrade path is straightforward. Run tsc and watch your builds get dramatically faster.

If you're using Vue, Svelte, or other frameworks that depend on the programmatic API, wait for 7.1 or use the dual-installation approach. The performance gains in CLI builds are real, but losing editor support in your framework's templates is a significant regression.

If you depend on ES5 targets or legacy module systems, this is a forcing function to modernize. Those targets were deprecated long ago, and TypeScript 7 closes that chapter.

The TypeScript team validated the release through extensive testing with Slack, Figma, and Google. Language server crashes reduced by over 60% and failing commands decreased by 80% compared to TypeScript 6.0.

Looking Forward

The native port opens possibilities that weren't practical before. Complex type-level libraries that pushed against the old checker's performance limits now have room to grow. Whether that's a feature or a bug depends on your perspective on type-level programming.

The WASM builds coming in future releases will be particularly interesting for browser-based tooling. Monaco-powered editors and online playgrounds have always been constrained by JavaScript performance - native speeds in the browser could change what's possible.

For now, TypeScript 7.0 delivers exactly what was promised: dramatically faster builds with full compatibility for the core language. The ecosystem will catch up with the API, and then the real benefits of the native port can fully materialize.

Sources

• TypeScript 7.0 Announcement
• Hacker News Discussion
• QuePaxa Paper (SOSP 2023)