TypeScript 7.0: The Go Rewrite Lands — What It Means for Your Projects

TypeScript 7.0 shipped on July 8, 2026. The compiler is now written in Go — a line-by-line port of the existing TypeScript codebase (codename "Corsa"), not a from-scratch rewrite. The result is 8–12x faster builds, dramatically faster editor responsiveness, and a language server that crashes far less often. This is the single biggest performance improvement in TypeScript's 12-year history. But it comes with real breaking changes, a missing programmatic API, and a migration path that rewards patience over haste.

The numbers

Before explaining architecture, here are the benchmarks that matter. These are from real-world codebases, not synthetic tests:

Scenario	Before (TS 6)	After (TS 7)	Speedup
VS Code codebase tsc --noEmit	36s	5s	~7x
VS Code project load in editor	17.5s	1.3s	~13x
Slack CI full type-check	7.5 min	1.25 min	~6x
Canva time-to-first-error	58s	4.8s	~12x
Memory usage (full builds)	baseline	6–26% less	—

These numbers are visceral. A 36-second wait becoming 5 seconds changes how you work — you stop batching saves, you stop switching tabs during builds, you just... type and get feedback.

Why it's faster: Go's goroutine model enables parallel type-checking with minimal coordination overhead. There's no V8 JIT warmup (the old compiler needed seconds just to warm up on large projects), no garbage-collector pauses at inconvenient times, and the port was structured specifically to exploit data-parallel opportunities that the single-threaded Node.js architecture could never reach.

New compiler flags

Two new flags control parallelism:

tsconfig.json

{
  "compilerOptions": {
    "checkers": 8,
    "builders": 4
  }
}

• --checkers N — number of parallel type-checking workers. Default: 4 (auto-detected from core count on most systems).
• --builders N — number of parallel project builders for --build mode with project references.

Most users won't need to touch these. The defaults are sensible. If you're on a 16-core CI machine, bumping --checkers higher may help. Profile before committing to non-default values.

The new language server

The old tsserver protocol is gone. TypeScript 7's language server speaks standard LSP (Language Server Protocol). This means:

• Any LSP-capable editor works — not just VS Code. Neovim, Helix, Zed, Sublime Text, Emacs with eglot — all get first-class TypeScript support from the same binary.
• Stability is dramatically better: 60% fewer crashes, 80% fewer failing commands compared to TS 6's language server.
• VS Code integration: The "TypeScript Native Preview" extension is already available. It will ship built-in to VS Code in an upcoming release.

The VS Code team's post on iterating faster with TS 7 has details on how this changed their own development workflow.

Breaking changes — what you need to fix

TypeScript 6 was explicitly designed as a bridge release. All the deprecation warnings it emitted? Those are now hard errors. If you skipped TS 6, expect a rough afternoon.

Removed options

Option	Replacement
target: "es5"	Removed entirely — target ES2015+
moduleResolution: "node" / "node10"	Use "nodenext" or "bundler"
outFile	Use an external bundler (esbuild, Rolldown, webpack)
baseUrl	Removed — update paths to be relative to project root
module: "amd" / "umd" / "systemjs" / "none"	Use "esnext" or "preserve"
esModuleInterop: false	Cannot be false — always-on
allowSyntheticDefaultImports: false	Cannot be false — always-on

New defaults

• strict: true (was false)
• module: "esnext" (was "commonjs")
• types: [] (was all @types/* auto-included)

Migration example

tsconfig.json — before (TS 5 era)

{
  "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "moduleResolution": "node",
    "baseUrl": ".",
    "paths": { "@/*": ["src/*"] },
    "outFile": "./dist/bundle.js",
    "esModuleInterop": true,
    "strict": false
  }
}

tsconfig.json — after (TS 7)

{
  "compilerOptions": {
    "target": "es2022",
    "module": "esnext",
    "moduleResolution": "bundler",
    "paths": { "@/*": ["./src/*"] },
    "strict": true
  }
}

caution

If your project still targets ES5, uses AMD/UMD modules, or relies on outFile for bundling — the migration is not trivial. These aren't just flag renames; they represent architectural decisions you'll need to revisit. Budget real time for this.

The full list of changes is the authoritative reference.

Migration path

The recommended upgrade path is TS 5 → TS 6 → TS 7. TypeScript 6 was purpose-built as the bridge: it deprecated everything that TS 7 removes, giving you actionable warnings without breaking your build.

Install TS 7:

npm install -D typescript

Side-by-side setup (run TS 7 for CLI builds, keep TS 6 for editor integrations that need the API):

package.json

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

The key insight: if you fix all TS 6 deprecation warnings first, the TS 7 upgrade is nearly frictionless. If you try to jump straight from TS 5 to TS 7, you'll be debugging a wall of errors with no incremental path.

• TypeScript 6.0 announcement — details on the bridge release and its deprecation warnings

tip

Start the TS 6 migration today, even if you're not ready for TS 7. Every deprecation warning you fix now is one less error when you upgrade. The TS 6 → TS 7 jump is trivial if you've done the prep work.

What's NOT ready yet

TypeScript 7.0 ships without a programmatic compiler API. The old typescript package exposed ts.createProgram(), ts.createSourceFile(), the entire AST visitor infrastructure — none of that exists yet in the Go port. It's expected in 7.1.

This affects more tools than you might expect:

• Vue (Volar), Svelte, Astro, MDX, Angular — all embed TypeScript's compiler API for template type-checking
• Custom transformers and ts-patch users
• Build tools that call the TS API directly (ts-loader in certain modes, some test frameworks)

note

If you're using Vue, Svelte, or Angular: use TS 7 for CLI tsc type-checking and builds, but keep TS 6 installed for editor integration. The dual-install pattern from the migration section handles this. Once 7.1 ships with the API, you can drop TS 6 entirely.

The native-tooling landscape

TypeScript moving to Go is the culmination of a trend that started with esbuild in 2020. The JavaScript ecosystem's performance-critical infrastructure is no longer written in JavaScript:

• esbuild (Go) proved native compilers work for JS/TS
• SWC, Rspack, Rolldown, Biome, oxc (Rust) built the tooling layer — see The Rust Wave Under Your node_modules
• Bun (Zig) took on the runtime
• TypeScript itself (Go) closed the loop

The @typescript/native-preview package hit 8.5 million weekly downloads before TS 7 even went stable. The developer appetite for faster tooling is not hypothetical — it's measured in npm install counts.

For a look at how the new compiler integrates with AI-assisted development workflows, see @ttsc/graph, which already uses the TS 7 compiler for codebase graph generation.

Practical next steps

• Greenfield projects: Use TS 7 now. There's no reason not to.
• Existing projects: Start the TS 6 migration today. Fix deprecation warnings. TS 7 follows naturally.
• Vue / Svelte / Angular: Use the dual-install pattern. Wait for 7.1 before dropping TS 6.
• CI pipelines: Even if you're not ready to migrate your codebase config, the raw speed improvement is worth a spike. A 6x CI speedup pays for the migration effort fast.

npm install -D typescript
npx tsc --version

---

Further reading:

• Announcing TypeScript 7.0 — the official announcement
• TypeScript Native Port — Anders Hejlsberg's original announcement of the Go port
• Iterating Faster with TS 7 — VS Code team's experience