What's New in Chrome 157: HTML Rendering on Canvas, the corner Property, and Streaming HTMLArticle · digest for November 5
Surrealist still life featuring a Canvas, live HTML blocks, and geometric shapes with squircle rounding in Chrome 157.
Article4 sections≈ 5 min

What's New in Chrome 157: HTML Rendering on Canvas, the corner Property, and Streaming HTML

Google Chrome 157's November stable release brings one of the largest sets of web-platform updates in recent years. The Chromium team focused on eliminating long-standing architectural bottlenecks: slow string parsing into the DOM, corner-styling limits, and the historical divide between procedural 2D canvas graphics and declarative HTML markup.

Let's dive into the official Chrome 157 release notes and break down practical features you can put to work right away.

HTML-in-canvas: Live Layout and Text Directly on a 2D Canvas

Every developer who has built games, diagram editors, or interactive maps on top of <canvas> knows the pain: a canvas is a "dumb" raster pixel matrix.

To render a polished card with wrapped text, a button, and a drop shadow, developers had to:

  • Manually compute coordinates for every character via ctx.fillText();
  • Implement their own complex line wrapping, alignment, and ellipsis truncation;
  • Or rely on workarounds like html2canvas, which converted a DOM fragment into SVG via foreignObject and blocked the browser's main thread for hundreds of milliseconds.

Chrome 157 debuts the long-awaited native HTML-in-canvas standard:

const canvas = document.getElementById('game-viewport');
const ctx = canvas.getContext('2d');

// Create a live DOM markup fragment
const cardElement = document.createElement('div');
cardElement.className = 'player-hud';
cardElement.innerHTML = '<h3>Player 1</h3><p>Rating: 2,450</p>';

// Native rendering of the styled block directly onto the canvas
ctx.drawElement(cardElement, 20, 20, 280, 120);

The browser draws the element through Blink's internal pipeline with native subpixel font anti-aliasing, gradients, shadows, and CSS styles. No more third-party libraries or manual word-wrapping math. Crucially, rendering is GPU-accelerated, so dynamically updating UI elements on canvas no longer tanks frame rates.

The corner Property and Superellipses: Modern Corner Geometry

For over fifteen years, rounding corners in CSS was limited to circles and ellipses via border-radius. Modern industrial UI design (Apple, Material You, Figma design systems) has long since moved to superellipses (squircles) and angled chamfered corners (bevels). Previously, achieving those meant generating heavy SVG clip-path paths or wrestling with complex masks.

Chrome 157 ships the official CSS Corner Shorthand specification:

/* Basic superellipse rounding: <radius> / <shape> */
.app-card {
  corner: 24px / squircle;
}

/* Granular control over individual card corners */
.dashboard-widget {
  corner-top-left: 20px / bevel;      /* Chamfered futuristic corner */
  corner-top-right: 28px / squircle;  /* Smooth superellipse */
  corner-bottom: 12px / round;        /* Classic circular rounding */
}

The property combines corner radius and geometric contour shape. For backward compatibility, the corners alias is preserved. Cards with iOS and Figma aesthetics can now be styled in a single clean line of CSS without cluttering the style tree with extra pseudo-elements and custom SVG paths.

Streaming Rendering: appendHTML and streamHTML

Working with dynamic HTML in JavaScript has relied on element.insertAdjacentHTML('beforeend', html) for years. It had two notable drawbacks: string position constants invited typos, and the method could not work with modern network streams at all.

Chrome 157 introduces two full-fledged, optimized replacements:

  1. element.appendHTML(htmlString): A direct high-performance replacement for appending to the end of an element. The method is optimized in V8: it avoids intermediate string allocations in RAM and validates markup directly in the parent node's context.
  2. element.streamHTML(readableStream): A real breakthrough for integrating with Server-Sent Events (SSE) and the streaming Fetch API:
// Streaming content rendering without waiting for full download
const response = await fetch('/api/feed-stream');
const feedContainer = document.getElementById('live-feed');

// Browser parses and appends chunks to the DOM as they arrive over the network
await feedContainer.streamHTML(response.body);

The browser no longer waits for a multi-megabyte response to arrive in full: elements render incrementally as network packets come in, drastically cutting First Contentful Paint latency. This fundamentally changes how news feeds, AI chat UIs, and analytical dashboards are architected in web apps.

Layout and Profiling Additions: From text-overflow to LoAF

The release also packs a handful of welcome quality-of-life improvements for everyday web development:

  • Custom strings in text-overflow: instead of the plain ellipsis …, you can now specify any arbitrary string:
    .feed-snippet {
      white-space: nowrap;
      overflow: hidden;
      text-overflow: " [read more]";
    }
    
  • Anchor positioning: position-visibility gains the anchor-visible value. A tooltip now hides automatically when its anchor element scrolls off-screen, ridding interfaces of floating orphaned overlays.
  • Granular Long Animation Frames (LoAF) metrics: the Long Animation Frames API now cleanly separates time spent on JavaScript execution from geometry recalculation (Style & Layout). In RUM monitoring systems, you can immediately see what slowed down a page—a heavy loop or an inefficient CSS selector.

As we saw in our breakdown of Chrome DevTools and new tools, the browser is evolving into a high-performance native platform, steadily retiring historical web workarounds and making applications faster.

Want a deep diveVotes help us choose what to break down in detail. This material has 0 votes.
Sources · 2