TypeScript 7.0 is GA: a 10x compiler to adopt in stages (2026)

Summary. TypeScript 7.0 reached general availability on July 8, 2026, three weeks after its June 18 release candidate. It is a native rewrite of the compiler in Go, internally called Project Corsa, and Microsoft measures it at 8x to 12x faster on full builds. On the VS Code codebase, a full type check dropped from 125.7 seconds on TypeScript 6 to 10.6 seconds on TypeScript 7, an 11.9x cut. The new binary is tsgo, shipped in the @typescript/native-preview package. The catch is not the speed. It is that TypeScript 7.0 has no stable programmatic API, so typescript-eslint, ts-jest, ts-morph, and the template type-checkers behind Vue, Svelte and Astro cannot run on it. That API is targeted for TypeScript 7.1, which Microsoft says is several months out. The right move for most teams in 2026 is to run tsgo as a fast, non-blocking type checker beside tsc, capture the speed in CI and the editor, and keep TypeScript 6.x as the source of truth for emit and tooling until 7.1 lands.

If you manage a large TypeScript codebase, the question this quarter is not whether the Go compiler is fast. Anders Hejlsberg, the lead architect of TypeScript at Microsoft, put the number plainly: "We quickly realized we could get 10x, half of it from being native code, and the other half from being able to take advantage of shared memory concurrency." The question is whether your linter, your test runner, your .d.ts emit and your framework tooling survive the upgrade. Right now, most of them do not. A team whose CI type check runs 90 seconds today, 200 times a day, is burning both wall-clock developer time and CI minutes at $0.006 per Linux minute. The speed is worth having. Ripping out tsc to get it is not.

This guide covers what actually shipped, exactly what breaks, and a four-phase plan to bank the performance now without a red pipeline.

What shipped on July 8, 2026

TypeScript 7.0 is the first stable release built on the Go compiler. Microsoft published the announcement on its TypeScript DevBlogs and described the port as a faithful reimplementation: the same type system, the same inference, the same diagnostics, rebuilt in Go to use native code and shared-memory concurrency. Hejlsberg first announced the plan to rewrite the compiler in Go more than two years earlier, and the work carried the codename Project Corsa.

The headline numbers are consistent across Microsoft's own measurements and independent coverage. The Register and Techzine both reported the 8x to 12x range on full builds, matching Microsoft's figures. The VS Code codebase check, the example Microsoft has used since the first previews, fell from 125.7 seconds to 10.6 seconds. Memory use roughly halves on large projects, because a native binary does not carry a JavaScript heap.

The tooling arrives in three pieces. The compiler binary is tsgo, distributed through the @typescript/native-preview package on npm. You install it beside your existing TypeScript rather than on top of it:

            npm install -D @typescript/native-preview
npx tsgo --noEmit
          

For editors, there is a separate TypeScript Native Preview extension for VS Code. Editor support has been the most mature part of the native effort for months, and for most teams the language-service experience in the editor is already stable enough for daily use.

One structural change sits behind all of this. TypeScript 6.0 is the last major release built on the JavaScript compiler. Microsoft is running a dual track: the 6.x line stays on the classic JavaScript codebase for compatibility, and the 7.x line is the native Go compiler going forward. That is why "migrate to TypeScript 7" is not a one-line version bump. You are moving between two compiler implementations, and only one of them currently supports the plugin ecosystem your repo depends on.

Why you cannot just install typescript@7 and move on

The classic TypeScript compiler exposes a programmatic API, historically called Strada, that tools import to walk your syntax tree and pull type information out of the checker. typescript-eslint uses it for type-aware lint rules. ts-jest uses it to transform and type-check tests. ts-morph and dozens of codegen tools use it. IDE plugins for Vue, Svelte and Astro use it through Volar to type-check the code inside templates and single-file components.

TypeScript 7.0 does not ship that API. A stable programmatic API for the native compiler is targeted for TypeScript 7.1, and Microsoft has said it is at least several months away. Until it lands, anything that imports from typescript and calls into the compiler is not guaranteed to work against the Go build.

You can watch this play out in the open. A TypeScript 7 support request filed against typescript-eslint on GA day, issue #12518, was closed as "not planned", because the fix genuinely sits on the TypeScript 7.1 side rather than in the linter. The published typescript-eslint package refuses to install alongside typescript@7 at all: its peer dependency range only allows TypeScript below 6.1.0, so npm install throws an ERESOLVE error. The ESLint core team is tracking its own update in issue #21070, blocked behind the same API. The Vue team is tracking native-compiler support in vuejs/language-tools issue #5381. Svelte and Astro, which share the Volar tooling foundation, are in the same position: their template and component type-checking cannot run on tsgo yet.

For a plain application repo that lint-checks with type-aware rules and tests with ts-jest, that means a naive upgrade to typescript@7 does not fail gracefully. It fails at npm install. For an Astro or Vue project, tsgo will happily type-check your .ts files but cannot check the types inside your .astro or .vue templates, which is often where the bugs hide.

What tsgo can and cannot do today

Even setting the plugin API aside, the native preview is not yet a drop-in replacement for tsc on the command line. Microsoft has been explicit that the previews are missing functionality the stable JavaScript compiler has today.

The gaps that matter most for build pipelines: --build mode for project references is not complete, --declaration emit for shipping .d.ts files is not there yet, and some downlevel emit targets are unfinished. The --watch mode exists but can be less efficient than the classic compiler in some setups, and teams have worked around that by pairing tsgo --incremental with a runner like nodemon.

There is one more caveat that belongs at the top of any migration checklist: the native compiler's diagnostics do not yet match the classic compiler 100%. In practice that cuts both ways. Some teams running tsgo on real monorepos have found it flags genuine bugs the old checker missed, which is good. But it also means you cannot assume a green tsgo run and a green tsc run are identical. You have to measure the difference before you trust it as your gate.

The honest reading: tsgo in July 2026 is an outstanding type checker and editor engine, and an incomplete build tool. Those two facts drive the whole migration strategy.

The migration that actually works: run both

The recommended pattern from the field, and the one Microsoft's own guidance points toward, is a sidecar rollout. You do not replace tsc. You add tsgo next to it, prove the diagnostics agree, capture the speed where it is safe, and only flip the default after 7.1 restores the tooling you removed.

Start by measuring, not switching. Install the preview and run both checkers several times so caching and machine noise average out:

            npm install -D @typescript/native-preview
# run each 7+ times, compare the reported diagnostics, then the timings
npx tsc --noEmit
npx tsgo --noEmit
          

If the diagnostics diff is zero across your repo, tsgo is safe to use as a fast, non-blocking signal. Wire it into CI beside the existing blocking tsc job rather than in place of it:

            # .github/workflows/typecheck.yml
jobs:
  typecheck:            # blocking, still the gate
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - run: npm ci
      - run: npx tsc --noEmit
  typecheck-native:     # non-blocking speed + diagnostics probe
    runs-on: ubuntu-latest
    continue-on-error: true
    steps:
      - uses: actions/checkout@v5
      - run: npm ci
      - run: npx tsgo --noEmit
          

Locally, developers can add a fast script and use the Native Preview editor extension while tsc stays the source of truth for emit, lint and framework checks:

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

The sequencing below keeps the pipeline green at every step. The only phase that waits on Microsoft is the last one.

This is the same discipline our teams apply to any toolchain swap. The real cost is never the flag you flip; it is the tooling downstream of it. Here the downstream is your linter, your test transform and your framework's template checker, and three of those are on hold until 7.1.

Who gets paid back first

Not every repo should bother yet. The teams that gain the most from a shadow rollout today share a profile: a CI type check that already runs longer than about 10 seconds, which usually means 500 or more files, and a monorepo where editor responsiveness has started to sag. For those teams the speed is not a vanity metric. It is minutes off every pull request and a noticeably snappier editor.

The dollar cost of slow type checks is modest on its own. GitHub-hosted standard Linux runners bill $0.006 per minute in 2026, down from $0.008 after a January 1 cut, with 2,000 free minutes a month on private repositories and unmetered minutes on public ones. A 90-second tsc --noEmit run 200 times a day is about 300 minutes, near $1.80 a day or roughly $54 a month, and tsgo would shrink that by an order of magnitude. The bigger number is human. Two hundred checks a day at a minute and a half each is five hours of cumulative waiting spread across the team, every day. That is the figure worth optimising.

India-specific considerations

For Indian product teams and the global capability centres running large TypeScript monorepos out of Bengaluru, Gurugram and Pune, the calculus tilts toward acting sooner on the shadow rollout, for two reasons. First, headcount-heavy engineering orgs feel cumulative wait time acutely: a 40-engineer team that each triggers a dozen type checks a day multiplies the five-hour figure fast, so at senior engineering rates the reclaimed developer time dominates any CI bill. Second, teams that self-host CI runners on their own cloud footprint pay per compute-minute directly, so cutting type-check time is a line-item saving, not an abstraction.

The constraint is the same everywhere: if your stack is Vue, Svelte or Astro, template type-checking stays on tsc until 7.1, so plan the rollout around your framework, not just your .ts files. A pragmatic split is to let backend and shared-library packages, which are usually plain TypeScript, adopt the tsgo shadow job first, and hold the front-end app packages until Volar tooling ships native support. This mirrors the phased approach we recommend in our Interop 2026 web platform developer guide for rolling platform changes through a monorepo without a big-bang cutover.

Adopt now, or wait?

The decision splits cleanly by team type. If you run a large plain-TypeScript backend or library monorepo with type-aware lint you can temporarily keep on the TypeScript 6 job, start Phase 0 this week. If you ship a Vue, Svelte or Astro front end, install the preview to feel the editor speed but hold the CI change until template checking works on the native API. If your build depends on --declaration emit to publish packages, you are on TypeScript 6 for emit regardless until that lands in a later 7.x preview.

What nobody should do is a blind npm install typescript@7 on a repo with typescript-eslint and expect it to work. It will not install. The upgrade that pays off in 2026 is additive: tsgo beside tsc, speed captured where it is safe, and the default flipped only once TypeScript 7.1 gives the ecosystem its API back. Teams already living on native TypeScript workflows, such as those using Node.js native TypeScript type stripping to run .ts without a build step, will find the shadow-compiler pattern familiar, and teams on Next.js can read how the framework wires the Go and Rust toolchains together in our note on the Next.js 16.3 TypeScript 7 toolchain. If you are still weighing runtimes underneath all of this, our Bun vs Node.js backend runtime decision covers the trade-offs that interact with your compiler choice.

FAQ

How eCorpIT can help

eCorpIT is a CMMI Level 5 and ISO 27001:2022 certified engineering organisation in Gurugram, and our senior-led teams run toolchain migrations on large TypeScript monorepos without stopping delivery. We can benchmark tsgo against your current tsc gate, wire a non-blocking shadow job into your CI, and sequence the cutover around your framework and emit constraints so nothing turns red. If you want a measured TypeScript 7 rollout plan for your codebase, talk to our engineering team.

References

1. Announcing TypeScript 7.0 (Microsoft DevBlogs)

1. A 10x Faster TypeScript (native port) (Microsoft DevBlogs)

1. Announcing TypeScript Native Previews (Microsoft DevBlogs)

1. Announcing TypeScript 7.0 RC (Microsoft DevBlogs)

1. @typescript/native-preview (npm)

1. typescript-eslint issue #12518: TypeScript 7.0 support (GitHub)

1. eslint/eslint issue #21070: Update to TypeScript 7 (GitHub)

1. vuejs/language-tools issue #5381: TypeScript Native / tsgo support (GitHub)

1. Speedier type checks in TypeScript 7.0 as first stable Go release ships (The Register)

1. TypeScript 7.0 lands with Go rewrite for 10x faster builds (Techzine)

1. Simpler pricing for GitHub Actions (2026) (GitHub Changelog)

_Last updated: July 28, 2026._