TypeScript 7 Is GA: A Staged Rollout Plan for the API Gap

The Go-based native port of TypeScript is no longer a preview. On July 8, 2026, Microsoft announced the general availability of TypeScript 7.0 — the same type system you already rely on, rebuilt in Go for "typically… between 8x and 12x" faster full builds. The install is boring, which is the point: npm install -D typescript now gives you the native tsc.

We covered the mechanics of the fast compiler when the beta landed in April. This post is about the harder question every team hits the moment they try to adopt the stable release: TypeScript 7.0 ships without a programmatic API, and a large part of your toolchain depends on that API. Getting the build-time win without breaking your lint, your transformers, or your framework's template checker takes a deliberate rollout. Here is the plan.

What GA changed since the previews

If you tried the previews, muscle memory will trip you up. Three things are different now:

• The binary is tsc, not tsgo. During the preview you installed @typescript/native-preview and ran tsgo. The stable release ships under the normal typescript package and provides the standard tsc executable. There is no separate tsgo in stable.
• Nightlies move to the typescript package. The @typescript/native-preview package (which peaked at over 8.5 million weekly downloads) is being retired for day-to-day use. Going forward, nightly builds resume under typescript with the next tag: npm install -D typescript@next.
• The parallelism flags are marked experimental. --checkers, --builders, and --singleThreaded are all still here and still useful, but treat their names and defaults as not-yet-frozen.

For a plain application — no custom compiler plugins — that is the whole migration: bump typescript to ^7, run npx tsc, and enjoy the speedup.

The numbers are real, and CI is where you feel them

Microsoft's published build-time comparisons run TypeScript 7 at its default of --checkers 4:

Codebase	TypeScript 6	TypeScript 7	Speedup
vscode	125.7s	10.6s	11.9x
sentry	139.8s	15.7s	8.9x
bluesky	24.3s	2.8s	8.7x
playwright	12.8s	1.47s	8.7x
tldraw	11.2s	1.46s	7.7x

Aggregate memory use also drops, by roughly 6% to 26% across those projects. But the figures that matter for a team's day are the production reports. Slack engineers said TypeScript 7 cut CI type-checking from about 7.5 minutes to 1.25 minutes and eliminated 40% of their merge-queue time. Microsoft's own News Services team estimated it saved 400 hours a month of waiting on CI. In the editor, opening a file with an error in the VS Code codebase went from about 17.5 seconds to under 1.3 — over 13x faster — and the new language server reportedly reduced failing language-server commands by more than 80% versus 6.0. That editor latency is where individual developers notice the difference every hour.

The catch: no API until 7.1

Here is the constraint that shapes everything. As the release states plainly: "While TypeScript 7.0 is here, it does not ship with an API." A new — and deliberately different — programmatic API is expected in TypeScript 7.1. Until then, anything that imports from typescript and calls into the compiler cannot run against the native build.

That is a bigger blast radius than it sounds, because so much tooling embeds the compiler:

• typescript-eslint imports the compiler for type-aware lint rules.
• ts-morph, custom AST transformers, and codegen call the compiler API directly.
• Bundler loaders — ts-loader for webpack and similar — depend on it.
• Framework template checkers built on Volar — vue-tsc, svelte-check, Astro and MDX tooling — and Angular's template type-checking all embed TypeScript into their own language services.

The GA notes are explicit that "workflows that use Vue, MDX, Astro, Svelte, and others will likely not yet be able to leverage TypeScript 7," and that this is "a point-in-time issue" the team is committed to fixing. So the answer is not "wait for 7.1" for everyone — it's to run the two versions side by side.

The staged rollout: TypeScript 7 for the build, 6.0 for the tools

Microsoft anticipated this and shipped a compatibility package, @typescript/typescript6, that provides a tsc6 executable and re-exports the 6.0 API. The recommended setup uses npm aliases so that the bare typescript specifier — the one your lint config and editor plugins resolve — points at 6.0, while the fast compiler is installed alongside it. From the announcement:

{
  "devDependencies": {
    "@typescript/native": "npm:typescript@^7.0.2",
    "typescript": "npm:@typescript/typescript6@^6.0.2"
  }
}

The mechanics are worth understanding rather than copy-pasting blindly. The typescript alias resolves to the 6.0 compatibility package, which is what typescript-eslint and other API consumers import, and it provides the tsc6 binary. The second alias installs the real TypeScript 7, which ships its own tsc, so npx tsc runs the native compiler. The net effect: your CI type-check gate and local tsc --watch get the 10x win, while lint and framework tooling keep working on the API they still need.

Wire that into your scripts so the split is explicit and nobody has to remember which binary is which:

{
  "scripts": {
    "typecheck": "tsc --noEmit",
    "typecheck:compat": "tsc6 --noEmit",
    "lint": "eslint ."
  }
}

For editors, install the TypeScript Native Preview extension for VS Code to get the fast language server today; built-in support is rolling into VS Code itself over the coming weeks, and Visual Studio enables it automatically based on your workspace. If you work in a Vue, Svelte, Astro, or Angular codebase where the editor plugin isn't ready, run the "Disable TypeScript 7 Language Server" command from the palette to fall back to 6.0 for editing — while still using tsc at the command line for fast, project-wide error detection.

A decision framework

Not every project should move the same way this quarter:

• Plain TypeScript, React, or Node service, no custom compiler plugins? Adopt TypeScript 7 as your default now. Confirm your tsconfig.json is clean under 6.0's defaults first — strict on, rootDir and types set explicitly, and none of the removed options like baseUrl or moduleResolution: node10 — then bump and go.
• You rely on typescript-eslint, custom transformers, or webpack loaders? Use the side-by-side alias setup. Run tsc (7.0) for type-checking and CI; keep tsc6 and the 6.0 API for the tools that need it.
• You're on Vue, Svelte, Astro, MDX, or Angular? Keep 6.0 as your editor and template-check baseline for now, but you can still add a fast tsc CLI gate for project-wide errors. Plan the full switch for after 7.1 lands the stable API.

One migration note carries over from 6.0 and still bites: 7.0 turns 6.0's deprecations into hard errors and adopts its stricter defaults. The cheapest path is to get green on TypeScript 6.0 before you flip to 7.0, so the jump is purely about speed and not about untangling old tsconfig settings under time pressure.

Takeaways

TypeScript 7 is the rare upgrade where the compiler is ready before the ecosystem around it is — so the win is real but the rollout needs care.

• Ship the fast tsc where nothing blocks it. For plain TS/React/Node apps, adopt now; the CI and editor gains are immediate.
• Use @typescript/typescript6 and npm aliases to run TypeScript 7 for builds while typescript-eslint, transformers, and bundler loaders stay on the 6.0 API.
• Framework users get a CLI-only win today. Add a fast tsc type-check gate now; keep 6.0 for editor and template checking until 7.1.
• Land on 6.0's defaults first. A clean 6.0 build makes the 7.0 cutover mechanical.
• Watch for TypeScript 7.1. The new programmatic API is what unblocks the rest of the toolchain, on the team's usual 3–4 month release cadence.

Sources: Announcing TypeScript 7.0 · Announcing TypeScript 7.0 RC · Iterating faster with TypeScript 7 (VS Code blog) · microsoft/typescript-go