Engineering

HTML Is Getting Native Streaming — And It Changes Everything

A proposal to stream HTML directly from the server could eliminate the JavaScript fetch-and-render cycle for good.

June 3, 2026·3 min read

For the past decade, displaying a user profile on the web has required the same multi-step ritual: download the HTML, download the JavaScript, make a fetch call, wait for the backend response, then manipulate the DOM with innerHTML. It works. But it's slow, fragile, and frankly unnecessary — and a new HTML proposal is about to make it obsolete.

A bigger idea

one step further into the future

HTML getting better

1HTML is getting a proposal for native streaming — the browser updates the DOM directly from a server HTML fragment
2The current 5-step pattern (HTML → JS → fetch → JSON → innerHTML) collapses into a single server response
3Named template regions with start/end markers define where streamed HTML lands
4This is a proposal, not a shipped feature — no browser implements it yet
5If adopted, it could make JavaScript unnecessary for the most common web rendering pattern

CURRENT RENDERING STEPS

STEPS WITH HTML STREAMING

PROPOSAL

STATUS

The Problem With How We Render Dynamic Content Today

Here's what happens today when you load a profile page. First, your browser fetches the HTML shell — a mostly empty page with a <div id="profile">Loading...</div> placeholder sitting in the middle. Then JavaScript loads. Then that JavaScript runs a fetch() call to an API. Then the API responds with the user's data. Then JavaScript calls document.getElementById('profile').innerHTML = ... and finally paints the real content.

Every one of those steps is a round trip, a delay, or a dependency. The browser is doing five jobs when it should be doing one.

Why this pattern became standard

JavaScript-driven rendering exploded because HTML had no native way to update itself after initial load. Frameworks like React, Vue, and Angular filled that gap. The new HTML streaming proposal is effectively the browser saying: we'll handle this natively now.

What HTML Streaming Actually Looks Like

The proposal introduces a simple but powerful idea: HTML elements can declare a named template region with a start and end marker. Inside those markers, you define the default state — typically a loading skeleton. You also assign the region a template name, like profile.

When your page loads, the browser renders that default state immediately. No JavaScript needed. Then, when your backend API responds, it doesn't return JSON for JavaScript to process — it returns an HTML fragment directly. The browser identifies the named region and swaps the content in-place, right in the DOM.

No getElementById. No innerHTML. No JavaScript download. The DOM updates itself.

profile.html

<!-- Before: the JavaScript way -->
<div id="profile">Loading...</div>
<script>
  fetch('/api/profile')
    .then(res => res.json())
    .then(data => {
      document.getElementById('profile').innerHTML = `
        <h1>${data.name}</h1>
        <p>${data.bio}</p>
      `;
    });
</script>
 
<!-- After: native HTML streaming (proposed) -->
<template name="profile">
  <start>
    <div class="skeleton">Loading profile...</div>
  </start>
  <end>
    <!-- Server streams this HTML fragment directly -->
  </end>
</template>

The Old Way vs. The New Way

The thing worth underlining

How the current JS render pattern works

1
HTML shell loads
Browser receives a mostly empty page with placeholder divs showing "Loading..."
2
JavaScript bundle downloads
The framework or custom script file is fetched, parsed, and executed by the browser
3
fetch() call fires
JavaScript makes a network request to a backend API endpoint
4
API returns JSON
The server responds with raw data — the client is responsible for knowing how to render it
5
JS injects HTML
document.getElementById().innerHTML is set with the constructed markup. The user finally sees content.

✓ With native HTML streaming

The server streams an HTML fragment directly into the named template region. The browser handles the DOM update natively. Steps 2, 3, 4, and 5 above disappear entirely — no JavaScript required.

Why This Is Architecturally Significant

This isn't just a developer convenience — it's a fundamental shift in where rendering responsibility lives. Right now, JavaScript frameworks are powerful precisely because the browser couldn't handle dynamic content natively. Frameworks like React exist to solve a browser limitation.

If the browser can stream and apply HTML fragments natively, you no longer need a client-side framework for the most common rendering pattern on the web: load a page, fetch some data, show it. That covers a huge percentage of real-world web pages.

The implications ripple out: smaller JavaScript bundles, faster time-to-interactive, fewer network waterfalls, and simpler backend contracts — the server returns HTML, not JSON that a client has to know how to render.

Pros

Eliminates the JS fetch-and-render cycle for the most common web pattern
Faster time-to-interactive — no JS download blocking rendering
Simpler architecture — server owns the rendering contract
Works without JavaScript enabled in the browser
Reduces bundle size for data-fetching-heavy apps

Cons

Still a proposal — not yet implemented in any browser
Server must return HTML, reducing caching flexibility vs JSON APIs
Less granular control for complex client-side state management
Existing frameworks and toolchains would need to adapt

The Historical Arc That Got Us Here

2015-2020
SPAs dominate. Everything is fetched as JSON and rendered client-side via React, Vue, and Angular.
2021-2023
Next.js, Remix, and Astro popularize server-side rendering. Sending HTML over the wire is cool again.
2024-2025
Cloudflare and Vercel make edge-rendered HTML mainstream. React Server Components push rendering back to the server.
2026
A formal proposal to bake streaming HTML updates into the HTML spec itself — no JavaScript in the render loop.

Where This Proposal Stands Today

As of mid-2026, this feature is in the proposal stage — not yet implemented in Chrome, Firefox, Safari, or any other major browser. The proposal is being discussed in the WHATWG community, which governs the HTML Living Standard. Browser vendors have not yet committed to implementation timelines.

That said, the direction aligns with everything the ecosystem is already building toward: server-side rendering is mainstream, edge computing has made dynamic HTML generation cheap, and frameworks like Astro, Remix, and Next.js have popularized sending HTML over the wire instead of JSON. Native browser support would formalize and accelerate what's already happening.

💡

Tip: If you want to explore this pattern today without waiting for the spec, look at HTMX and Hotwire Turbo — both achieve similar results using a small JavaScript library. Native HTML streaming would eventually make the library unnecessary.

Frequently asked questions

No. Frameworks handle far more than rendering — routing, state management, animations, and complex interactions still require them. Native HTML streaming eliminates the need for frameworks only in simple data-fetching scenarios.

That's the point. The proposal is designed so the browser handles the DOM update natively when the server streams the HTML fragment — no client-side JavaScript required.

Unknown. The proposal is in early discussion as of mid-2026. Browser implementation could take one to several years from proposal to stable release across all major browsers.

Libraries like HTMX and Hotwire Turbo achieve similar results using JavaScript. Native HTML streaming would achieve the same outcome built into the browser itself — no library download, no dependency.

Key takeaways

Libraries like HTMX and Hotwire Turbo achieve similar results using JavaScript. Native HTML streaming would achieve the same outcome built into the browser itself — no library download, no dependency.
The current 5-step JS pattern could collapse into a single server response
Named template regions define where streamed HTML lands in the DOM
This is a proposal, not a shipped feature — no browser implements it yet
If adopted, JavaScript becomes optional for the most common web rendering pattern

How we built the editor

A look behind the scenes at the engineering choices.

How we built the editor

A look behind the scenes at the engineering choices.