The New Performance Mandate: Less Framework, More Speed
Modern JavaScript framework performance refers to a design shift where libraries reduce memory usage, trim unused features, and align closely with native web standards so applications can handle more users and data with fewer resources while remaining responsive, predictable, and easier to maintain at scale. The latest releases of Jotai, TanStack Table, and Remix 3 are not random point updates; they are deliberate steps away from framework bloat and toward lean, efficient runtimes. Together they show a clear priority: runtime performance and state management efficiency now matter more than piling on features that most apps will never use. That is a healthy correction after a decade where developers treated heavy abstractions as a badge of sophistication rather than a cost they would eventually pay in memory leaks, sluggish tables, and brittle routing.
This pivot is overdue. Users no longer tolerate slow dashboards or overbuilt single-page apps when a simpler, faster site could do the job. Framework authors are feeling the pressure and answering with hard, internal changes instead of glossy marketing.
Jotai v2.20: Fixing High-Throughput Pain Without Breaking Apps
Jotai, the atomic state management library for React, has released Jotai v2.20.0 as a performance-focused update that reworks its internal store building blocks and prepares the ground for v3. This release centers on one goal: better performance in high-throughput scenarios where many atoms are created, read, and updated rapidly. The story here is not glamorous, but it is important. Earlier flexibility work introduced building blocks and a WeakMap-based approach so ecosystem tools could extend the store, but someone later reported a performance regression, with WeakMap identified as the main culprit. The team swapped WeakMap for passing everything as parameters instead, a more direct data path that cuts overhead even if it is "not super clean" in the author’s words.
For most developers, the everyday API is unchanged; creating and using a store still looks exactly as before, and the breaking changes sit in internals used mainly by library authors. That is a crucial point: Jotai is proving you can improve state management efficiency under the hood without forcing rewrites of application code. The follow-up patches v2.20.1 and v2.20.2 show a team tidying edge cases and treating performance as an ongoing discipline, not a single heroic fix. Jotai v2.20 is framed as the last step before serious work on v3 starts, underscoring that future designs will prioritize speed from the start rather than bolting it on later.
TanStack Table V9 Beta: Tree-Shakable Tables and Smarter State
TanStack Table, the headless UI library for tables and datagrids, has announced TanStack Table V9 in beta as a foundational release that reworks state management, memory usage, bundle size, and extensibility while keeping the core table logic familiar to developers. The headline change is brutal in its simplicity: features are now opt in. In V8, every feature shipped together, but in V9 the table registers only what it uses, which allows a small table to start at around 5kb while a full enterprise grid pulls in sorting, filtering, and pagination only when needed. That is memory optimization in web frameworks done right, and it is enforced by TypeScript so APIs like setSorting exist only when the related feature is active.
State management has also been rebuilt on TanStack Store, with table.state, table.store, and per-slice atoms replacing the older getState() pattern. A new table.subscribe API lets UI pieces re-render only when their slice of state changes, so something as mundane as row selection can update a single count instead of every control touching the table instance. That fine-grained control is a direct attack on wasteful re-renders and bloated memory footprints. Lead maintainer Kevin Van Cott admits the multi-year delay and says that the React Compiler becoming stable forced the rewrite because V8’s patterns "started breaking" under it. In other words, performance and compatibility pressure from the platform itself pushed TanStack Table to modernize or risk becoming unusable in serious apps.
Remix 3: Betting on Web Standards Over Framework Abstractions
Remix, the full-stack web framework from the team behind React Router, has released the Remix 3 beta preview as a ground-up rebuild that moves the project away from React and onto web platform primitives, announced by co-founder Michael Jackson. This is more than branding. Remix 3 reframes itself as a complete full stack, bundling routes, request handlers, middleware, sessions, auth, forms, uploads, assets, data and database management, UI components, theming, networking, and tests under one remix umbrella built from small composable packages. Architecturally, routes are Fetch API routes, controllers return web Response objects, and forms submit to URLs so the server owns the request lifecycle. On the frontend, Remix keeps JSX but drops the React runtime for a forked Preact and a more imperative model where state is plain variables and this.update() signals UI changes.
Set against other meta-frameworks, Remix 3 stands out as the boldest bet so far on web standards performance instead of heavier abstractions. Features like server-driven "frames" that load and reload independently and an "unbundling" approach where the runtime, not the bundler, is the source of truth all reinforce this direction. Commentary is divided; some praise it as a "Grug Brain" correction toward simpler, closer-to-the-platform tooling, while others accuse the project of becoming unrecognisable. That tension is healthy. If anything, it shows developers are finally arguing about how much framework is too much rather than assuming more layers are always better. Developers can try Remix 3 today with a simple command, npx remix@next new my-remix-app, which is an invitation to feel the difference instead of debating it in the abstract.
A Clear Trend: Runtime Performance Beats Feature Bloat
Taken together, these releases tell a blunt story: the JavaScript ecosystem is shifting from "more features" to "less waste". Jotai v2.20 focuses on performance in high-throughput scenarios by fixing internal regressions without touching the everyday API. TanStack Table V9 beta reworks state management and memory usage with tree-shakable, opt-in features so tables pay only for what they use. Remix 3 places the framework squarely on web platform primitives and bets that staying close to Fetch, Response, and URL forms will outperform a tower of custom abstractions. This is not coincidence; it is an industry trend toward lean, efficient frameworks as developers prioritize runtime performance over feature bloat.
Developers who ignore this shift risk shipping apps that feel dated the moment they load. Memory optimization in web frameworks, careful state management efficiency, and respect for web standards performance are becoming baseline expectations, not luxuries. The practical takeaway is simple: choose tools that prove they care about what happens at runtime, not just what reads nicely in a README. Jotai, TanStack Table, and Remix 3 are different kinds of projects, but they share a belief that smaller, clearer, and closer to the platform is the path to faster, more reliable applications. That belief is becoming the new default, and teams that embrace it now will be the ones whose apps still feel fast in five years.
