TypeScript 7 Will Be Written in Go: What Changes for Developers

Hello HaWkers, one of the biggest news in the JavaScript ecosystem in 2026 is the confirmation that TypeScript 7 will be completely rewritten in Go. Microsoft is betting big on a native compiler rewrite to solve historical performance issues.

Let's understand what this means, why it was done, and how you should prepare.

The Announcement

What Was Revealed

Microsoft announced that TypeScript 7.0, scheduled for 2026, will be the first version of the compiler written entirely in Go. TypeScript 6.0, released as a "bridge version," will be the last version written in TypeScript.

Official timeline:

TypeScript 5.9: Last version of the 5.x line (Q1 2026)
TypeScript 6.0: Transition version, still in TS (Q2 2026)
TypeScript 7.0: First native version in Go (Q3-Q4 2026)

Promised gains:

Up to 10x faster compilation
Significantly lower memory usage
Better parallelism on multi-core machines
Faster response times in IDEs

Why Rewrite in Go

Current TypeScript Problems

The current TypeScript compiler, written in TypeScript (which compiles to JavaScript), faces fundamental limitations.

Identified bottlenecks:

Single-threaded: JavaScript is predominantly single-threaded
Garbage Collection: V8's GC causes unpredictable pauses
Memory: Type representations consume a lot of memory
Startup: Significant initialization time

Real impact on projects:

Project Size	Current tsc	tsc 7 (projected)
Small (<100 files)	2-5s	<1s
Medium (100-1000 files)	15-45s	3-8s
Large (1000-5000 files)	1-5min	15-45s
Giant monorepo	5-15min	1-3min

Why Go

The choice of Go (and not Rust, C++, or another language) was deliberate.

Go advantages:

Simplicity: More accessible language for contributors
Concurrency: Goroutines facilitate parallelism
Efficient GC: Optimized garbage collector, short pauses
Fast compilation: Go itself compiles very fast
Cross-platform: Native binaries for all platforms

Why not Rust:

Steeper learning curve
Borrow checker adds complexity
Fewer developers available
Go meets requirements without additional overhead

What Changes for You

Compatibility

Microsoft promised the change will be transparent for most users.

What stays the same:

TypeScript syntax
Type semantics
Configuration via tsconfig.json
Programmatic APIs (with wrappers)
Integration with bundlers

What may change:

Error messages (may be slightly different)
Some edge cases of behavior
Plugins that depend on tsc internal APIs
Execution order of some checks

Transition Period

TypeScript 6.0 was designed as a transition version.

What TS 6.0 does:

// TS 6.0 deprecates some internal APIs
// that won't exist in TS 7.0

// Example: Custom transformation APIs
// that access compiler internals

// If you use something like this, prepare:
import * as ts from 'typescript';
// Some internal properties will be removed

Recommendations:

Update to TS 6.0 as soon as it's available
Fix all deprecation warnings
Test your build pipeline thoroughly
Report incompatibility bugs

Ecosystem Impact

Build Tools

Bundlers and build tools will need to adapt.

Status by tool:

Tool	TS 7 Status	Notes
tsc (official)	Supported	It is the compiler itself
esbuild	Already native	Doesn't use tsc, not affected
swc	Already native	Doesn't use tsc, not affected
Vite	Supported	Uses esbuild/swc internally
webpack	Update needed	ts-loader will need update
Rollup	Supported	Plugins may need update

IDEs and Editors

The IDE experience should improve significantly.

VS Code:

// Today: tsserver can consume >1GB in large projects
// and have perceptible delays in autocomplete

// With TS 7: Reduced memory, faster responses
// Benefit especially visible in:
// - Large monorepos
// - Files with complex types
// - Projects with many dependencies

Other editors:

WebStorm: Support confirmed
Vim/Neovim (coc-tsserver): Update needed
Sublime Text: Plugin will need update

Practical Demonstration

What You'll See Day-to-Day

Here's how the experience should change:

Project compilation:

# Today (TS 5.x on large project)
$ time tsc --noEmit
# real    2m15s
# user    2m10s
# sys     0m5s

# Future (TS 7 - projected)
$ time tsc --noEmit
# real    0m18s
# user    0m45s  # uses more cores
# sys     0m3s

Watch mode:

# Today: Incremental rebuild still takes seconds
$ tsc --watch
# Detected change, compiling...
# Compilation complete. Watching for changes... (3.2s)

# Future: Nearly instant rebuilds
$ tsc --watch
# Detected change, compiling...
# Compilation complete. Watching for changes... (0.4s)

TypeScript Code

The code you write doesn't change at all.

// This code works the same in TS 5, 6, and 7

interface User {
  id: number;
  name: string;
  email: string;
  createdAt: Date;
}

type CreateUserDTO = Omit<User, 'id' | 'createdAt'>;

function createUser(data: CreateUserDTO): User {
  return {
    ...data,
    id: generateId(),
    createdAt: new Date(),
  };
}

// Generics, utility types, everything works the same
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object
    ? DeepPartial<T[P]>
    : T[P];
};

How to Prepare

Preparation Checklist

Immediate action:

Identify dependencies that use TypeScript internal APIs
Update to latest versions of all tools
Ensure your CI can easily update TS version

When TS 6.0 launches:

Update immediately in test branch
Run entire test suite
Check deprecation warnings
Plan fixes before TS 7.0

When TS 7.0 launches:

Test in isolated environment first
Compare compilation output (should be identical)
Check performance in your use case
Update after complete validation

At-Risk Dependencies

Some dependencies may need special attention.

Risk categories:

// HIGH RISK: Dependencies accessing TS internals
// - Some ESLint plugins with type-aware rules
// - Custom code generation tools
// - Custom TypeScript transformers

// MEDIUM RISK: Dependencies wrapping tsc
// - ts-loader (webpack)
// - @rollup/plugin-typescript
// - Some Jest configs

// LOW RISK: Tools that don't use tsc
// - esbuild, swc, Bun (own transpilers)
// - Prettier (doesn't do type checking)
// - Most libraries

The Broader Context

TypeScript in 2026

TypeScript continues to dominate the JavaScript ecosystem.

2025 numbers:

Over 1 million contributors on GitHub
66% year-over-year growth
Nearly universal adoption in professional projects
Node.js now natively supports TypeScript

The Evolution of JS Tools

TypeScript 7 is part of a larger trend.

Native tools emerging:

esbuild: Bundler in Go (launched 2020)
swc: Transpiler in Rust (launched 2019)
Bun: Runtime in Zig (launched 2022)
Rolldown: Bundler in Rust for Vite (2026)
TypeScript 7: Compiler in Go (2026)

The trend is clear: JavaScript tools are being rewritten in native languages for better performance.

Conclusion

The TypeScript rewrite in Go represents a natural and necessary evolution. With TypeScript projects growing in size and complexity, the performance limits of the current compiler have become evident. TypeScript 7 promises to solve these problems while maintaining compatibility with existing code.

Key points:

TypeScript 7 will be written in Go, no longer in TypeScript
Up to 10x performance gains expected
Your TypeScript code doesn't need to change
TypeScript 6.0 is the transition version - pay attention
IDEs and editors will have much better experience

For developers, the main action is: keep your tools updated, test TS 6.0 when it launches, and prepare for a much faster development experience soon.

For more on the JavaScript ecosystem, read: Bun vs Node.js vs Deno in 2026: The Definitive Guide.