Three years later, I'd say this tweet was mostly correct.
1. Svelte is pushing React
Compilers are great, actually. Why not let the computer optimize your code versus humans? Svelte has always innovated with a compiler-first approach.
Svelte 5 continues to evolve with Runes, an explicit way of defining reactive state (
svelte.dev/blog/svelte-5-is-…).
On the React side, the React Compiler is finally available for use (now in beta) after many years of development (
react.dev/blog/2024/10/21/re…).
Compiler-friendly directives like 'use client' and 'use server' have become core to the React Server Components programming model (
react.dev/reference/rsc/use-…). And React frameworks like Next.js are adding their own directives like 'use cache' (
nextjs.org/blog/our-journey-…).
2. Remix is pushing Next.js
When this tweet was posted, the Next.js App Router wasn't even released. I remember two of our top requests for the Pages Router were: better support for layouts and global data fetching (e.g. _app.js).
Remix iterated on the `getServerSideProps` model of Next.js, allowing more granular data fetching, and added built-in conventions for layouts.
Ultimately, there's been a convergent evolution towards the Server Components and Server Actions model, with Remix helping shape some of the React 19 features as well.
The outcome has been, in my opinion, a better ecosystem for all React developers (
youtube.com/watch?v=AdkNcFUs…).
3. Prisma is pushing ORMs
Prisma has raised the bar for how the JS/TS ecosystem works with databases. Having great TypeScript support is now table stakes.
For example, Drizzle has taken this a step further by being able to define your schema and relations in TypeScript (versus the Prisma schema file).
Prisma should also get credit for helping push the entire "data layer" forward to be more lightweight and runtime agnostic. More libraries and vendors now use Web standard APIs, which means better interoperability between platforms.
With that context, it makes sense that you now see a Prisma managed Postgres database that connects over HTTP (
prisma.io/blog/announcing-pr…).
4. Deno is pushing Node.js
This was an understatement. Node.js has improved so much in the past three years.
I'd amend this original statement to add Bun as well. Multiple runtimes has meant more visibility and work towards performance, developer experience, and solving long standing papercuts.
For example, can you believe we will have native support for CJS/ESM interop in Node.js 22? Amazing.
Notably, Deno 2 is now stable (
deno.com/blog/v2.0) and has backwards compatibility with Node.js.
5. Supabase is pushing Firebase
I haven't kept up as much with Firebase, because Supabase has largely replaced it (for me).
That's not to say Firebase is bad. I still see it frequently used, especially when building web mobile apps together.
More so that Supabase has won the heart and minds of developers — and they've been able to ride the wave of Postgres love.
I'd amend this to say Supabase has pushed the entire BaaS (backend as a service) category forward.
6. esbuild / SWC are pushing JS tooling
After this tweet, I wrote an article about how Rust was becoming the future of JavaScript tooling infra (
leerob.com/n/rust).
That prediction turned out to be true. Now in 2024, we have Biome, Rspack, Rolldown, Oxc, Lightning CSS, Turbopack, and more.
This includes Vite/Rolldown/Oxc raising funding to continue investing in Rust tooling (
voidzero.dev/).
Notably, Turbopack Dev is now stable in Next.js 15. The team wrote up a very detailed post talking about the journey (
nextjs.org/blog/turbopack-fo…).
7. Bun is pushing SWC
Bun has pushed package managers, compilers, test runners, and other runtimes forward. It's shown there's many places to speed up the JavaScript ecosystem, if we try hard enough.
It's already been a year since Bun 1.0, and adoption seems to continue to rise. The iteration velocity of the team is incredibly high.
——
Now in 2024, what tools are pushing other tools? What will we look back and compare in three years?