CSS Anchors, WebGPU, and the Quiet Death of the Button

Three things landed in my feed this week that, taken separately, look like niche frontend curiosities. Taken together, they sketch something more structural: the web’s rendering and interaction model is being rebuilt from the spec level up — and most marketing and product teams haven’t noticed yet.

CSS Anchor Positioning Is Doing Layout Work You’re Paying JavaScript For

Bramus Van Damme’s reconstruction of Brave’s animated New Tab Page grid is worth reading slowly. The question at CSS Day — how does Brave animate a grid reorganisation as the viewport resizes, with interruptible transitions and no apparent View Transitions API? — is a good one. His answer: CSS Anchor Positioning combined with standard CSS Transitions.

The implication is sharper than it sounds. Animated layout responses to viewport change have historically required JavaScript: resize observers, state management, calculated positioning, requestAnimationFrame choreography. Every one of those is a payload cost, a hydration cost, and a potential jank vector. On Southeast Asian mobile networks — where median 4G throughput in markets like Indonesia and the Philippines still lags behind headline numbers — JavaScript-heavy motion is a real conversion risk, not a theoretical one.

CSS Anchor Positioning lets an element declare its position relative to another element anywhere in the DOM tree, not just its parent. Combined with transitions, the browser handles interpolation natively. The failure mode to watch: browser support is still maturing. Check Interop 2026 progress before committing this to a campaign landing page — partial implementations in older WebKit builds can produce silent positioning bugs that only surface on specific device/OS combinations.

WebGPU Is No Longer a Proof-of-Concept

Ming Jyun Hung’s technical breakdown of Still — a generative garden built in WebGPU, drawing on Akira Kurosawa’s visual language and Japanese ink wash aesthetics — is the kind of work that makes you recalibrate what a browser is capable of.

What’s strategically relevant here isn’t the art direction (though it’s exceptional). It’s the architecture. WebGPU enables compute shaders running directly on GPU hardware, bypassing the CPU bottlenecks that made complex generative visuals impractical for production web contexts. Procedural systems — particle simulations, noise-based textures, real-time rendering pipelines — are now viable in-browser without plugins, native apps, or pre-rendered video.

For brands operating premium digital experiences in Southeast Asia — luxury retail, automotive, high-consideration fintech — this changes the creative brief. Experiences that previously required a Unity build or a native app wrapper can now live at a URL, shareable via LINE or WhatsApp, accessible without a download gate. The practical barrier right now is talent: WebGPU shader programming sits closer to graphics engineering than frontend development. Budget accordingly, and don’t ask your React developer to own this.

---

The Button Is Being Quietly Retired

Smashing Magazine’s Carrie Webster makes the case that the dominant interaction paradigm of the web — menus, forms, discrete clicks — is giving way to intent-driven interfaces where the UI recedes and the system infers what you want. The framing is UX-philosophical, but the operational question is concrete: if users increasingly interact with AI-mediated surfaces that surface content and actions proactively, what happens to the click-through rate as a primary signal?

This matters for tracking architectures. Conversion measurement built around button clicks and form submissions assumes a visible, discrete action. Intent-driven interfaces — think conversational commerce on LINE OA, or Grab’s in-app recommendations — generate signals that are harder to attribute and don’t map cleanly onto traditional event schemas. If your analytics setup still treats click events as the primary conversion signal, you’re already measuring a shrinking slice of meaningful user behaviour.

The practical step isn’t to abandon click tracking. It’s to start instrumenting intent signals in parallel: dwell time on surface areas, query patterns in search interfaces, scroll depth on AI-curated feeds. Build the data history now, before you need it for optimisation.

Interop 2026 Is the Dependency You’re Not Tracking

Stefan Judis’s Web Weekly flagged something that rarely makes it into product planning conversations: the current state of Interop 2026. Interop is the cross-browser initiative where Apple, Google, Mozilla, and others align on implementing the same specs consistently. The CSS features covered this week — including progress() and further anchor positioning work — are on the Interop 2026 list.

Why does this matter operationally? Because teams building on emerging CSS capabilities often test in Chrome, ship to production, and discover breakage in Safari on iOS — which, in markets like Thailand and Malaysia where iPhone penetration among premium consumers is significant, is a costly oversight. Interop progress scores are public and updated regularly. Treat them as a dependency matrix, not a curiosity. Before committing a CSS feature to a high-traffic surface, check where it sits on the Interop dashboard and what the Safari Technology Preview behaviour looks like.

Key Takeaways

• CSS Anchor Positioning can replace JavaScript-driven layout animation — audit your motion stack for unnecessary JS before your next major build, especially for mobile-first Southeast Asian audiences.
• WebGPU generative rendering is production-viable for premium brand experiences, but the skill requirement is closer to graphics engineering than frontend; scope talent costs honestly.
• Intent-driven interfaces are eroding the click as a reliable conversion signal — start instrumenting dwell, query, and scroll-depth data now to build the attribution baseline you’ll need later.

---

The frontend stack is being renegotiated at the spec level — CSS is absorbing layout work, the GPU is absorbing rendering work, and AI interfaces are absorbing interaction work. The question worth sitting with: if the browser keeps getting more capable and the UI keeps getting more invisible, what exactly are we A/B testing in two years?

At grzzly, we work with digital and marketing teams across Southeast Asia who are trying to make sense of exactly these shifts — figuring out which emerging capabilities are ready to ship, which tracking assumptions need rebuilding, and where the real payload costs are hiding. If this week’s signals are prompting a conversation on your team, Let’s talk