TypeScript 7: The Native Go Compiler is Ready for Daily Use

Hello HaWkers, Microsoft has just announced a historic milestone for the TypeScript ecosystem: the native compiler written in Go is officially stable and ready for daily use. This marks the end of an era and the beginning of a revolution in how we work with TypeScript.

But what does this mean in practice? Let's dive into the technical details and understand why this change is so significant.

What is Happening With TypeScript?

Microsoft is porting the entire TypeScript compiler and language service from JavaScript/TypeScript to native Go code. TypeScript 6.0 will be the last major version built on the current JavaScript codebase (internally called "Strada").

Transition Timeline

Compiler evolution:

TypeScript 1.0-5.x: JavaScript/TypeScript compiler
TypeScript 6.0: Last JavaScript version (2025)
TypeScript 7.0: First native Go compiler (2026)

Current status (December 2025):

Native compiler: Stable for daily use
Type checking: Functional
Auto-imports: Reimplemented and working
Find-all-references: Available
Rename: Operational
Editor support: VS Code and others

Why Migrate to Go?

The decision to rewrite TypeScript in Go was based on several technical factors:

Performance Gains

Official Microsoft benchmarks:

Operation	tsc JavaScript	tsc Go	Improvement
Initial compilation	45s	4.5s	10x faster
Incremental check	8s	0.8s	10x faster
Find references	3s	300ms	10x faster
Auto-complete	500ms	50ms	10x faster
Memory used	4GB	800MB	5x less memory

Large projects (monorepos):

Build time: From 5 minutes to 30 seconds
CI/CD: 80% reduction in pipeline time
Developer experience: Instant feedback

Technical Advantages of Go

Why Go was chosen:

Compilation to native binary
Excellent memory management
Native concurrency with goroutines
Cross-platform portability
Easy distribution (single binary)

How to Test Today

You can already try the native compiler. Here's how to set it up:

# Install the native TypeScript preview version
npm install -g typescript@native

# Check the installed version
tsc --version
# Output: Version 7.0.0-dev.native

# Compile a project
tsc --project tsconfig.json

# Use in VS Code (add to settings.json)
{
  "typescript.tsserver.useSeparateServer": true,
  "typescript.tsdk.native": true
}

Configuration for Existing Projects

// tsconfig.json - compatible with both versions
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Impact For Developers

This change will have significant effects on the daily work of TypeScript developers:

Immediate Benefits

For local development:

Almost instant hot reload
Autocomplete without lag
Fluid code navigation
Less editor memory usage

For CI/CD:

Builds up to 10x faster
Lower infrastructure costs
More efficient pipelines
Lower resource consumption

For monorepos:

Type checking in seconds
More responsive watch mode
Better experience in large projects

Experience Comparison

// Example project with 10,000 TypeScript files

// BEFORE (JavaScript tsc)
// - Initial compilation: 2-3 minutes
// - Incremental check: 15-30 seconds
// - Autocomplete: 500ms-1s delay
// - Memory: 4-6GB

// AFTER (Native Go tsc)
// - Initial compilation: 15-20 seconds
// - Incremental check: 1-2 seconds
// - Autocomplete: <50ms delay
// - Memory: 800MB-1.2GB

Compatibility and Migration

Microsoft is working to ensure full compatibility:

What Changes

Invisible changes:

Internal compilation engine
Language server architecture
Memory management

What stays the same:

TypeScript syntax
tsconfig.json
Compiler APIs
Existing plugins

Migration Plan

Phase 1 (Current):

Preview available for early adopters
Community feedback
Critical bug fixes

Phase 2 (Q1 2026):

TypeScript 7.0 release candidate
Migration of large open source projects
Complete documentation

Phase 3 (Q2 2026):

Official TypeScript 7.0 launch
TypeScript 6.x enters maintenance mode
Native Go becomes the default

What This Means For the Ecosystem

The move to native Go will have impacts beyond TypeScript:

Affected Tools

Need updates:

Build plugins (Webpack, Vite, esbuild)
Linters and formatters
IDEs and editors
Static analysis tools

Already compatible:

VS Code (official support)
Prettier (no changes needed)
ESLint (TypeScript configuration)

Native Tools Trend

TypeScript joins a growing trend of JavaScript tools being rewritten in compiled languages:

Tool	Original	Rewritten in	Gain
esbuild	-	Go	100x faster than Webpack
SWC	-	Rust	20x faster than Babel
Turbopack	-	Rust	10x faster than Webpack
Rome/Biome	-	Rust	35x faster than ESLint
TypeScript 7	JavaScript	Go	10x faster
OxLint	-	Rust	100x faster than ESLint

How to Prepare

To make the most of this change:

Recommended Actions

Now:

Test the preview on personal projects
Identify dependencies that may be affected
Report bugs and feedback on GitHub

Next quarter:

Evaluate impact on production projects
Update build tools
Train the team on changes

2026:

Officially migrate to TypeScript 7.0
Leverage performance gains
Update CI/CD pipelines

Conclusion

TypeScript 7 with the native Go compiler represents one of the biggest technical evolutions of the language since its creation. With performance gains of up to 10x, the development experience with TypeScript will become dramatically better.

For us developers, this means faster builds, more responsive editors, and less time waiting for the compiler. It's a change that benefits projects of all sizes.

If you want to follow other important changes in the JavaScript ecosystem, I recommend checking out: Node.js Security Updates: Critical Vulnerabilities December 2025 where we cover the most recent security updates.