TypeScript 7.0 Ships a Native Go Compiler — And It Breaks Your Tooling

On July 8, 2026, Microsoft shipped TypeScript 7.0, a full rewrite of the TypeScript compiler and language service from its original TypeScript/JavaScript implementation into Go. Microsoft's own benchmarks, published on the TypeScript team blog, show full-build type-checking times dropping by 8x to 12x across real production codebases including VS Code, Sentry, Bluesky, Playwright, and tldraw. The catch: TypeScript 7.0 ships without a stable programmatic compiler API, which means ESLint's TypeScript plugin, Vue, Angular's template checker, Svelte, and Astro cannot run on it yet. If you maintain a TypeScript codebase, this is a real decision point, not a routine point release.

What shipped

TypeScript 7.0 is the culmination of "Project Corsa," a rewrite effort Microsoft first disclosed in March 2025. Rather than reimplementing TypeScript's type-checking logic from scratch, the team ported the existing checker line-by-line from TypeScript into Go, aiming to keep its behavior structurally identical while gaining native-code execution and real multithreading (something a single-threaded JavaScript compiler can't do). TypeScript 6.0, released earlier in 2026, was explicitly positioned as a "bridge" release to absorb deprecations before 7.0 turned them into hard errors.

The numbers, as published by Microsoft on the official TypeScript devblog:

Memory usage also dropped — by 6% to 26% depending on the project — and with the new --checkers 8 flag (which spreads type-checking across multiple threads) some of those speedups climb further, to as high as 16.7x on VS Code. Editor responsiveness improved too: Microsoft reports that opening a file with type errors in VS Code went from 17.5 seconds to under 1.3 seconds.

These are vendor-published numbers, worth treating as a best case rather than a guarantee — Microsoft picked five codebases it presumably knew would show off the rewrite well. But outside companies quoted in the same post back up the general direction. Slack said TypeScript 7 cut its CI type-checking time from about 7.5 minutes to 1.25 minutes and eliminated 40% of its merge-queue wait time. Canva said its language service went from roughly 58 seconds to around 4.8 seconds to show the first error in an editor. Vanta reported up to 9x on its largest project, and Microsoft's own News Services team said the switch saved roughly 400 engineering-hours a month previously spent waiting on CI builds. These are self-reported by each company in Microsoft's own announcement, not independently audited, but they're specific enough numbers from named organizations to be more than marketing color.

What breaks

TypeScript 7.0 isn't a drop-in upgrade. A batch of previously-optional or deprecated settings became defaults or were removed outright:

• strict is now true by default; module defaults to esnext; target defaults to the current stable ECMAScript version.
• types now defaults to an empty array — ambient @types packages that were picked up automatically before must now be listed explicitly.
• rootDir defaults to ./, which breaks projects whose tsconfig.json sits outside the actual source directory unless they set it explicitly (e.g., ./src).
• target: es5, downlevelIteration, moduleResolution: node/node10, moduleResolution: classic, and module: amd/umd/systemjs/none are no longer supported at all.
• baseUrl is removed; esModuleInterop and alwaysStrict can no longer be turned off.
• Template literal types now preserve Unicode code points correctly, meaning an emoji is treated as one unit rather than a UTF-16 surrogate pair — a subtle but real semantic change for any code doing character-level string type manipulation.

Microsoft's own guidance is to upgrade to 6.0 first, resolve every deprecation warning it surfaces, and only then move to 7.0 — not to jump straight from an older 5.x release.

What's missing

The bigger practical issue for most teams is that TypeScript 7.0 ships without a stable programmatic compiler API. The CLI (tsc) and the language server work today, but tools that hook into the compiler's internals to parse or rewrite TypeScript ASTs do not have anything to hook into yet. Concretely: as of this writing, installing typescript-eslint 8.63.0 alongside typescript@7 fails outright — its package.json still declares a peer dependency range of typescript@">=4.8.4 <6.1.0", and forcing the install anyway produces a runtime crash (Cannot read properties of undefined (reading 'Cjs')) inside its create-program module, per the open tracking issue on the typescript-eslint GitHub repo. Vue's SFC compiler, Angular's template type-checker, Svelte, Astro, and MDX tooling all have the same dependency and are similarly blocked. Microsoft says a new, different API is coming in TypeScript 7.1, with no committed date at time of writing.

For projects that need both — fast CLI builds today and working editor/lint tooling — Microsoft published a workaround: install the native compiler under an aliased package name alongside a compatibility shim that keeps the old TypeScript 6 API available for tools that still need it:

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

That's a real workaround, but it's also a sign the ecosystem hasn't caught up — you end up running two compiler implementations side by side to get full functionality.

What this changes

For a straightforward tsc --noEmit CI check or a plain command-line build, TypeScript 7.0 is very likely a meaningful, low-risk win once you clear the tsconfig migration — the speedups are large enough, and corroborated by enough independent companies, that they're worth planning for. This site's own codebase runs npx tsc --noEmit as a CI gate on every push (see the project's ci.yml), so a multi-x speedup on that step is a concrete, if not urgent, win to plan for once the tooling catches up.

But if your build pipeline leans on typescript-eslint, or if you ship a Vue, Angular, Svelte, or Astro frontend, TypeScript 7.0 is not usable end-to-end today — you'd be running the old compiler for tooling and the new one for raw builds, which adds complexity rather than removing it. The honest recommendation right now is: migrate to TypeScript 6.0 and clear its deprecation warnings this quarter if you haven't already, since that's a prerequisite either way, but hold off on flipping the switch to 7.0 in projects with API-dependent tooling until 7.1 ships a stable API and the ecosystem (typescript-eslint in particular) confirms support. Teams running framework-free, ESLint-light TypeScript builds have less to wait for.

If you're evaluating whether a TypeScript or Next.js codebase is worth modernizing around changes like this, that's the kind of migration assessment covered under Wise Hustlers' development services.

Sources

• Announcing TypeScript 7.0 — Microsoft TypeScript DevBlog
• Announcing TypeScript 7.0 Beta — Microsoft TypeScript DevBlog
• Announcing TypeScript 7.0 RC — Microsoft TypeScript DevBlog
• A 10x Faster TypeScript — Microsoft TypeScript DevBlog
• Microsoft Releases TypeScript 7.0 with a Native Go Compiler, Delivering 10x Faster Builds — InfoQ
• Microsoft steers native port of TypeScript to early 2026 release — InfoWorld
• TypeScript 7.0 RC Moves Microsoft's Go Rewrite Into the Mainline Compiler — Visual Studio Magazine
• microsoft/typescript-go — GitHub
• TypeScript 7.0.2 Support · Issue #12518 — typescript-eslint/typescript-eslint on GitHub