WebKit Features for Safari 26.4

Contents

• CSS
• WebTransport
• Web API
• JavaScript
• HTML
• SVG
• Safari Compact tabs
• Web Authentication
• Web Inspector
• Media Captions
• WebRTC
• Additional resolved issues
• Feedback

March has a way of bringing a lot of new things to WebKit — and this year is no exception. With 44 features, 191 fixes and one deprecation, Safari 26.4 is a release packed with web technology.

What’s most exciting? CSS Grid Lanes brings masonry-style layouts to the web platform — a long-awaited solution for building rich visual galleries and much more. WebTransport provides a modern alternative to WebSocket, opening the door to low-latency experiences like multiplayer games, live collaboration tools, and improved video conferencing. And Keyboard Lock API gives web apps better control over keyboard shortcuts.

Beyond the headliners, the heart of this release is focused on what web developers ask for most. We hear you loud and clear. Results from 2025 developer surveys made it clear you want time to catch up with new features, not be swamped with more. You want existing features to work consistently across every browser. You asked for browser engineers working on WebKit to help you by squashing bugs and closing gaps in spec coverage. That’s what this release aims to do.

Most of the features listed in the Safari 26.4 release notes are not entirely new. Many update features where the behavior didn’t quite match the latest web standard. Others make specific combinations of existing features work better together. Here’s one example — we shipped support for the CSS min() and max() functions in 2018, almost two years before any other browser. And we shipped the HTML sizes attribute for responsive images even longer ago, back in 2014. But until now, you couldn’t use min(), max(), or clamp() inside of the sizes attribute in WebKit. In Safari 26.4, you can.

And then there are the bug fixes — hundreds of them across the platform. WebKit engineers went deep to improve specific areas like SVG, Tables, MathML, and CSS Zoom. And we’re continuing our multi-year rewrite of the layout engine. Blocks-in-inline layout is complete in Safari 26.4, work on Flexbox continues, and we’ve now begun rewriting CSS Grid.

As we continue this work, we greatly value your input. If something has been bothering you, it’s worth testing in Safari 26.4 to see if it’s been fixed. If the bug is still there, please file it at bugs.webkit.org. Or if it’s already filed, add additional comments to the existing issue describing your experience and why fixing it matters for you. When multiple websites signal that something needs fixing, that helps. The more concrete you can be — a brief story about why this hurts your users, a link to a real website affected, a snippet of code or reduced test case — the better equipped we are to prioritize and fix what matters most. We are paying attention, even if our response shows up as a shipped fix rather than a reply in the issue.

We care deeply about the experience people have when using Safari. And we care about the experience people have when using any of the millions of iOS, iPadOS, macOS, visionOS, and watchOS apps that are built using WebKit and JavaScriptCore. When our customers open a news app, a shopping app, a travel app, a banking app — there’s a good chance the interface they’re interacting with is powered by the same HTML, CSS, and JavaScript you write every day when making web apps and websites that live at a URL. Every rendering fix, every improved feature, every performance gain we ship benefits everything touched by the web platform.

We are passionate about making experiences our customers love, no matter how they use their device. Web designers and developers are central to those experiences. You are our partners. We truly hope this release makes a real difference in your success.

CSS

Grid Lanes

Safari 26.4 adds support for Grid Lanes. It’s a new layout system that extends CSS Grid with powerful capabilities for creating flexible, flowing layouts. You might be familiar with the patterns it can create. Often called “masonry” or “waterfall” layouts, they were made popular like sites like Pinterest and attainable with Javascript libraries like masonry.js. Now this capability is available in CSS with display: grid-lanes.

And it can do much more than just the classic layout. At its root, Grid Lanes provides a way to pack content of different aspect ratios into either columns or rows. And does so in a way where users can tab through all the visible content, and where new content can be lazy-loaded at the end.

Grid Lanes builds on the foundation of CSS Grid, giving it powerful track sizing and explicit placement capabilities.

.container {
  display: grid-lanes;
  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
}

Safari 26.4 supports the recently-finalized core syntax for Grid Lanes (see Introducing CSS Grid Lanes), including support for flow-tolerance, which gives you control over how aggressively each item tries to “change lanes” to be closest to the start. This affects how much the placement of consecutive items shifts back and forth across the page — a particularly important consideration for accessibility. Try tuning the value, and see how it affects item placement and keyboard navigation across items.

Grid Lanes opens up new possibilities for layouts that have been difficult to achieve with existing CSS. In addition to the Pinterest-style masonry layouts, you can use it to create dynamic arrangements of content in either columns or rows. Check out our Grid Lanes demos for more ideas. Learn about browser support & progressive enhancement strategies in When will CSS Grid Lanes arrive? How long until we can use it?

We also added support for Grid Lanes to Web Inspector.

The Grid Inspector now supports CSS Grid Lanes with order number overlays that show the placement sequence of grid items. You can toggle order number visibility in the settings and visualize gaps between items arranged by Grid Lanes. Auto-completion for grid-lanes and inline-grid-lanes values in the display property makes it easier to experiment with these new layout options. Learn more in New Safari developer tools provide insight into CSS Grid Lanes.

Name-Only Container Queries

Safari 26.4 adds support for name-only @container queries, allowing you to target named containers without specifying any size conditions. Previously, container queries required both a container name and a condition — like @container sidebar (min-width: 300px). Now you can query just the container name:

@container sidebar {
  .card {
    padding: 1rem;
  }
}

This is useful when you want to apply styles based on which container an element is inside, regardless of that container’s size. It’s particularly handy for component variants or when you’re using container queries more for scoping styles than for responsive behavior. You still define the container name the same way:

.sidebar {
  container-name: sidebar;
  container-type: inline-size;
}

Now you can target elements inside that container without worrying about size breakpoints, giving you more flexibility in how you structure your component styles.

Custom Cursors on ::marker

Safari 26.4 adds support for the cursor property on the ::marker pseudo-element, letting you customize pointer behavior for list markers.

li::marker {
  cursor: pointer;
}

This is one step toward making ::marker more flexible.

Math Typography

Safari 26.4 adds several improvements for mathematical typography, making it easier to display and style mathematical notation on the web.

The math-depth property gives you control over the sizing of nested mathematical expressions. In complex formulas with fractions, superscripts, and subscripts, math-depth automatically scales nested elements appropriately, ensuring readability while maintaining proper mathematical hierarchy.

Safari 26.4 also adds support for font-size: math, which applies proper scaling logic for mathematical content. This works together with math-depth to ensure formulas render at the right size relative to surrounding text.

For layout performance, you can now use CSS size containment with MathML elements via contain-intrinsic-inline-size and contain-intrinsic-block-size. This helps the browser optimize rendering of complex mathematical expressions, particularly when they’re off-screen or being dynamically loaded.

Finally, math-style and math-shift now animate as discrete values, allowing you to create transitions between different mathematical presentation styles.

These additions make MathML more powerful and performant, particularly for educational content, scientific publications, and any site that needs to display mathematical notation.

Along with these new features, a number of MathML bugs were fixed:

• Fixed default MathML rule thickness to use the font’s underlineThickness metric with a zero fallback. (164693673)
• Fixed mpadded elements in RTL (dir="rtl") to respect lspace. (164740784)
• Fixed an issue where empty <msqrt> radical operators in MathML were not painted correctly. (164776629)
• Fixed MathML <mpadded>, <mfrac>, <munderover>, <mover> and <mspace> elements not updating layout when attributes like width, height, depth, lspace, and voffset etc. changed. (164797996)
• Fixed MathML boolean attributes so they are now compared ASCII case-insensitively. (164819048)
• Fixed incorrect positioning of mpadded content in right-to-left mode. (166045517)
• Fixed an issue where <msqrt> or <mroot> elements did not update their radical operators when children were dynamically added or removed. (166556627)
• Fixed <mpadded> so that percentage values for width, height, and depth attributes are treated as absent and use content dimensions as defaults, matching the MathML Core specification. (167350169)

Zoom

Safari 26.4 includes a significant set of CSS Zoom fixes. The zoom property in CSS scales an element and its contents. While transform: scale() does something similar, zoom is handy because it affects layout, causing surrounding content to respond to the change in size.

CSS zoom is separate from browser zoom, (the kind triggered by ⌘+ and ⌘−), but the two can compound. An element with zoom: 2 on a page that’s been zoomed in to 150% gets scaled by both factors. Getting everything to calculate correctly in that situation is genuinely tricky, and a lot of the fixes in this release are about getting that right. Properties like width, height, margin, and positional values now correctly apply zoom at used-value time. CSS calc() expressions correctly account for the zoom factor. And getBoundingClientRect() and getClientRects() in JavaScript now return properly scaled values.

Here’s the full list:

• Fixed width, height, min-width, min-height, max-width and max-height to apply CSS zoom at used-value time. (161848512)
• Fixed CSS zoom to scale <iframe> element contents. (162314059)
• Fixed getBoundingClientRect and getClientRects to return scaled lengths according to CSS zoom instead of unscaled values, aligning with the CSS Viewport specification. (162325730)
• Fixed top, left, right, and bottom to apply CSS zoom at used-value time (162663056)
• Fixed margin to apply CSS zoom at used-value time. (162907254)
• Fixed evaluation of calc() expressions to correctly apply the used zoom factor to length values, ensuring properties like line-height and box dimensions scale properly. (163141549)
• Fixed an issue where calc(em) values for unzoomed properties were incorrectly adjusted. (163267333)
• Fixed an issue where calc() incorrectly treated margins as present. (163605539)
• Fixed devicePixelRatio so that page zoom now affects the main frame consistently with iframes, keeping their values synchronized. (163857955)
• Fixed line-height to correctly scale font-relative units when text zoom is applied. (165073337)
• Fixed performance and correctness issues with inheritance in the modern CSS Zoom implementation. (167715972)
• Fixed an issue where <video> poster images were incorrectly double-scaled when zoom was applied by using the cached intrinsic poster size without reapplying zoom. (150976146)

Threaded Scroll-driven Animations

Safari 26.4 adds support for threaded Scroll-driven Animations. Now, the animations driven by scroll position run on the compositor thread, separate from the main thread. You don’t need do anything to get this benefit. When you use animation-timeline: scroll() or animation-timeline: view(), you automatically get the same kind of performance benefit that CSS transitions and keyframe animations have long enjoyed. Your scroll-driven animations will stay smooth even when the main thread is busy.

It also includes the following update:

• Fixed incorrect overlap calculations for transform animations including translate, scale, and rotate properties. (88383253)

Positioning

Safari 26.4 includes many refinements for Anchor Positioning. It updates absolutely positioned boxes in scrollable containing blocks to allow alignment overflow in scrollable directions, in accordance with a recent CSS spec change. And it folds several more fixes to positioning:

• Fixed an infinite style resolution loop when a position-try box was inside a display: none subtree. (161570947)
• Fixed position-area normal alignment to align toward the non-auto inset when only one inset is auto, in accordance with recent CSS spec changes. (163317238)
• Fixed an issue where fixed-positioned boxes using position-area were incorrectly included in the root scrollable containing block, ensuring they position correctly while still allowing overflow when appropriate. (163955483)
• Fixed an issue where padding-inline-end was not included in the scrollable overflow for block containers. (170503510)
• Fixed an issue where position-area for elements in scrollable containers only used the initial scrollport bounds instead of the entire scrollable area. (170503694)
• Fixed an issue where absolutely-positioned elements inside inline containers did not correctly account for the margin of a preceding block when determining their static position. (170934098)
• Fixed incorrect width calculation for positioned elements using box-sizing: border-box with an aspect-ratio, ensuring borders and padding are not double-counted. (121500004)
• Fixed getComputedStyle("top") to correctly resolve percentage values for absolutely positioned elements inside inline containers. (161390162)
• Fixed an issue where CSS @starting-style entry animations were only applied on the first transition, especially when interacting with anchor positioning or position fallbacks. (163928932)

Layout Engine Improvements

For several years, WebKit engineers have been working to rebuild each layout algorithm on a more modern foundation. Rather than waiting until a rewrite is complete before shipping its benefits, we’ve developed a mechanism so the new algorithm handles what it can as early as possible. Each algorithm starts with simpler use cases, then expands coverage over time as it becomes more capable — until it handles every situation.

Inline layout was completed in Safari 17.4 two years ago. Now, Safari 26.4 completes blocks-in-inline layout — fixing bugs and improving performance when block-level elements appear inside inline elements. Our work on the new Flexbox algorithm continues as well, covering increasingly complex cases over time.

Work on a new Grid layout engine is also now underway. When you use CSS Grid in a simple fashion, the new implementation in Safari 26.4 may be handling your layout. As the work progresses, support for more complex Grid layouts will follow.

Specific changes in Safari 26.4 include:

• Fixed incorrect min and max width calculations for block-level boxes inside inline content. (166157696)
• Fixed an issue where getClientRects returned an incomplete list of rectangles for inline boxes containing block elements. (167209147)
• Fixed baseline alignment for grid items by adding correct first baseline and last baseline row axis handling and properly accounting for baseline offsets. (155967278)

Table Layout

Table layout dates back to the early days of CSS, when the specification left a lot of behavior undefined. Browsers are still working through the consequences.

• Fixed an issue where max-width was not correctly applied to tables with fixed widths. (96554687)
• Fixed table layout so that fixed horizontal margins on <caption> elements now contribute to the table’s minimum preferred logical width, preventing captions from causing narrower than expected tables. (120990942)
• Fixed table column width distribution when a colspan spans mixed percentage and auto-width columns to properly respect percentage constraints. (165561401)
• Fixed baseline handling for table cells when cell has no inflow children. (160774504)
• Fixed element.clientWidth and element.clientHeight to correctly include padding for content-box tables. (165515755)
• Fixed table height calculation to correctly account for captions with orthogonal writing-mode. (167220730)

Additional changes to CSS

Safari 26.4 removes the deprecated FontFaceSet constructor from the CSS Font Loading API, aligning with a CSSWG resolution that deemed it unnecessary. The constructor was rarely used and its removal shouldn’t affect the web.

And this release includes even more improvements to CSS:

• Fixed an issue where display: list-item was incorrectly supported on fieldset. (95638460)
• Fixed incorrect sizing and fragment URL handling for SVG images used in -webkit-cross-fade(). (106633417)
• Fixed text-combine-upright to properly ignore letter-spacing when composing text horizontally, aligning with the CSS Writing Modes specification. (116562622)
• Fixed an issue where background-blend-mode was not applied correctly when combined with background-clip: text. (120901898)
• Fixed the UA style sheet to use :focus-visible instead of :focus for outline properties. (123155364)
• Fixed HighlightRegistry to remove its non-standard constructor and updated tests to use CSS.highlights while ensuring Map.prototype is properly restored after tampering. (125529396)
• Fixed handling of @property registration so that the initial-value descriptor can be optional. (131288198)
• Fixed scrolling behavior so that scrollRectToVisible() can bring fixed anchor-positioned boxes outside the viewport into view, improving keyboard navigation. (162378346)
• Fixed an issue where @font-face and FontFace.family failed when the font family name contained spaces, ensuring the family name is now treated as a plain string instead of being parsed. (162637501)
• Fixed incorrect underline positioning for text-decoration when inline box sides are trimmed. (163858721)
• Fixed -webkit-line-clamp so that it no longer propagates into inline-block children. (164488778)
• Fixed an issue where nested identical CSS filter effects were not rendered. (165163823)
• Fixed: Refactored the handling of block-level boxes inside inline boxes. (165523565)
• Fixed an issue where text-decoration: underline appeared higher than expected when text-box-trim was applied to the root inline box. (165614136)
• Fixed ::first-line pseudo-element to always use inline display to match the CSS Display specification. (166068698)
• Fixed an issue where shape-outside did not update correctly after web fonts loaded. (166336491)
• Fixed incorrect text selection ranges for truncated right-to-left content. (166944754)
• Fixed counter- properties serialization order. (167518994)
• Fixed outline-width and outline-offset to follow updated computed style resolution rules. (167618367)
• Fixed the computed style resolution for border-width properties. (167689519)
• Fixed the computed style resolution for the column-rule-width property. (167725940)
• Fixed border-width, outline-width, and column-rule-width so they now pixel snap correctly during CSS animations and transitions. (167763497)
• Fixed the disclosure triangle in <details> elements to use the larger system-ui font variant, preventing it from rendering as an emoji and ensuring consistent display across writing directions. (168364553)
• Fixed CSS rules within @scope not being applied to <input> and <textarea> elements. (169751338)
• Fixed an issue where empty CSS rules sharing a selector with non-empty rules could prevent dynamic style updates from applying correctly. (170348749)
• Fixed an issue where CSS transitions were incorrectly triggered when border-width computed values did not change, causing unexpected layout shifts. (170657059)
• Fixed an issue where multi-column layout rendered columns at incorrect positions for some fonts. (171016194)

WebTransport

Safari 26.4 adds support for WebTransport, a modern API for low-latency, bidirectional communication between clients and servers.

If you’ve been building real-time applications — like multiplayer games, live collaboration tools, or video conferencing — you’ve likely run into the limitations of existing technologies. WebSockets work well for many use cases, but they’re built on TCP, which means head-of-line blocking can cause delays when packets are lost. HTTP/3 and QUIC solve this problem, but don’t directly offer the same bidirectional streaming capabilities you might need.

WebTransport gives you the best of both worlds. It runs over HTTP/3 and QUIC, providing multiple streams that won’t block each other. You can send data reliably (like WebSockets) or unreliably (when you’d rather drop old data than wait for it), and you can mix both approaches in the same connection. This makes it particularly useful for applications where low latency matters most — think live audio, real-time sensor data, or fast-paced gaming. When the underlying network environment doesn’t support QUIC, WebTransport can run over HTTP/2 and TCP as a fallback with the same API.

The API is built around streams, similar to the Streams API you might already be using elsewhere. You can open bidirectional streams, send datagrams, and handle backpressure naturally. Here’s a basic example:

const url = 'https://example.com:443/webtransport';
const transport = new WebTransport(url);

await transport.ready;

// Send data via a unidirectional stream
const stream = await transport.createUnidirectionalStream();
const writer = stream.getWriter();
await writer.write(new Uint8Array([1, 2, 3]));
await writer.close();

WebTransport opens up new possibilities for what you can build on the web, bringing performance characteristics that previously required native applications or complex workarounds.

A related fix also landed:

• Fixed ReadableStream and WritableStream to correctly pass abort and cancel reasons and improved WebTransport stream handling. (165474756)

Also fixed in Networking:

• Fixed a regression where fetch() would throw a TypeError when using targetAddressSpace: 'loopback' for localhost requests. (166574523)

Web API

Keyboard Lock API

Safari 26.4 adds support for the Fullscreen Keyboard Lock API, which allows web applications to capture keyboard input that would normally be handled by the browser.

If you’ve ever built a game, a remote desktop client, or a creative tool, you’ve probably encountered this frustration: certain keyboard shortcuts are off-limits. Press the Escape key and you are thrown out of fullscreen mode. There’s been no way to prevent this — until now.

The Keyboard Lock API lets you request access to specific keys when your application needs it. A game can now use the Escape key for its own menu system. To exit fullscreen mode then the user would need to hold down the escape key for 1.5 seconds. A remote desktop client can pass through all keyboard shortcuts to the remote machine.

element.requestFullscreen({ keyboardLock: "browser" });

The browser automatically releases the lock when the user leaves fullscreen or switches tabs. And of course, this only works in secure contexts — sites served over HTTPS.

ReadableByteStream

Safari 26.4 adds support for ReadableByteStream, completing the implementation of byte-oriented streams in the Streams API.

Until now, ReadableStream has primarily worked with chunks of any type — objects, strings, or arbitrary data. ReadableByteStream is specifically designed for efficiently handling binary data, like files, network responses, or media streams.

The key advantage is memory efficiency. With byte streams, you can use BYOB (Bring Your Own Buffer) readers, which let you provide your own ArrayBuffer for the stream to fill. This means you can reuse buffers and avoid unnecessary allocations.

const reader = stream.getReader({ mode: 'byob' });
const buffer = new ArrayBuffer(1024);
const { value, done } = await reader.read(new Uint8Array(buffer));

Safari 26.4 also adds support for using byte streams as fetch request and response bodies, and for reading Blob.stream() with a BYOB reader. If you’re working with video, audio, large files, or any scenario where you’re moving significant amounts of binary data around, byte streams give you the tools to do it efficiently.

A related encoding fix also landed:

• Fixed incorrect handling of invalid UTF-8 sequences in the TextDecoder streaming decoder to properly manage partial sequence buffers. (166583808)

ReadableStream Async Iteration

Safari 26.4 adds support for ReadableStream.getIterator() and the [@@asyncIterator] method, making it much easier to work with streams using modern JavaScript syntax. Previously, reading from a stream required manually calling getReader() and repeatedly calling read() in a loop. Now you can use for await...of to iterate over stream chunks directly:

const response = await fetch('/data');
const stream = response.body;

for await (const chunk of stream) {
  // Process each chunk as it arrives
  console.log(chunk);
}

This is much cleaner than the previous approach and fits naturally with how you’re already using async iteration elsewhere in JavaScript. It’s particularly nice when you’re processing streaming data — like server-sent events, large file uploads, or any scenario where data arrives over time.

Improvements to Scoped Custom Element Registries

In September, Safari 26.0 was the first browser to ship support for the standardized version of Scoped Custom Element Registries. Before then, custom elements were always registered globally on a single registry shared across the entire document. This created problems when building component libraries or working with multiple frameworks. If two different parts of an application tried to register the same element name, one would fail.

Scoped registries solve this by letting you create separate registries for different parts of the same document:

const starRegistry = new CustomElementRegistry();
starRegistry.define('my-button', MyCustomButton);
document.createElement('my-button', { customElementRegistry: starRegistry });

const bananaRegistry = new CustomElementRegistry();
bananaRegistry.define('my-button', MyFancyButton);
document.createElement('my-button', { customElementRegistry: bananaRegistry });

Safari 26.4 now extends Scoped Custom Element Registries by:

• Upgrading elements in CustomElementRegistry.prototype.initialize
• Supporting the customelementregistry content attribute and handling of nullcustomElementRegistry values in document.createElement, document.createElementNS, and element.attachShadow
• Fixing shadowrootcustomelementregistry attribute serialization to correctly compare ShadowRoot and document registries. (165476421)

Auxiliary Mouse Button Support

Safari 26.4 adds support for auxiliary mouse button values in MouseEvent.button, so you can now detect additional mouse buttons beyond the standard left, middle, and right clicks. If you’re building applications that take advantage of gaming mice or other input devices with extra buttons, you can now respond to those inputs.

element.addEventListener('mousedown', (e) => {
  if (e.button === 3) { /* back button */ }
  if (e.button === 4) { /* forward button */ }
});

The button property will correctly report values for buttons 3, 4, and beyond, matching the behavior in other browsers.

Resource Timing

Safari 26.4 adds two new attributes from the Resource Timing Level 3 specification: finalResponseHeadersStart and firstInterimResponseStart. These give you more precise timing measurements for HTTP responses — particularly useful if you’re using 103 Early Hints.

firstInterimResponseStart captures when the first interim response (like a 103 Early Hints response) was received, and finalResponseHeadersStart captures when the final response headers arrived. Together they let you measure exactly how much time your 103 Early Hints are saving.

const [entry] = performance.getEntriesByType('resource')
  .filter(e => e.name.includes('example.com'));

console.log(entry.firstInterimResponseStart);  // when 103 arrived
console.log(entry.finalResponseHeadersStart);  // when final headers arrived

If you’re not yet using 103 Early Hints, these attributes give you a reason to explore it — you can now actually measure the impact.

MediaDeviceInfo in Secure Contexts Only

Safari 26.4 now exposes the MediaDeviceInfo interface only in secure contexts (HTTPS), aligning with the web specification. If you’re working with navigator.mediaDevices.enumerateDevices() to detect cameras and microphones, make sure your site is served over HTTPS.

Along the same lines:

• Fixed DeviceMotionEvent and DeviceOrientationEvent interfaces so that they only show up in secure contexts just like the corresponding events and made ondevicemotion and ondeviceorientation enumerable, aligning with the specification. (44804273)

Resolved issues

Safari 26.4 also includes a number of other Web API fixes:

• Fixed an issue where IntersectionObserver computed the root rectangle incorrectly when overflow clipping was present. (117143395)
• Fixed Trusted Types to correctly send CSP violation reports when a default policy returns an invalid javascript: URL or throws an exception. (160960418)
• Fixed Element.requestFullscreen on iOS to correctly reflect hardware keyboard attachment state during fullscreen sessions and exit automatically when the keyboard is detached. (161429040)
• Fixed event ordering and committed promise timing for intercepted Navigation API traverse navigations. (161445256)
• Fixed the processing order of Trusted Types for DOM attribute setting. (162143148)
• Fixed NavigateEvent to correctly fire an AbortSignal when a navigation is aborted. (163957784)
• Fixed NavigateEvent.sourceElement to correctly reference elements from different browsing contexts. (163962362)
• Fixed the Navigation API to prevent scripts from flooding the system with navigation requests. (164510890)
• Fixed an issue where scroll-margin from IntersectionObserver incorrectly applied to scrollers inside cross-origin iframes. (164994009)
• Fixed DigitalCredential behavior to make user mediation implicitly required. (165597827)
• Fixed an issue where the Big5 TextDecoder failed to recover and emit ASCII characters after encountering an invalid leading byte. (166672674)
• Fixed MouseEvent.offsetX and MouseEvent.offsetY so they are now calculated relative to the padding edge of the target element. (168015965)
• Fixed an issue where pointer events would fail to dispatch after a parent view’s custom gesture recognizer blocked touchesEnded: or touchesCancelled:. (169109808)
• Fixed an issue where JavaScript-to-native object serialization could fail entirely when any individual key-value pair could not be serialized, causing broken workflows in some apps. (171547386)

JavaScript

Safari 26.4 adds support for iterator sequencing. It lets you chain multiple iterators together into a single sequence using Iterator.concat().

const odds = [1, 3, 5].values();
const evens = [2, 4, 6].values();

for (const n of Iterator.concat(odds, evens)) {
console.log(n); // 1, 3, 5, 2, 4, 6
}

This is a clean alternative to flattening arrays or writing manual chaining logic just to iterate over several collections in sequence.

Resolved issues

Several JavaScript bugs were also fixed:

• Fixed Date constructor overflow handling so that invalid day values now return NaN. (155776209)
• Fixed Intl.DateTimeFormat to throw a RangeError for legacy non-IANA timezones, aligning behavior with TC39 standards. (156857252)
• Fixed Intl.Locale.prototype.getWeekInfo() to remove the minimalDays property for compliance with the specification. (165083619)
• Fixed Intl.NumberFormat to properly apply minimumFractionDigits and maximumFractionDigits to ensure currency and compact notations behave correctly. (165875014)
• Fixed %TypedArray%.prototype.includes to correctly check that the index is less than the array length, aligning its behavior with ECMA-262. (167183441)
• Fixed async functions without any await to inline their bodies for performance and corrected async stack traces with a single function entry for exceptions thrown from or through async functions. (167254635)

HTML

Safari 26.4 adds support for using the min(), max(), and clamp() math functions inside the sizes attribute of <img> elements.

The sizes attribute tells the browser how wide an image will be displayed at different viewport sizes, helping it choose the right image from your srcset. Until now, you were limited to media queries and length values. Now you can use CSS math functions for more precise control:

<img 
  srcset="small.jpg 400w, medium.jpg 800w, large.jpg 1200w"
  sizes="min(100vw, 1200px)"
  src="medium.jpg"
  alt="...">

This is particularly useful for responsive images that need to respect both viewport width and maximum content width. You can use clamp() to set minimum, ideal, and maximum sizes:

sizes="clamp(300px, 50vw, 800px)"

This gives you the same flexible sizing control in sizes that you already have in CSS, making responsive images easier to manage.

Resolved issues

• Fixed an issue where nested about:blank frames were incorrectly treated as self-referencing, preventing them from loading. (148373033)
• Fixed HTMLImageElement.currentSrc to return an empty string for <img src=""> instead of resolving to the document base URL. (167229274)
• Fixed image uploading to not transcode images when accept="image/*" is specified. (166124206)
• Fixed an issue where input fields did not display user input while typing. (163613957)
• Fixed an issue where input[type="search"] fields with appearance: none incorrectly reserved space for the datalist dropdown button. (166754216)
• Fixed an incorrect fallback for the menu style for empty lists, improving readability and correctness. (167662316)

SVG

Safari 26.4 adds support for the lighter operator in SVGFECompositeElement, aligning with the Compositing and Blending specification. This gives you an additional blending mode when compositing SVG filter effects, useful for creating additive lighting and glow effects in your SVG graphics. This example shows it in action. With support, there’s a soft glow around each circle. Without it, the glow is just not there.

Resolved issues

Safari 26.4 also includes a large number of SVG bug fixes:

• Fixed an issue where stroke-dasharray incorrectly propagated to SVG markers when explicitly marked as ‘0’. (46607685)
• Fixed an issue where foreignObject elements in SVG incorrectly allowed margin collapsing. (97208795)
• Fixed SVG intrinsic sizing and preferredAspectRatio() to correctly transpose dimensions for vertical writing modes. (103262534)
• Fixed animation of the stop-color attribute on <stop> elements. (109823555)
• Fixed an issue where dynamically changing marker-start, marker-mid, or marker-end attributes on SVG elements did not trigger re-rendering. (130678384)
• Fixed tiling gaps in CSS reference filters using <feDisplacementMap>. (135448018)
• Fixed SVGLength parsing to correctly return the initial value when encountering parser errors or invalid values. (136102554)
• Fixed an issue where SVGImage did not respect system dark mode changes. (140661763)
• Fixed breaking SVG resource referencing when removing a resource which shares its id with other resources. (147015037)
• Fixed behavior to avoid incorrect pruning of SVG mask subtrees based on visibility. (157729389)
• Fixed an issue where SVG animateTransform animations on hidden elements were triggering full-page rendering updates each frame. (159647563)
• Fixed SVGLength.prototype.valueAsString to throw a SyntaxError when assigned an empty string. (165429393)
• Fixed SVGLength percentage resolution for elements inside non-instanced <symbol> elements. (165431008)
• Fixed an issue where lengths with leading or trailing whitespace failed to be parsed. (165501190)
• Fixed an issue where SVGLength.value did not update for font-relative units (e.g., ch, em) after changes to writing-mode. (166190252)
• Fixed missing gradient fills when using paint-order stroke fill. (166997630)
• Fixed embedded <svg> elements in <img> without an explicit viewBox to synthesize preserveAspectRatio='none' so the SVG stretches to fill the container. (167121931)
• Fixed the <stop> element offset attribute in SVG to reject invalid values with trailing characters and correctly fall back to 0. (167356988)
• Fixed the transform order for clipPath elements so that the bounding box is scaled correctly before applying the local transform. (167417135)
• Fixed <clipPath> to clip to its <use> child element based on the visibility of the <use> target element. (167491519)
• Fixed incorrect rendering when combining markerUnits=strokeWidth with vector-effect=non-scaling-stroke. (167493417)
• Fixed displaying an SVG filter referencing an element with a huge stroke. (167516452)
• Fixed hit testing for overlapping <text> and <tspan> elements in SVG. (167691166)
• Fixed rendering of dimensionless SVG images. (168176556)

Safari Compact tabs

The Compact tabs option on macOS and iPadOS makes a return in Safari 26.4. If you preferred the more space-efficient tab design from earlier versions of Safari, you can now enable it again in Safari settings, under Tabs > Tab layout.

Web Authentication

Safari 26.4 adds two important WebAuthn improvements for advanced authentication scenarios.

The PRF (Pseudo-Random Function) extension enables credential-bound cryptographic secrets during both credential creation and authentication flows with security keys. This maps to the CTAP hmac-secret extension and allows you to derive cryptographic keys from WebAuthn credentials — useful for applications that need to encrypt user data with keys tied to their authentication credentials, such as password managers or encrypted storage systems.

Safari 26.4 also adds support for CTAP PIN/UV Auth Protocol 2, which uses HKDF-SHA-256 for key derivation. This enables proper support for newer FIPS-compliant authenticators, which is important for enterprise and government applications with strict security requirements.

Resolved issues

• Fixed an issue where the excludeCredentials list was not sent over CTAP when its size was 1. (164546088)

Web Inspector

In addition to the new Grid Lanes tooling described above, Safari 26.4 includes numerous Web Inspector enhancements to help you debug and build websites more effectively.

Layer Visualization

The Layers tab now shows actual composited layer snapshots instead of outline representations, giving you a more accurate picture of how your page is being rendered and composited.

Developer Experience

A new context menu option lets you copy pretty-printed HTML from DOM nodes in the Elements tab — much easier to read than minified markup. In the settings tab, you can now toggle the visibility of User Agent stylesheet rules, reducing clutter when you’re focused on your own styles.

The Timelines Heap view displays the dominator object when viewing the shortest GC path, making it easier to track down memory leaks. And Web Inspector now fetches CSS property keyword completions based on actual feature support, so auto-complete suggestions reflect what’s actually available.

Worker Debugging

You can now capture console.screenshot images within a Worker, supporting ImageData, ImageBitmap, OffscreenCanvas, and various canvas rendering contexts. Canvas recordings can also be started and stopped from the console within a Worker using console.record() and console.recordEnd().

Additional Improvements

Auto-completion now includes sideways-lr and sideways-rl values for the writing-mode property, making it easier to work with vertical text layouts.

Resolved issues

Safari 26.4 also includes a number of Web Inspector bug fixes:

• Fixed incorrect breakpoint and search result positions in the Web Inspector after pretty-printing inline scripts containing multi-line template literals. (29417859)
• Fixed the Styles sidebar filter in Web Inspector to be case-insensitive. (36086981)
• Fixed an issue where a large number of search results in the Search tab would freeze Web Inspector. (49234522)
• Fixed an issue where the Console tab search bar in Web Inspector would disappear when the window was too narrow. (50922509)
• Fixed an issue where CSS properties added to new rules were not applied and were marked as invalid. (103548968)
• Fixed context menu items to rename Copy HTTP Request and Copy HTTP Response to Copy HTTP Request Headers and Copy HTTP Response Headers for clarity. (117708766)
• Fixed incorrect grid track sizing display in the Web Inspector when using CSS custom properties. (141709306)
• Fixed an issue in the Console where the count of identical consecutive messages could be wrong. (162612099)
• Fixed an issue where breakpoints and search results in Web Inspector could point to the wrong location after a previously formatted source file was reopened in an unformatted state. (165059693)
• Fixed an issue where the Sources navigation sidebar could be empty when reloading the page. (166141968)
• Fixed timestamp formatting in the Web Inspector to remove unnecessary trailing .0 values for readability. (166500013)
• Fixed item order labels in the Web Inspector grid and flex overlays to remove the # symbol, changing from Item #N to Item N. (166767949)
• Fixed an issue where the text filter in the Sources tab did not apply to the Local Overrides and Console Snippets sections. (169804196)
• Fixed a performance issue in the Web Inspector search panel by limiting initial results to 100 per resource and adding UI controls to load more or all results, reducing unnecessary UI work for large queries. (169804865)
• Fixed an issue where the search bar settings icon disappeared when the search field was focused. (169997100)

Media Captions

Safari 26.4 adds improved caption controls on macOS, including a pop-up menu that lets users select and manage caption style profiles and configure subtitle display settings.

These enhancements give users more control over how captions appear — adjusting text size, color, background, and other styling options to match their preferences. If you’re providing video content with captions, users will have a better experience customizing how those captions are displayed.

Resolved issues

Quite a few media bugs were also fixed:

• Fixed dispatching of enter and exit events on TextTrackCue and VTTCue objects with no associated track, aligning with other browsers. (160195643)
• Fixed an issue where changing an HTMLMediaElement volume from 0 to 0 did not activate the audio session or update the sleep disabler. (161691743)
• Fixed an issue where videos would freeze on the first frame when transitioning from encrypted to clear content by ensuring the decoded buffer maintains at least 100ms of frames even when the next frame is far in the future. (162234566)
• Fixed an issue where the mute button disappeared in macOS inline videos with adjustable sizes. (162897286)
• Fixed playback of application/ogg blob media. (163119790)
• Fixed an issue where Video Viewer UI elements overlapped or exited unexpectedly. (164051864)
• Fixed an issue where empty <track> elements prevented media from advancing its readyState and blocked play() calls. (164125914)
• Fixed an issue where HTMLMediaElement did not correctly detect new audio or video tracks causing Safari to pause video when leaving a tab. (164514685)
• Fixed a crash in AudioData.copyTo() when copying the last channel of 3-channel audio. (164730320)
• Fixed an issue where the ended event for Media Source Extensions might never fire by ensuring buffered ranges update correctly and playback gaps are observed even when the video does not start at time zero. (165430052)
• Fixed an issue where caption previews were not shown in the default media controls. (165931046)
• Fixed the caption menu’s On option to correctly enable the highest-scoring text track and mark the appropriate language as checked in the subtitle menu. (166158394)
• Fixed parseSequenceHeaderOBU to return an AV1CodecConfigurationRecord, fully decode the Sequence Header OBU, and capture the complete color profile. (166439682)
• Fixed an issue where the macOS inline media controls timeline scrubber overlapped the right container buttons. (167634241)
• Fixed an issue where WebCodecs VideoDecoder could output H264 frames in the wrong order. (168046597)
• Fixed an issue where the mute button and volume slider overlapped in the video player controls when using a right-to-left language. (170174446)

WebRTC

Safari 26.4 adds two significant WebRTC enhancements for audio and networking.

On macOS, getUserMedia now supports capturing audio from multiple microphones simultaneously while intelligently managing echo cancellation. The system dynamically migrates existing audio captures to appropriate processing units, making it easier to build applications like podcasting tools, multi-participant recording, or music collaboration apps that need multiple audio inputs.

On iOS, Safari 26.4 adds network slicing support for WebRTC. Network slicing allows different types of traffic to be prioritized differently on cellular networks, which can improve quality and reliability for real-time communication applications in challenging network conditions.

Resolved issues

Several WebRTC bugs were also fixed:

• Fixed RTCDataChannelInit to support [EnforceRange] on the maxPacketLifeTime and maxRetransmits fields to align with the WebRTC specification. (133630397)
• Fixed an issue on macOS where calling getUserMedia with echo cancellation disabled could unintentionally affect existing audio tracks. (151143554)
• Fixed MediaStreamTrackProcessor to respect track.enabled = false. (165199900)
• Fixed an issue where RTCDataChannel close events did not fire when RTCPeerConnection was closed. (165617848)
• Fixed RTCConfiguration.iceServers to be a non-optional sequence with an empty array as the default, improving spec compliance and ensuring RTCPeerConnection behaves correctly when iceServers is undefined. (167607478)

Additional resolved issues

There are even more issues that have been fixed in Safari 26.4.

Accessibility

• Fixed an issue where Voice Control commands could cause Safari to hang. (168364189)
• Fixed an issue where a button’s label would not update when a descendant’s aria-hidden attribute changed. (169012516)
• Fixed elements with aria-controls or aria-expanded and the hidden attribute to no longer appear in VoiceOver’s Form Control menu. (169499630)
• Fixed an issue where VoiceOver would announce with extra verbosity when moving onto the first item of a list on the webpage. (169982730)
• Fixed an issue where controls with aria-labelledby pointing to visually-hidden elements could not obtain proper bounding box geometry through accessibility APIs. (170639492)

Browser

• Fixed Safari gesture support to prevent pages that should not be able to scroll, such as with explicit overflow: hidden, from unexpectedly scrolling. (163660111)

Canvas

• Fixed ImageBitmap created from SVG image sources to correctly honor the flipY orientation. (83959718)

Clipboard

• Fixed an issue where using the “Copy Image” context menu in Safari would also copy the image URL, causing some sites to paste the URL instead of the image. (76598990)

Editing

• Fixed incorrect text selection when dragging across pseudo elements. (142905243)
• Fixed an issue on iOS 26 where the edit menu would not appear when tapping inside an already-focused text field that had a looping content animation. (164290305)
• Fixed an issue where focusing a hidden editable element would incorrectly display the text cursor and selection at full opacity. (165489471)
• Fixed a regression where dragging to select text would stop scrolling when the cursor left the window. (169983104)

Events

• Fixed an issue where mouseleave and mouseout events were not dispatched when a window moved out from under a stationary cursor. (161493924)

Privacy

• Fixed an issue where cross-browser Private Click Measurement recorded attribution entries even when “Allow privacy-preserving measurement of ad effectiveness” was disabled. (170669444)

Rendering

• Fixed over-aggressive clipping of child layers in multicolumn layouts to prevent visual overflow issues with position: relative elements and transform:scale() text. (126413036)
• Fixed unreadable Scroll-to-Text-Fragment highlights on dark pages. (126539910)
• Fixed an issue where auto-positioned absolutely positioned descendants were not always marked for layout when their parent’s border box moved. (131806062)
• Fixed an issue where positioned, transformed, or opacity-altered <img> elements with HDR JPEG gainmaps would incorrectly render in SDR. (156858374)
• Fixed an issue on iPadOS where closing the sidebar or resizing the window could cause the page to remain zoomed in by recalculating the target scale to automatically match the new minimum scale. (157676989)
• Fixed an issue where fixed positioned elements were not rendered correctly in right-to-left pages using the vertical-rl writing mode. (161712734)
• Fixed a performance issue in layouts with long pre blocks and word-break: break-all by including whitespace in overflow width calculations. (162695099)
• Fixed an issue where overconstrained sticky elements were not properly adjusting their insets when the sticky box rectangle was larger than the viewport. (163654023)
• Fixed an issue where applying word-spacing to ::first-line could cause other lines to disappear. (163779992)
• Fixed inconsistent text layout when using list-style-type by ensuring outside list markers do not affect intrinsic width calculations. (164650313)
• Fixed an issue where color fonts could affect the color of other DOM elements. (166631312)
• Fixed <col> elements with span > 1 not applying their width to all spanned columns during table layout, aligning behavior with other browsers. (167225435)
• Fixed table layout min-width distribution for spanning cells with mixed percent, fixed, and auto columns. (167684748)
• Fixed: Improved drop-shadow and blur effects rendering performance. (169472992)

Spatial Web

• Fixed auto-dimming for playback sessions in visionOS. (163824973)

Storage

• Fixed an issue where IndexedDB databases might have mismatched metadata version and database name encoding format. (163219457)

WKWebView

• Fixed an issue where WKWebView apps with a toolbar would fail to display a top scroll edge effect when relying on automatic content inset adjustments. (161370795)

Web Extensions

• Fixed an issue where window.open() calls from web extensions would incorrectly open “about:blank” instead of the intended URL by ensuring each extension URL loads in a fresh tab configuration. (143901129)

WebAssembly

• Fixed Error.isError(WebAssembly.Exception) to correctly return false based on current WebAssembly spec semantics. (167110254)

WebGPU

• Fixed incorrect handling of some PNG pixel formats in WebGPU. (158797747)

Feedback

We love hearing from you. To share your thoughts, find us online: Jen Simmons on Bluesky / Mastodon, Saron Yitbarek on BlueSky / Mastodon, and Jon Davis on Bluesky / Mastodon. You can follow WebKit on LinkedIn.

If you run into any issues, we welcome your bug report. Filing issues really does make a difference.

You can also find this information in the Safari release notes.