TypeScript 7 (Project Corsa): What Next.js Devs Need to Know
TypeScript 7 rewrites the compiler in Go for 10x faster builds. Here's what it means for your Next.js project and what to do right now.
On this page
Introduction
TypeScript 7 rewrites the compiler in Go. Builds that took 90 seconds now take 8. That's the headline — here's everything else you actually need to understand.
On April 21, 2026, Microsoft released the TypeScript 7.0 Beta. It's the largest change to TypeScript in its 14-year history. Most coverage falls into two camps: deep-dive benchmarks for large engineering teams, or hype posts that skip the practical angle. This is the straightforward explainer for the Next.js developer who wants a clear answer: what is this, does it affect my project, and what should I actually do?
Step-by-Step Guide
Why the Old Compiler Was Slow
The original TypeScript compiler is a JavaScript program running on Node.js. In 2012 that was reasonable. In 2026, it's a bottleneck with three structural problems:
- Node.js is single-threaded — the compiler checks one thing at a time and cannot use multiple CPU cores.
- V8's garbage collector pauses type-checking at unpredictable moments, especially on large codebases.
- On a project with 100,000+ lines across multiple packages, teams wait 2–3 minutes for a full type check. Developers start ignoring errors because the feedback loop is too slow.
What tsgo Is and How to Try It
tsgo is the command-line tool for the Go-based TypeScript compiler. Install the beta preview alongside your existing tsc:
- Run
tsgo --noEmitinstead oftsc --noEmit— same type-checking, dramatically faster. - Microsoft tested
tsgoagainst 20,000 TypeScript test cases. Only 74 edge-case differences were found — for most projects, output is identical totsc. - VS Code (1.5 million lines of TypeScript) is compiled against
tsgodaily. It's stable enough for CI use right now.
npm install -D @typescript/native-preview
npx tsgo --noEmitTypeScript 6: The Bridge Release
Before TypeScript 7, Microsoft shipped TypeScript 6 (March 2026) as a deliberate stepping-stone. It's the last version using the JavaScript compiler, and it clears the path to TypeScript 7:
- Strict mode is on by default —
"strict": trueintsconfig.jsonis now the baseline, not opt-in. - Module resolution defaults changed. Some older import patterns that worked implicitly now require explicit configuration.
- Deprecated options that were warnings in TypeScript 5.x are now hard errors in TypeScript 6.
What This Means for Your Next.js Project Today
For most Next.js developers, day-to-day work is unchanged right now. Here's where the gains actually show up:
- Next.js uses SWC for transpilation (turning TypeScript into JavaScript). SWC is already fast —
tsgodoes not affect that step. tsgospeeds up type-checking — the--noEmitpass that validates your types without emitting JavaScript. This is the slow part ofnext buildon large projects.- The Vercel team is actively integrating
tsgo. Once it lands (expected with TypeScript 7 stable),next buildtype-checking speeds up automatically. - For now: add
npx tsgo --noEmitto your CI pipeline alongside your normal build to get faster type-check feedback today.
The Three-Step Practical Plan
What you should actually do, based on where you are today:
- On TypeScript 5.x: Upgrade to TypeScript 6. It's not breaking for most projects. Run
npx @andrewbranch/ts5to6to automate the mechanical migration steps, then fix the warnings TypeScript 6 surfaces. - On TypeScript 6 with a clean build: Install
@typescript/native-previewand runnpx tsgo --noEmit. Compare output totsc --noEmit. If they agree, usetsgoin CI for faster type-checks today. - In a monorepo with long build times: Move faster. Speed gains scale with project size, and the beta is genuinely stable for type-checking. Microsoft ships VS Code itself against
tsgodaily — the risk is low.
Real-World Benchmark Numbers
These are verified numbers from real production codebases, not synthetic benchmarks:
- VS Code (1.5 million lines of TypeScript):
tsc89 seconds →tsgo8.7 seconds - Sentry frontend (large React + TypeScript codebase):
tsc133 seconds →tsgo16 seconds - Typical Next.js app (50,000–100,000 lines): expect 5–15x improvement depending on complexity and number of packages
- Small projects under 10,000 lines see 2–4x gains. 10x+ improvements appear in large monorepos with many interdependent packages.
What to Watch For
TypeScript 7 stable is expected in Q3 2026. When it lands, tsc will call tsgo under the hood — most developers will see faster builds without changing anything. Two things to track before then:
- Custom TypeScript compiler plugins that read the TypeScript compiler API directly will need updates. The JavaScript compiler API is not ported to Go.
- Tools that import from the
typescriptpackage internally —ts-morph,ts-node,ts-jest— need updates before they work with TypeScript 7. Check each project's issue tracker. - Track
microsoft/typescript-goon GitHub for the Go compiler's changelog and breaking changes. - Watch the Next.js changelog for the integrated
tsgotype-checking update — it will ship as a minor version bump, not a major release.
Frequently Asked Questions
- Is tsgo a drop-in replacement for tsc?
- For type-checking (
--noEmit), yes. Runnpx tsgo --noEmitin place ofnpx tsc --noEmit. For emit (generating JavaScript from TypeScript source),tsgois still in beta and has some edge-case differences. Microsoft's recommendation: usetsgofor type-checking now, validate emit output separately before switching fully. - Does TypeScript 7 change the TypeScript language or just the compiler?
- Just the compiler. TypeScript 7 is a rewrite of the tooling, not a language revision. The same TypeScript syntax, type system, and
tsconfigoptions work identically. If you write valid TypeScript today, you will write valid TypeScript on TypeScript 7. The only change is how fast the compiler checks it. - Will ts-node, ts-jest, and ts-morph work with TypeScript 7?
- Not immediately. These tools import the TypeScript compiler API, which is a JavaScript API. The Go compiler does not expose the same API. Maintained projects are actively working on compatibility — check each project's GitHub issues for TypeScript 7 support status. This is the main ecosystem catch-up work before TypeScript 7 stable.
- Will my existing tsconfig.json work with tsgo?
- Yes, for the vast majority of configurations.
tsgoreads and respects your existingtsconfig.json. A small number of rarely-used compiler options are not yet implemented in the Go rewrite —tsgowill warn you if it encounters one it doesn't support, rather than silently ignoring it. - When will Next.js support tsgo natively?
- The Vercel team is actively working on it. As of May 2026, Next.js still uses the JavaScript-based TypeScript compiler for its built-in type-checking step. Native
tsgointegration is expected alongside TypeScript 7 stable in Q3 2026. Until then, runtsgo --noEmitseparately in CI to get faster type-check feedback without waiting for the official integration.
TypeScript 7 is the most significant change to the TypeScript toolchain since its original release. The Go rewrite removes the single biggest performance bottleneck for large TypeScript projects — and the gains are real, verified, and available to try today.
For your Next.js project: upgrade to TypeScript 6 if you haven't, run tsgo --noEmit in CI to measure your specific speed gains, and expect integrated Next.js support when TypeScript 7 hits stable. The upgrade will be quiet — just a version bump and faster builds.
Related Articles
How to Use Environment Variables in Next.js (Without Leaking Them to the Browser)
Learn how to use .env files in Next.js correctly. Understand NEXT_PUBLIC_, avoid common mistakes, and set variables in Vercel and Cloudflare.
Husky + Prettier + lint-staged Setup for Next.js
Set up Husky v9, Prettier, and lint-staged in your Next.js project. Step-by-step guide covering pre-commit hooks with the correct 2026 config.