TypeScript 7.0 (Project Corsa): 10x Faster Builds with the Go Compiler — Migration Guide 2026

TypeScript 7.0 — codenamed Project Corsa — is the most significant engineering change in TypeScript's 13-year history. The entire compiler has been rewritten from TypeScript into Go, delivering native execution speed and true shared-memory parallelism. The result is a type checker that is often 10 times faster than TypeScript 6.0, with 50% lower memory usage.

The beta landed on April 21, 2026. Stable is expected within a few months. This guide walks you through every step of migrating your project.

Prerequisites

Before starting, ensure you have:

• Node.js 18 or higher installed
• An existing TypeScript project on version 5.x or 6.x
• Familiarity with tsconfig.json configuration
• npm, pnpm, or yarn installed

What Is Project Corsa?

The existing TypeScript compiler is a single-threaded JavaScript program running on Node.js. For large codebases this creates a hard ceiling on type-check speed — you are limited by V8's JIT and JavaScript's single event loop.

Project Corsa breaks through that ceiling in two ways:

Native code execution: tsgo is a compiled Go binary. Instead of loading a large JS bundle into Node.js, the compiler executes as native machine code with direct CPU access.

Shared-memory parallelism: Go's goroutine model allows multiple type-checker workers to operate on different parts of your codebase simultaneously, sharing memory rather than serialising messages like Node.js worker_threads.

The port was methodical rather than a full rewrite — the type-checking logic is structurally identical to the original. Compatibility sits above 98%, with only 74 known edge-case differences from TS 6.0. It has already been validated on multi-million-line codebases at Bloomberg, Figma, Google, Notion, Slack, and Vercel.

Why Migrate to TypeScript 7.0?

• 10x faster type checking — a 60-second check becomes about 6 seconds
• Parallel checking via --checkers N (default: 4 workers)
• 50% memory reduction through shared-memory goroutines
• Lower CI costs — fewer build minutes per pipeline run
• Faster language server — the VS Code extension responds noticeably faster
• 98%+ type-check compatibility with TS 6.0

Step 1: Install TypeScript 7.0 Beta

During the beta period, TypeScript 7.0 is published under the @typescript/native-preview package:

npm install -D @typescript/native-preview@beta

Or with pnpm:

pnpm add -D @typescript/native-preview@beta

Verify the installation:

npx tsgo --version
# Version 7.0.0-beta

The tsgo binary is a drop-in replacement for tsc and accepts the same flags.

Step 2: Run Your First tsgo Check

Run a full type check with no configuration changes needed:

npx tsgo --noEmit

For a specific tsconfig file:

npx tsgo -p tsconfig.build.json --noEmit

Compare the speed

Time both compilers to see the difference on your project:

time npx tsc --noEmit
time npx tsgo --noEmit

Most medium-sized Next.js or Node.js projects see a 5–10x speedup immediately.

Step 3: Audit Your tsconfig.json

TypeScript 7.0 changes several defaults and removes legacy options. Audit your config:

npx tsgo --noEmit 2>&1 | grep -iE "deprecated|removed|unsupported|no longer"

Changed Defaults

The types: [] change is the most impactful. If your project relied on @types/node being auto-included, you must now declare it explicitly:

{
  "compilerOptions": {
    "types": ["node", "jest", "react"]
  }
}

Step 4: Fix Breaking Changes

TypeScript 7.0 removes several legacy configuration options. These are the most common ones:

Remove target: "es5"

ES5 targeting is gone — TypeScript 7.0 no longer ships a downlevel JavaScript emitter. Delegate ES5 output to your bundler (Vite, Rolldown, esbuild):

// Before (TS 6.0)
{ "compilerOptions": { "target": "es5" } }
 
// After (TS 7.0)
{ "compilerOptions": { "target": "es2022" } }

Replace baseUrl with paths

baseUrl has been removed. Migrate to paths with explicit relative anchors:

// Before
{
  "compilerOptions": {
    "baseUrl": "./src",
    "paths": { "@components/*": ["components/*"] }
  }
}
 
// After
{
  "compilerOptions": {
    "paths": { "@components/*": ["./src/components/*"] }
  }
}

Update moduleResolution

The node and node10 strategies are removed. Use bundler for most modern projects:

{
  "compilerOptions": {
    "moduleResolution": "bundler"
  }
}

Remove downlevelIteration

This flag is no longer valid — remove it from your config entirely.

Remove Legacy Module Formats

module: "amd", module: "umd", module: "system", and module: "none" are all removed. Migrate to "esnext" or "nodenext":

{
  "compilerOptions": {
    "module": "esnext"
  }
}

Set rootDir Explicitly

TypeScript 7.0 defaults rootDir to "./". If your sources are in a subdirectory, set it explicitly:

{
  "compilerOptions": {
    "rootDir": "./src",
    "outDir": "./dist"
  },
  "include": ["./src"]
}

Step 5: Enable Parallel Type Checking

TypeScript 7.0's biggest advantage is parallel type checking. By default it spawns 4 worker goroutines (--checkers 4). Tune this to your machine or CI environment:

# 8 workers on a powerful CI machine
npx tsgo --noEmit --checkers 8
 
# Single-threaded mode for debugging
npx tsgo --noEmit --singleThreaded

For monorepos using project references, parallel builds use --builders:

npx tsgo --build --builders 4

Add to your CI pipeline:

# .gitlab-ci.yml
typecheck:
  image: node:22
  script:
    - npm ci
    - npx tsgo --noEmit --checkers 4

Or in package.json:

{
  "scripts": {
    "typecheck": "tsgo --noEmit",
    "typecheck:ci": "tsgo --noEmit --checkers 8"
  }
}

Step 6: VS Code Integration

Install the official VS Code extension for the TypeScript 7.0 language server:

1. Open Extensions (Ctrl+Shift+X)
2. Search for "TypeScript Native Preview"
3. Install and reload VS Code

Configure your workspace to use the project's installed version:

// .vscode/settings.json
{
  "typescript.tsdk": "node_modules/@typescript/native-preview/lib",
  "typescript.enablePromptUseWorkspaceTsdk": true
}

You will notice significantly faster IntelliSense and error highlighting on large files.

Step 7: Run TypeScript 6 and 7 Side-by-Side

During migration, install TypeScript 6.0 alongside 7.0 to compare output:

npm install -D typescript@npm:@typescript/typescript6

Run both in parallel to verify no new errors are introduced:

# TS 6 check
npx tsc --noEmit
 
# TS 7 check  
npx tsgo --noEmit

If TypeScript 7.0 reports new errors that TS 6.0 did not, these are genuine type errors that the stricter defaults now surface. Fix them rather than suppressing them.

Testing Your Migration

After completing all tsconfig updates, run a full validation:

# Full type check
npx tsgo --noEmit
 
# Build (if using tsc for emit)
npx tsgo -p tsconfig.build.json
 
# Force rebuild all project references
npx tsgo --build --force

Performance Benchmarks

Real-world performance data from production codebases:

Memory typically drops from around 1.2 GB to under 600 MB for a 1000-file project.

Troubleshooting

"Option 'baseUrl' is no longer supported" — Migrate to paths with relative anchors (see Step 4).

"Option 'target' value 'es5' is not valid" — Set target to "es2022" or higher.

"Option 'types' default changed" — Add "types": ["node"] (or your @types packages) to compilerOptions.

TypeScript 7.0 finds new errors — These are real type errors. The most common causes are strict: true enabling strictNullChecks/noImplicitAny, and noUncheckedSideEffectImports: true. Fix them with proper type annotations.

VS Code still shows old TypeScript version — Press Cmd+Shift+P → "TypeScript: Select TypeScript Version" → "Use Workspace Version".

Next Steps

• Watch the stable release — TypeScript 7.0 stable is expected within two months of the April 2026 beta. Subscribe to the TypeScript blog for announcements.
• Pair with Vite 8 and Rolldown — Combine TypeScript 7.0's Go-native type checking with Rolldown's Rust-native bundling for a fully native build pipeline.
• Explore project references — The --builders flag makes large monorepo rebuilds dramatically faster.
• Report edge cases — File type-check differences on the TypeScript GitHub repository to help close the remaining 74 known edge cases.

Conclusion

TypeScript 7.0 (Project Corsa) is a foundational shift, not an incremental release. The Go rewrite delivers native execution speeds and true multi-threaded parallelism that no JavaScript runtime can match. For development teams running TypeScript in CI/CD pipelines, the 10x speed improvement directly translates to shorter feedback loops and lower cloud compute costs.

The migration path is clear: install @typescript/native-preview@beta, run npx tsgo --noEmit, fix the handful of breaking config changes, and enjoy dramatically faster type checking. With 98%+ type-check compatibility, the risk is low and the upside is substantial.