5 TypeScript Features That Define 2026 (And 2 I'm Still Waiting For)

1. The compiler went native, and it's roughly 10x faster

The headline feature of TypeScript 7 is that the compiler is now a native binary written in Go. Microsoft measured a full type-check of the VS Code codebase dropping from 77.8 seconds to 7.5 seconds. That's a 10.4x cut on real code, not a toy benchmark.

The project codename is Corsa, and Anders Hejlsberg (TypeScript's lead architect) is running it. The important part: there's no new type system and no new syntax. The team took the existing checker and ported it, keeping the logic structurally identical. So your types behave the same. The wait just gets shorter.

You can try it today from the preview package:

npm install -D @typescript/native-preview
      npx tsgo --noEmit
      

I ran it on one of our Expo apps. A clean tsc --noEmit took 4.2 seconds; the same check on tsgo took 0.8 seconds. That's about 5x on a small codebase, and the gap only widens on big ones, which is where the VS Code 10.4x comes from. Expect one bump on the way in: tsgo immediately rejected our baseUrl option with error TS5102, because TypeScript 7 removed it. Paths resolve relative to the config file now, so I deleted one line and it passed. From the release candidate onward the native compiler folds back into the normal typescript package and the tsc command, so most projects bump a version and change little else. The one caveat before you migrate: TypeScript 7.0 has no stable programmatic API yet, which is why some tools still lag (more on that below).

2. You can run TypeScript with no build step

TypeScript 5.8 added --erasableSyntaxOnly, which pairs with Node's native type stripping so you can run a .ts file directly. No transpile, no bundler, no dist folder for local scripts.

Node strips the type annotations and runs the rest. That works for almost everything, but a few TypeScript features emit real runtime code and can't be stripped: enums, namespaces with runtime bodies, and constructor parameter properties. The flag catches those at author time so you never ship code Node can't run:

// Both of these now error under erasableSyntaxOnly:
      enum Color { Red, Green }          // enums compile to a runtime object

      class User {
        constructor(private id: string) {}  // parameter property emits an assignment
      }
      

Turn it on in your config and run the file straight from Node (22.18 and up, on by default in Node 24):

// tsconfig.json
      { "compilerOptions": { "erasableSyntaxOnly": true } }
      

node server.ts
      

The trap: type stripping deletes types and runs the code without checking them. A type error won't stop the program. You still need tsc --noEmit in CI to actually catch mistakes.

3. import defer lets you lazy-load a module

TypeScript 5.9 shipped support for import defer, a Stage 3 ECMAScript proposal that delays evaluating a module until you first touch one of its exports. It's a clean win for expensive dependencies you don't always use.

import defer * as heavyAnalytics from "./heavy-analytics.js";

      export function trackFirstOpen() {
        // heavy-analytics.js runs only when this line executes,
        // not when the file is imported at startup
        heavyAnalytics.track("app_opened");
      }
      

One rule to remember: only namespace imports (import defer * as x) are allowed. Named and default imports aren't, because the whole point is to avoid evaluating the module up front. I use this for analytics and PDF generation, the code paths most users never hit on a cold start.

4. --module node20 gives you a target that stops moving

TypeScript 5.9 added --module node20, a stable option that models Node.js 20 behavior and implies --target es2023. The value here is predictability.

The older nodenext setting tracks whatever the latest Node does, so its behavior shifts under you as Node evolves. node20 pins to a known version and stays put, which is exactly what you want in a tsconfig.json you won't touch for a year:

// tsconfig.json
      {
        "compilerOptions": {
          "module": "node20"   // stable, and implies "target": "es2023"
        }
      }
      

Small feature, but it removes a class of "it worked last month" surprises in CI.

5. Better defaults and hovers make the editor pull its weight

TypeScript 5.9 reworked tsc --init to emit a lean config instead of a hundred commented-out lines, and it made editor hovers far more useful. This is the quality-of-life bucket, and it matters more than it sounds.

The new tsc --init writes a short, readable file instead of a wall of comments, close to this:

{
        "compilerOptions": {
          "target": "esnext",
          "module": "nodenext",
          "strict": true
        }
      }
      

On top of that, DOM type definitions now carry summary descriptions pulled from MDN, so hovering element.scrollIntoView explains what it does without a trip to the browser. Hovers also got expandable + and - buttons to drill into a deep type instead of squinting at a truncated blob.

The 2 I'm still waiting for

A stable compiler API on the native build. Every one of our repos runs typescript-eslint, and template type-checking for Vue, Svelte, and Astro all lean on TypeScript's programmatic API. TypeScript 7.0 ships without a stable one, so those tools can't run on the native compiler yet. The API is targeted for 7.1, several months out. Until then you get the fast tsc, but your lint and framework checks still ride the old engine.

Nominal (opaque) types. TypeScript is still structural, so two string aliases are interchangeable no matter what you name them. To fake a real distinct type, we hand-roll brands:

type UserId = string & { readonly __brand: "UserId" };
      type PostId = string & { readonly __brand: "PostId" };

      function getUser(id: UserId) { /* ... */ }
      // getUser(somePostId as PostId)  // the brand trick works, but it's a trick
      

It works, and it has saved us from passing a post id where a user id belongs. But a __brand phantom field is a workaround for a language feature that should exist. Give me a real nominal keyword.

Takeaway

The theme for TypeScript in 2026 is speed and less ceremony, not more type gymnastics. The native compiler makes big codebases feel small again, no-build-step .ts kills a whole tooling layer for scripts, and import defer trims your startup cost. Upgrade when you can, but keep tsc --noEmit in CI as your real safety net, because the fastest features here are the ones that skip type-checking entirely. Fast is only good when it's also correct.

---

I write these from real work at astraedus.dev, where I build apps and tools. Building something, or stuck on something like this? Reach me at astraedus.dev or [email protected].

Get the next one in your inbox → subscribe at astraedus.dev.