TypeScript 7 Is in Beta: How to Try the 10x-Faster Native Compiler Today

The single biggest performance change to hit the TypeScript ecosystem in a decade is now usable in your day job. On April 21, 2026, Microsoft announced TypeScript 7.0 Beta — the result of a year-long effort to port the entire compiler and language service from JavaScript to Go. The team's headline claim is blunt: TypeScript 7.0 is "often about 10 times faster" than 6.0, and the beta is stable enough to put into your CI pipelines today.

If you maintain a large TypeScript codebase, this is the upgrade you have been waiting for through every slow tsc --noEmit and every multi-second editor stall. Here is what is actually shipping, how to run it now, and the migration details that will trip you up if you skip the reading.

What "native port" actually means

TypeScript has always been written in TypeScript and compiled to JavaScript that runs on Node. That bootstrapping is elegant, but it caps how fast the compiler can ever be. The native effort — codenamed "Corsa," versus "Strada" for the original codebase — rewrites that toolchain in Go to get native code speed, real shared-memory parallelism, and roughly half the memory usage.

Crucially, this is a port, not a rewrite. As the team stresses, the Go code "was methodically ported from our existing implementation rather than rewritten from scratch, and its type-checking logic is structurally identical to TypeScript 6.0." That is the reason you can trust it: the same type system, the same decade of accumulated test suite, the same diagnostics — just dramatically faster.

The numbers from the original 10x announcement are worth internalizing because they are measured on real projects, not synthetic benchmarks:

Codebase	Size (LOC)	tsc (JS)	Native	Speedup
VS Code	1,505,000	77.8s	7.5s	10.4x
Playwright	356,000	11.1s	1.1s	10.1x
TypeORM	270,000	17.5s	1.3s	13.5x
date-fns	104,000	6.5s	0.7s	9.5x

Editor latency improves on the same order. Loading the full VS Code project in the editor drops from about 9.6 seconds to about 1.2 seconds — an 8x improvement in project load time, which is the gap between "open the repo and start typing" and "open the repo and go get coffee."

Running tsgo today

The beta ships under a separate package so it can sit alongside your existing typescript install without conflict. Install it as a dev dependency:

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

The executable is called tsgo, and it is a drop-in for tsc:

npx tsgo --version
# Version 7.0.0-beta

npx tsgo --noEmit

The package name will eventually become typescript and the binary will become tsc, but for now the separate name is deliberate — it lets you run tsgo and tsc side by side and diff the output. The fastest, lowest-risk way to evaluate it is to add a parallel script to package.json and compare against your existing type-check on a few branches:

{
  "scripts": {
    "typecheck": "tsc --noEmit",
    "typecheck:native": "tsgo --noEmit"
  }
}

For the editor, install the TypeScript Native Preview extension for VS Code. It is built on the Language Server Protocol, so the same engine that powers the CLI powers completions, go-to-definition, and find-all-references — and because it speaks LSP, it runs in most modern editors rather than being locked to VS Code.

The new parallelism controls

The speedup is not only "native code is faster." TypeScript 7.0 now parses, type-checks, and emits in parallel, and it exposes flags to tune that for your hardware.

Type-checking is the hard part to parallelize because files share type information and ordering can matter. The compiler solves this by spawning a fixed number of type-checker workers that each get an identical view of the program, so results stay deterministic. The default is four, controlled by --checkers:

# More workers on a beefy dev machine
tsgo --noEmit --checkers 8

# Fewer on a constrained CI runner to avoid overhead
tsgo --noEmit --checkers 2

For monorepos, --builders controls how many project-reference projects build at once. Note that it multiplies with --checkers — --checkers 4 --builders 4 permits up to 16 concurrent type-checkers, which is usually too many. Tune to your core count and memory rather than maxing both.

There is also a --singleThreaded flag that caps everything to one thread. It is useful for debugging, for comparing apples-to-apples against TS6, or when an outer process is already orchestrating parallel builds and you do not want nested contention.

A practical note for CI: pin --checkers to a fixed value across your team. In rare cases varying the checker count can surface order-dependent type results, so a consistent number keeps everyone — and your pipeline — seeing identical output.

The migration gotchas live in TypeScript 6

Here is the part teams underestimate. TypeScript 7.0 adopts TypeScript 6.0's new defaults and turns 6.0's deprecations into hard errors. So the real migration work is adopting 6.0 cleanly first; once your project is happy under 6.0 without ignoreDeprecations, the jump to 7.0 is mostly mechanical. Adopt 6.0 first and you de-risk the whole thing.

The default changes most likely to surprise you, per the beta announcement:

• strict is now true by default.
• module defaults to esnext, and target to the current stable ECMAScript version just below esnext.
• rootDir now defaults to ./. Projects whose tsconfig.json sits above a src directory need to set it explicitly.
• types now defaults to [] instead of pulling in every @types package automatically. You must list what you depend on.

Those last two cause the most confusion, and both have simple fixes:

{
  "compilerOptions": {
    "rootDir": "./src",
    // Only the global types you actually rely on
    "types": ["node", "jest"]
  },
  "include": ["./src"]
}

A set of long-deprecated options are now hard errors with no-op behavior, including target: es5, downlevelIteration, moduleResolution: node/node10 and classic, baseUrl, and the legacy module values amd, umd, systemjs, and none. The recommended replacements are nodenext or bundler for resolution and esnext or preserve for module output. If your tsconfig still carries any of these from a project that started years ago, fix them now under 6.0 rather than discovering them on the 7.0 cutover.

JavaScript-with-JSDoc codebases get a stricter, more consistent analysis too — Closure-style function syntax, @enum, and a standalone ? as a type are no longer specially handled. The team tracks these differences in a CHANGES.md file in the typescript-go repo, which is the canonical place to check before you migrate a JS-heavy project.

One caveat for tooling authors

If you consume the TypeScript compiler API programmatically — custom transformers, codegen, lint rules that import from typescript — note that a stable programmatic API for the native compiler is not expected until TypeScript 7.1 or later. The beta is production-ready for type-checking and editing, but API-dependent tooling should plan to stay on the 6.0 line a little longer. Microsoft published a @typescript/typescript6 compatibility package with a tsc6 entry point precisely so you can run 7.0 for builds while other tooling keeps importing the 6.0 API.

Takeaways

TypeScript 7.0 is the rare upgrade that is mostly upside: the same type system you already trust, running roughly ten times faster, with a stable beta you can adopt now. The team's stated plan is to release stable within about two months of the April beta, with a release candidate first — so this is the moment to get ahead of it.

If you do three things this quarter, do these: add a tsgo --noEmit script and run it next to your existing type-check to see your real numbers; migrate your tsconfig.json to TypeScript 6.0's defaults so the 7.0 jump is trivial; and have anyone who lives in their editor install the Native Preview extension, because the latency win is where your team will feel it daily. The build-time savings are CI money; the editor savings are focus you get back.

Sources: Announcing TypeScript 7.0 Beta · A 10x Faster TypeScript · microsoft/typescript-go