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.
SvelteKit 3 is near: goto absorbs shallow routing and errors are required
The Svelte team published its August SvelteKit 3 preview. Shallow routing moves into goto, invalidateAll becomes refreshAll, and two new $app modules make service workers richer.
Vue 3.6 RC: Vapor Mode is done — the virtual DOM is now optional
Vue 3.6 entered release-candidate with Vapor Mode feature-complete. Components now compile directly to real DOM operations — no virtual DOM, smaller bundles, Solid.js-tier speed.
MCP 2026-07-28: the protocol goes stateless and ditches sessions
The biggest revision to the Model Context Protocol since launch dropped yesterday as a release candidate. The handshake is gone, the session header is gone, and round-robin load balancers finally just work.
TypeScript 7 ports the compiler to Go — builds are now 10x faster
Microsoft shipped TypeScript 7.0: a Go-native compiler that makes builds 8 to 12 times faster. Great news for most projects — but Vue, Svelte and Astro users will need to wait a few months.
WebMCP: your website as a tool for AI agents
WebMCP is an emerging W3C standard that lets websites expose their own functionality directly to browser AI agents. Instead of guessing and clicking, the agent just calls the tools — if you wire them up.
Node.js patches three LTS versions at once — HIGH severity lands Monday
The Node.js team has announced HIGH severity security patches for 26.x, 24.x and 22.x all at once, scheduled for July 27. Do you know which version you're running?
CSS Anchor Positioning is widely available — Floating UI can retire
With Safari 26 completing cross-browser support, CSS Anchor Positioning is now Baseline 2026 and available everywhere. The reason to install Floating UI or Popper.js for a tooltip no longer exists.
Nuxt 4.5 streams the page while Vue is still rendering
Nuxt 4.5 ships experimental SSR streaming: the HTML shell lands in the browser while Vue is still rendering the rest. It also moves Nuxt onto Vite 8 with Rolldown internals.
JavaScript's Date is dead — long live Temporal
After nine years of development, the Temporal API is now part of ECMAScript 2026 and broadly available in Chrome and Firefox. JavaScript's most notorious object finally has a worthy successor.
Next.js makes security a scheduled event, not an incident
Vercel launches a monthly security release program for Next.js, driven by the explosive growth of AI-assisted vulnerability research. What it means if you run Next.js in production.
CSS Anchor Positioning replaces Floating UI — no JavaScript needed
CSS Anchor Positioning is Baseline 2026, supported across Chrome, Firefox, and Safari. Placing tooltips and dropdowns correctly is now browser work, not library work.
Chrome 150: text-fit and gradient borders are now native CSS
Chrome 150 ships two long-awaited CSS features that retire JavaScript hacks and border-image workarounds: text that auto-fits its container and true gradient borders in a single declaration.
HTML-in-Canvas API: DOM and GPU finally share the same frame
Chrome launches an origin trial that breaks twenty years of canvas isolation: render live DOM elements into WebGL and WebGPU without sacrificing accessibility.
Node.js 26.5 ships text file imports as modules
Node.js 26.5.0 lets you import text files directly as ES modules — a pattern frontend bundlers have supported for years but one that always needed workarounds in Node itself. Plus richer Blob streaming and stream forking.
Copilot agents now drive the browser — the agentic loop is closed
GitHub Copilot agents in VS Code can open, click through and screenshot live web apps since July 1 — on by default. What it means when the feedback loop closes itself.
SvelteKit 2.62 drops the separate config file
SvelteKit 2.62 lets you drop svelte.config.js and put everything inside vite.config.js. A small tidy-up with a bigger signal — it previews how SvelteKit 3 will require it.
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.