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

On July 8, 2026, Microsoft shipped the biggest architectural change TypeScript has seen since the language launched in 2012: TypeScript 7.0, a compiler rewritten from scratch in Go. The headline is speed — Microsoft reports full builds running roughly 8x to 12x faster than the previous release — but the deeper story is that the tool almost every modern web and app project now depends on just stopped being a bottleneck. For teams whose CI queues, editor lag and cold-start times have crept upward with every new file, this is the rare upgrade you feel on day one.

Here is what actually changed under the hood, what the numbers really say, how the versioning works so you install the right thing, and what to check before you flip a large codebase over to it.

What Project Corsa actually rebuilt

For its entire history, the TypeScript compiler was itself written in TypeScript and run on Node.js. That was elegant — the language compiled with itself — but it capped performance. JavaScript is single-threaded by default and garbage-collected, so type-checking a large project meant one core doing an enormous amount of allocation-heavy work while the rest of the machine sat idle.

The rewrite, internally codenamed Project Corsa, is a full native port of the compiler to Go. The effort ran for roughly a year before landing as a release candidate on June 18, 2026, and then as general availability on July 8. Go was chosen for a specific reason: it compiles to native machine code, has real multithreading, and its memory model maps closely enough to the existing compiler's structure that the team could port the logic rather than redesign it. The result is the same type system and the same rules — just executed by a program that runs an order of magnitude faster.

The benchmarks, in context

Raw multipliers are easy to over-hype, so it helps to anchor them to a real codebase. Microsoft's flagship example is Visual Studio Code itself, a large, mature TypeScript project:

Metric	TypeScript 6 (JS compiler)	TypeScript 7 (Go compiler)
Full type-check of the VS Code codebase	125.7 seconds	10.6 seconds
Effective speedup	—	~11.9x
Typical full-build range (Microsoft's own guidance)	baseline	8x–12x faster
Language-server (editor) failures	baseline	~20x fewer

Two things matter here beyond the top-line number. First, the 8x–12x band is Microsoft's honest framing: your mileage depends on project shape, how many type instantiations you have, and how much of your time was spent in type-checking versus emit. Second — and this is easy to miss — the language server got dramatically more reliable, with failures dropping by more than twenty times. That is the process behind autocomplete, go-to-definition and inline errors in your editor. Fewer failures means less of the "TypeScript is loading…" spinner that plagues big monorepos.

How the versioning works (so you install the right thing)

The version jump is intentional and worth understanding, because there is no "TypeScript 6.x" branch you keep sitting on the way you might with a language runtime. The native compiler is the mainline now.

• npm install -D typescript now gives you 7.0. General availability ships under the normal latest tag, so a fresh install pulls the native build by default.
• The name tsgo is retired from everyday use. During the preview period the native build was distributed as a separate @typescript/native-preview / tsgo package. With 7.0, the native build simply is tsc. The tsgo name now refers only to the bleeding-edge nightly channel for people who want unreleased changes.
• Your commands don't change. tsc --noEmit, tsc --watch and the flags you already use work the same — they just finish sooner.

What stays exactly the same

This is the reassuring part, and the reason the upgrade is lower-risk than the version bump suggests. The rewrite deliberately preserved behaviour:

• The type system is identical. Same inference, same structural typing, same rules. Code that type-checked before still type-checks; code that errored still errors, with the same diagnostics.
• Your tsconfig.json is unchanged. The same compiler options are honoured. There is no new config format to migrate to.
• The output is the same JavaScript. Emit targets, module formats and source maps behave as before.

In other words, Project Corsa was a performance rewrite, not a redesign of the language. That is precisely what makes a "major version" this large adoptable in practice.

What to check before you upgrade

"Same behaviour" is the goal, but a from-scratch reimplementation of a decade-old compiler is not going to be byte-identical everywhere on day one. A sensible rollout looks like this:

1. Pin and test in a branch. Install typescript@7 on a feature branch and run your full tsc --noEmit plus your test suite. Diff the error output against your current version — you are looking for any diagnostics that appear or disappear unexpectedly.
2. Audit compiler plugins and tooling. Anything that hooked into the old JavaScript compiler's internal API — custom transformers, some lint rules, certain build-tool integrations — may need an updated version that targets the native build. Bundlers and type-aware linters were high on the ecosystem's port list, so check for current releases.
3. Watch editor extensions. Your IDE's TypeScript support needs to point at the 7.0 language server to get the reliability win. Update your editor and its TypeScript extension, or configure the workspace to use your local typescript version.
4. Roll CI last. Once a branch is green locally and in review, switch your CI image. Because commands are unchanged, this is usually a one-line dependency bump — and it is where you will feel the speedup most, since type-checking often dominates a JavaScript project's CI time.

For most application codebases the migration is uneventful. The projects that need care are the ones with deep toolchain customisation or heavy reliance on compiler internals.

Why a faster compiler is a business decision, not just a developer treat

It is tempting to file "10x faster builds" under developer comfort. It is more than that. Compile and type-check time sits on the critical path of nearly every step in shipping software: the editor feedback loop while writing code, the pre-commit check, the CI pipeline on every pull request, and the production build. Shrinking that from minutes to seconds compounds across a team and a year.

The same convergence we described in the Next.js 16 and React 19 server-first shift — compiler-driven optimisation as the baseline rather than an add-on — is now reaching the language tooling itself. And it pairs neatly with Node.js running TypeScript natively: Node strips and runs your .ts files with no build step, while TypeScript 7 does the actual type-checking far faster on the side. Execution and verification, both sped up, from the two most important tools in the stack.

There is a cost angle, too. Faster feedback means engineers spend less time waiting and more time building, which is a direct input into how much a project takes to deliver. If you are scoping or briefing work, a modern stack that keeps iteration tight is one of the quiet levers on what a website or app actually costs to build.

How it fits the wider 2026 tooling shift

TypeScript 7 is not an isolated event. It is part of a broader move across web tooling toward native, compiled cores — the same logic behind fast Rust- and Go-based bundlers and formatters that displaced their JavaScript predecessors over the last few years. As more day-to-day code is scaffolded by AI coding tools, the value of a compiler that can type-check a large, machine-generated project in seconds only grows: faster verification is exactly what you want when more code is being produced, faster, than any human wrote by hand.

The takeaway

TypeScript 7's native Go compiler delivers a genuine, measurable step change — roughly 8x to 12x faster type-checking and a far more reliable editor experience — while keeping the type system, your config and your output the same. That combination, big speed win with small behavioural risk, is unusual for a major version. Test it in a branch, update your toolchain and editor, then roll it into CI where the payoff is largest. For most teams the upgrade will be one of the highest-leverage, lowest-drama changes they make all year.

Frequently asked questions

Is TypeScript 7 really 10x faster?

For full type-checks, yes in the common case. Microsoft's own guidance is 8x–12x faster on full builds, and its VS Code benchmark fell from 125.7 seconds to 10.6 seconds — about 11.9x. The exact multiplier depends on your project, but large codebases see the biggest gains because type-checking dominates their build time.

Do I need to change my code or tsconfig to upgrade?

No. The type system, compiler options and emitted JavaScript are unchanged. You install typescript@7 and run the same tsc commands. The main work is testing that error output matches and updating any tooling that relied on the old compiler's internal API.

What happened to tsgo and the native-preview package?

Those were the preview distribution channels for the native build. With 7.0 GA, the native compiler simply is tsc inside the normal typescript package. The tsgo name now applies only to the bleeding-edge nightly channel.

Why was the compiler ported to Go instead of Rust?

Go compiles to native code and offers real multithreading, and its memory model was close enough to the existing compiler's structure that the team could port the logic directly rather than redesign it. That kept the type system's behaviour identical while unlocking native-code speed and parallelism.

Should I upgrade a large production codebase now?

For most projects, yes — after a branch test. Pin typescript@7, run your full type-check and tests, diff the diagnostics, and update editor and build tooling. Roll it into CI last. Codebases with heavy custom transformers or deep reliance on compiler internals should verify their tooling has a 7.0-compatible release first.