Quick take: TypeScript 7 (Project Corsa) is the same language on a native Go compiler. It went GA on July 8, 2026, ships as the standard
tsc, and runs 8x to 12x faster. The type system is unchanged, so most React and Node projects upgrade in a day.
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 after using it: choosing portability over the "cooler" language was the right engineering call, and it's why Corsa actually shipped in 2026 instead of 2029.
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? Mostly, yes. Microsoft's published benchmarks put ordinary apps in the same 8x to 12x band, which turns a 14-second cold type-check on a 40,000 line React app into well under 2 seconds. The TypeScript 7 benchmarks deep dive breaks down methodology and results across small, medium, and large repos.
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 most single-package React or Node apps that's a one-day job. Here's the exact sequence I ran on the 40,000 line React app mentioned above:
# 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.
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.