TypeScript 7, codenamed Project Corsa, is a ground-up rewrite of the TypeScript compiler and language service in Go. It reached general availability on July 8, 2026. The headline is raw speed: Microsoft reports 8x to 12x faster full builds, and type-checking the VS Code codebase fell from 77.8 seconds to 7.5 seconds, a 10.4x speedup (TypeScript Blog, July 2026). The type system itself is unchanged, so your generics, conditional types, and strict-mode config all behave the same. The native compiler ships as the ordinary tsc binary, installed with npm install -D typescript. There is no separate tsgo command at GA, that name only applied to the preview package. The one real catch: frameworks that need a programmatic compiler API, Vue, Svelte, Astro, and Angular template checking, cannot fully use TypeScript 7 yet. React and Node projects can upgrade today.
Teams that ran the preview on production codebases for months keep landing on the same conclusion: the speed genuinely changes how you work. This guide is the hub for everything TypeScript 7 on Coding Dunia. Start here, then follow the links into the deep dives.
What Is Project Corsa?
Project Corsa is Microsoft's internal codename for the from-scratch port of the TypeScript compiler and language service from JavaScript to Go, released publicly as TypeScript 7.0. Microsoft announced the native port in March 2025. The plan was bold: take the entire TypeScript compiler, roughly 100,000 lines of carefully tuned code, and port it to Go while preserving exact behavioral parity. The old JavaScript-based compiler got the nickname Strada. The new Go one got Corsa.
Why Go and not Rust? Ryan Cavanaugh and Anders Hejlsberg explained that Go maps cleanly onto the compiler's existing structure: heavy use of graphs, shared mutable state, and functions that pass data around by reference. A Rust rewrite would have forced a redesign of that core and added years to the timeline. Go let the team port the logic almost function for function, which is how they hit behavioral parity instead of shipping a subtly different type-checker.
Here's my opinion: choosing portability over the "cooler" language was the right engineering call, and it's why Corsa actually shipped in 2026 instead of years later.
Choosing portability over the cooler language was the right engineering call, and it's why Corsa actually shipped in 2026 instead of years later.
How Much Faster Is TypeScript 7, Really?
The numbers are hard to overstate. At default settings, type-checking VS Code went from 77.8 seconds to 7.5 seconds. Opening a file with errors dropped from 17.5 seconds to under 1.3 seconds, over 13x faster, which is the difference you actually feel while editing. Memory usage fell between 6 and 26 percent depending on the codebase.
Do those gains hold on a normal-sized app, not just a 1.5 million line monster? Less than Microsoft's headline, but still a lot. The TypeScript 7 benchmarks deep dive measured type-checking on three workspaces of the monorepo behind this site, from about 2.4k to about 74k source lines, and found TypeScript 7 4.4x to 5.8x faster, with the biggest workspace going from 6.19 seconds to 1.07. It breaks down methodology and results across those repos.
TypeScript 7 dropped VS Code type-checking from 77.8 seconds to 7.5 seconds, a 10.4x speedup, while opening a file with errors fell from 17.5 seconds to under 1.3 seconds and memory usage dropped 6 to 26 percent.
How Do You Verify Your Project Runs the Native Compiler?
Before trusting the speedup, confirm the binary you're actually running is the Go-based Corsa compiler and not a stale JavaScript build cached somewhere in node_modules. Run through this checklist after any TypeScript bump.
- Run
npx tsc --versionand confirm the reported version is 7.0.0 or newer. - Delete
node_modules/.cacheand any editor TypeScript server cache, then restart the language server, since a stale install can shadow the new binary. - Time a clean
tsc --noEmitrun and compare it against your pre-upgrade baseline, expect roughly an 8x to 12x drop. - Check
package.jsonfor a pinnedtypescriptversion rather than a loose range, so CI and local machines stay on the same compiler build.
What Actually Changed?
Less than you'd fear. The compiler is new; the language is not. Three things are worth knowing up front:
- The binary is
tsc, still. You installtypescriptand get the Go compiler. Thetsgoname lived in the@typescript/native-previewpackage, which pulled over 8.5 million weekly downloads before GA and is now winding down in favor oftypescript@nextfor nightlies. - TypeScript 6 is the bridge. TS 6 was the final JavaScript-based release. Every option it deprecated becomes a hard error in TS 7. That's why the smart migration path runs through 6 first, a point I unpack in TypeScript 6 vs 7.
- A handful of legacy features are gone. ES5 output, AMD/UMD/SystemJS modules, and classic module resolution were all removed. The full before-and-after is in the step-by-step migration guide.
Should You Upgrade Now?
Ask one question first: what does your framework need from the compiler?
If you're on React, Next.js, Node, or plain TypeScript, upgrade this week. These setups only ask the compiler to type-check and emit, which is exactly what Corsa does at full speed. If you're on Vue, Svelte, Astro, or you rely on Angular template checking, hold off on flipping the default. Those tools hook into a programmatic API that TypeScript 7 hasn't stabilized, so they can't drive the native compiler yet. I cover the workarounds and the current support matrix in TypeScript 7 framework support.
How Do You Actually Migrate?
The short version: upgrade to TS 6, fix every deprecation warning, then bump to TS 7. For a single-package React or Node app that's usually a short job. Here's the sequence I'd follow:
# Step 1: land on TypeScript 6 first, the JS-based bridge release
npm install -D typescript@6
# Step 2: surface every deprecation as a hard error before you touch TS 7
npx tsc --noEmit
# fix each reported deprecation (ES5 target, AMD/UMD modules, classic
# module resolution), then re-run tsc until the output is clean
# Step 3: bump to the native Go compiler
npm install -D typescript@7
npx tsc --noEmitNothing in your tsconfig.json needs to change for that jump, assuming you're not on any of the removed options. Not sure? Paste your config into the TypeScript 7 Migration Readiness Checker and it'll flag exactly what needs to go before it flags anything in CI. Strict mode, path mapping, and paths aliases all carry over untouched. Behavioral parity means the new Go compiler produces the same type-checking results as the old JavaScript one, function for function, so a project that compiled cleanly on TypeScript 6 should compile just as cleanly on TypeScript 7 once the deprecation warnings are fixed. The details differ by project shape, so I've split them out:
- React apps have Vite plugins, Vitest, and ESLint to line up, walked through in the React migration checklist.
- Monorepos add project references and workspace ordering, covered in migrating a TypeScript monorepo.
- CI is where the speedup pays rent, wired up in TypeScript 7 in CI/CD.
TypeScript 6 vs TypeScript 7 Timing
| TypeScript 6 | TypeScript 7 (Project Corsa) | |
|---|---|---|
| Compiler language | JavaScript (Strada) | Go (Corsa) |
| VS Code codebase type-check | 77.8 seconds | 7.5 seconds |
| Opening a file with errors | 17.5 seconds | Under 1.3 seconds |
| Memory usage | Baseline | Down 6-26 percent |
| Framework support at GA | Vue, Svelte, Astro, Angular templates | React, Next.js, Node, plain TypeScript |
Why This Matters for Your Codebase
A 10x faster type-check isn't just a nicer number on a benchmark chart. When tsc finishes in two seconds instead of twenty, you start running it on every save, your CI feedback loop tightens, and reviewers stop waiting on green checks. Fast tools change habits. That's the real story of Project Corsa, and it's why this is the biggest shift in the TypeScript toolchain since the language shipped in 2012.
Project Corsa is the biggest shift in the TypeScript toolchain since the language shipped in 2012. A 10x faster type-check changes habits: developers run tsc on every save instead of skipping it, and CI feedback loops tighten from minutes to seconds.
Related
- TypeScript generics explained - the generic patterns Corsa type-checks 10x faster, unchanged from TS 5 and 6
- TypeScript strict mode guide - strict is the default in TS 7, so turn it on during the TS 6 step
- TypeScript utility types guide - Partial, Pick, and Omit all still work identically on the native compiler
- TypeScript 7.0 Is GA - the release announcement, if you want the ship-date details rather than the architecture
Check Your Own tsconfig.json
Paste it below for an instant readiness score against everything TypeScript 7 removed or changed. Runs in your browser, nothing is uploaded.
Need to check package.json too, or want the full breakdown? Use the full TypeScript 7 Migration Readiness Checker.