Big projects are ditching TypeScript… why?
Based on Fireship's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Several major open-source projects are moving away from TypeScript in their internal library codebases, even while end users can still use TypeScript through framework tooling.
Briefing
Big projects aren’t abandoning TypeScript because types are suddenly useless—they’re walking away from TypeScript’s *costs* in library development, while keeping its benefits in application development. The shift shows up as major open-source teams moving away from TypeScript in their codebases, even as end users can still use TypeScript normally through framework integrations. The practical question becomes less “Did TypeScript win?” and more “Which parts of the TypeScript toolchain are worth paying for, and where?”
The timeline helps explain the reversal. TypeScript debuted in 2012 from Microsoft and initially drew little attention. Adoption accelerated when Angular 2 embraced it, and by the early 2020s it was everywhere—so much so that many former skeptics became “true believers.” Now, with TypeScript saturation approaching its peak, a new wave of projects is choosing plain JavaScript instead of TypeScript for their internal implementation.
Svelte, Drizzle, and Turbo are cited as examples of libraries that are dropping TypeScript *for development*, not necessarily for users. That distinction matters: developers using Svelte can still write TypeScript in their own apps. What’s changing is the language used inside the library’s source code, where the tradeoffs look different.
One major reason is friction from TypeScript’s “type gymnastics.” DHH, creator of Ruby on Rails, is highlighted for getting rid of TypeScript and Turbo, arguing that the compile step isn’t the real issue—TypeScript’s complexity pollutes the codebase with contortions to satisfy the type system. The transcript frames this as especially painful when building libraries, where developers often need to fight the IDE and the compiler to keep types accurate. In strict mode, avoiding explicit types can force heavy use of `any`, producing code that feels less readable and less “beautiful,” even if it’s technically correct.
Turbo’s reaction is described as angry and frustrated, with TypeScript contributors feeling their work is now “dead on arrival.” Svelte’s reasoning is portrayed as more pragmatic. Rich Harris’s approach is to remove the compile step for Svelte’s core while preserving much of TypeScript’s value through a documentation-and-types workflow: using JSdoc-style comments to declare types and generate `.d.ts` files. That still delivers editor IntelliSense and early bug detection, but without requiring the project itself to be written in TypeScript.
The transcript draws a boundary between libraries and applications. For app frameworks like SvelteKit or Next.js, TypeScript integration is described as seamless, making it unlikely that many teams will abandon it for real products. Finally, it points to a potential future détente: an ECMAScript proposal for optional native type annotations in JavaScript could make TypeScript “nearly obsolete,” turning today’s holy war into a more unified ecosystem.
Cornell Notes
TypeScript’s dominance is being challenged not by a rejection of types, but by a rejection of TypeScript’s overhead inside some large open-source libraries. Projects such as Svelte, Turbo, and Drizzle are moving away from TypeScript in their *codebases*, while still allowing end users to use TypeScript normally through framework tooling. Critics like DHH argue that TypeScript can force “type gymnastics” that clutter library code, especially under strict mode where avoiding explicit types can lead to frequent `any`. Svelte’s alternative keeps editor benefits by using JSdoc-style comments to generate `.d.ts` files, preserving IntelliSense without a compile step. For application frameworks like SvelteKit and Next.js, TypeScript integration remains convenient, so abandonment is less likely.
Why are some big open-source projects ditching TypeScript in their own codebases?
How can a project drop TypeScript internally while still supporting TypeScript for users?
What is Svelte’s practical alternative to TypeScript, and what benefits does it preserve?
Why does the transcript suggest TypeScript is still likely to stick around for application frameworks?
What future change could reduce the need for TypeScript?
Review Questions
- What specific pain points make TypeScript feel less attractive for library authors compared with app developers?
- How does JSdoc-based typing with generated `.d.ts` files replicate key TypeScript benefits like IntelliSense?
- What distinction does the transcript make between dropping TypeScript in a library codebase versus abandoning it for end users?
Key Points
- 1
Several major open-source projects are moving away from TypeScript in their internal library codebases, even while end users can still use TypeScript through framework tooling.
- 2
DHH’s criticism centers on TypeScript “type gymnastics” that clutter library code, not on the existence of a compile step.
- 3
Strict TypeScript mode can push developers toward explicit types or frequent `any`, which can reduce code clarity and maintainability.
- 4
Svelte’s approach keeps editor value by using JSdoc-style type annotations to generate `.d.ts` files, enabling IntelliSense without compiling TypeScript.
- 5
Library development and application development have different tradeoffs; app frameworks like SvelteKit and Next.js are described as integrating TypeScript smoothly.
- 6
A stage 1 ECMAScript proposal for optional type annotations could eventually make TypeScript less necessary by bringing typing closer to native JavaScript.