TypeScript 6.0: Last JavaScript Compiler Before Go

TypeScript 6.0: The Last of the JavaScript-Based Compiler

TypeScript 6.0 beta is historically significant not because of new language features, but because of what it signals about the infrastructure underneath. It is the final release of the compiler written in JavaScript and TypeScript - the tool that has underpinned TypeScript development since 2012. TypeScript 7.0, already stable since January 2026 after a year of preview starting in May 2025, runs on a fully native Go implementation called Project Corsa. The language itself - TypeScript's type system, syntax, and compatibility with JavaScript - remains unchanged. Only the compiler toolchain changes.

The staging repository for the native compiler, microsoft/typescript-go on GitHub, is public and will eventually be merged back into the main microsoft/TypeScript repository. Type-checking parity is already near-complete: only 74 discrepancies remain across 20,000 test cases, according to Microsoft's December 2025 progress update.

Default Changes That Will Break Your Builds

TypeScript 6.0 ships with changed defaults across five critical tsconfig settings. Teams upgrading from 5.x without explicit configuration will encounter build failures - potentially hundreds of errors on a mature codebase.

The types: [] change is the one that catches teams off-guard most often. Previously, TypeScript automatically included all installed @types/* packages. Now you must declare them explicitly. A repository that never specified types will suddenly lose all ambient type declarations. The recommended bridge for teams not ready for a full migration: add "ignoreDeprecations": "6.0" to tsconfig to keep deprecated options working until you are prepared for TypeScript 7.0.

New Features and What Gets Removed

TypeScript 6.0 adds ECMAScript 2025 support and deprecates a set of legacy options that will be fully removed in TypeScript 7.0. The deprecation list is the more operationally significant part for enterprise teams running older build pipelines.

ECMAScript 2025 Additions

• Temporal API types: Full type support for the Stage 4 Temporal proposal - the modern replacement for the Date object, available via -target esnext or "lib": ["esnext"]
• Map/WeakMap upsert: getOrInsert and getOrInsertComputed methods eliminate boilerplate when working with Map; available in the esnext lib
• DOM iterables by default: Contents of lib.dom.iterable.d.ts are now included in lib.dom.d.ts - "lib": ["dom"] is sufficient
• Subpath imports with #/: Support for Node.js subpath imports under node20, nodenext, bundler
• es2025 target/lib: RegExp.escape, updated Promise and Iterator utilities

The -stableTypeOrdering Flag

TypeScript 6.0 introduces a diagnostic flag designed specifically for teams preparing to migrate to TypeScript 7.0. The flag stabilizes type ordering to match the deterministic behavior of the Go compiler's parallel architecture. Use it to surface discrepancies before switching to the native compiler. It can slow type-checking by up to 25% - this is a migration diagnostic tool, not a permanent configuration setting.

Options Being Removed in TypeScript 7.0

• target: es5 - minimum target is now ES2015
• -moduleResolution node (node10) - migrate to nodenext or bundler
• -module amd | umd | systemjs - migrate to ESM
• -outFile - migrate to esbuild, Vite, or webpack
• -baseUrl without paths
• -esModuleInterop false and -allowSyntheticDefaultImports false (now always enabled)
• -downlevelIteration - tied to ES5, no longer needed

Why Microsoft Chose Go Over Rust

Anders Hejlsberg - creator of TypeScript, C#, and Turbo Pascal - explained the decision publicly in a discussion on the microsoft/typescript-go repository. The choice came down to a concrete engineering constraint: the TypeScript compiler relies heavily on shared mutability and garbage collection. A port to Rust would require rethinking the entire memory architecture - that is not a port, it is a rewrite. Preserving 100 person-years of investment in the existing compiler architecture made Go the only practical option, as reported by The New Stack in their interview with the TypeScript team.

Go's structural similarity to the existing TypeScript codebase allowed a direct mapping of data structures. The 10x performance gain comes from two compounding factors: Web Development on native binaries delivers roughly 3-4x improvement over running on Node.js/V8, and Go goroutines enable parallel parsing, binding, and type-checking across independent parts of the program simultaneously, adding another 2-3x. That kind of parallelism is architecturally impossible in Node.js's event loop model - worker threads solve it only partially and require a separate architecture to implement correctly.

The Trade-offs Microsoft Accepted

Go's garbage collector can produce rare performance spikes - Rust's memory model would give more predictable latency at the cost of a complete rewrite. Browser-based tooling, including the TypeScript playground and web editors, is harder to port with Go due to WASM binary size. These are acknowledged trade-offs, not oversights. Microsoft prioritized speed of delivery and preservation of the compiler's existing architecture over the theoretical ceiling of Rust's performance characteristics.

10x Faster: What the Benchmarks Actually Show

The 10x headline is not marketing - it is a floor, not a ceiling, on what Microsoft measured across real production codebases. VS Code (1.5 million lines), Playwright (356,000 lines), and TypeORM (270,000 lines) all show double-digit multiplication factors when compiled with the native Go-based compiler, according to Microsoft's official benchmark data.

The language service improvements are equally meaningful for developer experience. Loading VS Code's codebase into the language service drops from 9.6 seconds to 1.2 seconds - an 8x improvement that translates directly into faster IntelliSense, quicker error feedback, and more responsive refactoring in every editor. Memory consumption is roughly half the current compiler's usage, and the Microsoft team has not yet begun targeted memory optimization work. These numbers will improve further.

Teams running 15-minute CI builds can expect approximately 3 minutes of savings per run with properly configured TypeScript 6.0, even before switching to the native compiler. Setting types explicitly in tsconfig - one of the new required defaults - eliminates unnecessary type resolution work and alone accounts for 20-50% build speedup in tested projects.

Go in Enterprise: 18,000 Companies and a Clear Pattern

Go is not a niche language or an emerging trend. Over 18,000 companies use Go in production as of 2025, with 2.2 million professional developers working in it as their primary language - a number that doubled over five years. An additional 11% of developers plan to start using Go within the next 12 months, according to ecosystem data compiled by JetBrains. Microsoft, by choosing Go for the TypeScript compiler, adds a globally-used developer tool to a list that already includes some of the most demanding production environments in the world.

The fintech numbers are worth examining specifically. Monzo processes 4,000 transactions per second at peak load, with certain APIs handling over 20 million requests per minute. Go-based systems - from fintech platforms to a dental seo company managing patient appointment flows - maintain latency below 20 milliseconds under concurrent load. Goroutines consume only a few kilobytes each, allowing any web design agency building high-traffic platforms to handle millions of connections without infrastructure overhead. These characteristics - predictable latency, efficient concurrency, low memory footprint per connection - are not coincidences. They reflect the architectural properties that made Go attractive to these companies.

How We Think About Go at Webdelo

At Webdelo, Go has been our primary language for fintech, performance-critical seo platforms, and digital marketing automation for several years. The reasons align directly with what Microsoft articulated when choosing Go for the TypeScript compiler: predictable latency under load, goroutines that scale concurrency without the overhead of thread pools, and a codebase that is maintainable by engineers who didn't write the original code. We've had the same conversations Microsoft had about Go versus the alternatives - and reached the same conclusions for the same reasons.

The question we hear most often from clients is a reasonable one: "We've been running on Java for 10 years - or PHP for 8 years - and it works. Why change?" The answer is not "because Go is modern" or "because it's faster." The answer depends on what the client is building and what they need to be true about their system. For a fintech service processing payments with strict latency requirements, or a high-load API where infrastructure costs scale with concurrent connections, or an AI integration that needs to handle thousands of concurrent webhook events - Go delivers measurable ROI. For a legacy monolith with deep Java ecosystem integration, the right approach is often a strangler fig migration, introducing Go for new services while the existing system continues to run.

What We Tell Clients Considering a Stack Change

• Start with a new service, not a migration: A new project or isolated service is the right entry point - no legacy constraints, clean architecture decisions
• Go reads more simply than it looks: Static typing, explicit error handling, and straightforward concurrency primitives make Go code easier to reason about than comparable Java or PHP code at scale
• Count TCO, not just build cost: Go services consistently require less infrastructure for equivalent load - fewer instances, lower memory per connection, predictable scaling behavior
• The strangler fig pattern works: Migrating everything at once is rarely necessary or wise; coexistence during transition is a first-class pattern

When Go Is Not the Right Choice

The same intellectual honesty that shapes our technology recommendations applies here. Go is not the correct answer for every class of problem, and we would rather say so directly than oversell it.

• Browser and WASM applications: Go compiles to heavy WASM binaries - it is not suited for frontend. This is also why Microsoft acknowledged the WASM trade-off when choosing Go for the TypeScript compiler
• CPU-intensive work without GC: If you need deterministic latency without garbage collection pauses - certain real-time trading systems, embedded contexts - Rust gives more predictable behavior
• Data science and ML pipelines: Python and R have a richer ecosystem of libraries for data analysis and model training; Go is not a meaningful competitor here
• Teams with no Go experience: Onboarding time is real and belongs in TCO calculations - if the team has deep Java expertise and the project is a standard enterprise application without heavy concurrency requirements, the switching cost may not pay off
• Legacy monoliths with heavy framework integration: Sometimes the right engineering decision is incremental improvement within the existing stack, not a rewrite

Our position: we recommend Go where it delivers a measurable advantage for the specific problem being solved - not because it is currently a notable trend in the industry.

Migrating to TypeScript 6.0: A Practical Checklist

Migrating from TypeScript 5.x to 6.0 requires explicit configuration of settings that were previously inferred or automatically applied. The fastest way to understand the scope of required changes in your repository is a dry-run diagnostic with the beta version.

Start Here: Quick Diagnostic

npm install -D typescript@beta
npx tsc -noEmit 2>&1 | head -50

Critical Migration Steps

1. Declare "types" explicitly: Add "types": ["node"] or list the specific @types packages your project uses. Without this, the new default of [] will cause 100+ errors from missing ambient type declarations
2. Set "rootDir": "./src" explicitly: Automatic inference has been removed
3. Replace "moduleResolution": "node": Migrate to "nodenext" or "bundler"
4. Remove "outFile": Replace with esbuild, Vite, or webpack as your bundler
5. Update "target": Replace "es5" with "es2015" or higher
6. Replace "module": "amd"/"umd"/"systemjs": Migrate to ESM
7. Run the TS 7.0 alignment check: npx tsc -stableTypeOrdering -noEmit and address the discrepancies before moving to the native compiler
8. Use the temporary bridge if needed: Add "ignoreDeprecations": "6.0" to tsconfig to keep deprecated options functional while working through the migration

For monorepos, the ts5to6 CLI automates baseUrl removal and rootDir inference across multiple packages. Teams running incremental builds with -watch can expect approximately 25% faster restarts after migration, reducing feedback loops in active development. Enterprise repositories typically save around 3 minutes on a 15-minute CI build from TypeScript 6.0 configuration improvements alone, before any transition to the native Go compiler.

Frequently Asked Questions

What is TypeScript 6.0 and how does it differ from TypeScript 7.0?

TypeScript 6.0 beta is the last version of the compiler written in JavaScript and TypeScript. TypeScript 7.0 uses a native compiler written in Go (Project Corsa), which has been stable since January 15, 2026. The TypeScript language itself - syntax, type system, JavaScript compatibility - is unchanged in both versions. Only the compiler toolchain differs.

Why did Microsoft choose Go over Rust for the TypeScript compiler?

The TypeScript compiler relies on shared mutability and garbage collection - a direct port to Rust would require redesigning the entire memory architecture, which is not a port but a complete rewrite. Go allowed direct mapping of existing data structures, preserving 100 person-years of compiler investment. Go's garbage collection is compatible with the compiler's existing design, and goroutines provide the parallelism needed for 10x performance without an architectural overhaul.

How long will migrating from TypeScript 5.x to 6.0 take?

Migration time depends on the age and configuration of your repository. A well-maintained project with explicit tsconfig settings may require only a few hours. A legacy repository that relied on automatic @types inclusion, used target: es5, or depends on outFile could require a day or more of work. The ts5to6 CLI automates the most repetitive changes for monorepos.

Go or Java/PHP for a new B2B project - which to choose?

For a new B2B service with high concurrency requirements, fintech transaction processing, or real-time integrations - Go delivers measurable ROI: lower infrastructure costs, predictable latency, and straightforward scaling. For a project where the team has deep Java expertise and the workload doesn't demand heavy concurrency, the switching cost may not be justified. The honest answer requires understanding the specific requirements before recommending a stack.

What are goroutines and why do they matter for high-load systems?

Goroutines are Go's lightweight concurrency primitive. Each goroutine uses only a few kilobytes of memory, compared to megabytes for OS threads or Java threads. This means a Go service can maintain millions of concurrent connections without the memory overhead that forces horizontal scaling in Java or PHP-based systems. The TypeScript native compiler uses goroutines to parallelize parsing, binding, and type-checking - the mechanism behind the 10x build speedup.

Can Go be used for fintech applications with high security requirements?

Yes. Monzo, one of Europe's largest cloud-native banks, runs its core financial transaction processing on Go, handling 4,000 transactions per second at peak. PayPal, American Express, and Nubank use Go for production financial systems. Go's static typing, explicit error handling, and straightforward concurrency model make it well-suited for financial applications where correctness and predictability matter. Security practices - encryption, access control, audit logging, compliance with GDPR and relevant financial regulations - are implementation concerns independent of language choice.

When will TypeScript 7.0 on Go be production-ready for my project?

TypeScript 7.0 reached stable release on January 15, 2026, after a year of preview. Type-checking parity with the JavaScript-based compiler stands at 99.6% (74 discrepancies across 20,000 test cases). For most projects, TypeScript 7.0 is already production-ready. Teams with highly complex type configurations should run the -stableTypeOrdering diagnostic on TypeScript 6.0 first to identify any discrepancies before switching to the native compiler.

Conclusion

TypeScript 6.0 is a line in the history of developer tooling. It closes the chapter on the JavaScript-based compiler and opens the one where Go runs TypeScript's most critical infrastructure. Microsoft's choice - made for pragmatic engineering reasons, not trend-following - is the same choice that Monzo, PayPal, Uber, Salesforce, and thousands of other companies made when they needed systems that scale predictably under load.

• TypeScript 6.0 beta changes five critical defaults - teams with legacy repositories need to act before upgrading
• TypeScript 7.0 on Go is stable and delivers 10x build speedup on real codebases, with memory consumption roughly halved
• Microsoft chose Go over Rust for the same reasons enterprise engineering teams choose it: GC compatibility, structural similarity to existing code, and goroutine-based parallelism that is straightforward to reason about
• Go is in production at 18,000+ companies; 2.2 million professional developers use it as their primary language
• The right entry point for a new Go service is a greenfield project or isolated service - not a full migration of existing systems

If you are building a fintech service, a high-load API, or an AI integration and want to discuss whether Go is the right choice for your architecture, get in touch with the Webdelo team to order development of a service on Go.