869: Node + TypeScript in 2025

Episode Summary

Executive Summary: The episode explains how TypeScript can now run more directly in Node via experimental type stripping, reducing the need for build steps and simplifying development. It contrasts Node’s current limitations with tools like TSX, ts-node, Deno, and Bun, and argues that TypeScript usage should favor future-compatible patterns like avoiding enums and using explicit type imports.

Main Topics: Node’s new experimental TypeScript support: Node 23.6 unflags TypeScript type stripping, allowing .ts files to run without a separate compile step, though it remains experimental and only strips types rather than transforming code. Type stripping vs. compilation: The hosts distinguish between simply removing type annotations and fully compiling/transpiling TypeScript, noting that stripping avoids source-map complexity but cannot handle syntax transformations. Limitations and unsupported TypeScript features: Current Node support cannot handle TypeScript features that alter runtime output, especially enums, namespace/legacy modules, and parameter properties, though loader work is underway. Alternative runtime tools: TSX and ts-node: TSX is presented as a strong replacement for running TypeScript in Node, with smooth CLI flag forwarding and even production use; ts-node is mentioned as a more established alternative. Deno and Bun as first-class TypeScript runtimes: Deno and Bun already treat TypeScript as a native capability and also support JSX, which Node’s current type stripping does not. JSDoc as a gradual typing path: JSDoc is highlighted as a useful alternative or bridge for JavaScript projects, providing editor types, deprecation metadata, and documentation without renaming files. Developer experience and future direction: Both speakers emphasize that modern tooling has reduced the friction of TypeScript dramatically, making manual build-watch pipelines increasingly obsolete.

Key Arguments: Node’s built-in TypeScript support is a major quality-of-life improvement because it removes the need for a compile step in many cases. The current Node implementation is type stripping, not transformation, so it cannot support TypeScript features that generate JavaScript runtime code. Enums are discouraged because they blur the line between type-only syntax and real runtime JavaScript, making them incompatible with pure type stripping. Explicit type imports (`import type`) are required for Node’s TypeScript mode and help prevent accidental runtime imports from leaking into client/server boundaries. TSX is praised as a practical, nearly seamless tool for running TypeScript in production and development without a separate build pipeline. Deno and Bun have an advantage in ergonomics because they support TypeScript and JSX as first-class features. JSDoc provides a viable incremental path to stronger typing in JavaScript and adds benefits like deprecation tags and function documentation.

Data Points: Node version: 23.6 - The episode says TypeScript type stripping was unflagged in Node 23.6 and can now run without a flag, though still experimental. Number of TypeScript runtime approaches discussed: 4+ - The conversation covers Node’s native support, TSX, ts-node, Deno, and Bun as ways to run or use TypeScript. JSDoc adoption path: Gradual migration - JSDoc is described as a way to add types to existing JavaScript without renaming files to .ts.

Pivotal Quotes: "TypeScript can be run in Node without a flag right now." — Wes Bos: Explaining Node 23.6’s unflagged experimental type stripping support. "If you don't have to get into my TS config to run TypeScript code and, you know, not have to deal with that compilation step, then yeah, I'm going to do that." — Scott Tolinski: Reacting to the simplification of running TypeScript directly in Node. "I love where we're at with this world compared to where we were at five years ago, even two years ago, one year ago in TypeScript." — Wes Bos: Reflecting on how much easier TypeScript tooling has become.

Implications: TypeScript is moving closer to a zero-config, runtime-native experience, reducing build complexity and encouraging simpler, more future-compatible code patterns. Developers should prefer non-transforming syntax and keep an eye on Node, Deno, and Bun as the ecosystem evolves.