Home Liquid Glass iOS: Is Stacking Causing UI Bugs?

Apps

Liquid Glass iOS: Is Stacking Causing UI Bugs?

Experiencing visual glitches in iOS 26 Liquid Glass UI? Learn why overlapping glass elements causes unwanted highlights and how to fix it.

byDev Solutions

February 23, 2026

iOS 26 Liquid Glass UI bug where tapping one translucent card causes nearby cards to glow unexpectedly, visualizing a rendering glitch

🧊 The new Liquid Glass iOS 26 design introduces rendering bugs when layering with GlassMaterial.
⚠️ Tapping one translucent SwiftUI element unintentionally highlights or flickers nearby elements.
🛠️ Developers have confirmed the issue stems from shared GPU render layers caused by SwiftUI optimizations.
🎯 Applying .compositingGroup() and avoiding overlaps are effective workarounds for isolating tap feedback.
🧪 The issue appears to be a regression in iOS 26, not found in iOS 15–25 versions.

Liquid Glass iOS: Is Stacking Causing UI Bugs?

The new Liquid Glass look in iOS 26 aims to be modern and soft. But there's a problem. Developers are finding a UI bug: when you tap one glass element, nearby or stacked ones might glow or briefly highlight wrong. If you’re using SwiftUI’s GlassMaterial for layered cards, panels, or blur-based interfaces, chances are this glitch is affecting your app. Let’s break down what’s going on, why it’s happening, and what you can do to fix it or work around it today.

Understanding iOS 26’s Liquid Glass UI

iOS 26 brings more see-through interfaces. People call this "Liquid Glass iOS." This is not just a new look. It shows a bigger change in how Apple wants apps to appear, to make them look lighter and have more layers.

At the heart of this shift is SwiftUI’s new GlassMaterial, part of Apple’s compositional material system. Before, designs used levels like .ultraThinMaterial, .regularMaterial, and .thickMaterial. But GlassMaterial gives a more active look. It changes with background colors and text size. It also has small color changes based on your wallpaper or theme.

This update allows developers to create UI elements with frosted glass-like blur, layered depth, and soft highlights. However, while it looks good, Liquid Glass makes things harder to draw. This is true when many see-through parts are in the same visual space or stacked.

The Bug: Nearby Glass Elements Flicker or Highlight on Tap

The new design looks nice. But a new issue comes up: when you tap a GlassMaterial view in SwiftUI, nearby views sometimes react in small, unexpected ways.

These symptoms include:

A brief glow or brightness pulse in nearby parts.
Ghost-like flickers on untapped views.
Quick highlights across other GlassMaterial views stacked nearby.

This is most clear when using ZStack or similar ways to put interactive cards, panels, or buttons on top of each other. Visually, it looks like the tap effect spreads into nearby parts. This happens even when only one view should be the only one to react.

From the user’s perspective, this can be disorienting. If you tap a settings card, its neighboring UI block might flash a little. This makes it seem like it was also tapped.

Why It's Happening: Apple’s Complex Compositing and Touch Pipeline

The root of this UI bug is how Apple's drawing process for see-through views is set up. Here's a simplified explanation of what's likely going on.

Whenever you use a translucent or material-based view in SwiftUI, you're asking the system to draw that element in relation to its background. For this, Apple uses GPU shaders to:

Capture the background behind the view.
Apply layered blur and colorization passes.
Combine the final texture with other UI elements using the GPU.

This process works well most of the time. But problems appear when many GlassMaterial views are stacked too close or handle touches in similar ways. Simply put, the GPU makes things faster by grouping similar material views. It puts them into a shared drawing group or shader pass.

But this way of making things faster is good and bad at the same time. It allows quick drawing. But it also means that when one view changes (like from a tap), it can affect visually connected views next to it that are drawn in the same GPU group. So, when one card is tapped, nearby parts might react too. This wrongly makes it seem like they are also selected or changed.

Diagnosing the Real Culprit: Touch, Overlap, or Shared Layers?

When you see these visual bugs, finding the real reason is important. Here are the main factors that should be evaluated:

Touch Spreading: SwiftUI lets touch events pass up through the view layers. If gesture recognizers are not set up right, many views might think they were tapped.
View Overlap: Stacking parts on top of each other with ZStack or other containers makes it more likely that drawing states are shared.
Shared GPU Layers: This is the likely reason. SwiftUI often groups views next to each other that use similar modifiers, like GlassMaterial. It puts them in the same GPU context to make things faster. When animations or state changes happen in these shared groups, other "innocent" views are redrawn by accident.

To distinguish between these, developers should monitor their view stack arrangements and run diagnostics using Xcode’s rendering tools. Instruments and SwiftUI previews can show unexpected redraws or highlights while the app is running.

Is This a Regression in iOS 26?

Yes. More and more, developers say that designs that worked perfectly in iOS 15 through 25 now show strange visual reactions in iOS 26.

This suggests either:

A change in SwiftUI’s internal handling of compositing layers.
A regression in the GPU batching mechanism for material views.
A bug that came in during the system update to support GlassMaterial.

Even experienced developers who have worked a lot with Material and UIVisualEffectView confirm this behavior is new. It is only in iOS 26, especially when quickly moving between interactive glass views.

Apple has not said anything about this issue. But many developer reports make it clear that this is an internal change or bug that affects drawing.

Widespread Reports from Devs Confirm the Issue

This is not just guessing. Discussions across forums show many real cases of this bug:

Developers using RoundedRectangle().fill(.ultraThinMaterial) report unintended shimmer effects on nearby cards.
Apps with stacked dashboard layouts get odd highlight flickers that do not match the taps.
The issue shows up on all devices, from real iPhones and iPads to simulators.

In many cases, even simplifying UI layouts to their most basic layered parts (two or more GlassMaterial views with padding) will show the issue often.

This strengthens the idea that it's a drawing issue from Apple's side, not a problem with how individual developers built their apps.

Why Overlapping Glass Views Trigger These Glitches

When two or more GlassMaterial views are stacked close, Apple’s drawing system sees them as part of a shared "visual context." This context combines background capture, blur processing, and animation behavior to make things faster.

Normally, that's good. It lowers the work and makes frames load faster. But it also means:

When one view animates, the system recalculates the entire context.
State changes like a tap highlight ripple through the context.
This causes small but clear redraws for untapped views that "shouldn't" be involved.

Think of it like a ripple effect on a shared water surface. Drop a stone (start an action) into one corner. The ripples travel across the entire pool, affecting areas far past your original drop point.

Impact on UX: Distracting and Misleading

These visual glitches are not just annoying. They can really hurt user experience (UX):

Tapping one UI element seems to affect others. This makes it less clear what was tapped.
Users may assume multiple items were selected or triggered.
Small visual errors, like extra blur or a light "glow," draw attention when they shouldn't.

For apps with important tasks, like banking apps, health trackers, or productivity tools, this side effect creates trust and reliability problems. Even brief inconsistencies can make an app seem unstable or unpolished.

Workarounds: How Developers Are Fixing This Today

Until Apple issues a fix, here are the most effective techniques developers are using to reduce or eliminate the visual ripple effect when working with GlassMaterial.

1. Use `.compositingGroup()`

Isolate rendering by placing each GlassMaterial view in its own compositing group:

RoundedRectangle(cornerRadius: 16)
    .fill(.ultraThinMaterial)
    .compositingGroup()

This makes the GPU treat each instance as a separate drawing layer. It stops visual errors from overlapping or being drawn together.

2. Collapse Tap Animation Feedback

Do not use built-in or default animations on touch. SwiftUI might apply small scale or glow effects on tap that accidentally affect nearby parts.

Where possible:

Disable implicit animations using .transaction
Use withAnimation(nil) during critical interactions

3. Increase Padding or Insets

Give glass elements more space. Even a small visual space (6-12 pts) between views can cause the GPU to separate groups and so stop ripple effects.

4. Wrap in Containers

You can put each interactive element inside a ZStack, Group, or VStack. This makes layouts checked separately and lowers shared visual context.

5. Delay Transitions

For animations that cause state changes, put a short delay between actions. This lets drawing groups settle before updating the next visual container.

Try UIKit’s Custom Visual Effects Instead

If you need more exactness and full control over see-through effects, use UIKit's UIVisualEffectView.

Unlike SwiftUI’s GlassMaterial, UIKit allows:

Custom blur styles (light, thin, dark, system-specific).
Close control over view layers using z-ordering and view setup.
Explicit management of interaction layering.

Example:

let blurEffect = UIBlurEffect(style: .systemThinMaterial)
let blurView = UIVisualEffectView(effect: blurEffect)
blurView.frame = CGRect(x: 0, y: 0, width: 200, height: 200)
blurView.isUserInteractionEnabled = false

You can put this inside SwiftUI with UIViewRepresentable. This gives your app strong hybrid UI features.

Should You Pause Use of GlassMaterial?

Maybe. If your app needs smooth and clear feedback when you tap things, you might want to think again about using GlassMaterial a lot. This is true at least until Apple fixes the problem in a future update (likely iOS 26.1 or later).

Other ways include:

Using flat color backgrounds with alpha for a glass-like gradient.
Applying blur views only to static panes or passive backgrounds.
Reserving GlassMaterial for elements that aren’t interactive.

Reporting the Bug to Apple the Right Way

To get a faster fix, developers should send in clear bug reports that others can repeat. Include:

A minimal SwiftUI code sample showing the issue.
A brief screen recording (GIF or MP4) capturing the flicker or highlight behavior.
Device details: iOS version, model, simulator vs. real device.
Use of keyword phrases: “Liquid Glass iOS,” “iOS 26 UI bug,” “glass element highlight effect.”

Submit via: Feedback Assistant

The higher the volume and quality of reports, the more likely Apple is to prioritize and test a fix.

Best Practices for Building with Liquid Glass Going Forward

Building stable and beautiful apps under Liquid Glass iOS means planning ahead. Follow these guidelines:

🧮 Use .compositingGroup() carefully on interactive see-through views.
📐 Reduce stacked or nested glass layouts when not essential.
📊 QA your designs on multiple devices and refresh rates (60Hz, 120Hz).
👩‍🏫 Tell your designers: not all blur is the same. Good looks should not be more important than how the UI works.
🔁 Check your views again after updates. Once Apple fixes this, simplify or remove old fixes if needed.

To keep up with changes like this and make better SwiftUI interfaces, bookmark Devsolus. And then check back for regular updates. We do more than just talk about the bug to give you clear, working fixes.