Intro
With all the noise about yet another shiny AI model, most of us completely missed a much bigger and more impactful announcement. Summer 2026 delighted us with Microsoft rolling out the TypeScript 7.0 RC. TypeScript, which was previously written in TypeScript itself, has been ported to Go!
In the official YouTube video announcement, Anders Hejlsberg starts with the statement that they have likely reached the limit of what they can squeeze out of JavaScript.
TypeScript has been written in itself, and that has brought a lot of benefits, but it has also consistently brought some challenges, in particular around performance and skill availability.
The JavaScript runtime platform is really optimized for UI and browser usage, and not so much for compute-intensive workloads like compilers and system-level tools. The future of TypeScript became questionable, and some fundamental changes were required.
Codenamed Project Corsa, the port took the team more than a year and eventually became an installable npm package.
Big early adopters report outstanding benchmarks:
The VS Code codebase, roughly 1.5 million lines of TypeScript, now compiles in approximately 7.5 seconds — down from approximately 78 seconds. Language server failures dropped by over 20x compared to TypeScript 6.0.
I am especially happy about the drop in language server failures, but those numbers alone say nothing. I got curious: how did they make these numbers possible, and what does this change mean for TypeScript users and the JavaScript ecosystem in general? That is what we are going to explore, based on the official announcement and publicly available facts.
Ported, not rewritten
The main reason for a port: performance and scalability.
It simply was not feasible to rewrite instead of porting, because we would have had to solve a bunch of new problems.
The Microsoft team has been crystal clear that they are porting the existing codebase instead of rewriting the whole thing from scratch. This is important, because this approach guarantees core compatibility. Code that compiles in TypeScript 6.0, with stableTypeOrdering enabled and no deprecated flags, should compile identically in TypeScript 7.0.
Rewriting the compiler from scratch would mean reevaluating design decisions, algorithms and data structures, whereas porting means a file-by-file migration of the existing codebase to Go, preserving the existing algorithms and data structures.
Anders Hejlsberg thinks that rewrites are often toxic for an ecosystem because they sacrifice compatibility: you never come back to exactly what you had before. Backwards compatibility is important if you want to keep your ecosystem happy.
Go Rust, or Go fast?
The first and most obvious question that comes to mind is: why not Rust? Why Go? Anders Hejlsberg explains in his interview that there were several reasons.
- Rust doesn't have garbage collection. Memory is managed manually or through the borrow checker, but the latter doesn't allow circular data structures (and the TS compiler is packed with those).
- The target language should have access to shared memory and treat functions as first-class citizens.
Of course, there are libraries that provide garbage collection, but they come with restrictions and cannot guarantee safety, whereas Go is type- and memory-safe.
Go was the most suitable option.
Numbers
10x speed is more the result than the final goal. Microsoft's official wording is "often about 10 times faster", which means it can be even higher.
Large codebases and monorepos will immediately see the gain, whereas small projects will not see the same dramatic improvement.
Build speed affects CI pipeline wait times and deployment feedback loops, but the improvement doesn't stop there. The developer experience got a huge boost as well: failing language server commands dropped by over 20x relative to TypeScript 6.0.
In large monorepos, where VS Code's language server was a known bottleneck, will feel the difference most immediately. I personally work with multiple large monorepos in WebStorm and have also noticed a huge performance boost.
If you work with AI to write your code, you have probably noticed that the TS server doesn't keep up with the changes the agent makes in your project, and you get those 'phantom errors' on typecheck.
And that is just the problem we have today. With a fast and stable type-checker, new AI features become possible: immediate typechecking of an LLM's output, providing semantic information in LLM prompts, and much more.
This improvement will make it possible to build many new IDE features that were not feasible before, and to truly scale alongside agentic development.
Breaking changes
The type system is identical, that was the core promise of the port approach.
TypeScript 7.0 adopts TypeScript 6.0's new defaults and promotes deprecation warnings to hard errors. Specifically, these flags and patterns now cause compilation errors:
-
target: es5— downcompilation to ES5 is no longer supported downlevelIteration-
moduleResolution: node/node10 -
module: amd,umd,systemjs,none -
baseUrl(usepathsinstead) -
esModuleInterop: false,allowSyntheticDefaultImports: false - Namespace
modulekeyword, closure-style function syntax in JSDoc
New defaults include:
strict: truemodule: esnext-
target— the current stable ECMAScript version immediately precedingesnext noUncheckedSideEffectImports: truelibReplacement: false-
stableTypeOrdering: true(and cannot be disabled) -
rootDir: ./— inner source directories must now be set explicitly -
types: []— list the global types you need explicitly, e.g.["node", "jest"]
Migration plan
It is not recommended to jump right into the void upgrading to the latest version. First, you should upgrade to version 6, which surfaces upcoming errors as warnings and lets you prepare for the migration to v7.
Some articles recommend installing both v6 and v7 and running a side-by-side comparison, but that was true for the RC version. Now version 7 is stable and production-ready, so you can skip this step.
But here is the catch. The current TypeScript version doesn't have a programmatic API yet, it is coming in version 7.1. Thus, if your project depends on TypeScript as a library — plugin systems, custom transformers, specialized language server integrations — you may face compatibility issues until that API stabilizes. This is the single largest drawback for early adopters with complex toolchains.
Until then, the official announcement recommends keeping v6 around through the @typescript/typescript6 compatibility package for tools that need programmatic access to the compiler, such as typescript-eslint. The same goes for editor support in Vue, Svelte, Astro and MDX, which still runs on v6 for now.
Conclusion - The Last Piece of the Native Puzzle
TypeScript 7.0 is not an unexpected surprise. It is a logical step in a transformation that is already happening across the JavaScript ecosystem.
esbuild (Go), SWC (Rust), and Bun (Zig/C++) demonstrated that native-compiled tooling can dramatically outperform JavaScript-implemented tools. JavaScript naturally has constraints that make scaling impossible: the single-threaded event loop, JIT warmup overhead, and the absence of shared-memory parallelism.
It doesn't mean that JavaScript is a bad language, of course not; it just means that it is not designed for this job. It is actually better that JS has only one thread. Shared memory and multiple threads in a language with mutable data sounds hideous.
TypeScript used to be a bottleneck for every tool that consumes TypeScript's type information. esbuild and SWC addressed the build pipeline, while TypeScript type-checking remained JavaScript-based. TypeScript 7.0 closes that last gap by making the type-checker itself native.
Long term, cheaper type-checking enables more ambitious static analysis, more precise refactoring assistance, and richer IDE features that were previously too expensive to run interactively.
The transition won't be that effortless: a whole bunch of tooling depends on the programmatic API, so we should wait until version 7.1 stabilizes. Those who depend heavily on this API shouldn't rush the migration for now.
