Over the last few years, frontend development has quietly entered a new phase. React, once the undisputed champion of JavaScript frameworks, is now being challenged. Modern browsers are more capable, developers are more discerning, and the jig is almost up.

At the same time, various tools are showing that there’s more than one way to build fast, maintainable, interactive apps.

So is React being replaced? Not quite. But we are seeing a shift — a post-React era — not defined by React’s disappearance, but by its loss of monopoly. This article explores what that actually looks like.

React Is No Longer the Only Answer

For over a decade, React has shaped how we write frontend code. It redefined UI architecture with a component-based model, virtual DOM, and a robust state ecosystem. But the very assumptions React was built on are now under scrutiny. Do we still need the virtual DOM when the native DOM has become faster and more consistent? Must every interaction rely on hydration and JavaScript-heavy abstractions?

These questions are being asked in earnest as developers seek lighter, faster alternatives. React’s one-size-fits-all dominance is giving way to more web-native approaches that embrace simplicity. It’s not necessarily that React is bad — it’s that the frontend landscape has evolved.

The tools we once needed to patch browser inconsistencies are now solving problems they might have created. As frameworks and developers rethink old patterns, the frontend is no longer “React by default.”

Remix’s Pivot Signals a Broader Shift

When Remix v3 announced a shift away from React in some parts of its architecture, it sparked a fresh wave of discussion. The announcement wasn’t a condemnation of React, but rather a pragmatic step toward rethinking assumptions. Remix had long been seen as a React-based, full-stack framework — but that label was always a little misleading. The team at Remix built around the web platform first, with React more as an implementation detail than a gospel truth.

Their recent shift reflects a deeper realization: we don’t need React for everything. Server-side rendering, native DOM manipulation, progressive enhancement — these are all things that the web platform handles pretty well on its own now.

Remix’s decision to lean into that strength rather than fight it with abstraction-heavy patterns is a wake-up call. Developers have grown weary of hydration overhead, state management complexity, and overengineering for simple tasks.

Instead, frameworks like Remix are returning to fundamentals: HTML-first rendering, declarative data fetching via standard browser APIs, and server-first routing logic. That doesn’t mean React is being tossed out, but it does mean React is now optional. This opens the door to a more modular, composable approach where React is just one of many tools — not the foundation for everything.

The Rise of HTML-First and Native DOM Frameworks

React was born at a time when browsers were inconsistent and JavaScript was the only reliable way to deliver interactive experiences. But modern browsers have matured. APIs like form.submit(), fetch, Web Components, and View Transitions API mean we can build compelling experiences without reaching for a component framework every time.

That’s why HTML-first frameworks are gaining steam. Tools like Astro, HTMX, and Enhance are flipping the script. They prioritize minimal JavaScript, server-rendered HTML, and progressive enhancement. Instead of treating the DOM like a dirty hack to be abstracted away, they embrace it as a first-class citizen. Interactivity is layered on top only where needed.

Astro, for example, lets you ship zero JavaScript by default. HTMX turns your existing HTML into reactive interfaces without a client-side framework. These tools align better with the performance and accessibility needs of today’s web. They’re not trying to replace React in its entirety, but rather solve different problems more efficiently. The era of “React or nothing” is over.

React’s Server Component Gamble

React isn’t asleep at the wheel. Its creators see the shift too, and they’ve launched their own counter-narrative: React Server Components (RSC). The idea is to split the app between server and client more intelligently, sending only what’s absolutely necessary to the browser. This promises better performance, smaller bundles, improved developer ergonomics, and potentially benefits in optimizing cloud costs by reducing payloads and server strain.

But RSC has sparked its own schism. It dramatically alters how React apps are built. It breaks compatibility with existing patterns, tooling, and even mental models. The complexity of adopting RSC in existing apps is non-trivial. It also locks developers more tightly into meta-frameworks like Next.js, which already add layers of abstraction atop React.

Some developers feel like RSC is a reinvention that solves problems React created in the first place. Hydration issues? Virtual DOM inefficiencies? These are artifacts of the client-heavy model React originally popularized. RSC aims to correct this, but at the cost of simplicity. Whether this gamble pays off remains to be seen — especially as other frameworks achieve similar outcomes with less ceremony.

Frameworks Are Thinking Outside the JSX Box

JSX used to feel magical. It let developers write HTML-like syntax in JavaScript and blurred the line between logic and markup. But that blurring now feels like baggage in some contexts. Developers are reconsidering whether tightly coupling rendering logic to stateful components is really necessary for every project.

Take SolidJS, Qwik, or Svelte — each is redefining how components are compiled, rendered, or resumed. Svelte compiles away during build time. Qwik introduces resumability for near-instant interactivity. Solid sidesteps the virtual DOM entirely for fine-grained reactivity.

Even Lit and Web Components are getting their second wind, championed by the very platform React abstracted away. And let’s not ignore the native DOM APIs themselves — far from dead, they’re powering leaner, faster apps without a JavaScript-heavy stack.

JSX still has fans, but the tooling monoculture is cracking.

Is React Still King?

React still dominates in terms of job listings, npm downloads, and GitHub stars. Its ecosystem is mature; and for large apps with complex state, it’s still a solid bet. But its dominance is no longer absolute. We’re seeing a diversification of tooling, philosophies and tradeoffs.

What we’re witnessing isn’t a dethroning, but a decentering. React is no longer the default answer. The frontend space is becoming polyglot again — choosing a stack now means asking what kind of interactivity you need, what constraints matter, and what kind of developer experience you prefer.

For many teams, React is still the right tool. But for others, a return to simpler, more native web approaches is yielding better performance, faster development, and lower cognitive overhead.

Final Thoughts

“Post-React” doesn’t imply that React is obsolete — it just means we’re thinking beyond React now. It means we’re acknowledging that React’s solutions are not always ideal and that alternatives are mature enough to challenge it credibly. It’s a mindset shift: from framework-first to web-first.

This isn’t the end of React, but the start of a broader, richer frontend ecosystem. One where developers are empowered to use the right tool for the job — even if that tool is just a <form> tag and a sprinkle of fetch. We’re rediscovering the power of the web itself.

The post Why React Is No Longer the Undisputed Champion of JavaScript appeared first on The New Stack.

It doesn't mean that you discover if something works when it's live and in use. You should test that it does what it's supposed to do before making it publicly available. (It's not an excuse for not verifying your work before saying it's done.)

It doesn't mean that you first lean about any problems with a change when it's in production. Changes should be reviewed before release and possible or likely problems addressed in advance.

It can mean that you release new functionality behind feature flags and roll them out slowly to all people.

It can mean that you A/B test new functionality in real scenarios.

It can mean that you monitor your systems in production to ensure reliability and performance.

It means that you need a way to gather feedback and errors from live systems.

It is also to recognize that things may happen in production that may not happen elsewhere.

Everyone should test in production. No one should only test in production.

Angular partnered with the Chrome team to create a new custom track for Angular in Chrome DevTools. The tool provides Angular-specific data and insights from the Chrome DevTools performance panel.

“Traditionally, Chrome’s performance panel is excellent for detailed function call analysis, while Angular DevTools offers a higher-level view based on framework concepts like components, lifecycle hooks, bindings, etc.,” Angular developers Mark Thompson and Pawel Kozlowski wrote in Wednesday’s announcement. “Unfortunately, having two separate tools leads to a fragmented understanding of performance.”

The blog post provides screenshots to help developers understand the new interactive track, or you can head straight to the documentation.

Astro Rolls Out Intro Course

If you’d like to learn more about Astro’s recent release of live content collections, or just Astro in general, the framework’s maintainers hosted and participated in a series of virtual events last week, called the Solstice Festival.

Among the events was the release of an Intro to Astro course, a discussion with core maintainer Sarah Rainsberger, a panel on learning Astro and a drill-down on content collections with Kane and senior software engineer and YouTuber Nick Taylor.

Included in the event was a deep-dive post into the new live content collections by Astro core maintainer Matt Kane.

Astro is a content-focused web framework. Content collections were originally a way to structure content from files (Markdown, MDX and JSON), allowing developers to build blogs and documentation sites, he explained. But they’ve since evolved into a content layer that supports pluggable loaders for a variety of data sources, including APIs and CMS, Kane wrote.

Live content collections bring real-time data capabilities to the content collections API. Use cases include e-commerce sites that need frequent inventory changes, news and social media aggregation, and using custom loaders in pages.

Deep Dive into Shopify’s Frontend Tech Stack

Shopify’s tech stack is known for its scalability, and now we can see how it was built, thanks to a recent in-depth look published by the blog ByteByteGo. Shopify assisted with the piece.

“Shopify’s frontend has gone through multiple architectural shifts, each one reflecting changes in the broader web ecosystem and lessons learned under scale,” the blog post noted. “The early days used standard patterns: server-rendered HTML templates, enhanced with jQuery and prototype.js.”

Shopify then built its own single-page application framework called Batman.js, which offered reactivity and routing, but became a long-term maintenance problem. They next shifted to statically rendered HTML and vanilla JavaScript.

Now, TypeScript is paired with React.

“Today, the Shopify Admin interface runs on React, React Router by Remix, written in TypeScript, and driven entirely by GraphQL,” the post stated. “It follows a strict separation: no business logic in the client, no shared state across views. The Admin is one of Shopify’s biggest apps, built on Remix that behaves as a stateless GraphQL client. Each page fetches exactly the data it needs, when it needs it.”

For mobile development, they use React Native.

The piece also explores the backend tech stack.

Figma Adds Custom Interactions With React

Figma is best known as a design tool, but it supports developer collaboration in a number of ways. In June, the cloud-based design and prototyping tool introduced code layers, which is a new way to build custom interactions in Figma Sites — its tool for designing, prototyping and publishing websites directly from Figma designs.

Code layers use custom React code to add interaction and motion. Of course, it leverages AI to do so.

“Whether you’re creating an element from scratch or riffing on an existing design, code layers allow you to add dynamic functionality to your site — from flyouts and dropdowns to shaders and maps — by converting components to code layers, chatting with AI to build and tweak them, or editing directly in Figma’s code composer,” the company wrote in it’s announcement. “By creating a code layer for a component, you can add dynamic behavior simply by prompting the built-in AI chat — powered by Figma Make.”

Code layers can be turned into reusable components and Figma allows users to import packages of code from npm to unlock richer interactions, it adds.

Canva Offers More AI Integration

Speaking of design tools that are building out support for developers, last week Canva launched a Canva MCP Server that will connect users’ Canva content and design capabilities to AI tools.

The Canva MCP Server allows any AI assistant to tap directly into a user’s full Canva workspace — including design history, creative tools and templates — to generate designs, iterate or draft design copy, resize assets; all within a conversational flow, the company stated.

With the Canva MCP Server, AI assistants and AI agents can:

• Generate any design type, from social posts to presentations, incorporating context from the AI chat.
• Autofill charts with labeled, formatted data from AI-generated insights;
• Resize and export branded templates, from Presentations to Canva Docs, with on-brand, contextual copy; and
• Import PDFs or files directly from a link.

MCP integrations with Claude, ChatGPT and Salesforce will be available soon, the company added.

Canva also launched a deep research connector for ChatGPT. It connects Canva users’ designs directly to ChatGPT, “enabling specific, thoughtful, and context-rich responses grounded in your past work,” the company said.

Usage of the Canva GPT, which generates new designs that can be edited in Canva, has surged 375% YoY, making it one of ChatGPT’s top productivity apps, according to the company.

Canva already offers a Dev MCP Server.

The post Angular Releases New Profiling Track for Chrome DevTools appeared first on The New Stack.

Adobe has launched a mobile Photoshop app for iPhone and Android. Here's what it offers.

Plus: Iran-linked hackers threaten to release Trump campaign emails, Chinese hackers still in US telecoms networks, and an abusive deepfake website plans an expansion.

Apple has released a new AI model on Hugging Face that is designed to write code out of order, rather than the usual left-to-right, top top-to-bottom approach.

The post Apple’s New AI Coding Language Model Is Here first appeared on Redmond Pie.