No compiler in sight: running TypeScript files for real

For years, TypeScript carried a quiet tax. You wrote the typing you loved, and then you stood around while the compiler did its job — tsc, then tsx, then ts-node, each dance the same: write, compile, run. The build step was simply part of life.

That tax is quietly disappearing. In 2026, the mainstream runtimes run .ts files natively. For a lot of everyday work, the build-to-JS step is now optional.

What actually changed

The trick is called type stripping, and it is exactly as straightforward as it sounds. When Node loads a .ts file, it erases the type annotations and replaces them with whitespace before the code runs. Node 22.6.0 shipped this experimentally in August 2024 behind the --experimental-strip-types flag. Since Node 22.18.0 and 23.6.0, it has been on by default. You just run:

node server.ts

No flag. No tsc. No ts-node. The file runs.

Because stripping swaps annotations for whitespace rather than deleting them, your line numbers never shift, and stack traces stay accurate. And it is worth being clear about what this will not do: it performs no type checking. It strips. That is the whole job.

What does not survive the strip

Stripping only understands erasable syntax — anything with no runtime meaning. The code-generating features are another story. Enums, namespaces with runtime values, and parameter properties generate real code, so basic stripping leaves them out. Node keeps an experimental flag for exactly these cases:

node --experimental-transform-types server.ts

It is still there as of Node 24. If your codebase leans on enums, you will want that transform — or one of the runtimes below.

Deno and Bun never needed this fight

Deno treated TypeScript as first-class from day one. deno run main.ts works with no compiler, no config, and no build step — and because Deno runs the full language, enums just work. When you want the real safety net, deno check runs the actual type checker, the same thing tsc --noEmit gives you. Deno has also integrated the new native TypeScript compiler — tsgo, written in Go and roughly ten times faster than the JavaScript tsc — behind an unstable flag. That is a preview, so keep it out of CI for now.

Bun, for its part, runs TypeScript and JSX first-class with zero configuration, transpiling on the fly: bun run server.ts.

What this means for your project

This is a steady, verified trend, not a rumor. For many projects, the compile step becomes something you reach for only when you actually need it: a real type check before a release, or an enum-happy codebase. Everyday work — a script, a small service, a side project — can run the source directly.

Concretely, that changes the everyday loop. A script you touch a few times a week no longer needs a config file; an API service starts and restarts faster, because there is no compile step sitting in the middle; a fresh repo can be up and running with the runtime you already have installed. The toolchain gets simpler, and the pieces that still ask for a build step are the ones that genuinely need one.

tsx and ts-node are not obsolete overnight. Plenty of teams will keep them, and publishing a bundle for production still very much exists. But for a growing share of work, the new default is "types erased, checked separately." A simpler toolchain, fewer moving parts, the same language. That is the good kind of boring.