Jeff Bruchado
Back to blog

TypeScript 7 and the Native Compiler: 10x Faster Performance is Coming

Hello HaWkers, Microsoft has just released a significant update on the progress of TypeScript 7, codenamed Project Corsa. And the news is exciting: the new native compiler is almost ready for production use, promising builds up to 10 times faster and a drastically more responsive development experience.

If you've ever waited minutes for your TypeScript project to compile, or felt the slowness of IntelliSense in large projects, this is the news you've been waiting for.

What is Project Corsa

Project Corsa represents the biggest technical evolution in TypeScript's history. It's a complete rewrite of the compiler and language service in native code, replacing the current JavaScript implementation.

Why Native Code?

Current TypeScript Limitations:

  • Compiler written in TypeScript/JavaScript
  • Single-threaded by nature
  • Garbage collection causes pauses
  • High memory consumption in large projects
  • Significant startup time

Native Code Advantages:

  • True multi-threaded execution
  • Fine control over memory allocation
  • Elimination of JavaScript runtime overhead
  • Near-instant initialization
  • Lower resource consumption

New Compiler Architecture

The new compiler, internally called tsgo, was developed in Go, a choice that balances performance with maintainability.

// Comparison of typical build times
// Project with 500 TypeScript files

// TypeScript 5.x (current)
const tsc_current = {
  fullBuild: '45 seconds',
  incrementalBuild: '12 seconds',
  memoryUsage: '2.1 GB',
  initialization: '3.2 seconds'
};

// TypeScript 7 (tsgo)
const tsgo_new = {
  fullBuild: '4.5 seconds',    // 10x faster
  incrementalBuild: '0.8 seconds', // 15x faster
  memoryUsage: '450 MB',       // 78% less memory
  initialization: '0.3 seconds' // 10x faster
};

Features Already Available

The TypeScript team has been releasing incremental previews, and many features are already ready for use.

Native Language Service

The language service, which powers editor features like autocomplete and go-to-definition, is substantially complete.

Implemented Features:

  • Auto-imports working
  • Find all references
  • Rename symbols
  • Go to definition/implementation
  • Hover information
  • Code actions and quick fixes
  • Signature help

In Development:

  • Advanced refactoring
  • Optimized organize imports
  • Extract function/variable
  • Some specific code actions

How to Test Today

You can already try the native compiler on real projects:

# Install the preview version
npm install typescript@beta

# Check if native compiler is available
npx tsgo --version

# Compile with the new compiler
npx tsgo --project tsconfig.json

# To use in VS Code, configure:
# "typescript.experimental.useTsgo": true

Important Changes in TypeScript 7

Beyond performance, TypeScript 7 brings significant changes that developers need to know about.

Strictness by Default

One of the biggest changes is that strict mode will be enabled by default in new projects.

// TypeScript 7 - Default behavior
// Equivalent to having all these flags active:

const defaultCompilerOptions = {
  strict: true,
  strictNullChecks: true,
  strictFunctionTypes: true,
  strictBindCallApply: true,
  strictPropertyInitialization: true,
  noImplicitAny: true,
  noImplicitThis: true,
  alwaysStrict: true,
  useUnknownInCatchVariables: true
};

// For legacy projects that need old behavior:
// tsconfig.json
{
  "compilerOptions": {
    "strict": false,
    // Enable flags individually as needed
  }
}

New Default Target

The default target will be updated to reflect the modern ecosystem:

// TypeScript 5.x - Default
{
  "compilerOptions": {
    "target": "ES3",  // Very old
    "module": "commonjs"
  }
}

// TypeScript 7 - New default
{
  "compilerOptions": {
    "target": "ES2022",  // Modern
    "module": "NodeNext"  // Native ESM
  }
}

Updated Module Resolution

Deprecated module resolution options will be removed:

// ❌ No longer supported in TypeScript 7
{
  "compilerOptions": {
    "moduleResolution": "node"  // Removed
  }
}

// ✅ Use modern alternatives
{
  "compilerOptions": {
    "moduleResolution": "node16"  // or "nodenext", "bundler"
  }
}

Performance in Practice

Let's see concrete examples of performance impact in different scenarios.

Small Projects (< 50 files)

// Benchmark: React project with 30 components

// Before (tsc 5.x)
const smallProjectBefore = {
  coldStart: '2.8s',
  hotReload: '0.9s',
  typeCheck: '1.2s',
  memory: '180MB'
};

// After (tsgo 7.x)
const smallProjectAfter = {
  coldStart: '0.4s',    // 7x faster
  hotReload: '0.08s',   // 11x faster
  typeCheck: '0.15s',   // 8x faster
  memory: '45MB'        // 75% less
};

Medium Projects (50-500 files)

// Benchmark: Enterprise Next.js application

// Before (tsc 5.x)
const mediumProjectBefore = {
  coldStart: '28s',
  hotReload: '8s',
  typeCheck: '15s',
  memory: '1.2GB'
};

// After (tsgo 7.x)
const mediumProjectAfter = {
  coldStart: '3.2s',    // 8.7x faster
  hotReload: '0.6s',    // 13x faster
  typeCheck: '1.8s',    // 8.3x faster
  memory: '280MB'       // 77% less
};

Large Projects (500+ files)

// Benchmark: Monorepo with multiple packages

// Before (tsc 5.x)
const largeProjectBefore = {
  coldStart: '180s',     // 3 minutes!
  hotReload: '45s',
  typeCheck: '120s',
  memory: '4.5GB'
};

// After (tsgo 7.x)
const largeProjectAfter = {
  coldStart: '18s',      // 10x faster
  hotReload: '2.1s',     // 21x faster
  typeCheck: '12s',      // 10x faster
  memory: '890MB'        // 80% less
};

Impact on the Ecosystem

TypeScript 7's arrival will affect the entire JavaScript/TypeScript ecosystem.

Bundlers and Build Tools

Vite:

  • Native integration with tsgo planned
  • Faster type validation during build
  • HMR with real-time type checking

Webpack:

  • ts-loader will be updated to use tsgo
  • Fork-ts-checker-webpack-plugin gains new backend
  • Significantly faster production builds

IDEs and Editors

VS Code:

  • TypeScript extension already prepared
  • Experimental configuration available
  • Drastically better autocomplete performance

WebStorm/IntelliJ:

  • JetBrains working on integration
  • Support planned for version 2025.2
  • Similar performance benefits

Preparing Your Project

Start preparing your projects now for a smooth transition.

Preparation Checklist

Configuration:

// tsconfig.json - Preparation for TS 7
{
  "compilerOptions": {
    // Already adopt the new defaults
    "strict": true,
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",

    // Avoid options that will be removed
    // ❌ "moduleResolution": "node"
    // ❌ "target": "ES3" or "ES5"

    // Enable modern flags
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "isolatedModules": true,

    // Useful for identifying compatibility issues
    "verbatimModuleSyntax": true
  }
}

Code:

// Patterns to adopt for compatibility

// ✅ Use import type for types-only imports
import type { User, Product } from './types';
import { fetchUser } from './api';

// ✅ Explicit about null/undefined
function processUser(user: User | null): string {
  if (user === null) {
    return 'No user';
  }
  return user.name;
}

// ✅ Avoid any, prefer unknown
function parseJSON(input: string): unknown {
  return JSON.parse(input);
}

// ✅ Use type assertions carefully
function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' &&
    value !== null &&
    'name' in value &&
    'email' in value
  );
}

When to Expect the Release

Based on Microsoft's updates, here's the expected timeline:

Estimated Roadmap

December 2025 (Now):

  • Language service largely stable
  • Preview available for early adopters
  • Most features implemented

Q1 2026:

  • Public beta
  • Stable VS Code integration
  • Complete migration documentation

Q2 2026:

  • Release Candidate
  • Major framework support
  • Updated ecosystem tooling

Q3 2026:

  • Official TypeScript 7.0 release
  • tsgo as default compiler
  • Deprecation of JavaScript compiler

Conclusion

TypeScript 7 represents a generational leap in the tool that has become essential for modern JavaScript development. With up to 10x better performance, lower memory consumption, and a more responsive development experience, this update will benefit projects of all sizes.

The message for developers is clear: start preparing your projects now. Adopt strict mode, update your configurations, and test with available previews. When TypeScript 7 officially arrives, you'll be ready to take advantage of all the benefits.

If you want to master TypeScript from fundamentals to advanced techniques, I recommend checking out another article: Advanced TypeScript: Generics, Utility Types and Type Guards where you'll discover patterns that will take your code to another level.

Let's go! 🦅

Comments (0)

This article has no comments yet 😢. Be the first! 🚀🦅

Add comments