TypeScript 7 (Project Corsa): The 10x Faster Go Compiler Guide

TypeScript 7 landed on July 8, 2026 — a milestone that closes a chapter in JavaScript tooling history. After more than a year of public previews under the codename Project Corsa, Microsoft shipped a complete rewrite of the TypeScript compiler in Go, delivering roughly 10 times faster builds with no changes to the type system. For teams wrestling with multi-minute type checks on large codebases, this is transformative.

What Is Project Corsa?

Project Corsa is the internal codename for Microsoft's effort to port the entire TypeScript compiler — parser, binder, type-checker, emitter, and language service — from JavaScript to Go. The initiative was announced in late 2025 and shipped its stable release as TypeScript 7.0.

The motivation was fundamental: the TypeScript compiler runs on Node.js, which is single-threaded by design. No matter how powerful the machine, the old compiler could only use one CPU core. Go's goroutines and shared-memory model let the new compiler distribute work across all available cores, scaling with hardware instead of being capped by it.

How Much Faster? The Real Benchmarks

The improvements are not incremental. Daniel Rosenwasser, TypeScript's PM lead, posted concrete numbers at launch:

• VS Code codebase (1.5M lines): type-checking fell from 89 seconds to under 9 seconds — roughly 10x faster
• Large React monorepo: 133 seconds down to 16 seconds (8x faster)
• Typical Next.js app: anywhere from 5 to 15 times faster depending on project size

Memory usage also dropped significantly. The Go compiler uses around 60 to 70 percent less peak memory than the Node.js version, which matters on CI runners with tight resource limits.

A machine with 8 cores now does roughly 8 times the work per second compared to the single-threaded Node.js compiler. That scaling relationship is the core architectural win.

How the Go Rewrite Works

TypeScript 7 is not a new language or a new type system. The syntax you write, the rules it enforces, and the .d.ts output it produces are identical to TypeScript 5 and 6. What changed is what happens when you run tsc.

The old compiler was a JavaScript program. It parsed your files, built an AST, ran type inference, and emitted JavaScript — all in a single thread on Node.js. The new compiler is a compiled Go binary that does the same logical work but:

1. Runs natively — no V8 startup, no JIT warm-up, direct OS execution
2. Uses real parallelism — goroutines type-check independent files concurrently
3. Manages memory efficiently — Go's allocator is purpose-built for this kind of workload

During the preview period, the Go compiler was available as tsgo via @typescript/native-preview. As of version 7.0, it ships as the default tsc.

What Changed: Breaking Changes and New Defaults

TypeScript 6 was the intentional bridge release — it enabled stricter defaults and deprecated legacy options so teams could clean up before the 7.0 migration. If you skipped TypeScript 6, those warnings have now become errors.

Strict mode is on by default

strict: true is now the default. Any project that relied on the old permissive baseline will see new errors on upgrade. The fix is explicit — add "strict": false to opt out, or address the type gaps one by one.

Target changed to ES2022

The default compilation target shifted from ES3 to ES2022. Code that relied on TypeScript emitting ES3 polyfills will need an explicit "target": "ES3" in tsconfig.json.

Module resolution defaults updated

moduleResolution now defaults to "bundler" for most configurations, and verbatimModuleSyntax defaults to true. If your codebase uses import type inconsistently, you will see errors at type-check time.

Hard errors on deprecated options

The importsNotUsedAsValues and preserveValueImports options now cause hard errors. Remove them from your tsconfig.json and use the new unified configuration:

{
  "compilerOptions": {
    "moduleResolution": "bundler",
    "strict": true,
    "verbatimModuleSyntax": true
  }
}

Compiler plugin API is incompatible

If your project uses TypeScript compiler plugins — transformer plugins, ts-patch, or similar tools — they will not work with the Go compiler. The plugin API relied on the JavaScript API surface that no longer exists. Plugin authors are actively shipping Go-based equivalents.

Tool Compatibility

Not all TypeScript-adjacent tools work yet with the new compiler:

Framework Compatibility

Next.js

Next.js works with TypeScript 7 for builds, but full native tsgo integration is expected in Q3 2026. In the meantime, separate type-checking from your build process:

// next.config.ts
const config = {
  typescript: {
    ignoreBuildErrors: true,
  },
};
 
export default config;

Then run tsc --noEmit as a dedicated CI step alongside your build.

Vue, Svelte, Astro, and MDX

Teams using Vue, Svelte, Astro, or MDX should wait for TypeScript 7.1. The Go compiler is missing a programmatic API that these frameworks depend on for editor integration and file processing. Using TypeScript 7.0 with these frameworks will break IDE support.

VS Code

The language service — the part that powers IntelliSense, hover types, and go-to-definition — is still being ported to Go. The Go-based language service is expected in late 2026 or early 2027. Until then, VS Code continues using the JavaScript-based service, so editor performance is unchanged by the TypeScript 7 upgrade.

Installing TypeScript 7

npm install -D typescript@7

To validate the Go compiler before fully committing:

npm install -D @typescript/native-preview
npx tsgo --noEmit

Run tsgo alongside your existing tsc to compare output. Once the results match, switch your CI pipeline to the new compiler.

Migration Path: Three Steps

Step 1 — Upgrade to TypeScript 6 first

TypeScript 6 is the prerequisite bridge release. It converts 7.0 errors into warnings first, giving you a chance to fix them incrementally.

npm install -D typescript@6
npx tsc --noEmit
# Fix all warnings before proceeding

Step 2 — Run the Go compiler in parallel

npm install -D @typescript/native-preview
npx tsgo --noEmit   # Go compiler
npx tsc --noEmit    # JS compiler — compare output

Both should produce identical errors. Differences are bugs — report them on the TypeScript GitHub repository.

Step 3 — Switch CI to TypeScript 7

npm install -D typescript@7

Update your CI script to run tsc --noEmit as a dedicated type-checking step, separate from the build itself.

What Is Coming in TypeScript 7.1

The TypeScript team has outlined several features for 7.1:

• Watch mode (--watch) — the main gap in 7.0 for local development workflows
• Programmatic API — unblocks Vue, Svelte, Astro, and MDX toolchains
• VS Code language service in Go (preview)
• Compatibility layers for ts-node and ts-morph

Watch mode being absent in 7.0 is the most noticeable gap for day-to-day development. Until 7.1, keep the old tsc --watch running via a separate devDependencies entry pointing to TypeScript 6.

The Bigger Picture

The Go rewrite changes the economics of TypeScript at scale. Monorepos with hundreds of packages that once required dedicated type-checking servers can now complete full builds in the time it previously took to check a single package. CI bills go down. Developer feedback loops tighten.

TypeScript 7 does not change what you write. It changes how fast the toolchain can tell you whether you wrote it correctly. For most teams, that is the right trade-off: zero migration cost to the type system, and significant improvements to the experience of working in it every day.