TypeScript 5.5 to 7: The Native Compiler Migration Guide

If you are still on TypeScript 5.5, you are two major versions behind, and the gap is not the usual kind. TypeScript 7 replaced the compiler. It is no longer a JavaScript program type-checking your code — it is a native binary written in Go.

That produces a very large speed improvement and a real set of breaking changes. This guide is the path from 5.5 to 7, and the one caveat that may stop you upgrading today regardless of how much you want to.

What actually changed

The headline is speed. Full builds typically run 8 to 12 times faster. Microsoft's own benchmark on the VS Code source went from 125.7 seconds to 10.6 — roughly a twelvefold improvement — with about 18% less memory.

That is not a micro-optimisation. On a large codebase it is the difference between a type-check you avoid running and one you run on every save.

Importantly, the checker was ported rather than rewritten. The team moved the existing implementation to Go and kept the logic structurally identical, which is why type-checking behaviour is broadly the same. You are getting the same compiler, executed differently.

The breaking changes

Notice the pattern: most of these were already deprecated in 6.0 and merely warned. Going 5.5 → 7 in one jump turns every one of those warnings into an error at the same moment, which is why the intermediate step matters.

The caveat that may block you

This is the part to check before planning anything else.

TypeScript 7.0 ships without a public compiler API. Any tool that programmatically drives the compiler cannot work with it yet. In practice that includes Vue, Astro, Svelte, MDX and Angular templates — all of which rely on that API to type-check their own file formats.

If your stack includes any of them, you cannot move to TypeScript 7 today. The API is expected in 7.1.

This is not a minor footnote — it excludes a large share of front-end projects. Check it first, because if it applies, the rest of the migration is a plan for later rather than this sprint.

# Does anything in your tree depend on the compiler API?
npm ls typescript
grep -rl "require('typescript')\|from 'typescript'" node_modules --include=*.js | head

The migration path

Do not jump straight from 5.5 to 7. Go through 6, which is where the deprecations are warnings rather than errors.

Step 1 — turn on strict while still on 5.5

// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler"
  }
}

Do this first and separately. Strict mode is where most of the real work is, and you want those errors surfacing while your toolchain is still stable rather than mixed in with a compiler swap.

Step 2 — upgrade to 6 and clear every warning

npm i -D typescript@6
npx tsc --noEmit

Treat each deprecation warning as a required fix, not advice. Every one you leave becomes a hard error in 7.

Step 3 — remove dead configuration

Delete es5 targets, AMD/UMD/SystemJS module settings and moduleResolution: node10. If something still needs ES5 output, that is now a bundler's job rather than the compiler's.

Step 4 — upgrade to 7

npm i -D typescript@7
npx tsc --noEmit
npm run build

If steps 1 to 3 were done properly, this step is usually quiet — which is the point of doing them.

What did not change

Worth stating, because "rewritten compiler" sounds more alarming than it is:

• The type system. Generics, conditional types, mapped types, inference — all identical.
• Your syntax. No language changes to adopt.
• Type-checking results. The checker was ported, not reimplemented, so the same code produces the same errors.
• Editor experience. Faster, but the same features.

This is a delivery change, not a language change. You are not learning new TypeScript.

Should you upgrade now?

Yes, if you are on a plain TypeScript stack — Node services, React with a standard bundler, libraries. The speed gain is large and immediate, and the breaking changes are mostly configuration.

Not yet, if you use Vue, Astro, Svelte, MDX or Angular templates. Wait for the compiler API in 7.1. Use the time to do steps 1 to 3, so you are ready when it lands.

Either way, enable strict mode now. It is the largest piece of work, it is valuable independently of any upgrade, and doing it in isolation is far easier than doing it alongside a compiler change.

Frequently asked questions

What is the latest version of TypeScript?

TypeScript 7.0. If you are on 5.5 you are two majors behind, and the gap includes a compiler replacement rather than only new language features.

What changed in TypeScript 7?

The compiler was ported from JavaScript to a native Go binary, giving roughly 8-12x faster full builds and about 18% lower memory use. Alongside that, strict and esnext became defaults, the es5 target and AMD/UMD/SystemJS module formats were removed, and 6.0's deprecations became hard errors.

Is TypeScript 7 faster?

Substantially. Full builds typically run 8 to 12 times faster — Microsoft's VS Code benchmark went from 125.7 seconds to 10.6, with around 18% less memory.

Can I upgrade to TypeScript 7 with Vue or Astro?

Not yet. TypeScript 7.0 ships without a public compiler API, which Vue, Astro, Svelte, MDX and Angular templates depend on to type-check their own file formats. The API is expected in 7.1.

Should I upgrade straight from 5.5 to 7?

No. Go through 6 first. Most of 7's breaking changes were deprecation warnings in 6, so passing through it lets you fix them one at a time instead of meeting them all as errors at once.

Will my code break on TypeScript 7?

The type system and syntax are unchanged, so the language itself will not break. What breaks is configuration — removed targets, removed module formats — and code that only passed because strict mode was off.

Why was TypeScript rewritten in Go?

For speed. A native binary avoids the overhead of running the compiler as a JavaScript program. The checker was methodically ported from the existing implementation rather than rebuilt, which is why behaviour stayed consistent.

Do I need to change my code for TypeScript 7?

Usually not the code itself, only tsconfig.json — unless strict mode was previously off, in which case expect real type errors to surface. Enable strict on your current version first to separate that work from the upgrade.