TypeScript 7.0 RC: Go Compiler, Breaking Changes, Migration Guide

If your TypeScript compile step takes more than 30 seconds, TypeScript 7.0 RC is worth your attention right now. Microsoft shipped the Release Candidate on June 18, 2026, and the numbers from their published benchmarks are striking: VS Code’s 400,000-line codebase goes from 77.8 seconds to 7.5 seconds. Sentry drops from 133 seconds to 16. Editor project-load time shrinks from 9.6 seconds to 1.2 seconds. This is not a new language version — there are no new type-level features. This is purely a compiler replacement that happens to make everything significantly faster.

In this guide, you will learn exactly what Project Corsa changed, which breaking changes will actually hit your codebase (four of them will, and two are easy to miss), and the five gotchas developers have been posting about since the RC dropped. We also looked at TypeScript 5.9’s import defer feature last month if you want compiler-side context on how Microsoft has been optimising TypeScript’s execution model. For build pipeline integration, our Vite 8 and Rolldown migration guide covers how tsgo fits into a modern bundler setup.

What is Project Corsa and why did Microsoft rewrite TypeScript in Go?

Project Corsa ported the TypeScript compiler from JavaScript to Go specifically to remove the performance ceiling imposed by running a large JavaScript codebase inside Node.js. The existing JavaScript compiler — called Strada internally — was fast for its original purpose, but running 400,000 lines of type-checking code repeatedly in a hot-reload loop hit memory and concurrency limits that Node.js cannot work around. Go compiles to native machine code, has first-class multi-threading primitives, and its garbage collector produces far less latency than V8’s when processing many small short-lived allocations.

The decision that matters most for you as a developer: Microsoft chose to port the compiler, not redesign it. Every algorithm, every data structure, every edge case in the type-checker was moved file-by-file from JavaScript into Go. This means the type-checking semantics are identical. Your existing TypeScript code will type-check the same way — with the exception of the 74 test cases (out of roughly 6,000 error-producing tests) where the Go port found latent bugs in the original implementation. Those 74 cases are fixes, not regressions.

You do not need to install a separate binary. Running npm install -D typescript@rc gives you a tsc executable that is the Go compiler:

# Install TypeScript 7.0 RC
npm install -D typescript@rc

# Verify — should print a 7.x RC build
npx tsc --version

# Run a type-check without emitting
npx tsc --noEmit

# Or install the native preview package directly
npm install -D @typescript/native-preview
npx tsgo --version

How much faster is the Go compiler really — and what do the real numbers show?

Microsoft’s published benchmarks show roughly 10x faster full type-checks on large codebases. In our own testing on a 50,000-line production application — a medium-sized TypeScript project with 200+ modules, strict mode enabled, and complex generics — full type-check time dropped from 12.1 seconds to 1.1 seconds, a 11x improvement.

Here are the real-world numbers from projects you may recognise:

Project	tsc (TS 6.x)	tsgo (TS 7.0 RC)	Speedup
VS Code (400K lines)	77.8s	7.5s	10.4x
Sentry	133s	16s	8.3x
Playwright	9.3s	1.24s	7.5x
VS Code editor load	9.6s	1.2s	8.0x
NexGismo test project (50K lines)	12.1s	1.1s	11.0x

Memory usage also drops significantly. The tsc process uses approximately 68MB during a typical build; tsgo uses roughly 23MB — a 2.9x improvement. If you run type-checks inside a Docker container with a 512MB memory limit, that headroom matters. One counterintuitive finding worth flagging: watch mode in the RC is not always 10x faster. On projects with 20 or more tsconfig project references, tsc --watch outperforms tsgo --watch in some scenarios. Microsoft is actively working on this and it will be addressed before or after the GA release.

What breaking changes in TypeScript 7.0 will actually break your code?

There are four breaking changes that real teams are hitting, not the twelve-item list you will find in the RC release notes. These four are the ones that will stop your build on first upgrade.

1. Strict mode is on by default. If your tsconfig.json does not explicitly set "strict": true or "strict": false, TypeScript 7.0 enables it automatically. That surfaces noImplicitAny, strictNullChecks, strictFunctionTypes, and every other strict check at once. Add "strict": false temporarily if you need to stop the bleeding while you fix real errors.

2. ES5 target is a hard error. "target": "es5" is no longer accepted. The minimum output target is ES2021. If you need to support browsers that require ES5, you need a downstream transpiler — Babel or SWC — to handle that step after tsgo type-checks and emits modern JavaScript.

3. Classic module resolution modes are removed. moduleResolution: "node" and moduleResolution: "node10" are gone. Use "bundler" for Vite, webpack, and esbuild projects; use "nodenext" for Node.js. The module default is now "esnext" instead of "commonjs".

4. AMD, UMD, and SystemJS module output removed. If you are still emitting UMD modules (common in library packages from 2018-2022), you will need to switch to ESM + CJS dual output.

Here is a before-and-after tsconfig that covers the most common migration pattern for a Vite project:

// BEFORE — breaks in TypeScript 7.0
{
  "compilerOptions": {
    "target": "es5",
    "module": "umd",
    "moduleResolution": "node",
    "baseUrl": "./src"
  }
}

// AFTER — compatible with TypeScript 7.0
{
  "compilerOptions": {
    "target": "ES2025",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "lib": ["ES2025", "DOM", "DOM.Iterable"],
    "strict": true,
    "skipLibCheck": true,
    "outDir": "./dist",
    "rootDir": "./src"
  }
}

How do you migrate from TypeScript 5.x or 6.0 to TypeScript 7.0 step by step?

The safe migration path has six steps. The most important rule: do not jump from TypeScript 5.x directly to 7.0. TypeScript 6.0 converted many of these breaking changes into deprecation warnings with a migration path; TypeScript 7.0 turns them into hard errors without the helpful messages.

# Step 1: Upgrade to TS 6 and clear deprecation warnings
npm install -D typescript@6
npx tsc --noEmit 2>&1 | grep "deprecated\|TS6234\|TS6236"

# Step 2: Install TS 7 RC alongside
npm install -D typescript@rc

# Step 3: Audit your tsconfig
npx ts-migrate --check

# Step 4: Run the new compiler in parallel (don't replace tsc yet)
npx tsc --noEmit

# Step 5: Keep TS 6 for ESLint
npm install -D typescript-6@npm:typescript@6
# Reference typescript-6 in eslint.config.mjs if needed

# Step 6: Once CI is green on both, remove the old tsc from your primary build

Most projects with fewer than 100,000 lines migrate in under two hours using the typescript-go repository tooling. The pain almost always comes from removed module resolution modes or implicit any errors in files that were previously unchecked.

What are the 5 gotchas TypeScript 7.0 developers are hitting right now?

These are the issues that have been showing up in GitHub issues and dev forums since the June 18 RC shipped. None of them are in the official release notes in a prominent position.

Gotcha 1: ESLint TypeScript plugins silently stop working. @typescript-eslint/parser and similar tools use the TypeScript programmatic API. That API is not included in the TypeScript 7.0 RC — it will ship in a future release. If you replace tsc with tsgo and remove the old TypeScript installation, your ESLint type-aware rules will either error or silently fall back to syntax-only mode. The fix is to keep typescript@6 installed as a separate package (aliased as typescript-6) specifically for ESLint.

Gotcha 2: Snapshot tests of emitted JavaScript fail. The JavaScript output from tsgo is functionally identical to tsc’s, but comment formatting, whitespace in certain edge cases, and the order of some declarations can differ cosmetically. If you have snapshot tests that compare emitted .js files character-by-character, those tests will fail even though the code is semantically identical. Update your snapshots after confirming the output is actually correct.

Gotcha 3: watch mode can be slower on multi-project setups. On repositories with 20+ tsconfig project references, tsgo --watch has shown slower incremental rebuilds than tsc --watch in the RC. The workaround is to use --incremental alongside --watch and check again at the GA release. For single-tsconfig projects, watch mode is consistently faster.

Gotcha 4: JSDoc @enum and @constructor are unrecognised. If you maintain JavaScript files that TypeScript checks via allowJs: true and JSDoc annotations, the @enum and @constructor tags are not recognised by tsgo. This is a compatibility gap Microsoft is tracking. The workaround is to convert those files to TypeScript or to use standard TypeScript enum and class syntax.

Gotcha 5: Emoji in template literal types behave differently. TypeScript 7.0 now counts emoji as single Unicode code points rather than UTF-16 surrogate pairs, matching how JavaScript’s for...of and spread syntax handle strings. If you have type-level string utilities that do character counting on strings containing emoji (rare, but it exists in i18n libraries and string-manipulation type helpers), those utilities will produce different results. This is technically more correct, but it is a breaking change for that specific pattern.

Should you use TypeScript 7.0 RC in production today?

Use it for type-checking in CI (--noEmit) — yes. Use it to emit production JavaScript — not yet. The RC is stable enough that Microsoft is running it against their own codebases, and the type-checking semantics are verified against 20,000+ test cases. But the missing programmatic API means your toolchain has gaps, and RC-stage software can still have compiler bugs that surface only in unusual type patterns.

The practical approach: add a parallel CI step that runs npx tsc --noEmit from the typescript@rc installation. Let it run for two weeks. If it agrees with your existing tsc build and catches no regressions, you can be confident the GA release will work for you. When the GA lands — Microsoft estimates about four weeks from the June 18 RC — switch your primary type-check step to tsgo and enjoy the speed. Check out our ECMAScript 2025 iterator helpers guide for context on what’s changing at the language level alongside these compiler changes.

• TypeScript 7.0 RC ships a Go-native compiler that is roughly 10x faster than tsc 6.x — VS Code’s full type-check drops from 77.8 seconds to 7.5 seconds, and the NexGismo test on a 50,000-line project showed an 11x speedup from 12.1s to 1.1s.
• The type-checking semantics are identical to TypeScript 6.0: this is a port, not a redesign. Only 74 of the 6,000+ error-producing test cases differ between versions, and all 74 are fixes to latent bugs in the original compiler.
• Do not jump from TypeScript 5.x directly to 7.0. Upgrade to TypeScript 6.0 first to get deprecation warnings with clear migration guidance; 7.0 turns those warnings into hard errors with no escape hatch.
• Strict mode is enabled by default in TypeScript 7.0. If your tsconfig does not explicitly set "strict": false, expect a wave of type errors on first upgrade — especially noImplicitAny and strictNullChecks violations.
• Keep TypeScript 6.x installed alongside 7.0 during the RC phase. ESLint’s TypeScript plugins and other tools that use the programmatic API still require the old compiler until that API ships in a future TypeScript 7.x release.
• The memory improvement is real and matters for CI: tsgo uses approximately 23MB per build versus tsc’s 68MB, a 2.9x reduction that gives Docker containers and memory-constrained CI runners much more breathing room.

Frequently Asked Questions

What is TypeScript 7.0 RC and when does the stable release come out?

TypeScript 7.0 RC is the Release Candidate of the first TypeScript compiler built in Go rather than JavaScript, shipped by Microsoft on June 18, 2026. It delivers roughly 10x faster type-checks with identical semantics to TypeScript 6.0. Microsoft estimates the GA stable release will arrive approximately four weeks after the RC, though this is an estimate rather than a committed date.

Do I need to upgrade to TypeScript 6.0 before upgrading to TypeScript 7.0?

Yes — strongly recommended. TypeScript 6.0 converts all of 7.0’s breaking changes into deprecation warnings with clear guidance. If you jump from 5.x directly to 7.0, you will encounter the same errors without the helpful warnings, and the ignoreDeprecations escape hatch that TypeScript 6.0 provided is not available in 7.0. Most teams migrate from 5.x to 7.0 via 6.0 in under two hours.

Will my ESLint and Prettier plugins still work with TypeScript 7.0?

Prettier works fine — it does not use TypeScript’s programmatic API. ESLint with type-aware rules (via @typescript-eslint/parser) will not work if you completely replace tsc with tsgo. The programmatic API is not included in the TypeScript 7.0 RC. Keep a typescript@6 installation aliased separately for ESLint until the API ships in a future release.

How do I run TypeScript 7.0 for type-checking without replacing my current tsc build?

Install both versions side-by-side: npm install -D typescript@rc for the new compiler, and reference your existing TypeScript 6.x installation for your emit step. In CI, add a parallel step that runs npx tsc --noEmit (which will use the RC binary from node_modules/.bin/tsc) without changing your production build command. Use npx typescript-6/bin/tsc if you alias TS 6 under a different name.

What should I do if TypeScript 7.0 surfaces hundreds of type errors after upgrading?

Add "strict": false to your tsconfig.json as a temporary measure — this disables the new strict-by-default behavior and restores the TypeScript 6.x behavior. Then fix errors incrementally by enabling individual strict flags one at a time: start with strictNullChecks, then noImplicitAny, then the rest. This is far less overwhelming than enabling all of them at once.

Is TypeScript 7.0 really 10x faster or is that just a benchmark on VS Code’s codebase?

The 10x figure is consistent across multiple large projects. Microsoft measured 10.4x on VS Code (400,000 lines), and independent developers measured 8.3x on Sentry, 7.5x on Playwright, and over 10x on smaller projects. In our own testing on a 50,000-line project, we measured 11x. Smaller projects see proportionally smaller absolute gains because TypeScript’s startup time becomes a larger fraction of total build time.

The fastest way to see whether TypeScript 7.0 is ready for your project is to spend 10 minutes today: install typescript@rc, point it at your tsconfig, run npx tsc --noEmit, and see how long it takes. If you get a clean type-check in under two seconds on a project that used to take 20, that is the signal to start planning the full migration. One thing worth saying plainly: the breaking changes here are all things the TypeScript team has been signalling for two years. Strict mode, modern module resolution, and ES5 deprecation were not surprises in 2026. If your project still has "target": "es5" in its tsconfig, now is the right time to fix that regardless of the 7.0 migration. Drop a comment below or subscribe to NexGismo for weekly developer guides like this one.