TypeScript 7 (Project Corsa): What Next.js Devs Need to Know

TypeScript 7 rewrites the compiler in Go. Builds that took 90 seconds now take 8. That is the headline, and here is everything else you actually need to understand.

On April 21, 2026, Microsoft released the TypeScript 7.0 Beta. It is the largest change to TypeScript in its 14-year history. This is the practical explainer for the Next.js developer: what is this, does it affect my project, and what should you do right now?

The original TypeScript compiler is a JavaScript program running on Node.js. In 2012, that was a reasonable choice because JavaScript was the only language the team could guarantee every contributor already knew. In 2026, that decision has become a structural bottleneck with three distinct causes:

The Go decision surprised many developers who expected Rust. Microsoft's rationale came down to three factors: Go's goroutine-based concurrency maps naturally to the compiler's workload (parsing, binding, and checking files in parallel), Go's garbage collector is fast enough for compiler workloads without the complexity of manual memory management, and the existing TypeScript team could become productive in Go within weeks rather than months.

Rust would have offered zero-cost abstractions and no GC pauses, but the learning curve for the team would have added 6 to 12 months to the project timeline. C++ was never seriously considered because of its memory safety risks and build system complexity.

The practical result: Go's goroutines let the compiler check multiple files simultaneously across all available CPU cores. A machine with 8 cores can now do roughly 8 times the work per second compared to the single-threaded Node.js compiler.

Understanding the architectural changes helps explain why the speed gains are so dramatic and where they apply most.

The old compiler processes files sequentially: parse file A, check file A, parse file B, check file B. The new compiler builds a dependency graph of your project, identifies which files can be checked independently, and fans the work out across goroutines. Files that depend on each other are still checked in order, but independent branches of your import tree are checked simultaneously.

This is why monorepos with many independent packages see the largest speed gains. Each package's internal files can be checked on a separate core.

The JavaScript compiler creates millions of small objects (type nodes, symbol tables, diagnostic records) that V8's garbage collector must scan and reclaim. On a 500K-line codebase, GC pauses can individually last 50 to 200 milliseconds, and they occur hundreds of times during a full check.

Go's garbage collector is designed for low-latency workloads. Pauses are typically under 1 millisecond, and the compiler's memory layout is optimized to reduce allocations in the first place. The result is not just faster overall time but smoother, more predictable performance.

The old compiler runs as JavaScript interpreted by V8, which JIT-compiles hot paths but still carries the overhead of a dynamic language runtime. The Go compiler produces a native binary that your OS executes directly. There is no startup cost for a JavaScript runtime, no JIT warmup phase, and no dynamic dispatch overhead.

This difference is most noticeable on cold starts. The first invocation of tsc on a CI server includes V8 startup time (200 to 500 ms). tsgo starts in under 10 ms.

These are verified numbers from real production codebases, not synthetic benchmarks. The speed gains vary based on project structure, dependency graph complexity, and how many files can be checked in parallel:

Small projects see the smallest gains because the old compiler was already fast enough that the bottleneck was I/O (reading files from disk) rather than CPU. Large monorepos see the biggest gains because they have the most independent files that benefit from parallel checking.

CI environments often see even larger gains than local development because CI runners typically have many CPU cores but slow single-thread performance. The Go compiler's parallelism turns those extra cores into real build time savings.

As of the TypeScript 7.0 Beta, tsgo covers the vast majority of tsc functionality. However, a few features are still catching up. Here is the current status:

The missing watch mode is notable for local development. Until tsgo supports --watch, you will want to keep using tsc --watch for your development workflow and reserve tsgo for CI type checks and one-off validation.

The language service gap means VS Code still uses the JavaScript-based TypeScript server for editor features like autocomplete, hover types, and go-to-definition. Microsoft is actively porting the language service, but it is the most complex part of the compiler and will take longer.

tsgo is the command-line tool for the Go-based compiler. You can run it alongside your existing tsc without committing to a full switch:

Before switching your CI pipeline, validate that tsgo produces the same diagnostics as tsc on your specific project. This script captures the output of both and compares them:

If the diff shows no differences, you can confidently replace tsc --noEmit with tsgo --noEmit in your CI pipeline. If differences appear, review each one carefully. Most are cosmetic (different error message ordering) rather than actual type-checking disagreements.

Next.js developers often assume that tsc speed directly controls next build speed. That is only partially true. Understanding the Next.js build pipeline helps you know exactly where tsgo fits in.

When you run next build, several things happen in sequence: TypeScript type-checking, page compilation via SWC (Rust-based transpiler), static page generation, and bundle optimization. The TypeScript type-check step is where tsgo makes its impact.

On a typical Next.js project, type checking accounts for 30 to 60% of total next build time. If your build takes 120 seconds and type checking is 60 seconds of that, switching to tsgo could reduce your total build to 66 seconds (saving 54 seconds on the type-check phase alone).

For projects using next build with ignoreBuildErrors: true in next.config.ts (which skips type checking during build), the impact of tsgo on build time is zero. However, you should still use tsgo --noEmit as a separate CI step to catch type errors without slowing your deployment.

Before TypeScript 7, Microsoft shipped TypeScript 6 (March 2026) as a deliberate stepping-stone. If your project is not on TypeScript 6 yet, start here. TypeScript 6 enforces stricter defaults and removes deprecated options, which means any project that compiles cleanly on TS6 is ready for the TS7 compiler switch.

These are the most frequent issues teams encounter when upgrading from TypeScript 5.x to 6. Address them before attempting the jump to TypeScript 7:

Teams upgrading to TypeScript 7 or adopting tsgo hit a few recurring issues. Knowing them in advance saves hours of debugging.

If your project uses custom TypeScript compiler plugins (configured via compilerOptions.plugins in tsconfig.json), those plugins will not work with tsgo. They are written against the JavaScript compiler API, which does not exist in the Go binary. This affects tools like typescript-plugin-css-modules and custom transformers.

The workaround is to run tsgo without plugins for type checking and keep tsc for any build steps that require plugin functionality. Microsoft has announced a new plugin API for the Go compiler, but it is not available yet.

Projects using paths in tsconfig.json with wildcard patterns occasionally see differences between tsc and tsgo in how path resolution is handled. The most common case is nested wildcards that resolve differently:

If you use simple path aliases (like @/* mapping to ./src/*), you will not encounter any issues. Complex multi-wildcard patterns should be tested explicitly with tsgo before switching.

Monorepos using TypeScript project references (references in tsconfig.json) actually benefit the most from tsgo, because the Go compiler can check referenced projects in parallel rather than sequentially. However, you need to ensure all referenced projects are also compatible with tsgo.

Run tsgo --build (the equivalent of tsc --build) from the root of your monorepo to validate all projects at once. If any individual project has issues, tsgo will report which one failed.

TypeScript 7 stable is expected Q3 2026. When it lands, tsc will call tsgo under the hood, so most developers will see faster builds without changing anything. Two areas to track before that happens:

TypeScript 7 is the most significant change to the TypeScript toolchain since its original release. The Go rewrite removes the single biggest performance bottleneck, and the gains are real, verified, and available to try today.

For your Next.js project: upgrade to TypeScript 6 if you have not already, 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 for most teams: just a version bump and faster builds.

The developers who benefit most are those on large codebases who have been skipping type checks because they were too slow. With tsgo, the type checker finally runs fast enough to include in every PR check, every commit hook, and every save. That is the real win: not just speed, but bringing type safety back into the development loop where it was being skipped for practical reasons.