2.1 Why Is It the Last JS Version?#

Since its inception, TypeScript’s compiler has been self-hosted using TypeScript/JavaScript. As project scale grew and the user base expanded (over 10 million developers worldwide), the performance bottleneck of JS single-threading became increasingly prominent.

Microsoft launched Project Corsa in 2025—rewriting the TypeScript compiler core in Go:

2.2 Development Progress of 7.0#

TypeScript 7.0 is “very close to completion,” and Nightly Builds can be experienced early through the following:

1
npm install -D @typescript/native-preview

Meanwhile, VS Code users can install the corresponding Nightly extension to test the actual performance of the Go native compiler on large codebases.

3.1 es2025 Target / Lib#

TypeScript 6.0 adds es2025 as a compilation target and library option. The core content of the es2025 type comes from TC39 proposals that have reached Stage 4:

• RegExp.escape(): Safely escape special characters in regular expressions
• Promise.try(): Unified Promise wrapping for sync/async function calls
• Iterator helper methods: Chained operations like Iterator.prototype.map/filter/take/drop
• Set methods: Set operations like Set.prototype.union/intersection/difference/symmetricDifference

1
// es2025 new capabilities example
2
const escaped = RegExp.escape("foo.bar");  // "foo\\.bar"
3

4
const result = await Promise.try(() => mayThrow());
5

6
const nums = new Set([1, 2, 3]);
7
const evens = new Set([2, 4, 6]);
8
const union = nums.union(evens);  // Set {1, 2, 3, 4, 6}

3.2 Temporal API Type Support#

The Temporal API has reached Stage 4 and will become the standard date-time handling solution for JavaScript. TypeScript 6.0 provides full type support through the esnext.temporal lib:

1
// Temporal API — modern JavaScript date handling
2
const now = Temporal.Now.plainDateTimeISO();
3
const meeting = now.add({ hours: 2, minutes: 30 });
4

5
const duration = meeting.since(now);
6
console.log(duration.toString()); // "PT2H30M"

3.3 Map “Upsert” Methods#

TypeScript 6.0 adds two practical type methods to Map:

• getOrInsert(key, value): Insert a default value when the key doesn’t exist and return it
• getOrInsertComputed(key, factory): Compute and insert via a factory function when the key doesn’t exist

1
const cache = new Map<string, number[]>();
2

3
// Traditional approach
4
let items = cache.get("key");
5
if (!items) {
6
  items = [];
7
  cache.set("key", items);
8
}
9

10
// 6.0 new approach
11
const items = cache.getOrInsertComputed("key", () => []);

3.4 Subpath Imports (#/)#

TypeScript 6.0 officially supports Node.js-style in-package import paths under nodenext and bundler module resolution modes:

1
{
2
  "imports": {
3
    "#utils/*": "./src/utils/*.ts",
4
    "#components/*": "./src/components/*.ts"
5
  }
6
}

1
// Concise imports with the # prefix
2
import { formatDate } from "#utils/date";
3
import { Button } from "#components/Button";

3.5 --stableTypeOrdering Flag#

TypeScript 6.0 adds the --stableTypeOrdering migration diagnostic flag. When enabled, 6.0’s type ordering algorithm aligns with 7.0’s deterministic ordering algorithm.

⚠️ Note: This flag may reduce type-checking speed by 25%. Only use it when preparing to migrate to 7.0.

3.6 DOM Type Merging#

The contents of dom.iterable and dom.asynciterable have been merged into the dom lib, and developers no longer need to separately declare iterable DOM types.

4.1 Overview of Default Value Changes#

This is the most far-reaching change in TypeScript 6.0—multiple historical defaults were flipped all at once:

4.2 The Huge Impact of types: []#

The most closely watched change is types defaulting to an empty array. This means @types packages are no longer automatically discovered and loaded, and must be explicitly declared via the types field.

The Microsoft team revealed that some projects saw cold build times reduced by 20%-50% as a result.

After upgrading, you must immediately check tsconfig.json:

1
{
2
  "compilerOptions": {
3
    "types": ["node"]  // Must be declared explicitly
4
  }
5
}

Otherwise, you’ll encounter numerous missing identifier errors such as Cannot find name 'console' and Cannot find name 'process'.

4.3 rootDir Defaults to .#

This change affects the output directory structure:

1
# Old behavior (rootDir automatically inferred as src/)
2
# New behavior (rootDir defaults to .)
3
# Output: dist/src/index.js   ← an extra level!

When upgrading, it’s recommended to explicitly set:

1
{
2
  "compilerOptions": {
3
    "rootDir": "./src"
4
  }
5
}

4.4 strict: true Enabled by Default#

TypeScript 6.0 enables strict: true by default, meaning all of the following sub-options are enabled by default:

• strictNullChecks
• strictBindCallApply
• strictFunctionTypes
• strictPropertyInitialization
• noImplicitAny
• noImplicitThis
• alwaysStrict
• useUnknownInCatchVariables

If your project previously did not enable strict mode, you may see numerous new type errors after upgrading. Most errors are legitimate, reflecting potential bugs in the code.

5.1 Compiler Options#

5.2 Syntax Deprecations#

• Module namespace syntax: module Foo { } → Use namespace Foo { }
• Import Assertions: import ... assert { type: "json" } → Use import ... with { type: "json" }

5.3 How to Cope#

In 6.0, you can temporarily suppress deprecation errors via configuration:

1
{
2
  "compilerOptions": {
3
    "ignoreDeprecations": "6.0"
4
  }
5
}

But note: 7.0 will no longer support these options at all, and ignoreDeprecations: "6.0" will also cease to work by then.

6.1 Minimal Migration Steps#

The recommended process for upgrading an existing project to TypeScript 6.0:

1
# 1. Upgrade TypeScript
2
npm install -D typescript@latest
3

4
# 2. Check the TypeScript version
5
npx tsc --version

6.2 Required Configuration Adjustments#

After upgrading, most projects need two configuration adjustments immediately:

1
{
2
  "compilerOptions": {
3
    // 1. Explicitly declare the type source (required!)
4
    "types": ["node"],
5

6
    // 2. Explicitly set rootDir (otherwise the output structure breaks)
7
    "rootDir": "./src"
8
  }
9
}

6.3 Recommended Migration Path#

1
Existing projects
2
  ├── Upgrade to TypeScript 6.0
3
  ├── Handle new errors caused by strict being enabled by default
4
  ├── Explicitly set types, rootDir
5
  ├── Eliminate deprecation warnings one by one
6
  ├── Configure the new module/target defaults
7
  ├── (Optional) Enable --stableTypeOrdering tests 7.0 compatibility
8
  └── Prepare for the TypeScript 7.0 Go compiler

6.4 Incremental Migration in Large Projects#

For large codebases, it is recommended to:

1. First run 6.0 compilation separately in CI, without blocking the main workflow
2. Gradually fix strict errors, batch by file or directory
3. Use ignoreDeprecations to buy time, but have a clear plan for eliminating them
4. Try out @typescript/native-preview early, to assess 7.0 compatibility in advance

7.1 Timeline#

7.2 Outlook for TypeScript 7.0#

TypeScript 7.0 will be a complete compiler rewrite—not an incremental improvement, but a rebuild of the entire compilation pipeline in Go:

• Shared-memory multithreading: Full utilization of multi-core CPUs, rather than Worker thread communication
• Native code performance: Moving away from JS GC, achieving deterministic memory management
• 10x compilation speed: Compilation times for large projects will drop from minutes to seconds
• Extremely low LSP latency: Code completion, error hints, refactoring—everything will be faster

7.3 Ecosystem Impact#

TypeScript’s Go rewrite is not just a performance upgrade; it also marks a systems-programming-language-ification trend in the JavaScript toolchain:

1
Toolchain evolution trends:
2
JavaScript → TypeScript (self-hosted) → Go/Rust/Zig (systems languages)
3

4
Completed / in progress:
5
✅ esbuild (Go)    — extremely fast bundler
6
✅ Rolldown (Rust) — Vite 8 underlying layer
7
✅ Oxc (Rust)      — high-performance parser
8
✅ Turbopack (Rust)— Next.js bundling
9
🔄 TypeScript (Go) — compiler 7.0

This trend means that frontend engineering is shifting from “good enough” to “native performance,” and the developer experience will see a qualitative leap.