← Back to blog

Oct 15, 2026 · 8 min read

TypeScript 7 Goes Native: What the Go Rewrite Means for Your Build

Microsoft rewrote the TypeScript compiler in Go, and TypeScript 7 is dramatically faster. Here's what changed, what breaks, and why you might not be able to upgrade everything at once.

TypeScriptToolingWeb Development

Microsoft rewrote the TypeScript compiler in Go. TypeScript 7, released in late 2025, is the result, and the performance numbers are dramatic: 10x faster type checking, 5x faster builds, and a compiler that can keep up with modern development workflows.

But it's not a drop-in replacement. The native compiler doesn't expose the JavaScript compiler API that many tools depend on. Here's what changed, what breaks, and how to think about the upgrade.

The performance win

The numbers are real:

OperationTypeScript 6TypeScript 7
Type checkingBaseline10x faster
BuildBaseline5x faster
Language serverBaselineSignificantly faster
Memory usageBaselineLower

For large codebases (1000+ files), the difference is transformative. A typecheck that took 30 seconds now takes 3. A build that took 2 minutes now takes 25 seconds. The language server doesn't lag behind your typing.

The Go rewrite is not a small optimization. It's a fundamental reimplementation that changes what's practical. Type checking that was too slow to run in CI now runs in seconds.

What changed under the hood

The TypeScript compiler was originally written in TypeScript, running on Node.js. TypeScript 7 is written in Go and compiles to a native binary.

The implications:

  • No more Node.js dependency for type checking. The compiler is a standalone binary.
  • No JavaScript compiler API. The native compiler doesn't expose the internal APIs that tools like typescript-eslint, ts-morph, and other tooling depend on.
  • Different memory model. Go's garbage collection and memory layout are different from V8's.

What breaks

typescript-eslint can't consume TypeScript 7. This is the big one. typescript-eslint uses the TypeScript compiler's JavaScript API to parse and analyze code. The native compiler doesn't expose this API.

The typescript-eslint team has acknowledged the issue and is working on a solution, but as of late 2025, you can't use TypeScript 7 with typescript-eslint directly.

The workaround: Run TypeScript 6 alongside TypeScript 7. Use TypeScript 7 for type checking (the fast path) and TypeScript 6 for ESLint (the compatible path):

// package.json
{
  "scripts": {
    "typecheck": "node node_modules/ts7/bin/tsc --noEmit",
    "lint": "eslint ."
  },
  "dependencies": {
    "typescript": "6.0.3",
    "ts7": "npm:typescript@7.0.2"
  }
}

ts-morph and other compiler API tools. Any tool that uses the TypeScript compiler API (ts.createProgram, ts.transform, etc.) won't work with TypeScript 7. This includes some code generators, documentation tools, and refactoring tools.

Custom transformers. If you have custom TypeScript transformers (for build-time code transformation), they won't work with the native compiler.

What doesn't break

Type syntax. TypeScript 7 supports the same type syntax as TypeScript 6. Your .ts files don't need changes.

tsconfig.json. Most configuration options are the same. A few have been removed (baseUrl is gone in TS 7), but the common ones work.

Type definitions. .d.ts files work the same way.

The language server. VS Code and other editors that use the TypeScript language server get the performance benefits automatically.

How to upgrade

Step 1: Install TypeScript 7 alongside TypeScript 6.

Use a package alias so both are available:

pnpm add -D typescript@6.0.3
pnpm add -D ts7@npm:typescript@7.0.2

Step 2: Update your typecheck script.

{
  "scripts": {
    "typecheck": "node node_modules/ts7/bin/tsc --noEmit"
  }
}

Step 3: Keep TypeScript 6 for ESLint.

Your eslint script continues to use the regular typescript package (6.x), which typescript-eslint can consume. Don't change this until typescript-eslint officially supports TypeScript 7.

Step 4: Remove baseUrl from tsconfig.json.

TypeScript 7 removed the baseUrl option. paths now resolves relative to the config file itself.

Step 5: Test and verify.

Run pnpm typecheck and confirm it passes. Run pnpm lint and confirm ESLint still works. Run your build and confirm it succeeds.

Who should upgrade

Upgrade now if:

  • You have a large codebase where typecheck time is a bottleneck
  • You run typecheck in CI on every push
  • Your editor's language server is slow on your project
  • You don't depend on tools that use the TypeScript compiler API

Wait if:

  • You depend heavily on typescript-eslint and can't run the side-by-side setup
  • You use ts-morph or other compiler API tools that don't have TypeScript 7 support yet
  • You have custom TypeScript transformers

The bigger picture

The Go rewrite is a bet that TypeScript's future is as a high-performance tool, not just a type checker. The 10x performance improvement opens up use cases that weren't practical before: type checking in pre-commit hooks, real-time type checking in editors for large monorepos, and type-aware tooling that was too slow to run interactively.

The compiler API breakage is painful in the short term, but it's the right call. The old compiler API was a constraint that limited what the compiler could do. By dropping it, Microsoft can make the compiler faster and more maintainable.

The tools that depend on the compiler API will adapt. typescript-eslint will find a way to work with the native compiler (likely through a different integration point). ts-morph will either add native compiler support or be replaced by tools that do. The ecosystem will catch up.

In the meantime, the side-by-side setup works. You get the performance of TypeScript 7 for type checking and the compatibility of TypeScript 6 for linting. It's not elegant, but it's practical, and it's what we run on our own projects.

If you've been frustrated by slow TypeScript builds, the upgrade is worth the setup cost. The performance difference is not incremental — it's transformative.

Need help applying this?

Schedule call →