Notes from the studio
Field notes on building native mobile apps — how we make calls, what we've learned, and where the platforms are heading.
Chrome ships native HTML streaming to the browser
For the first time in twenty years the browser gets a native primitive for server-driven HTML updates — no JavaScript library required. What Declarative Partial Updates are and why they matter.
TypeScript is now the default, not an upgrade
Starting in plain JavaScript is now the choice that raises eyebrows. How typed-by-default quietly became the 2026 baseline — and why it pays off for apps you keep iterating on.
Remix 3 bets on the web platform — and drops React
Remix 3's creators are stepping away from React to bet on the web platform itself. Why 'lean on the browser' is the direction frontend is heading — and what we make of it.
Why we build fully native, not cross-platform
Cross-platform frameworks promise one codebase for both stores. Here's why we still write Swift and Kotlin by hand — and when that choice pays off.
Bun is becoming the default JavaScript toolkit
One binary for runtime, package manager, bundler and test runner. How Bun went from curiosity to default — and what it means for your build.
React Server Components have grown up
What started as a controversial idea is now the default way to build data-driven React apps. What that changes in practice.
Signals: fine-grained reactivity is winning
Frameworks are converging on signals to update exactly what changes. Why that makes screens faster and code more predictable.
The View Transitions API brings native-like transitions to the web
Smooth screen transitions were long the domain of native apps. The View Transitions API brings them to the browser — with surprisingly little code.
WebAssembly has crossed into production
Heavy compute in the browser was long slow or impossible. WebAssembly has moved from experimental to production-viable for compute-heavy web work.
Web Components are mature enough for design systems
Build one component library and reuse it in React, Vue, Svelte and Angular. Web Components finally make framework-agnostic design systems practical.
Node.js is closing the gap with the browser
fetch, Web Streams and more are now first-class in Node. Why the same APIs on server and client make your code simpler.
INP is the new measure of responsiveness
Interaction to Next Paint replaced the old responsiveness metric. Why it measures how fast your app truly reacts — and how to score well.
Tailwind v4 goes CSS-first
Less JavaScript config, more real CSS. Why Tailwind’s new direction makes builds faster and stays closer to the platform.
Rust bundlers are finally making builds fast
The toolchain is moving to Rust. Why faster bundling is more than comfort — and what it does to how a team works.
Modern CSS now does what used to need JavaScript
:has(), container queries and more are everywhere now. Why a lot of UI logic no longer needs JavaScript.
Edge rendering is becoming the norm
Running your app close to the user, worldwide. Why the edge cuts load times — and where the pitfalls are.
AI assistants are part of the workflow — but they don't change the craft
AI speeds up writing code. Why judgement, architecture and care for the user still make the difference.
Passkeys are making the password obsolete
Signing in without a password, safer and faster. Why passkeys are becoming the standard — and what it means for your users.
Islands architecture: JavaScript only where it earns its place
Static HTML by default, with interactivity as isolated islands. Why that makes content sites blazing fast.
End-to-end typed APIs: fewer mistakes between front and back
Types that flow from server to client catch a whole class of bugs before runtime. Why that makes teams faster and calmer.
The runtime wars are good news for everyone
Node, Deno and Bun are pushing each other. Why that competition produces better tooling — whichever you pick.
WebGPU brings serious graphics power to the browser
From 3D visualisations to machine learning in the tab. Why WebGPU opens up what used to be native-only.
Progressive Web Apps are back — and better
Installable, offline and app-like, without a store. Why PWAs are relevant again and when they replace native.
The hypermedia revival: less JavaScript, more HTML
A counter-movement to heavy SPAs: let the server send HTML and keep the client thin. Why it works surprisingly well for many apps.