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 viaforeignObjectand 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:
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.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-visibilitygains theanchor-visiblevalue. 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.


