TypeScript 6.0 to 7.0: The 2026 Upgrade Plan

TypeScript 6.0 shipped on March 23, 2026, and just four weeks later the team announced the TypeScript 7.0 beta on April 21. The headline: TypeScript 6.0 is the transition release that changes defaults, deprecates legacy options, and prepares projects for a native, Go‑based compiler in 7.0 that’s often dramatically faster. If you own a modern web stack, this is the upgrade window that pays dividends all year.

What changed, and when?

Let’s anchor the timeline. On March 23, 2026, 6.0 became generally available. On April 21, 2026, 7.0 entered beta with a native compiler and a side‑by‑side story so teams can trial it without destabilizing builds. The gap between those dates is intentional: 6.0 nudges the ecosystem into modern defaults and surfaces deprecations; 7.0 validates the performance story and editor parity.

Here’s the thing: if your tsconfig hasn’t been touched since 5.x, 6.0 will make you look. That’s the point. It aligns default behavior with today’s ESM‑first, evergreen‑runtime reality and makes the jump to 7.0 smoother.

TypeScript 6.0: what’s new and why it matters

These are the changes most teams will feel first:

Modern defaults. New projects now default to strict: true, module: esnext, and a floating target that maps to the current standard (as of today, effectively es2025). For teams that already opted into strict+ESM, nothing breaks; for everyone else, you’ll make intent explicit in tsconfig rather than inheriting legacy behavior.

Types array is now explicit. The implicit “load every @types package in node_modules” behavior is gone. The default is an empty list to avoid pulling thousands of declarations across a workspace. Expect missing globals like process until you add something like types: ["node"].

Root directory clarity. 6.0 always assumes the tsconfig’s directory as root unless you set rootDir. If your emit started landing under dist/src unexpectedly, that’s your nudge to specify it.

Standard library updates. There’s a new es2025 lib/target, built‑in types for the now‑standard Temporal API, upsert‑style Map helpers (getOrInsert/getOrInsertComputed), and RegExp.escape in the lib. These don’t change how your code runs; they make intent and safety clearer in your types.

Module resolution alignment. Node’s modern resolution patterns are first‑class under moduleResolution: nodenext, and bundler‑centric projects should use moduleResolution: bundler. The old node/node10 path is deprecated.

A bridge flag that saves CI diffs. Add --stableTypeOrdering in 6.0 while you test 7.0. It keeps diagnostic and type‑printing order stable across the toolchain so your CI doesn’t light up from churn that isn’t a real regression.

What 6.0 deprecates before 7.0 turns them into errors

6.0 marks these as deprecated; 7.0 will treat them as hard errors. The sooner you clear them, the less weekend you’ll donate later.

• ES5 output target. target: es5 is deprecated. If you still need ES5 in a niche environment, that’s a job for a separate compiler/transpiler stage, not tsc.
• Legacy module systems. module: amd, umd, systemjs, and none are out. Move to ESM and—if needed—use a bundler or import maps for the gaps.
• moduleResolution: node/node10. Migrate to nodenext (Node apps) or bundler (bundled apps/Bun).
• baseUrl. It’s deprecated because it quietly changed how non‑mapped imports resolved. Use explicit paths entries instead; add a catch‑all mapping if you truly relied on a lookup root.
• downlevelIteration. It existed for ES5 emit; with ES5 gone, so is this flag.

Yes, you can set "ignoreDeprecations": "6.0" to buy time. But that’s debt with interest—7.0 removes the escape hatch.

Meet TypeScript 7.0 beta: a native compiler and a faster editor

The 7.0 beta runs a Go‑based compiler and language service with parallel parsing, checking, and emitting. On large codebases, many teams are already reporting order‑of‑magnitude wins on clean builds and snappier editor feedback. Two pragmatic notes:

• Try it side‑by‑side. The beta ships under a preview package and a separate command so you can compare tsc (6.0) vs tsgo (7.0) on the same repo. That’s your low‑risk bakeoff.
• Tooling API isn’t final until 7.1. If you maintain plugins or tools that import TypeScript programmatically, keep those integrations pinned to 6.0 while you test the 7.0 CLI and editor.

There are also useful controls: --checkers to tune type‑checker workers and --builders for parallel project‑reference builds, plus a --singleThreaded mode for reproducible debugging or constrained runners.

Upgrade framework: a 9‑step, low‑drama plan

Use this checklist on a feature branch. Budget a day for a mid‑sized app, two to three for a large monorepo.

1. Inventory your tsconfigs. List every tsconfig in the repo (apps, packages, tools). Note custom flags, especially module*, target, types, rootDir, baseUrl, and any path mappings.
2. Pin 5.x first if needed. If you’re on 5.1–5.8 with ad‑hoc flags, pin to the last stable 5.9 in a short PR and clean obvious warnings. It reduces diff noise when you jump to 6.0.
3. Adopt 6.0 with stable diagnostics. Upgrade to 6.0 and enable --stableTypeOrdering. Fix new errors in this order: set types explicitly (e.g., ["node"]), set rootDir, then align module/moduleResolution.
4. Replace baseUrl with paths. Remove baseUrl. Add explicit paths mappings, including a "*": ["./src/*"] catch‑all only if you truly relied on base lookups.
5. Retire ES5 and legacy modules. Move remaining scripts off target: es5 and away from AMD/UMD/SystemJS. If there’s a hard dependency, quarantine it behind a bundler plugin or a compatibility layer.
6. Run your CI matrix. Expect “missing global” errors until types are explicit. Fix, re‑run, and record baseline timings for clean and incremental builds.
7. Trial 7.0 beta side‑by‑side. Add the preview package; wire a parallel CI job that runs the same build with tsgo. Compare times, memory, and diagnostics. Keep your production job on 6.0 for now.
8. Tune concurrency. On big repos, experiment with --checkers and --builders. Watch RAM usage on CI runners; more workers aren’t free.
9. Plan for the API shift. If you own custom transformers, code mods, or lint rules that import from typescript, keep them on 6.0 and schedule the 7.1 rework. Document this in your repo’s upgrade notes.

People also ask: quick answers

Is TypeScript 6.0 backwards compatible with 5.x?

Mostly, yes—API‑wise it’s aligned with 5.9. The sharp edges are new defaults (strict, module, target), the explicit types list, and deprecations that reveal hidden coupling (like baseUrl). Expect config edits, not mass rewrites.

Should I wait for 7.0 stable?

No reason to stall. Move to 6.0 now, clear deprecations, and pilot the 7.0 beta in CI and editors. When 7.0 goes stable, flipping the switch will be a non‑event for app teams; tool authors should wait for 7.1 to target the new programmatic API.

Will my editor feel faster?

Very likely. The native preview extension brings the compiler’s speedups to your editor. Most teams see responsiveness gains on larger workspaces. Try it without touching production builds.

Real‑world migration notes from shipping teams

On multi‑package repos, the most painful regressions aren’t code—they’re config drift. Standardize tsconfig bases per package type (web app, Node service, library). Enforce them with a tiny script that validates required flags on CI.

If you rely on typescript-eslint, keep it on a version chain tested against 6.0 while you evaluate 7.0 in parallel. Use npm aliases to keep your tooling importing 6.0’s API while tsgo runs your builds. This one change has de‑risked trials for several teams I’ve advised this spring.

Targeting both Node and the browser? Prefer module: preserve with moduleResolution: bundler for libraries and nodenext for server code. It mirrors reality and reduces workaround glue for ESM/CJS edges.

A focused tsconfig template you can copy

For a typical web app compiled and bundled for evergreen browsers:

• compilerOptions: strict: true, module: esnext, target: es2025, moduleResolution: bundler, rootDir: ./src, outDir: ./dist, types: ["node", "jest"]
• paths: add explicit mappings for aliases you actually use; avoid wildcard sprawl unless you’re mirroring a folder structure on purpose
• include: ["src"] and let your bundler own everything else

For a Node service:

• compilerOptions: module: esnext, moduleResolution: nodenext, types: ["node"]
• Set type: module in package.json if you’re ESM‑only, or keep compatibility layers extremely thin

For libraries:

• Prefer module: preserve and ship ESM primary with well‑documented CJS interop if needed
• Use exports and imports maps in package.json; avoid sneaky base‑path tricks

Performance: measure twice, switch once

Don’t guess. Capture three numbers on 6.0 before trialing 7.0 beta: cold build time, incremental build time after a typical edit, and memory usage on your CI runners. Then run the same workflow with tsgo. If you see the big wins many teams report, prioritize the move; if not, tune --checkers and --builders, or examine hotspots like type‑heavy generated code.

Editor responsiveness matters just as much. Ask your team to run the native preview for a few days and give subjective ratings on auto‑imports, go‑to‑def, and diagnostics. If developer flow improves, that’s real ROI even before you swap the CLI.

Risks and edge cases to plan for

Tooling that imports TypeScript directly. Custom transformers, code mods, and some linters expect a stable compiler API. Keep them on the 6.0 chain and plan the 7.1 adjustment window.

Packages still on AMD/UMD. If a legacy vendor bundle is stuck there, treat it like a third‑party artifact and integrate via your bundler’s compatibility plugin rather than forcing tsc to emit it.

JS projects with TypeScript type‑checking. 7.0 changes some special cases around JavaScript patterns. Validate your JS+JSDoc flows under tsgo early while you’re still on the preview path.

Monorepo cascade effects. One stray tsconfig with types: ["*"] or a forgotten baseUrl can tank build times or mask import mistakes. Enforce tsconfig baselines and fail CI if a package opts out without an ADR.

Where this intersects budgets and roadmaps

Upgrading isn’t just a tech flex; it’s schedule math. If your team spends hours per week waiting on builds, cutting those times by even a factor of two pays back quickly. If you need help sequencing this work alongside a feature roadmap, our team has a battle‑tested approach for planning runtime and tooling upgrades that actually ship. You can also see how we stage discovery and risk‑reduction in our web development process, and how we price upgrade and maintenance tracks in this 2026 cost guide. If you’re evaluating partners, start with the right questions from our agency selection checklist.

What to do next (this week and this quarter)

This week

• Upgrade one service/app to 6.0, enable stableTypeOrdering, and fix config errors.
• Remove baseUrl and migrate to explicit paths.
• Trial the editor’s native preview on a few engineers’ machines and gather feedback.
• Spin up a parallel CI job that runs the 7.0 beta CLI for timing only.

This quarter

• Standardize tsconfig bases across the repo and validate them in CI.
• Map every deprecation to an owner and deadline; eliminate ignoreDeprecations by end of sprint two.
• Decide on your 7.0 adoption trigger (for app teams) and a 7.1 window (for tool maintainers).
• Document the upgrade in your engineering handbook so new projects start with the sane defaults.

FAQ for leaders: how risky is this?

If your stack already leaned into ESM and strict typing, very low. The main work is tsconfig hygiene and clearing deprecated flags. The 7.0 beta is mature enough to test in CI and editors without destabilizing production. The one caveat is tooling that imports TypeScript directly; for that slice, plan to hold at 6.0 until 7.1’s API story lands.

Zooming out

JavaScript’s baseline got better—evergreen browsers, modern Node, robust bundlers. TypeScript 6.0 leans into that reality; TypeScript 7.0 capitalizes on it with a faster compiler and editor. Move now while the path is paved and the deprecations are warnings, not walls. Your future self (and your CI minutes) will thank you.