TypeScript 7 (tsgo): 10x Faster Compiler in 2026

TypeScript 7 is a native port of the compiler and tooling from JavaScript to Go. Microsoft says it runs about 10x faster than TypeScript 6, and you can install the public beta today with one npm command. Here's exactly what shipped, what breaks, and when the stable release is expected — sourced from Microsoft's own announcements.

TL;DR

• TypeScript 7 (codename "Corsa") is a native port of the tsc compiler, language service, and tooling from the bootstrapped JavaScript codebase to Go.¹²
• Microsoft says it is "often about 10 times faster than TypeScript 6.0," thanks to native code speed plus shared-memory parallelism.²
• The public beta landed on April 21, 2026. Install it with npm install -D @typescript/native-preview@beta and run tsgo in place of tsc.²
• On Microsoft's published tsc benchmarks, the native port checked the 1.5M-line VS Code codebase in 7.5s vs 77.8s (10.4x) and cut editor project-load time from ~9.6s to ~1.2s (8x), with roughly half the memory.¹
• It introduces real breaking changes: strict on by default, module defaults to esnext, and a list of deprecated flags (target: es5, baseUrl, moduleResolution: node, and others) that are now hard errors.²
• As of mid-June 2026, TypeScript 7 is still in beta, moving toward a release candidate. Microsoft's stated plan put stable within about two months of the April beta — i.e., roughly late June 2026.²

What You'll Learn

• What TypeScript 7 actually is, and how it differs from TypeScript 6
• The performance numbers Microsoft published — and what the baseline really is
• How to install tsgo and run it side-by-side with your current tsc
• The new parallelism controls: --checkers, --builders, and --singleThreaded
• Which config flags and patterns break when you upgrade
• Why Microsoft chose Go over Rust or C#
• Where the stable 7.0 release stands as of June 2026

What TypeScript 7 Is

TypeScript 7 is the release name for the native port of the TypeScript compiler. For its entire life, tsc has been written in TypeScript and run as JavaScript on Node.js, which means it inherits V8's garbage collector and single-threaded execution model. Over roughly a year, Microsoft rebuilt that codebase in Go.¹²

A key detail that gets lost in the "rewrite" headlines: this is a port, not a redesign. As the TypeScript team put it, the Go codebase "was methodically ported from our existing implementation rather than rewritten from scratch, and its type-checking logic is structurally identical to TypeScript 6.0."² In other words, the type system you already know is unchanged — the same .ts files that compile under TS 6 are meant to compile identically under TS 7, just much faster.

Microsoft uses two internal codenames you'll see in commits and discussions: "Strada" for the original TypeScript codebase, and "Corsa" for the native port.¹ For naming going forward, the team refers to them simply as TypeScript 6 (JS) and TypeScript 7 (native).¹

How Much Faster Is It, Really?

The headline is "10x," and Microsoft's framing in the beta announcement is specific: TypeScript 7.0 is "often about 10 times faster than TypeScript 6.0."² That speedup comes from two things working together — compiled native code instead of interpreted JavaScript, and shared-memory parallelism that the old single-threaded runtime couldn't exploit.²

When Microsoft first announced the native port in March 2025, it published tsc command-line timings across well-known open-source codebases. These compare the native port against the existing JavaScript-based compiler:¹

The speedups cluster around an order of magnitude regardless of project size, which is why the "10x" shorthand stuck.¹

The number most developers will actually feel, though, is editor startup. Using the VS Code codebase as a benchmark, Microsoft measured the time to load the entire project in the editor dropping from about 9.6 seconds to about 1.2 seconds — an 8x improvement in project-load time.¹ Overall memory usage came in at roughly half the JavaScript implementation, with the team noting they hadn't even optimized for memory yet.¹

One honest caveat for anyone repeating these figures: the benchmark table above is from the original 2025 announcement and measures the native port against the then-current JS compiler. The "10x vs. TypeScript 6.0" claim is the one Microsoft attached to the actual 7.0 beta.¹² Both are Microsoft's own numbers on Microsoft's own hardware — representative, but not an independent benchmark.

Installing and Running tsgo

You don't have to wait for the stable release to try it. The beta ships under a preview package name with a separate binary so it can't collide with your existing toolchain.²

npm install -D @typescript/native-preview@beta

Then run tsgo exactly where you'd run tsc:

npx tsgo --version
# Version 7.0.0-beta

npx tsgo --project tsconfig.json

The tsgo executable "has the same behavior on all TypeScript code as tsc from TypeScript 6.0 — just much faster."² Note the package name and binary are temporary: at stable release, TypeScript 7 will publish under the regular typescript package and use the familiar tsc entry point.²

For the editor, install the TypeScript Native Preview extension for VS Code. It's built on the Language Server Protocol (LSP) — a long-planned infrastructure change that aligns TypeScript with how other languages integrate into editors — so it can run in most modern editors, not just VS Code.¹²

Running side-by-side with TypeScript 6

Because the stable 7.0 will eventually claim the tsc name, Microsoft published a compatibility package, @typescript/typescript6, which exposes a tsc6 entry point and re-exports the TypeScript 6.0 API.² That lets tooling which imports from typescript directly (typescript-eslint, for example) keep working. The recommended approach is an npm alias:²

npm install -D typescript@npm:@typescript/typescript6

The New Parallelism Controls

The biggest architectural change Go unlocks is doing work in parallel. TypeScript 7 parallelizes parsing, type-checking, and emitting — steps that the single-threaded JavaScript runtime had to do one at a time.² Three new flags give you control over that:

• --checkers sets the number of type-checking workers. The default is 4. Each worker gets its own view of the program; given the same inputs they divide work identically and produce the same results. More checkers can speed up large codebases on many-core machines, at the cost of memory. CI runners with few cores may want fewer.²
• --builders controls how many project-reference builders run at once — useful for monorepos with many composite projects. It multiplies with --checkers, so --checkers 4 --builders 4 can spawn up to 16 type-checkers simultaneously, which Microsoft notes "may be excessive."²
• --singleThreaded forces everything onto one thread. It's meant for debugging, apples-to-apples comparisons with TypeScript 6, or resource-constrained environments.²

One subtlety worth flagging for teams: in rare cases, varying --checkers can surface order-dependent results, so Microsoft suggests fixing a checker count across your team for consistency.²

Breaking Changes You Need to Plan For

"Structurally identical type-checking" does not mean "drop-in upgrade." TypeScript 7 adopts TypeScript 6.0's new defaults and turns previously deprecated options into hard errors.² This is exactly why Microsoft shipped TypeScript 6 first as a JavaScript-based bridge release — it introduced the deprecations so the jump to 7 would be smaller.²³

The notable default changes:²

• strict is now true by default.
• module defaults to esnext.
• target defaults to the current stable ECMAScript version immediately preceding esnext.
• noUncheckedSideEffectImports is true by default.
• stableTypeOrdering is true and cannot be turned off.
• rootDir now defaults to ./ (projects whose tsconfig.json sits outside src should set it explicitly).
• types now defaults to [] — list the @types packages you need (e.g. ["node", "jest"]) explicitly.

And the deprecated options that are now hard errors with no-op behavior:²

• target: es5 and downlevelIteration are no longer supported.
• moduleResolution: node/node10 and moduleResolution: classic are gone — use nodenext or bundler.
• module: amd, umd, system, and none are gone — use esnext or preserve with a bundler.
• baseUrl is no longer supported — make paths relative to the project root instead.
• esModuleInterop and allowSyntheticDefaultImports can no longer be set to false.

There's also a quieter set of JavaScript/JSDoc changes: TypeScript 7 reworked its JS support to behave more like its .ts analysis, so some Closure-style JSDoc patterns (@enum, @class on a function, standalone ? as a type, Closure function syntax) are no longer specially recognized.² If you have a large JS-with-JSDoc codebase, budget time to test it.

If you maintain tooling, note one more thing: a stable programmatic API won't arrive until TypeScript 7.1 or later — "at least several months" after the 7.0 beta.² If your build depends on importing the compiler API, that's a reason to stay on TypeScript 6 for now.

Why Go, and Not Rust or C#?

This was the internet's favorite argument when the port was announced, so it's worth getting right. Lead architect Anders Hejlsberg said the team prototyped the port in several languages and found Go the best fit. The core reason is pragmatic: the existing compiler leans heavily on shared mutable data structures, reference graphs, and pointer-heavy traversals, and translating that to Go was far more straightforward than to Rust — whose borrow checker would have forced a fundamental redesign of those data structures.⁴

Hejlsberg described Go as roughly the lowest-level language that still offered optimized native code on every platform, good control over data layout, support for cyclic data structures, automatic memory management via a garbage collector, and strong concurrency through goroutines.⁴ TypeScript dev lead Ryan Cavanaugh put the Rust question succinctly: Rust "succeeds wildly at its design goals, but 'is straightforward to port to Rust from this particular JavaScript codebase' is very rationally not one of its design goals."⁴

So this wasn't a referendum on which language is "better" — it was about which language let Microsoft port a decade-old, pointer-graph-heavy codebase with the highest fidelity and lowest risk.

Where the Stable Release Stands (June 2026)

At the April 21, 2026 beta, Microsoft said its plan was to release TypeScript 7.0 within the next two months, with a release candidate a few weeks prior.² That puts the stable target at roughly late June 2026. As of mid-June 2026, TypeScript 7 is still in beta, with the team focused on bug fixes, compatibility, editor polish, and a more efficient --watch implementation.

It is not vaporware, though. Microsoft says the beta has been running on multi-million-line codebases inside and outside the company, and that teams at Bloomberg, Canva, Figma, Google, Lattice, Linear, Miro, Notion, Slack, Vanta, Vercel, and VoidZero tested pre-release builds, reporting similar speedups.² The "beta" label here is more conservative than it sounds — Microsoft explicitly says you can "probably start using this in your day-to-day work immediately."²

If you want to go deeper on the language-design tradeoffs behind all this, our deep dive into Python, JavaScript, TypeScript, Go, and Rust covers why these ecosystems keep converging on native tooling. And if you're upgrading a TypeScript service, our gRPC in Node.js and TypeScript production guide and MCP server in TypeScript tutorial are both built on configs that benefit directly from tsgo's faster checks.

The Bottom Line

TypeScript 7 is the most consequential change to the TypeScript toolchain in a decade — not because the language changed, but because the compiler got an order of magnitude faster without changing the semantics you depend on. The practical playbook today: install @typescript/native-preview, run tsgo against your CI and local builds to confirm the speedup, and use the beta window to clean up the tsconfig.json flags that will become hard errors. Adopting TypeScript 6 first makes the eventual jump to 7 almost boring — which, for a port this ambitious, is exactly what you want.