By ByteBot
Microsoft released TypeScript 6.0 on March 23, marking the end of an era. This is the final major version built on the original JavaScript compiler codebase that’s powered the language since 2012. The 14-year-old architecture is being retired for a complete rewrite in Go—codenamed “Project Corsa”—that promises 10x faster compilation speeds. Microsoft’s benchmark shows build times for massive codebases like VS Code dropping from 78 seconds to 7.5 seconds. TypeScript 7.0, expected within a few months, will be the first release on the new Go foundation. However, the compressed timeline and ecosystem disruption risks have developers asking: Is this necessary progress or reckless ambition?
The Go Rewrite: 10x Speed, Real Risks
TypeScript 7.0 will be built entirely in Go, promising dramatic performance gains through native code execution and multi-threading. JavaScript’s single-threaded nature limits how fast the current compiler can run—it can only use one CPU core at a time. Go changes that equation completely. Microsoft’s official benchmark shows VS Code’s 1.5 million-line codebase compiling in 7.5 seconds versus 78 seconds with the current JavaScript-based compiler. That’s a genuine 10x improvement, not marketing hype.
However, the rewrite carries real risks. Evan You, Vue.js creator and Rust tooling expert, publicly raised concerns about Go’s WebAssembly performance. Web-based editors, playgrounds, and development tools often run the TypeScript compiler directly in the browser. In his testing, simple typechecking tasks in Go-compiled WebAssembly were slower than the existing JavaScript implementation. That’s a problem for tools like CodeSandbox, StackBlitz, and GitHub Codespaces.
Microsoft chose Go over Rust deliberately. Go’s syntax closely resembles TypeScript, making it easier to port the compiler’s logic while preserving existing behavior and optimizations. Rust would require rethinking memory management, mutation, and data structures from scratch—essentially a redesign, not a port. The tradeoff: Microsoft prioritized faster delivery over maximum theoretical performance.
TypeScript 6.0 Breaking Changes Hit Hard
TypeScript 6.0 isn’t just a milestone marker—it introduces significant breaking changes. Strict mode is now enabled by default. ESM replaces CommonJS as the default module system. The target defaults to es2025, which automatically updates with each TypeScript release. Moreover, legacy options are gone: --outFile, AMD/UMD/SystemJS module formats, and classic module resolution have been removed entirely.
The import syntax changed too. The deprecated assert keyword for JSON imports must be replaced with with:
// OLD (TypeScript 5.x - deprecated):
import data from "./data.json" assert { type: "json" };
// NEW (TypeScript 6.0 - required):
import data from "./data.json" with { type: "json" };Additionally, developers must explicitly configure types in tsconfig.json. Automatic discovery of @types packages is disabled:
{
"compilerOptions": {
"types": ["node"], // Explicit - auto-discovery removed
"rootDir": "./src", // Explicit - no longer inferred
"strict": true, // Now default
"module": "esnext", // ESM default
"target": "es2025" // Floating target
}
}A migration CLI (npx @andrewbranch/ts5to6) automates most mechanical changes, but the sheer number of breaking changes adds up. Consequently, with TypeScript 7.0 coming within months, developers face migrating twice in quick succession.
The Rewrite Risk: Netscape’s Ghost Haunts TypeScript
Joel Spolsky’s 2000 essay “Things You Should Never Do, Part I” argues that complete rewrites are “the single worst strategic mistake any software company can make.” His prime example: Netscape’s decision to rewrite their browser from scratch between versions 4.0 and 6.0. That rewrite took three years, during which Internet Explorer captured Netscape’s market share. The delay killed the company.
Microsoft isn’t blind to this history. The TypeScript team explicitly frames this as a port, not a redesign. They’re maintaining existing behavior and optimizations rather than rebuilding from first principles. Still, a ground-up rewrite inherently carries risks of subtle behavioral differences that only emerge after widespread adoption.
Recent rewrite successes provide a counterargument. Discord rewrote their read states service from Go to Rust, eliminating garbage collection pauses that caused latency spikes every two minutes. Dropbox took a hybrid approach, keeping Python orchestration while rewriting compute-intensive operations in Rust. Facebook rewrote their source control backend from Python to Rust, attracted by Rust’s safety guarantees. These examples show rewrites can succeed with careful execution and clear technical motivations.
TypeScript’s motivation is clear: performance. Large monorepos at companies like Google, Meta, and Microsoft experience 10-20 minute CI/CD builds dominated by type-checking. Cutting that to 1-2 minutes is a game-changer for developer productivity. The question is whether Microsoft’s compressed timeline—7.0 expected “within a few months”—leaves enough room for the ecosystem to catch up.
What Developers Should Do
Upgrade to TypeScript 6.0 immediately. Don’t wait for 7.0. Spreading the migration pain across two releases is far less risky than handling all breaking changes at once. Furthermore, add explicit "types": ["node"] to your tsconfig.json and set an explicit "rootDir": "./src" if your project relies on inference. Update import syntax from assert to with using the migration CLI.
Test with the preview build. Install @typescript/native-preview in a separate branch and run your full test suite. Watch for async API changes that could break build tooling—webpack’s ts-loader may lose its type-checking mode in TypeScript 7.0. Therefore, monitor the microsoft/typescript and microsoft/typescript-go GitHub repositories for breaking change reports.
Most importantly, prepare for rapid change. TypeScript 7.0 is coming within months, not years. The ecosystem—ESLint plugins, formatters, build tools—may lag behind. Budget time for tool updates and compatibility fixes. Microsoft has a strong backward compatibility track record, but no rewrite is risk-free.
Key Takeaways
- TypeScript 6.0 (March 23) is the final release on the original JavaScript codebase; TypeScript 7.0’s Go rewrite is coming within months
- Performance gains are real—10x faster compilation (78s → 7.5s on large codebases) through native code and multi-threading
- Breaking changes hit hard: strict mode default, ESM default, import syntax changes, explicit types configuration required
- The rewrite carries risks: WebAssembly performance concerns (Evan You), ecosystem tool compatibility, potential subtle behavioral differences
- Upgrade to TypeScript 6.0 now, test 7.0 preview builds, and monitor ecosystem tool updates—the compressed timeline leaves little room for delay
This is necessary modernization. TypeScript’s 14-year-old JavaScript foundation couldn’t scale to the massive monorepos dominating modern development. However, Microsoft’s aggressive timeline—from 6.0 to 7.0 within months—puts pressure on both the TypeScript team and the ecosystem. Performance gains are compelling, but the risks are real. The next few months will determine whether this rewrite joins the success stories or becomes a cautionary tale.
