TypeScript 7.0 Native: Microsoft Rewrites Compiler in Go and Promises 10x Faster Performance

Hello HaWkers, Microsoft has just announced one of the biggest changes in TypeScript history: the compiler will be completely rewritten in Go, promising performance gains of up to 10x. The project, called Project Corsa, marks a new era for the language that dominates 69% of enterprise applications.

Have you ever imagined your editor responding instantly, without that annoying lag when opening large projects? That is exactly what Microsoft promises to deliver.

What Is Happening with TypeScript

Microsoft revealed in December 2025 the details of TypeScript 7.0, also known as Project Corsa. The idea is simple but ambitious: port the entire TypeScript compiler and language service to native code using the Go language.

Why Go and Not Rust?

Many developers were surprised by the choice of Go instead of Rust. Microsoft explained that:

Reasons for the choice:

Go offers garbage collection, making it easier to port existing JavaScript code
The TypeScript team has more experience with Go
Go's concurrency model is ideal for parallel compilation operations
Rust would require a deeper rewrite of the architecture

Release Timeline

Microsoft has set an aggressive timeline:

Version	Expected Date	Description
TypeScript 6.0	Q1 2026	Last JavaScript version
TypeScript 7.0 Preview	Q2 2026	First native preview
TypeScript 7.0 Stable	Late 2026	Official release

Impressive Performance Gains

The preliminary benchmarks of Project Corsa are impressive. Microsoft shared data from real projects:

Performance Comparison

Editor load time:

TypeScript 5.x: 15-30 seconds on large projects
TypeScript 7.0: 1-3 seconds

Memory usage:

TypeScript 5.x: 2-4 GB in monorepos
TypeScript 7.0: 500 MB - 1 GB

Type checking:

TypeScript 5.x: 45-90 seconds
TypeScript 7.0: 5-10 seconds

💡 Context: Projects like VS Code, which has over 1 million lines of TypeScript, will benefit the most.

How to Test Today

You can already try the native TypeScript previews. Microsoft has made test builds available:

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

# Check the version
tsc --version

# Run on a project
tsc --noEmit

The command above installs the preview version that already runs in native code. You can test it on your projects and compare performance.

Impact on the JavaScript Ecosystem

This change does not only affect those who use TypeScript directly. The entire JavaScript ecosystem will be impacted.

Tools That Will Benefit

Editors and IDEs:

VS Code will have instant autocomplete
WebStorm will be able to process larger projects
Vim/Neovim with LSP will be more responsive

Build Tools:

Webpack, Vite, and Rollup will have faster builds
ESLint with TypeScript rules will be more agile
Jest and Vitest will run tests faster

Guaranteed Compatibility

Microsoft guaranteed that there will be no breaking changes in TypeScript syntax or semantics. Code that works today will continue to work:

// This code works the same in TS 5.x and TS 7.0
interface User {
  id: number;
  name: string;
  email: string;
  createdAt: Date;
}

async function fetchUser(id: number): Promise<User> {
  const response = await fetch(`/api/users/${id}`);

  if (!response.ok) {
    throw new Error(`Failed to fetch user: ${response.status}`);
  }

  return response.json();
}

// Generics, utility types, everything continues to work
type PartialUser = Partial<User>;
type UserKeys = keyof User;

Node.js Also Supports TypeScript Natively

While Microsoft works on the native compiler, Node.js took an important step: native TypeScript support.

How It Works

Starting from Node.js 22.6.0, you can run TypeScript files directly:

# Run TypeScript directly in Node.js
node --experimental-strip-types app.ts

# From Node.js 22.18.0, without experimental flag
node app.ts

Node.js uses a technique called "type stripping" - it removes types at runtime without doing type checking. This means:

Advantages:

Instant execution of .ts files
No need for pre-compilation
Ideal for scripts and prototyping

Limitations:

Does not do type checking
Some advanced features are not supported
For production, compilation is still recommended

What This Means for Developers

The combination of native TypeScript 7.0 with Node.js support completely changes the development experience.

Modern Workflow

// src/server.ts - Run directly with Node.js or use the new tsc

import { createServer } from 'http';

interface RequestContext {
  method: string;
  url: string;
  timestamp: Date;
}

const server = createServer((req, res) => {
  const context: RequestContext = {
    method: req.method ?? 'GET',
    url: req.url ?? '/',
    timestamp: new Date(),
  };

  console.log(`[${context.timestamp.toISOString()}] ${context.method} ${context.url}`);

  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ status: 'ok', ...context }));
});

server.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

Skills in High Demand

With these changes, some skills will be even more valued:

Advanced TypeScript: Generics, utility types, type inference
Performance profiling: Understanding how to optimize builds
Modern tooling: Knowing Vite, esbuild, and the new tools
Updated Node.js: Taking advantage of new runtime features

Trends for 2026

TypeScript continues its growth trajectory. Some impressive numbers:

Enterprise adoption:

69% of enterprise applications use TypeScript
38.5% of developers on GitHub use TypeScript
TypeScript surpassed Java in the ranking of most popular languages

Companies using TypeScript:

26,748 verified companies in production
Sectors: financial, manufacturing, software development
Big players: Microsoft, Google, Airbnb, Slack

Conclusion

Native TypeScript 7.0 represents the biggest evolution of the language since its creation in 2012. The combination of 10x faster performance, native Node.js support, and ecosystem maturity makes 2026 a decisive year for those working with JavaScript/TypeScript.

If you have not mastered TypeScript yet, this is the ideal time to invest in this knowledge. Companies are increasingly requiring professionals who deeply understand the language.

If you feel inspired by the power of TypeScript, I recommend checking out another article: Signals in JavaScript: The New Era of Reactivity where you will discover how reactivity is evolving in frontend.