diff --git a/Example/Shared/ContentView.swift b/Example/Shared/ContentView.swift
index 3001dd532..517cbf54f 100644
--- a/Example/Shared/ContentView.swift
+++ b/Example/Shared/ContentView.swift
@@ -10,6 +10,6 @@ import SwiftUI
 
 struct ContentView: View {
     var body: some View {
-        TextExample()
+        AsyncRenderExample()
     }
 }
diff --git a/Example/Shared/Render/Async/AsyncRenderExample.swift b/Example/Shared/Render/Async/AsyncRenderExample.swift
new file mode 100644
index 000000000..ff6bb7b87
--- /dev/null
+++ b/Example/Shared/Render/Async/AsyncRenderExample.swift
@@ -0,0 +1,21 @@
+//
+//  GeometryEffectExample.swift
+//  Shared
+
+struct AsyncRenderExample: View {
+    @State private var items = [6]
+
+    var body: some View {
+        VStack(spacing: 10) {
+            ForEach(items, id: \.self) { item in
+                Color.blue.opacity(Double(item) / 6.0)
+                    .frame(height: 50)
+                    .transition(.slide)
+            }
+        }
+        .animation(.easeInOut(duration: 2), value: items)
+        .onAppear {
+            items.removeAll { $0 == 6 }
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUI/Integration/Hosting/UIKit/View/UIHostingView.swift b/Sources/OpenSwiftUI/Integration/Hosting/UIKit/View/UIHostingView.swift
index 823a95eab..90e49a971 100644
--- a/Sources/OpenSwiftUI/Integration/Hosting/UIKit/View/UIHostingView.swift
+++ b/Sources/OpenSwiftUI/Integration/Hosting/UIKit/View/UIHostingView.swift
@@ -12,7 +12,9 @@ import OpenAttributeGraphShims
 @_spi(ForOpenSwiftUIOnly)
 @_spi(Private)
 public import OpenSwiftUICore
+#if _OPENSWIFTUI_SWIFTUI_RENDER
 import OpenSwiftUISymbolDualTestsSupport
+#endif
 import COpenSwiftUI
 
 /// A UIView which hosts an OpenSwiftUI View hierarchy.
diff --git a/Sources/OpenSwiftUI/Render/DisplayList/AppKitDisplayList.swift b/Sources/OpenSwiftUI/Render/DisplayList/AppKitDisplayList.swift
index 0699156b7..4e8d16410 100644
--- a/Sources/OpenSwiftUI/Render/DisplayList/AppKitDisplayList.swift
+++ b/Sources/OpenSwiftUI/Render/DisplayList/AppKitDisplayList.swift
@@ -11,7 +11,9 @@
 @_spi(DisplayList_ViewSystem)
 import OpenSwiftUICore
 import AppKit
+#if _OPENSWIFTUI_SWIFTUI_RENDER
 import OpenSwiftUISymbolDualTestsSupport
+#endif
 import COpenSwiftUI
 import QuartzCore_Private
 import OpenRenderBoxShims
diff --git a/Sources/OpenSwiftUI/Render/DisplayList/UIKitDisplayList.swift b/Sources/OpenSwiftUI/Render/DisplayList/UIKitDisplayList.swift
index c022482c9..164aa721b 100644
--- a/Sources/OpenSwiftUI/Render/DisplayList/UIKitDisplayList.swift
+++ b/Sources/OpenSwiftUI/Render/DisplayList/UIKitDisplayList.swift
@@ -10,7 +10,9 @@
 import COpenSwiftUI
 @_spi(DisplayList_ViewSystem) import OpenSwiftUICore
 import UIKit
+#if _OPENSWIFTUI_SWIFTUI_RENDER
 import OpenSwiftUISymbolDualTestsSupport
+#endif
 import QuartzCore_Private
 import OpenRenderBoxShims
 import OpenSwiftUI_SPI
diff --git a/Sources/OpenSwiftUICore/Graphic/BackdropEffect.swift b/Sources/OpenSwiftUICore/Graphic/BackdropEffect.swift
index dad000af7..310db2f39 100644
--- a/Sources/OpenSwiftUICore/Graphic/BackdropEffect.swift
+++ b/Sources/OpenSwiftUICore/Graphic/BackdropEffect.swift
@@ -2,7 +2,7 @@
 //  BackdropEffect.swift
 //  OpenSwiftUICore
 //
-//  Audited for 6.0.87
+//  Audited for 6.5.4
 //  Status: WIP
 
 package struct BackdropEffect {
@@ -12,7 +12,12 @@ package struct BackdropEffect {
 
     package var filters: [GraphicsFilter]
 
-    package init(scale: Float = 1, color: Color.Resolved = .black, filters: [GraphicsFilter] = [], captureOnly: Bool = false) {
+    package init(
+        scale: Float = 1,
+        color: Color.Resolved = .black,
+        filters: [GraphicsFilter] = [],
+        captureOnly: Bool = false
+    ) {
         self.scale = scale
         self.color = color
         self.filters = filters
diff --git a/Sources/OpenSwiftUICore/Graphic/GraphicsContext.swift b/Sources/OpenSwiftUICore/Graphic/GraphicsContext.swift
index ae1bcf36a..fcf38327f 100644
--- a/Sources/OpenSwiftUICore/Graphic/GraphicsContext.swift
+++ b/Sources/OpenSwiftUICore/Graphic/GraphicsContext.swift
@@ -536,6 +536,10 @@ extension GraphicsContext {
         #endif
     }
 
+    package func renderMissingPlatformView(size: CGSize) {
+        _openSwiftUIUnimplementedWarning()
+    }
+
     // FIXME
     struct ORBLayerFlags: OptionSet {
         let rawValue: UInt32
diff --git a/Sources/OpenSwiftUICore/Graphic/GraphicsFilter.swift b/Sources/OpenSwiftUICore/Graphic/GraphicsFilter.swift
index 1e3a3dc6f..90c73fd8b 100644
--- a/Sources/OpenSwiftUICore/Graphic/GraphicsFilter.swift
+++ b/Sources/OpenSwiftUICore/Graphic/GraphicsFilter.swift
@@ -3,7 +3,8 @@
 //  OpenSwiftUICore
 //
 //  Audited for 6.0.87
-//  WIP
+//  Status: WIP
+//  ID: 07401C2C9845FAA2984B0D65D34F2B64 (SwiftUICore)
 
 package enum GraphicsFilter {
     case blur(BlurStyle)
@@ -125,4 +126,16 @@ package enum GraphicsBlendMode: Equatable {
             default: false
         }
     }
+    
+    @inline(__always)
+    var filter: Any? {
+        switch self {
+        case let .caFilter(filter):
+            return filter
+        case let .blendMode(mode):
+            // TODO: _ORBBlendModeGetCompositingFilter & ORBBlendMode
+            _openSwiftUIUnimplementedWarning()
+            return nil
+        }
+    }
 }
diff --git a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayList.swift b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayList.swift
index a01bfff14..2f9dda039 100644
--- a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayList.swift
+++ b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayList.swift
@@ -178,10 +178,28 @@ extension DisplayList {
             indirect case view(any _DisplayList_ViewFactory)
             case placeholder(id: Identity)
         }
+        
         package init(_ value: Content.Value, seed: Seed) {
             self.value = value
             self.seed = seed
         }
+        
+        @inline(__always)
+        var features: DisplayList.Features {
+            switch value {
+            case let .platformView(factory):
+                return factory.features
+            case let .text(view, _):
+                let resolved = view.text
+                return resolved.isDynamic && resolved.archiveOptions.isArchived ? .dynamicContent : []
+            case let .flattened(list, _, _):
+                return list.features.union(.flattened)
+            case .view, .placeholder:
+                return .views
+            default:
+                return []
+            }
+        }
     }
 
     package typealias ViewFactory = _DisplayList_ViewFactory
@@ -209,13 +227,63 @@ extension DisplayList {
         indirect case interpolatorRoot(InterpolatorGroup, contentOrigin: CGPoint, contentOffset: CGSize)
         case interpolatorLayer(InterpolatorGroup, serial: UInt32)
         indirect case interpolatorAnimation(InterpolatorAnimation)
-    }
         
+        @inline(__always)
+        var features: DisplayList.Features {
+            switch self {
+            case let .properties(properties):
+                return properties.features
+            case let .platformGroup(factory):
+                return factory.features
+            case .mask(let list, _):
+                return list.features
+            case .animation:
+                return .animations
+            case .view:
+                return .views
+            case let .platform(platformEffect):
+                return platformEffect.features
+            case .state:
+                return .stateEffects
+            case .interpolatorRoot:
+                return .interpolatorRoots
+            case let .interpolatorLayer(group, _):
+                return group.features.union([.interpolatorLayers, .required])
+            default:
+                return []
+            }
+        }
+    }
+
     package enum Transform {
         case affine(CGAffineTransform)
         case projection(ProjectionTransform)
         case rotation(_RotationEffect.Data)
         case rotation3D(_Rotation3DEffect.Data)
+
+        @inline(__always)
+        package var affineTransform: CGAffineTransform? {
+            switch self {
+            case let .affine(transform):
+                return transform
+            case let .rotation(data):
+                return data.transform
+            case .projection, .rotation3D:
+                return nil
+            }
+        }
+
+        @inline(__always)
+        package var projectionTransform: ProjectionTransform? {
+            switch self {
+            case let .projection(transform):
+                return transform
+            case let .rotation3D(data):
+                return data.transform
+            case .affine, .rotation:
+                return nil
+            }
+        }
     }
     
     package typealias AnyEffectAnimation = _DisplayList_AnyEffectAnimation
@@ -260,6 +328,9 @@ extension DisplayList {
         package static func < (lhs: Version, rhs: Version) -> Bool {
             lhs.value < rhs.value
         }
+        
+        @inline(__always)
+        var seed: Seed { .init(self) }
     }
 
     package struct Seed: Hashable {
@@ -299,9 +370,11 @@ extension DisplayList {
     
     package struct Properties: OptionSet {
         package let rawValue: UInt8
+
         package init(rawValue: UInt8) {
             self.rawValue = rawValue
         }
+
         package static let foregroundLayer = Properties(rawValue: 1 << 0)
         package static let ignoresEvents = Properties(rawValue: 1 << 1)
         package static let privacySensitive = Properties(rawValue: 1 << 2)
@@ -310,6 +383,11 @@ extension DisplayList {
         package static let tertiaryForegroundLayer = Properties(rawValue: 1 << 5)
         package static let quaternaryForegroundLayer = Properties(rawValue: 1 << 6)
         package static let screencaptureProhibited = Properties(rawValue: 1 << 7)
+        
+        @inline(__always)
+        var features: DisplayList.Features {
+            contains(.privacySensitive) ? .required : []
+        }
     }
     
     package struct Key: PreferenceKey {
@@ -399,16 +477,37 @@ extension DisplayList {
         }
         
         package mutating func skip(list: DisplayList) {
-            _openSwiftUIUnimplementedFailure()
+            for item in list.items {
+                skip(item: item)
+            }
         }
         
         package mutating func skip(item: Item) {
-            _openSwiftUIUnimplementedFailure()
+            guard item.identity == .none else { return }
+            let saved = enter(identity: item.identity)
+            defer { leave(index: saved) }
+            switch item.value {
+            case let .content(content):
+                if case let .flattened(list, _, _) = content.value {
+                    skip(list: list)
+                }
+            case let .effect(effect, list):
+                skip(list: list)
+                skip(effect: effect)
+            default:
+                break
+            }
         }
         
         package mutating func skip(effect: Effect) {
-            
-            _openSwiftUIUnimplementedFailure()
+            switch effect {
+            case let .archive(archiveIDs):
+                updateArchive(entering: archiveIDs != nil)
+            case let .mask(list, _):
+                skip(list: list)
+            default:
+                break
+            }
         }
         
         package func assertItem(_ item: Item) {}
@@ -482,26 +581,35 @@ extension DisplayList.Item {
         // TODO eg. .opacity(1.0) -> .identity
     }
 
-    // TBA
     package func matchesTopLevelStructure(of other: DisplayList.Item) -> Bool {
-        guard identity == other.identity else { return false }
         switch (value, other.value) {
         case (.empty, .empty):
             return true
-        case (.content, .content):
-            return true
-        case (.effect, .effect):
-            return true
-        case (.states, .states):
-            return true
+        case let (.content(lhs), .content(rhs)):
+            return compareEnumTags(lhs.value, rhs.value)
+        case let (.effect(lhs, _), .effect(rhs, _)):
+            return compareEnumTags(lhs, rhs)
+        case let (.states(lhs), .states(rhs)):
+            guard lhs.count == rhs.count else { return false }
+            return zip(lhs, rhs).allSatisfy { $0.0 == $1.0 }
         default:
             return false
         }
     }
-
+    
     package var features: DisplayList.Features {
-        // TODO
-        []
+        switch value {
+        case .empty:
+            return []
+        case let .content(content):
+            return content.features
+        case let .effect(effect, list):
+            return effect.features.union(list.features)
+        case let .states(states):
+            return states.reduce(into: [.states]) { features, state in
+                features.formUnion(state.1.features)
+            }
+        }
     }
 }
 
@@ -552,6 +660,10 @@ extension DisplayList {
             _openSwiftUIEmptyStub()
         }
 
+        var features: Features {
+            []
+        }
+
         func rewriteDisplayList(
             _ list: inout DisplayList,
             time: Attribute<Time>,
diff --git a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListAnimations.swift b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListAnimations.swift
index 295a63870..87ad53368 100644
--- a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListAnimations.swift
+++ b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListAnimations.swift
@@ -4,7 +4,7 @@
 //
 //  Audited for 6.5.4
 //  Status: Complete
-//  ID: B86250B2E056EB47628ECF46032DFA4C (SwiftUICore)
+//  ID: 25E61DBD3DDB4AD4C9A82B4C3137A7B6 (SwiftUICore)
 
 import Foundation
 
diff --git a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListAsyncLayer.swift b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListAsyncLayer.swift
new file mode 100644
index 000000000..8f89b0653
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListAsyncLayer.swift
@@ -0,0 +1,64 @@
+//
+//  DisplayListAsyncLayer.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+import Foundation
+import OpenQuartzCoreShims
+
+protocol _DisplayList_ViewUpdater_AsyncLayerProperty {
+    associatedtype Value
+
+    static var keyPath: String { get }
+    static var supportsPresentationModifier: Bool { get }
+    static func boxValue(_ value: Value) -> NSObject
+}
+
+extension _DisplayList_ViewUpdater_AsyncLayerProperty {
+    static var supportsPresentationModifier: Bool { true }
+}
+
+extension DisplayList.ViewUpdater {
+    struct AsyncLayer {
+        typealias Property = _DisplayList_ViewUpdater_AsyncLayerProperty
+
+        var layer: CALayer
+        let cache: UnsafeMutablePointer<DisplayList.ViewUpdater.ViewCache>
+        let kind: PlatformViewDefinition.ViewKind
+        let flags: DisplayList.ViewUpdater.Platform.ViewFlags
+        var nextUpdate: Time
+        var isInvalid: Bool
+
+        @inline(__always)
+        var isBoundsOriginEnabled: Bool {
+            flags.contains(.boundsOrigin)
+        }
+
+        @inline(__always)
+        var isAffineTransformEnabled: Bool {
+            flags.contains(.affineTransform)
+        }
+
+        @inline(__always)
+        var isProjectionGeometryEnabled: Bool {
+            flags.contains(.projectionGeometry)
+        }
+
+        @inline(__always)
+        var isClipRectEnabled: Bool {
+            flags.contains(.clipRect)
+        }
+
+        @inline(__always)
+        var isMaskLayerEnabled: Bool {
+            flags.contains(.maskLayer)
+        }
+
+        @inline(__always)
+        var isContentGeometryEnabled: Bool {
+            flags.contains(.contentGeometry)
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewCache.swift b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewCache.swift
index 178e80bd6..3785bec94 100644
--- a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewCache.swift
+++ b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewCache.swift
@@ -99,6 +99,20 @@ extension DisplayList.ViewUpdater {
             asyncModifierGroup = nil
         }
 
+        @inline(__always)
+        mutating func clearPendingAsyncValues() {
+            pendingAsyncValues = [:]
+            pendingAsyncUpdates = []
+        }
+
+        mutating func invalidateAll() {
+            map = map.mapValues { info in
+                var info = info
+                info.seeds.invalidate()
+                return info
+            }
+        }
+
         mutating func reclaim(time: Time) {
             removed.forEach { key in
                 guard let info = map[key], info.isRemoved else { return }
@@ -119,9 +133,7 @@ extension DisplayList.ViewUpdater {
                    let newInfo = map.removeValue(forKey: key) {
                     removeRecursively(newInfo as AnyObject)
                 }
-                #if canImport(Darwin)
-                CoreViewRemoveFromSuperview(system: platform.viewSystem, view: view)
-                #endif
+                platform.removeFromSuperview(view)
             }
         }
 
@@ -197,8 +209,7 @@ extension DisplayList.ViewUpdater {
                 update()
             }
             // Reset state
-            pendingAsyncValues = [:]
-            pendingAsyncUpdates = []
+            clearPendingAsyncValues()
             #else
             _openSwiftUIPlatformUnimplementedWarning()
             #endif
@@ -274,7 +285,7 @@ extension DisplayList.ViewUpdater {
                 info.cacheSeed = cacheSeed
                 // Update nextUpdate
                 let newSeed = DisplayList.Seed(version)
-                var isInserted = info.seeds.item != newSeed || state.pointee.globals.pointee.time >= info.nextUpdate
+                var changed = info.seeds.item != newSeed || state.pointee.globals.pointee.time >= info.nextUpdate
                 info.nextUpdate = .infinity
                 // Update parentID
                 let oldParentID = info.parentID
@@ -290,23 +301,21 @@ extension DisplayList.ViewUpdater {
                 }
                 if info.view !== oldView {
                     reverseMap.removeValue(forKey: unsafeBitCast(oldView, to: OpaquePointer.self))
-                    #if canImport(Darwin)
-                    CoreViewRemoveFromSuperview(system: platform.viewSystem, view: oldView)
-                    #endif
+                    platform.removeFromSuperview(oldView)
                     reverseMap[unsafeBitCast(info.view, to: OpaquePointer.self)] = key
                     #if canImport(QuartzCore)
                     if index.archiveIdentity == .none, item.identity != .none {
                         info.layer.displayListID = item.identity
                     }
                     #endif
-                    isInserted = true
+                    changed = true
                 }
                 return Result(
                     view: info.view,
                     container: info.container,
                     id: info.id,
                     key: key,
-                    isInserted: isInserted,
+                    changed: changed,
                     isValid: !info.isInvalid,
                     nextUpdate: info.nextUpdate
                 )
@@ -333,7 +342,57 @@ extension DisplayList.ViewUpdater {
                     container: info.container,
                     id: info.id,
                     key: key,
-                    isInserted: true,
+                    changed: true,
+                    isValid: !info.isInvalid,
+                    nextUpdate: info.nextUpdate
+                )
+            }
+        }
+
+        mutating func updateAsync(
+            oldItem: DisplayList.Item,
+            oldState: UnsafePointer<Model.State>,
+            newItem: DisplayList.Item,
+            newState: UnsafePointer<Model.State>,
+            tag: Tag,
+            updateView: (
+                inout AsyncLayer,
+                DisplayList.Index,
+                DisplayList.Item,
+                UnsafePointer<Model.State>,
+                DisplayList.Item,
+                UnsafePointer<Model.State>
+            ) -> Bool
+        ) -> AsyncResult? {
+            guard oldItem.identity == newItem.identity else {
+                return nil
+            }
+            let key = Key(id: index.id, tag: tag)
+            return withUnsafeMutablePointer(to: &self) { cache in
+                guard var info = cache.pointee.map[key] else {
+                    return nil
+                }
+                var layer = AsyncLayer(
+                    layer: info.layer,
+                    cache: cache,
+                    kind: info.state.kind,
+                    flags: info.state.flags,
+                    nextUpdate: .infinity,
+                    isInvalid: info.isInvalid
+                )
+                guard updateView(&layer, cache.pointee.index, oldItem, oldState, newItem, newState) else {
+                    return nil
+                }
+                let shouldWriteBack = info.isInvalid != layer.isInvalid || info.nextUpdate != layer.nextUpdate
+                info.isInvalid = layer.isInvalid
+                info.nextUpdate = layer.nextUpdate
+                if shouldWriteBack {
+                    cache.pointee.map[key] = info
+                }
+                return AsyncResult(
+                    view: info.view,
+                    key: key,
+                    changed: oldItem.version != newItem.version,
                     isValid: !info.isInvalid,
                     nextUpdate: info.nextUpdate
                 )
@@ -345,7 +404,7 @@ extension DisplayList.ViewUpdater {
             var container: AnyObject
             var id: ViewInfo.ID
             var key: Key
-            var isInserted: Bool
+            var changed: Bool
             var isValid: Bool
             var nextUpdate: Time
         }
@@ -360,8 +419,10 @@ extension DisplayList.ViewUpdater {
         }
 
         struct AsyncResult {
-            var unknown: AnyObject // FIXME
+            var view: AnyObject
             var key: Key
+            var changed: Bool
+            var isValid: Bool
             var nextUpdate: Time
         }
 
diff --git a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewModel.swift b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewModel.swift
new file mode 100644
index 000000000..19b47c137
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewModel.swift
@@ -0,0 +1,778 @@
+//
+//  DisplayListViewModel.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: CA3A65C294B7CEBAC4D3EE28C528C257 (SwiftUICore)
+
+import OpenCoreGraphicsShims
+
+// MARK: - DisplayList.ViewUpdater.Model
+
+extension DisplayList.ViewUpdater {
+    enum Model {
+        static func merge(
+            item: inout DisplayList.Item,
+            index: DisplayList.Index,
+            into state: inout Model.State
+        ) -> MergedViewRequirements {
+            if case let .states(states) = item.value {
+                let list: DisplayList
+                if let hash = state.stateHashes.popLast(),
+                   let match = states.first(where: { $0.0 == hash }) {
+                    list = match.1
+                } else {
+                    list = DisplayList()
+                }
+                item.value = .effect(.identity, list)
+            }
+            let shouldRewriteVibrancyFilter =
+                (state.opacity != 1.0 && state.blend != .normal) ||
+                state.rewriteVibrantColorMatrix ||
+                state.filters.contains { filter in
+                    switch filter {
+                    case .colorMultiply: false
+                    default: true
+                    }
+                }
+            if shouldRewriteVibrancyFilter,
+               case let .effect(effect, list) = item.value,
+               case let .filter(filter) = effect,
+               case let .vibrantColorMatrix(matrix) = filter {
+                item.rewriteVibrancyFilterAsBackdrop(matrix: matrix, list: list)
+            }
+            var requirements: MergedViewRequirements = item.discardContainingClips(state: &state) ? .visibleContent : []
+
+            if !state.clips.isEmpty {
+                if !item.canMergeWithClipMask(state: state) {
+                    requirements.insert(.inheritedView)
+                } else if let clipRect = state.clipRect() {
+                    if !item.canMergeWithClipRect(clipRect, state: &state) {
+                        requirements.insert(.inheritedView)
+                    }
+                }
+            }
+            if !requirements.contains(.inheritedView),
+               state.transform != .identity,
+               !item.canMergeWithTransform {
+                requirements.insert(.inheritedView)
+            }
+            if !requirements.contains(.inheritedView),
+               (state.shadow != nil || !state.filters.isEmpty),
+               !item.canInheritShadowOrFilters {
+                requirements.insert(.inheritedView)
+            }
+            if !requirements.contains(.inheritedView),
+               state.properties.contains(.ignoresEvents),
+               !item.canInheritIgnoresEvents {
+                requirements.insert(.inheritedView)
+            }
+            if requirements.contains(.inheritedView) {
+                state.reset()
+            }
+            state.transform = state.transform.translatedBy(x: item.position.x, y: item.position.y)
+            state.versions.transform.combine(with: item.version)
+            let value = item.value
+            value.finishMerge(&requirements, item: &item, state: &state)
+            return requirements
+        }
+        
+        struct MergedViewRequirements: OptionSet {
+            let rawValue: UInt8
+            
+            init(rawValue: UInt8) {
+                self.rawValue = rawValue
+            }
+
+            // NOTE: These three flags are fully inlined and the names are inferred from the merge/update call sites.
+            static let itemView = MergedViewRequirements(rawValue: 1 << 0)
+            static let inheritedView = MergedViewRequirements(rawValue: 1 << 1)
+            static let visibleContent = MergedViewRequirements(rawValue: 1 << 2)
+        }
+
+        fileprivate static func merge(
+            _ content: DisplayList.Content,
+            from item: DisplayList.Item,
+            into state: inout State,
+            requirements: inout MergedViewRequirements
+        ) {
+            requirements.insert(.itemView)
+            state.versions.properties.combine(with: item.version)
+            switch content.value {
+            case let .backdrop(effect):
+                appendInheritedFilters(effect.filters, version: item.version, into: &state)
+            case let .chameleonColor(_, filters):
+                appendInheritedFilters(filters, version: item.version, into: &state)
+            case .view, .platformView, .platformLayer:
+                requirements.insert(.inheritedView)
+            default:
+                break
+            }
+        }
+
+        fileprivate static func merge(
+            _ effect: DisplayList.Effect,
+            list: DisplayList,
+            item: inout DisplayList.Item,
+            into state: inout State,
+            requirements: inout MergedViewRequirements
+        ) {
+            switch effect {
+            case .identity, .geometryGroup, .archive, .animation, .contentTransition,
+                    .accessibility, .interpolatorRoot, .interpolatorLayer, .interpolatorAnimation:
+                requirements.insert(.visibleContent)
+            case .compositingGroup:
+                state.compositingGroup = true
+                state.versions.properties.combine(with: item.version)
+                requirements.formUnion([.inheritedView, .visibleContent])
+            case let .backdropGroup(enabled):
+                if enabled {
+                    state.backdropGroupID &+= 1
+                }
+                state.versions.properties.combine(with: item.version)
+                requirements.insert(.visibleContent)
+            case let .properties(properties):
+                state.properties.formUnion(properties)
+                state.versions.properties.combine(with: item.version)
+                requirements.insert(.visibleContent)
+            case .platformGroup, .view, .platform:
+                requirements.formUnion([.inheritedView, .visibleContent])
+            case let .opacity(opacity):
+                state.opacity *= opacity
+                state.versions.opacity.combine(with: item.version)
+                requirements.insert(.visibleContent)
+            case let .blendMode(blend):
+                state.blend = blend
+                state.versions.blend.combine(with: item.version)
+                requirements.insert(.visibleContent)
+            case let .clip(path, style, _):
+                state.addClip(path, style: style)
+                state.versions.clips.combine(with: item.version)
+                requirements.insert(.visibleContent)
+            case .mask:
+                requirements.formUnion([.inheritedView, .visibleContent])
+            case let .transform(transform):
+                merge(transform, item: item, into: &state, requirements: &requirements)
+            case let .filter(filter):
+                merge(filter, list: list, item: &item, into: &state, requirements: &requirements)
+            case let .state(hash):
+                state.stateHashes.append(hash)
+                requirements.formUnion([.inheritedView, .visibleContent])
+            }
+        }
+
+        private static func merge(
+            _ transform: DisplayList.Transform,
+            item: DisplayList.Item,
+            into state: inout State,
+            requirements: inout MergedViewRequirements
+        ) {
+            switch transform {
+            case let .affine(transform):
+                state.adjust(for: transform)
+                state.transform = transform.concatenating(state.transform)
+                state.versions.transform.combine(with: item.version)
+                requirements.insert(.visibleContent)
+            case let .projection(transform) where transform.isAffine:
+                let affine = CGAffineTransform(transform)
+                state.adjust(for: affine)
+                state.transform = affine.concatenating(state.transform)
+                state.versions.transform.combine(with: item.version)
+                requirements.insert(.visibleContent)
+            default:
+                requirements.formUnion([.inheritedView, .visibleContent])
+            }
+        }
+
+        private static func merge(
+            _ filter: GraphicsFilter,
+            list: DisplayList,
+            item: inout DisplayList.Item,
+            into state: inout State,
+            requirements: inout MergedViewRequirements
+        ) {
+            if state.rewriteVibrantColorMatrix,
+               case let .colorMatrix(matrix, false) = filter {
+                item.rewriteVibrancyFilterAsBackdrop(matrix: matrix, list: list)
+                requirements.formUnion([.itemView, .visibleContent])
+                return
+            }
+            switch filter {
+            case let .shadow(shadow):
+                state.shadow = Indirect(shadow)
+                state.versions.shadow.combine(with: item.version)
+            case let .vibrantColorMatrix(matrix):
+                state.rewriteVibrantColorMatrix = true
+                state.filters.append(.colorMatrix(matrix, premultiplied: false))
+                state.versions.filters.combine(with: item.version)
+            default:
+                state.filters.append(filter)
+                state.versions.filters.combine(with: item.version)
+            }
+            requirements.insert(.visibleContent)
+        }
+
+        @inline(__always)
+        private static func appendInheritedFilters(
+            _ filters: [GraphicsFilter],
+            version: DisplayList.Version,
+            into state: inout State
+        ) {
+            guard !filters.isEmpty else {
+                return
+            }
+            state.filters.append(contentsOf: filters.reversed())
+            state.versions.filters.combine(with: version)
+        }
+        
+        // MARK: - DisplayList.ViewUpdater.Clip
+        
+        struct Clip: Equatable {
+            var path: Path
+            var transform: CGAffineTransform?
+            var style: FillStyle
+
+            var isEmpty: Bool {
+                path.isEmpty
+            }
+            
+            func clipRect() -> FixedRoundedRect? {
+                guard transform == nil else {
+                    return nil
+                }
+                switch path.storage {
+                case let .rect(rect):
+                    return FixedRoundedRect(rect, cornerSize: .zero, style: .circular)
+                case let .ellipse(rect):
+                    // OpenSwiftUI Addition:
+                    // SwiftUI 6.5.4 Buggy implementation: guard rect.width == rect.height
+                    // SwiftUI 7.2.5 Fixed: guard abs(rect.width - rect.height) < 0.001
+                    guard rect.width.approximates(rect.height, epsilon: 0.001) else {
+                        return nil
+                    }
+                    let radius = rect.width * 0.5
+                    return FixedRoundedRect(rect, cornerRadius: radius, style: .circular)
+                case let .roundedRect(roundedRect):
+                    return roundedRect
+                default:
+                    return nil
+                }
+            }
+        }
+        
+        // MARK: - DisplayList.ViewUpdater.State
+
+        struct State {
+            struct Globals {
+                var updater: DisplayList.ViewUpdater
+                var time: Time
+                var maxVersion: DisplayList.Version
+                var environment: DisplayList.ViewRenderer.Environment
+            }
+            var globals: UnsafePointer<Globals>
+            var opacity: Float = 1.0
+            var blend: GraphicsBlendMode = .normal
+            var transform: CGAffineTransform = .identity
+            var clips: [Clip] = []
+            var filters: [GraphicsFilter] = []
+            var shadow: Indirect<ResolvedShadowStyle>?
+            var properties: DisplayList.Properties = []
+            var rewriteVibrantColorMatrix: Bool = false
+            var compositingGroup: Bool = false
+            var backdropGroupID: UInt32 = .zero
+            var stateHashes: [StrongHash] = []
+            var platformState: PlatformState = .init()
+            struct Versions {
+                var opacity: DisplayList.Version = .init()
+                var blend: DisplayList.Version = .init()
+                var transform: DisplayList.Version = .init()
+                var clips: DisplayList.Version = .init()
+                var filters: DisplayList.Version = .init()
+                var shadow: DisplayList.Version = .init()
+                var properties: DisplayList.Version = .init()
+            }
+            var versions: Versions = .init()
+
+            var hasDODEffects: Bool {
+                guard shadow == nil else {
+                    return true
+                }
+                return filters.contains { filter in
+                    switch filter {
+                    case let .blur(blurStyle):
+                        !blurStyle.isOpaque
+                    case let .variableBlur(variableBlurStyle):
+                        !variableBlurStyle.isOpaque
+                    case .shadow:
+                        true
+                    default:
+                        false
+                    }
+                }
+            }
+
+            mutating func reset() {
+                opacity = 1.0
+                blend = .normal
+                transform = .identity
+                clips = []
+                filters = []
+                shadow = nil
+                properties = []
+                stateHashes = []
+                versions = .init()
+            }
+
+            func clipRect() -> FixedRoundedRect? {
+                guard clips.count == 1,
+                      let rect = clips[0].clipRect(),
+                      transform.isRectilinear
+                else {
+                    return nil
+                }
+                return rect.applying(transform.inverted())
+            }
+
+            fileprivate mutating func adjust(for transform: CGAffineTransform) {
+                guard shadow != nil || !filters.isEmpty else {
+                    return
+                }
+                let transformedWidth = CGSize(width: 1.0, height: 1.0).applying(transform).width
+                guard abs(transformedWidth - 1.0) > 0.001 else {
+                    return
+                }
+                let scale = 1.0 / transformedWidth
+                if let shadow {
+                    var value = shadow.value
+                    value.radius *= scale
+                    value.offset *= scale
+                    self.shadow = Indirect(value)
+                }
+                for (index, filter) in filters.enumerated() {
+                    guard case var .blur(blurStyle) = filter else {
+                        continue
+                    }
+                    blurStyle.radius *= scale
+                    filters[index] = .blur(blurStyle)
+                }
+            }
+
+            fileprivate mutating func addClip(_ path: Path, style: FillStyle) {
+                guard transform.isRectilinear else {
+                    appendClip(path, transform: transform, style: style)
+                    return
+                }
+                switch path.storage {
+                case .empty:
+                    clips = [Clip(path: path, transform: nil, style: style)]
+                case let .rect(rect):
+                    appendClip(
+                        Path(rect.applying(transform)),
+                        transform: nil,
+                        style: style
+                    )
+                case let .ellipse(rect):
+                    appendClip(
+                        Path(ellipseIn: rect.applying(transform)),
+                        transform: nil,
+                        style: style
+                    )
+                case let .roundedRect(roundedRect):
+                    appendClip(
+                        Path(storage: .roundedRect(roundedRect.applying(transform))),
+                        transform: nil,
+                        style: style
+                    )
+                default:
+                    appendClip(
+                        path,
+                        transform: transform,
+                        style: style
+                    )
+                }
+            }
+
+            @inline(__always)
+            private mutating func appendClip(_ path: Path, transform: CGAffineTransform?, style: FillStyle) {
+                if transform == nil {
+                    for (index, clip) in clips.enumerated() where clip.transform == nil {
+                        var existingPath = clip.path
+                        if existingPath.intersectRoundedRects(path) {
+                            clips[index].path = existingPath
+                            return
+                        }
+                    }
+                }
+                clips.append(Clip(path: path, transform: transform, style: style))
+            }
+        }
+    }
+}
+
+// MARK: - DisplayList.Item.Value helper
+
+extension DisplayList.Item.Value {
+    @inline(__always)
+    internal func finishMerge(
+        _ requirements: inout DisplayList.ViewUpdater.Model.MergedViewRequirements,
+        item: inout DisplayList.Item,
+        state: inout DisplayList.ViewUpdater.Model.State
+    ) {
+        switch self {
+        case .empty:
+            requirements.remove(.inheritedView)
+        case let .content(content):
+            DisplayList.ViewUpdater.Model.merge(content, from: item, into: &state, requirements: &requirements)
+        case let .effect(effect, list):
+            DisplayList.ViewUpdater.Model.merge(effect, list: list, item: &item, into: &state, requirements: &requirements)
+        case .states:
+            _openSwiftUIUnreachableCode()
+        }
+    }
+}
+
+// MARK: - Path + intersectRoundedRects
+
+@available(OpenSwiftUI_v1_0, *)
+extension Path {
+    fileprivate mutating func intersectRoundedRects(_ other: Path) -> Bool {
+        guard let lhs = roundedRect(), let rhs = other.roundedRect() else {
+            return false
+        }
+        guard lhs.cornerSize != .zero || rhs.cornerSize != .zero else {
+            self = Path(lhs.rect.intersection(rhs.rect))
+            return true
+        }
+        if lhs.cornerSize == rhs.cornerSize && lhs.style == rhs.style {
+            if lhs.rect.x.approximates(rhs.rect.x, epsilon: 0.001),
+               lhs.rect.width.approximates(rhs.rect.width, epsilon: 0.001) {
+                let y = max(lhs.rect.y, rhs.rect.y)
+                let height = min(lhs.rect.y + lhs.rect.height, rhs.rect.y + rhs.rect.height) - y
+                let storage: Path.Storage = height > 0 ? .roundedRect(FixedRoundedRect(
+                    CGRect(x: lhs.rect.x, y: y, width: lhs.rect.width, height: height),
+                    cornerSize: lhs.cornerSize,
+                    style: lhs.style
+                )) : .empty
+                self = Path(storage: storage)
+                return true
+            }
+            if lhs.rect.y.approximates(rhs.rect.y, epsilon: 0.001),
+               lhs.rect.height.approximates(rhs.rect.height, epsilon: 0.001) {
+                let x = max(lhs.rect.x, rhs.rect.x)
+                let width = min(lhs.rect.x + lhs.rect.width, rhs.rect.x + rhs.rect.width) - x
+                let storage: Path.Storage = width > 0 ? .roundedRect(FixedRoundedRect(
+                    CGRect(x: x, y: lhs.rect.y, width: width, height: lhs.rect.height),
+                    cornerSize: lhs.cornerSize,
+                    style: lhs.style
+                )) : .empty
+                self = Path(storage: storage)
+                return true
+            }
+        }
+        if lhs.contains(rhs) {
+            self = Path(storage: .roundedRect(rhs))
+            return true
+        } else if rhs.contains(lhs) {
+            self = Path(storage: .roundedRect(lhs))
+            return true
+        } else {
+            return false
+        }
+    }
+}
+
+// MARK: - DisplayList.Item helper
+
+extension DisplayList.Item {
+    func canMergeWithClipMask(state: DisplayList.ViewUpdater.Model.State) -> Bool {
+        switch value {
+        case .empty:
+            return true
+        case let .content(content):
+            switch content.value {
+            case .platformView, .platformLayer, .text:
+                return false
+            case let .flattened(_, _, options), let .drawing(_, _, options):
+                return options.isAccelerated
+            default:
+                return true
+            }
+        case let .effect(effect, _):
+            switch effect {
+            case .platformGroup, .mask:
+                return false
+            case let .transform(transform):
+                guard let affineTransform = transform.affineTransform else {
+                    return false
+                }
+                return affineTransform == .identity
+            case .animation, .view:
+                _openSwiftUIUnreachableCode()
+            default:
+                return true
+            }
+        case .states:
+            _openSwiftUIUnreachableCode()
+        }
+    }
+
+    func canMergeWithClipRect(
+        _ clipRect: FixedRoundedRect,
+        state: inout DisplayList.ViewUpdater.Model.State
+    ) -> Bool {
+        switch value {
+        case .empty:
+            return true
+        case let .content(content):
+            switch content.value {
+            case .backdrop, .color, .chameleonColor, .shadow, .text, .flattened, .drawing:
+                return frame.insetBy(dx: -0.001, dy: -0.001).contains(clipRect.rect)
+            case .image:
+                return frame.approximates(clipRect.rect, epsilon: 0.001)
+            case let .shape(path, _, _):
+                guard case let .rect(rect) = path.storage else {
+                    return false
+                }
+                return rect.contains(clipRect.rect)
+            case .platformView, .platformLayer:
+                return false
+            case .view, .placeholder:
+                _openSwiftUIUnreachableCode()
+            }
+        case let .effect(effect, _):
+            switch effect {
+            case .filter(let filter):
+                guard case .shadow = filter else {
+                    return true
+                }
+                return false
+            case .animation:
+                _openSwiftUIUnreachableCode()
+            default:
+                return true
+            }
+        case .states:
+            _openSwiftUIUnreachableCode()
+        }
+    }
+
+    var canMergeWithTransform: Bool {
+        guard case let .effect(effect, _) = value else {
+            return true
+        }
+        switch effect {
+        case let .clip(path, _, _):
+            switch path.storage {
+            case .rect, .roundedRect:
+                return false
+            case let .ellipse(rect):
+                // SwiftUI 6.5.4 Buggy implementation: rect.width == rect.height
+                // SwiftUI 7.2.5 Fixed: !rect.width.approximates(rect.height, epsilon: 0.001)
+                return !rect.width.approximates(rect.height, epsilon: 0.001)
+            default:
+                return true
+            }
+        default:
+            return true
+        }
+    }
+
+    var canInheritShadowOrFilters: Bool {
+        switch value {
+        case .empty:
+            return true
+        case let .content(content):
+            switch content.value {
+            case .shadow, .platformView, .platformLayer:
+                return false
+            default:
+                return true
+            }
+        case let .effect(effect, _):
+            switch effect {
+            case let .blendMode(blend):
+                return blend == .normal
+            case .clip, .platformGroup, .mask:
+                return false
+            case let .transform(transform):
+                guard let affineTransform = transform.affineTransform else {
+                    return false
+                }
+                return affineTransform.isUniform
+            case let .filter(filter):
+                if case .shadow = filter {
+                    return false
+                } else {
+                    return true
+                }
+            case .animation, .view:
+                _openSwiftUIUnreachableCode()
+            default:
+                return true
+            }
+        case .states:
+            _openSwiftUIUnreachableCode()
+        }
+    }
+
+    var canInheritIgnoresEvents: Bool {
+        switch value {
+        case .empty:
+            return true
+        case let .content(content):
+            if case .platformView = content.value {
+                return false
+            } else {
+                return true
+            }
+        case let .effect(effect, _):
+            if case .platformGroup = effect {
+                return false
+            } else {
+                return true
+            }
+        case .states:
+            _openSwiftUIUnreachableCode()
+        }
+    }
+
+    fileprivate mutating func rewriteVibrancyFilterAsBackdrop(
+        matrix: _ColorMatrix,
+        list: DisplayList
+    ) {
+        let backdropItem = DisplayList.Item(
+            .content(
+                DisplayList.Content(
+                    .backdrop(BackdropEffect(color: .clear)),
+                    seed: .init()
+                )
+            ),
+            frame: CGRect(origin: .zero, size: size),
+            identity: .none,
+            version: version
+        )
+        let filterItem = DisplayList.Item(
+            .effect(
+                .filter(.colorMatrix(matrix, premultiplied: false)),
+                DisplayList(backdropItem)
+            ),
+            frame: CGRect(origin: .zero, size: size),
+            identity: .none,
+            version: version
+        )
+        value = .effect(.mask(list), DisplayList(filterItem))
+    }
+    
+    #if OPENSWIFTUI_SUPPORT_2025_API
+    // 7.2.5
+//    fileprivate mutating func rewriteVibrancyFilterAsBackdrop(
+//        _ matrix: GraphicsFilter.VibrantColorMatrix,
+//        list: DisplayList
+//    ) {
+//        guard matrix.options == [], matrix.maxColorComponent == .inf else {
+//            return
+//        }
+//        let backdropItem = DisplayList.Item(
+//            .content(DisplayList.Content(.backdrop(BackdropEffect(color: .clear)), seed: .init())),
+//            frame: CGRect(origin: .zero, size: size),
+//            identity: .none,
+//            version: version
+//        )
+//        let filterItem = DisplayList.Item(
+//            .effect(
+//                .filter(.colorMatrix(matrix, premultiplied: false)),
+//                DisplayList(backdropItem)
+//            ),
+//            frame: CGRect(origin: .zero, size: size),
+//            identity: .none,
+//            version: version
+//        )
+//        value = .effect(.mask(list), DisplayList(filterItem))
+//    }
+    #endif
+    
+    fileprivate func discardContainingClips(
+        state: inout DisplayList.ViewUpdater.Model.State
+    ) -> Bool {
+        guard !state.clips.isEmpty else {
+            return true
+        }
+        guard !state.clips[0].isEmpty else {
+            return false
+        }
+        guard case let .content(content) = value,
+              state.transform.isRectilinear else {
+            return true
+        }
+        let inverseTransform = state.transform.inverted()
+        var effectOutset: CGFloat?
+        var index = 0
+        while index < state.clips.endIndex {
+            guard let clipRect = state.clips[index].clipRect() else {
+                index &+= 1
+                continue
+            }
+            var localClipRect = clipRect.applying(inverseTransform)
+            let sectionRect: CGRect
+            switch content.value {
+            case .backdrop, .color, .chameleonColor, .image, .text, .flattened, .drawing:
+                sectionRect = frame
+            case let .shape(path, _, _):
+                sectionRect = path.boundingRect.offsetBy(dx: frame.origin.x, dy: frame.origin.y)
+            case .shadow, .platformView, .platformLayer, .view, .placeholder:
+                return true
+            }
+            guard localClipRect.hasIntersection(sectionRect) else {
+                return false
+            }
+            let resolvedEffectOutset = effectOutset ?? state.clipDiscardEffectOutset
+            effectOutset = resolvedEffectOutset
+            if resolvedEffectOutset != 0 {
+                guard let insetClipRect = localClipRect.insetBy(dx: resolvedEffectOutset, dy: resolvedEffectOutset) else {
+                    index &+= 1
+                    continue
+                }
+                localClipRect = insetClipRect
+            }
+            guard localClipRect.contains(rect: sectionRect) else {
+                index &+= 1
+                continue
+            }
+            state.clips.remove(at: index)
+        }
+        return true
+    }
+}
+
+// MARK: - DisplayList.ViewUpdater.Model.State helper
+
+extension DisplayList.ViewUpdater.Model.State {
+    @inline(__always)
+    fileprivate var clipDiscardEffectOutset: CGFloat {
+        var outset: CGFloat = 0
+        if let shadow {
+            outset += shadow.value.clipDiscardOutset
+        }
+        for filter in filters {
+            switch filter {
+            case let .blur(blurStyle):
+                if !blurStyle.isOpaque {
+                    outset += blurStyle.radius * 2.8
+                }
+            default:
+                break
+            }
+        }
+        return outset
+    }
+}
+
+// MARK: - ResolvedShadowStyle helper
+
+extension ResolvedShadowStyle {
+    @inline(__always)
+    fileprivate var clipDiscardOutset: CGFloat {
+        radius * 2.8 + max(abs(offset.width), abs(offset.height))
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewPlatform.swift b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewPlatform.swift
index 6a6a35f22..20bb40b06 100644
--- a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewPlatform.swift
+++ b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewPlatform.swift
@@ -7,7 +7,11 @@
 //  ID: 8BBC66CBE42B8A65F8A2F3799C81A349 (SwiftUICore)
 
 public import OpenQuartzCoreShims
+import Foundation
 import OpenSwiftUI_SPI
+#if canImport(QuartzCore)
+import QuartzCore_Private
+#endif
 
 // MARK: - PlatformViewDefinition
 
@@ -56,9 +60,7 @@ open class PlatformViewDefinition: @unchecked Sendable {
     open class func makeView(kind: PlatformViewDefinition.ViewKind, item: Any) -> AnyObject { _openSwiftUIBaseClassAbstractMethod() }
     #endif
     open class func makeView(kind: PlatformViewDefinition.ViewKind) -> AnyObject { _openSwiftUIBaseClassAbstractMethod() }
-    #if canImport(Darwin)
     open class func makeLayerView(type: CALayer.Type, kind: PlatformViewDefinition.ViewKind) -> AnyObject { _openSwiftUIBaseClassAbstractMethod() }
-    #endif
     open class func makePlatformView(view: AnyObject, kind: PlatformViewDefinition.ViewKind) { _openSwiftUIBaseClassAbstractMethod() }
     open class func makeDrawingView(options: PlatformDrawableOptions) -> any PlatformDrawable { _openSwiftUIBaseClassAbstractMethod() }
     open class func setPath(_ path: Path, shapeView: AnyObject) { _openSwiftUIBaseClassAbstractMethod() }
@@ -76,15 +78,111 @@ extension DisplayList.ViewUpdater {
         let rawValue: UInt
 
         struct State {
-            var position: CGPoint
-            var size: CGSize
+            var position: CGPoint = .infinity
+            var size: CGSize = .infinity
             let kind: PlatformViewDefinition.ViewKind
-            var flags: ViewFlags
-            var platformState: Platform.PlatformState
+            var flags: ViewFlags = []
+            var platformState: Platform.PlatformState = .init()
+            
+            mutating func reset() {
+                position = .infinity
+                size = .infinity
+                flags = []
+            }
+
+            @inline(__always)
+            var isBoundsOriginEnabled: Bool {
+                get { flags.contains(.boundsOrigin) }
+                set {
+                    if newValue {
+                        flags.insert(.boundsOrigin)
+                    } else {
+                        flags.remove(.boundsOrigin)
+                    }
+                }
+            }
+
+            @inline(__always)
+            var isAffineTransformEnabled: Bool {
+                get { flags.contains(.affineTransform) }
+                set {
+                    if newValue {
+                        flags.insert(.affineTransform)
+                    } else {
+                        flags.remove(.affineTransform)
+                    }
+                }
+            }
+
+            @inline(__always)
+            var isProjectionGeometryEnabled: Bool {
+                get { flags.contains(.projectionGeometry) }
+                set {
+                    if newValue {
+                        flags.insert(.projectionGeometry)
+                    } else {
+                        flags.remove(.projectionGeometry)
+                    }
+                }
+            }
+
+            @inline(__always)
+            var isClipRectEnabled: Bool {
+                get { flags.contains(.clipRect) }
+                set {
+                    if newValue {
+                        flags.insert(.clipRect)
+                    } else {
+                        flags.remove(.clipRect)
+                    }
+                }
+            }
+
+            @inline(__always)
+            var isMaskLayerEnabled: Bool {
+                get { flags.contains(.maskLayer) }
+                set {
+                    if newValue {
+                        flags.insert(.maskLayer)
+                    } else {
+                        flags.remove(.maskLayer)
+                    }
+                }
+            }
+
+            @inline(__always)
+            var isContentGeometryEnabled: Bool {
+                get { flags.contains(.contentGeometry) }
+                set {
+                    if newValue {
+                        flags.insert(.contentGeometry)
+                    } else {
+                        flags.remove(.contentGeometry)
+                    }
+                }
+            }
         }
 
-        struct ViewFlags {
+        struct ViewFlags: OptionSet {
             let rawValue: UInt8
+            
+            @inline(__always)
+            static var boundsOrigin: ViewFlags { .init(rawValue: 1 << 0) }
+            
+            @inline(__always)
+            static var affineTransform: ViewFlags { .init(rawValue: 1 << 1) }
+            
+            @inline(__always)
+            static var projectionGeometry: ViewFlags { .init(rawValue: 1 << 2) }
+            
+            @inline(__always)
+            static var clipRect: ViewFlags { .init(rawValue: 1 << 3) }
+            
+            @inline(__always)
+            static var maskLayer: ViewFlags { .init(rawValue: 1 << 4) }
+
+            @inline(__always)
+            static var contentGeometry: ViewFlags { .init(rawValue: 1 << 5) }
         }
     }
 }
@@ -113,6 +211,895 @@ extension DisplayList.ViewUpdater.Platform {
         _openSwiftUIPlatformUnimplementedFailure()
         #endif
     }
+    
+    @inline(__always)
+    package func subviews(_ view: AnyObject) -> [AnyObject] {
+        #if canImport(QuartzCore)
+        CoreViewSubviews(system: viewSystem, view: view) as [AnyObject]
+        #else
+        _openSwiftUIPlatformUnimplementedFailure()
+        #endif
+    }
+    
+    @inline(__always)
+    package func removeFromSuperview(_ view: AnyObject) {
+        #if canImport(QuartzCore)
+        CoreViewRemoveFromSuperview(system: viewSystem, view: view)
+        #else
+        _openSwiftUIPlatformUnimplementedFailure()
+        #endif
+    }
+
+    @inline(__always)
+    package func addSubview(_ child: AnyObject, to parent: AnyObject, at index: Int) {
+        #if canImport(QuartzCore)
+        CoreViewAddSubview(
+            system: viewSystem,
+            parent: parent,
+            child: child,
+            index: UInt(index)
+        )
+        #else
+        _openSwiftUIPlatformUnimplementedFailure()
+        #endif
+    }
+
+    @inline(__always)
+    package func setFrame(_ frame: CGRect, of view: AnyObject) {
+        #if canImport(QuartzCore)
+        CoreViewSetFrame(system: viewSystem, view: view, frame: frame)
+        #else
+        _openSwiftUIPlatformUnimplementedFailure()
+        #endif
+    }
+
+    @inline(__always)
+    package func frame(of view: AnyObject) -> CGRect? {
+        #if canImport(QuartzCore)
+        CoreViewGetFrame(system: viewSystem, view: view)
+        #else
+        _openSwiftUIPlatformUnimplementedFailure()
+        #endif
+    }
+
+    @inline(__always)
+    package func bounds(of view: AnyObject) -> CGRect? {
+        #if canImport(Darwin)
+        view.bounds
+        #else
+        _openSwiftUIPlatformUnimplementedFailure()
+        #endif
+    }
+
+    @inline(__always)
+    package func maskView(_ view: AnyObject) -> AnyObject? {
+        #if canImport(QuartzCore)
+        CoreViewMaskView(system: viewSystem, view: view) as AnyObject?
+        #else
+        _openSwiftUIPlatformUnimplementedFailure()
+        #endif
+    }
+
+    @inline(__always)
+    package func setClipsToBounds(_ clips: Bool, of view: AnyObject, onLayer: Bool) {
+        #if canImport(QuartzCore)
+        CoreViewSetClipsToBounds(
+            system: viewSystem,
+            view: view,
+            clips: clips,
+            onLayer: onLayer
+        )
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        #endif
+    }
+
+    @inline(__always)
+    package func setGeometry(
+        of view: AnyObject,
+        useViewAPIs: Bool,
+        positionChanged: Bool,
+        boundsOriginChanged: Bool,
+        boundsSizeChanged: Bool,
+        position: CGPoint,
+        bounds: CGRect
+    ) {
+        #if canImport(QuartzCore)
+        CoreViewSetGeometry(
+            system: viewSystem,
+            view: view,
+            useViewAPIs: useViewAPIs,
+            positionChanged: positionChanged,
+            boundsOriginChanged: boundsOriginChanged,
+            boundsSizeChanged: boundsSizeChanged,
+            position: position,
+            bounds: bounds
+        )
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        #endif
+    }
+
+    @inline(__always)
+    package func setMaskGeometry(of view: AnyObject, bounds: CGRect) {
+        #if canImport(QuartzCore)
+        CoreViewSetMaskGeometry(system: viewSystem, view: view, bounds: bounds)
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        #endif
+    }
+    
+    package func setShadow(_ shadow: ResolvedShadowStyle?, layer: CALayer) {
+        #if canImport(QuartzCore)
+        if let shadow {
+            if viewSystem != .caLayer, let delegate = layer.delegate {
+                let view = delegate as AnyObject
+                CoreViewSetShadow(
+                    system: CoreViewResolvedSystem(system: viewSystem, view: view),
+                    view: view,
+                    color: shadow.color.cgColor,
+                    radius: shadow.radius,
+                    offset: shadow.offset
+                )
+            } else {
+                CoreViewSetShadow(
+                    system: .caLayer,
+                    view: layer,
+                    color: shadow.color.cgColor,
+                    radius: shadow.radius,
+                    offset: shadow.offset
+                )
+            }
+        } else {
+            if viewSystem != .caLayer, let delegate = layer.delegate {
+                let view = delegate as AnyObject
+                CoreViewSetShadow(
+                    system: CoreViewResolvedSystem(system: viewSystem, view: view),
+                    view: view,
+                    color: nil,
+                    radius: 0,
+                    offset: .zero
+                )
+            } else {
+                CoreViewSetShadow(
+                    system: .caLayer,
+                    view: layer,
+                    color: nil,
+                    radius: 0,
+                    offset: .zero
+                )
+            }
+        }
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        #endif
+    }
+    
+    func updateItemView(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        index: DisplayList.Index,
+        item: DisplayList.Item,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) {
+        _openSwiftUIUnimplementedFailure()
+    }
+    
+    func updateItemViewAsync(
+        layer: inout DisplayList.ViewUpdater.AsyncLayer,
+        index: DisplayList.Index,
+        oldItem: DisplayList.Item,
+        oldState: UnsafePointer<DisplayList.ViewUpdater.Model.State>,
+        newItem: DisplayList.Item,
+        newState: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) -> Bool {
+        _openSwiftUIUnimplementedFailure()
+    }
+    
+    func updateState(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        item: DisplayList.Item,
+        size: CGSize,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) {
+        #if canImport(QuartzCore)
+        if viewInfo.seeds.opacity != state.pointee.versions.opacity.seed {
+            CoreViewSetOpacity(
+                system: viewSystem,
+                view: viewInfo.view,
+                opacity: CGFloat(state.pointee.opacity)
+            )
+            viewInfo.seeds.opacity = state.pointee.versions.opacity.seed
+        }
+        if viewInfo.seeds.blend != state.pointee.versions.blend.seed {
+            CoreViewSetCompositingFilter(
+                system: viewSystem,
+                view: viewInfo.view,
+                filter: state.pointee.blend.filter
+            )
+            viewInfo.seeds.blend = state.pointee.versions.blend.seed
+        }
+        if viewInfo.seeds.filters != state.pointee.versions.filters.seed {
+            var filters = state.pointee.filters
+            if viewInfo.state.kind == .drawing {
+                let color = filters.popColorMultiply(drawable: viewInfo.view as? PlatformDrawable)
+                viewInfo.layer.contentsMultiplyColor = color?.cgColor
+            }
+            CoreViewSetFilters(
+                system: viewSystem,
+                view: viewInfo.view,
+                filters: filters.caFilters()
+            )
+            viewInfo.seeds.filters = state.pointee.versions.filters.seed
+        }
+
+        let clipRectChanged: Bool
+        if viewInfo.seeds.clips != state.pointee.versions.clips.seed ||
+            viewInfo.seeds.transform != state.pointee.versions.transform.seed {
+            let oldFlags = viewInfo.state.flags
+            updateClipShapes(&viewInfo, state: state)
+            viewInfo.seeds.clips = state.pointee.versions.clips.seed
+            clipRectChanged = oldFlags.union(viewInfo.state.flags).contains(.clipRect)
+        } else {
+            clipRectChanged = false
+        }
+        let boundsChanged = updateGeometry(
+            &viewInfo,
+            item: item,
+            size: size,
+            state: state,
+            clipRectChanged: clipRectChanged
+        )
+        if boundsChanged || viewInfo.seeds.shadow != state.pointee.versions.shadow.seed || viewInfo.seeds.item != item.version.seed {
+            updateShadow(&viewInfo, state: state, item: item)
+            viewInfo.seeds.shadow = state.pointee.versions.shadow.seed
+        }
+        if viewInfo.seeds.properties != state.pointee.versions.properties.seed {
+            updateProperties(&viewInfo, state: state)
+            viewInfo.seeds.properties = state.pointee.versions.properties.seed
+        }
+        switch viewInfo.state.kind {
+        case .image, .drawing, .platformView, .platformGroup, .platformLayer:
+            break
+        default:
+            viewInfo.layer.contentsScale = state.pointee.globals.pointee.environment.contentsScale
+        }
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        #endif
+    }
+
+    func updateStateAsync(
+        layer: inout DisplayList.ViewUpdater.AsyncLayer,
+        oldItem: DisplayList.Item,
+        oldSize: CGSize,
+        oldState: UnsafePointer<DisplayList.ViewUpdater.Model.State>,
+        newItem: DisplayList.Item,
+        newSize: CGSize,
+        newState: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) -> Bool {
+        _openSwiftUIUnimplementedFailure()
+    }
+
+    func _makeItemView(
+        item: DisplayList.Item,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) -> DisplayList.ViewUpdater.ViewInfo {
+        switch item.value {
+        case let .content(content):
+            switch content.value {
+            case .backdrop:
+                #if canImport(QuartzCore)
+                let view = definition.makeLayerView(type: CABackdropLayer.self, kind: .backdrop)
+                #else
+                let view = definition.makeLayerView(type: CALayer.self, kind: .backdrop)
+                _openSwiftUIPlatformUnimplementedWarning()
+                #endif
+                return DisplayList.ViewUpdater.ViewInfo(
+                    view: view,
+                    layer: viewLayer(view),
+                    container: view,
+                    state: .init(kind: .backdrop)
+                )
+            case .color:
+                return DisplayList.ViewUpdater.ViewInfo(
+                    platform: self,
+                    kind: .color
+                )
+            case .chameleonColor:
+                return DisplayList.ViewUpdater.ViewInfo(
+                    platform: self,
+                    kind: .chameleonColor
+                )
+            case .image:
+                #if canImport(QuartzCore)
+                let view = definition.makeLayerView(type: ImageLayer.self, kind: .image)
+                #else
+                let view = definition.makeLayerView(type: CALayer.self, kind: .image)
+                _openSwiftUIPlatformUnimplementedWarning()
+                #endif
+                return DisplayList.ViewUpdater.ViewInfo(
+                    view: view,
+                    layer: viewLayer(view),
+                    container: view,
+                    state: .init(kind: .image)
+                )
+            case let .shape(path, paint, _):
+                var visitor = ShapeLayerHelper.Visitor(
+                    shapeType: ShapeType(path),
+                    mayClip: !state.pointee.hasDODEffects,
+                    requiredType: nil
+                )
+                paint.visit(&visitor)
+                let view = definition.makeLayerView(type: visitor.requiredType!, kind: .shape)
+                return DisplayList.ViewUpdater.ViewInfo(
+                    view: view,
+                    layer: viewLayer(view),
+                    container: view,
+                    state: .init(kind: .shape)
+                )
+            case .shadow:
+                return DisplayList.ViewUpdater.ViewInfo(
+                    platform: self,
+                    kind: .shadow
+                )
+            case let .platformView(factory):
+                let view = factory.makePlatformView() ?? missingPlatformView()
+                definition.makePlatformView(view: view, kind: .platformView)
+                return DisplayList.ViewUpdater.ViewInfo(
+                    view: view,
+                    layer: viewLayer(view),
+                    container: view,
+                    state: .init(kind: .platformView)
+                )
+            case let .platformLayer(factory):
+                let layerType = factory.platformLayerType
+                let view = definition.makeLayerView(type: layerType, kind: .platformLayer)
+                return DisplayList.ViewUpdater.ViewInfo(
+                    view: view,
+                    layer: viewLayer(view),
+                    container: view,
+                    state: .init(kind: .platformLayer)
+                )
+            case .text:
+                let view = definition.makeDrawingView(options: .init(base: .init())) as AnyObject
+                return DisplayList.ViewUpdater.ViewInfo(
+                    view: view,
+                    layer: viewLayer(view),
+                    container: view,
+                    state: .init(kind: .drawing)
+                )
+            case let .flattened(_, _, options), let .drawing(_, _, options):
+                let view = definition.makeDrawingView(options: .init(base: options)) as AnyObject
+                return DisplayList.ViewUpdater.ViewInfo(
+                    view: view,
+                    layer: viewLayer(view),
+                    container: view,
+                    state: .init(kind: .drawing)
+                )
+            case .view, .placeholder:
+                _openSwiftUIUnreachableCode()
+            }
+        case let .effect(effect, _):
+            switch effect {
+            case .geometryGroup:
+                return DisplayList.ViewUpdater.ViewInfo(platform: self, kind: .geometry)
+            case .compositingGroup:
+                let info = DisplayList.ViewUpdater.ViewInfo(platform: self, kind: .compositing)
+                #if canImport(QuartzCore)
+                let layer = info.layer
+                info.layer.allowsGroupOpacity = true
+                info.layer.allowsGroupBlending = true
+                #else
+                _openSwiftUIPlatformUnimplementedWarning()
+                #endif
+                return info
+            case let .platformGroup(factory):
+                let view = factory.makePlatformGroup() ?? missingPlatformView()
+                definition.makePlatformView(view: view, kind: .platformGroup)
+                return DisplayList.ViewUpdater.ViewInfo(
+                    view: view,
+                    layer: viewLayer(view),
+                    container: factory.platformGroupContainer(view),
+                    state: .init(kind: .platformGroup)
+                )
+            case .mask:
+                return DisplayList.ViewUpdater.ViewInfo(platform: self, kind: .mask)
+            case let .transform(transform) where transform.projectionTransform != nil:
+                var info = DisplayList.ViewUpdater.ViewInfo(platform: self, kind: .projection)
+                info.state.isProjectionGeometryEnabled = true
+                return info
+            case .transform:
+                _openSwiftUIUnreachableCode()
+            case .platform:
+                return DisplayList.ViewUpdater.ViewInfo(platform: self, kind: .platformEffect)
+            default:
+                _openSwiftUIUnreachableCode()
+            }
+        case .empty, .states:
+            _openSwiftUIUnreachableCode()
+        }
+    }
+
+    private func missingPlatformView() -> AnyObject {
+        let drawable = definition.makeDrawingView(options: .init(base: .init()))
+        let view = drawable as AnyObject
+        setClipsToBounds(false, of: view, onLayer: false)
+        var content = PlatformDrawableContent()
+        content.storage = .graphicsCallback { context, size in
+            context.renderMissingPlatformView(size: size)
+        }
+        _ = drawable.update(content: content, required: false)
+        return view
+    }
+
+    private func updateShapeView(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        state: inout DisplayList.ViewUpdater.Model.State,
+        size: inout CGSize,
+        path: Path,
+        paint: AnyResolvedPaint,
+        style: FillStyle,
+        contentsChanged: Bool
+    ) {
+        let currentLayerType = type(of: viewInfo.layer)
+        let originalSize = size
+        let contentsScale = state.globals.pointee.environment.contentsScale
+        var bounds = ShapeLayerHelper.makeLayerBounds(
+            size: originalSize,
+            path: path,
+            layerType: currentLayerType,
+            contentsScale: contentsScale
+        )
+
+        if contentsChanged {
+            var helper = ShapeLayerHelper(
+                layer: viewInfo.layer,
+                layerType: currentLayerType,
+                path: path,
+                origin: bounds.origin,
+                paint: paint,
+                paintBounds: CGRect(
+                    origin: CGPoint(x: -bounds.origin.x, y: -bounds.origin.y),
+                    size: originalSize
+                ),
+                style: style,
+                contentsScale: contentsScale,
+                mayClip: !state.hasDODEffects
+            )
+            paint.visit(&helper)
+            if helper.layerType != currentLayerType {
+                bounds = ShapeLayerHelper.makeLayerBounds(
+                    size: originalSize,
+                    path: path,
+                    layerType: helper.layerType,
+                    contentsScale: contentsScale
+                )
+                helper.origin = bounds.origin
+                helper.paintBounds = CGRect(
+                    origin: CGPoint(x: -bounds.origin.x, y: -bounds.origin.y),
+                    size: originalSize
+                )
+                let view = definition.makeLayerView(type: helper.layerType, kind: .shape)
+                viewInfo = DisplayList.ViewUpdater.ViewInfo(
+                    view: view,
+                    layer: viewLayer(view),
+                    container: view,
+                    state: .init(kind: .shape)
+                )
+                helper.layer = viewInfo.layer
+                paint.visit(&helper)
+            }
+            let shapePath: Path
+            if bounds.origin.y == 0 {
+                shapePath = path
+            } else {
+                let offset = -bounds.origin.y
+                shapePath = path.applying(CGAffineTransform(translationX: offset, y: offset))
+            }
+            definition.setPath(shapePath, shapeView: viewInfo.view)
+            viewInfo.state.isContentGeometryEnabled = true
+        }
+        state.transform = state.transform.translatedBy(x: bounds.origin.x, y: bounds.origin.y)
+        size = bounds.size
+    }
+
+    private func updateShadowView(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        path: Path,
+        shadow: ResolvedShadowStyle,
+        size: CGSize
+    ) {
+        #if canImport(QuartzCore)
+        let layer = viewInfo.layer
+        if path.boundingRect == CGRect(origin: .zero, size: size) {
+            var helper = ShapeLayerShadowHelper(
+                platform: self,
+                layer: layer,
+                path: path,
+                offset: .zero,
+                shadow: shadow,
+                updateShape: true
+            )
+            helper.visitPaint(Color.Resolved.white)
+        } else {
+            layer.shadowPath = path.cgPath
+            layer.shadowPathIsBounds = false
+            setShadow(shadow, layer: layer)
+        }
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        #endif
+    }
+
+    private func updateDrawingView(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        options: RasterizationOptions,
+        contentsScale: CGFloat,
+        content: PlatformDrawableContent.Storage,
+        sizeChanged: Bool
+    ) {
+        let oldView = viewInfo.view
+        let drawable = updateDrawingView(
+            &viewInfo.view,
+            options: options,
+            contentsScale: contentsScale
+        )
+        var drawableContent = PlatformDrawableContent()
+        drawableContent.storage = content
+        viewInfo.isInvalid = !drawable.update(
+            content: drawableContent,
+            required: sizeChanged
+        )
+        if viewInfo.view !== oldView {
+            viewInfo.reset(platform: self)
+        }
+    }
+
+    private func updateShapeViewAsync(
+        layer: inout DisplayList.ViewUpdater.AsyncLayer,
+        oldState: inout DisplayList.ViewUpdater.Model.State,
+        oldSize: inout CGSize,
+        oldPath: Path,
+        oldPaint: AnyResolvedPaint,
+        oldStyle: FillStyle,
+        newState: inout DisplayList.ViewUpdater.Model.State,
+        newSize: inout CGSize,
+        newPath: Path,
+        newPaint: AnyResolvedPaint,
+        newStyle: FillStyle,
+        contentsChanged: Bool
+    ) -> Bool {
+        _openSwiftUIUnimplementedFailure()
+    }
+
+    private func updateDrawingViewAsync(
+        _ asyncLayer: inout DisplayList.ViewUpdater.AsyncLayer,
+        oldOptions: RasterizationOptions,
+        newOptions: RasterizationOptions,
+        content: PlatformDrawableContent.Storage,
+        sizeChanged: Bool,
+        newSize: CGSize,
+        newState: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) -> Bool {
+        guard oldOptions == newOptions,
+              let delegate = asyncLayer.layer.delegate,
+              let drawable = delegate as? PlatformDrawable
+        else {
+            return false
+        }
+        let bounds: CGRect
+        if asyncLayer.isClipRectEnabled, let clipRect = newState.pointee.clipRect() {
+            bounds = clipRect.rect
+        } else {
+            bounds = CGRect(origin: .zero, size: newSize)
+        }
+        var drawableContent = PlatformDrawableContent()
+        drawableContent.storage = content
+        guard let update = drawable.makeAsyncUpdate(
+            content: drawableContent,
+            required: sizeChanged,
+            layer: asyncLayer.layer,
+            bounds: bounds
+        ) else {
+            return false
+        }
+        asyncLayer.cache.pointee.pendingAsyncUpdates.append(update)
+        return true
+    }
+
+    private func updateClipShapes(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) {
+        #if canImport(QuartzCore)
+        if let clipRect = state.pointee.clipRect() {
+            setClipsToBounds(true, of: viewInfo.view, onLayer: false)
+            let layer = viewInfo.layer
+            layer.cornerRadius = clipRect.clampedCornerRadius
+            layer.cornerCurve = clipRect.style == .continuous ? .continuous : .circular
+            viewInfo.state.isClipRectEnabled = true
+            if viewInfo.state.isMaskLayerEnabled {
+                layer.mask = nil
+                viewInfo.state.isMaskLayerEnabled = false
+            }
+
+        } else {
+            if viewInfo.state.isClipRectEnabled {
+                viewInfo.state.isClipRectEnabled = false
+                setClipsToBounds(false, of: viewInfo.view, onLayer: false)
+                let layer = viewInfo.layer
+                var bounds = layer.bounds
+                bounds.origin = .zero
+                layer.bounds = bounds
+                layer.cornerRadius = 0
+                layer.cornerCurve = .circular
+            }
+            let clips = state.pointee.clips
+            guard !clips.isEmpty else {
+                if viewInfo.state.isMaskLayerEnabled {
+                    let layer = viewInfo.layer
+                    layer.mask = nil
+                    viewInfo.state.isMaskLayerEnabled = false
+                }
+                return
+            }
+            let layer = viewInfo.layer
+            let maskLayer: MaskLayer
+            if let mask = layer.mask as? MaskLayer {
+                maskLayer = mask
+            } else {
+                maskLayer = MaskLayer()
+                maskLayer.anchorPoint = .zero
+                maskLayer.setNoAnimationDelegate()
+                layer.mask = maskLayer
+            }
+            viewInfo.state.isMaskLayerEnabled = true
+            let transform = state.pointee.transform.inverted()
+            if maskLayer.clips != clips || maskLayer.clipTransform != transform {
+                maskLayer.setClips(clips, transform: transform)
+            }
+        }
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        #endif
+    }
+
+    private func updateGeometry(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        item: DisplayList.Item,
+        size: CGSize,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>,
+        clipRectChanged: Bool
+    ) -> Bool {
+        #if canImport(QuartzCore)
+        let sizeChanged = viewInfo.state.size != size
+        let transformSeed = DisplayList.Seed(state.pointee.versions.transform)
+        let transformChanged = viewInfo.seeds.transform != transformSeed
+        viewInfo.seeds.transform = transformSeed
+        guard sizeChanged || transformChanged || clipRectChanged else {
+            return false
+        }
+        // TBA
+        let hadBoundsOrigin = viewInfo.state.isBoundsOriginEnabled
+        let hadAffineTransform = viewInfo.state.isAffineTransformEnabled
+        let usesProjection = viewInfo.state.isProjectionGeometryEnabled
+        let usesClipRect = viewInfo.state.isClipRectEnabled
+
+        var clipRectPresent = false
+        var bounds = CGRect(origin: .zero, size: size)
+        var position = CGPoint(x: state.pointee.transform.tx, y: state.pointee.transform.ty)
+        if usesClipRect, let clipRect = state.pointee.clipRect() {
+            clipRectPresent = true
+            bounds = clipRect.rect
+            position.x += bounds.origin.x
+            position.y += bounds.origin.y
+        }
+
+        let shouldComparePosition = transformChanged || (clipRectPresent && clipRectChanged)
+        let positionChanged = shouldComparePosition && viewInfo.state.position != position
+        if positionChanged {
+            viewInfo.state.position = position
+        }
+
+        let boundsSizeChanged = viewInfo.state.size != bounds.size
+        if boundsSizeChanged {
+            viewInfo.state.size = bounds.size
+        }
+
+        let hasBoundsOrigin = bounds.origin != .zero
+        let boundsOriginChanged = hadBoundsOrigin || hasBoundsOrigin
+        let boundsChanged = boundsOriginChanged || boundsSizeChanged
+
+        if boundsOriginChanged {
+            viewInfo.state.isBoundsOriginEnabled = hasBoundsOrigin
+        }
+
+        if usesProjection {
+            if boundsChanged {
+                CoreViewSetSize(system: viewSystem, view: viewInfo.view, size: bounds.size)
+            }
+            viewLayer(viewInfo.view).contentsScale = state.pointee.globals.pointee.environment.contentsScale
+            if boundsChanged, viewInfo.state.kind == .mask {
+                setMaskGeometry(of: viewInfo.view, bounds: bounds)
+            }
+            return boundsChanged
+        }
+
+        var affineTransform = state.pointee.transform
+        affineTransform.tx = 0
+        affineTransform.ty = 0
+        let hasAffineTransform = affineTransform != .identity
+        if transformChanged && (hadAffineTransform || hasAffineTransform) {
+            CoreViewSetTransform(
+                system: viewSystem,
+                view: viewInfo.view,
+                transform: affineTransform
+            )
+            if hasAffineTransform {
+                viewInfo.state.isAffineTransformEnabled = true
+            } else {
+                viewInfo.state.isAffineTransformEnabled = false
+            }
+        }
+
+        let useViewAPIs: Bool
+        switch viewInfo.state.kind {
+        case .platformView, .platformGroup, .platformLayer:
+            useViewAPIs = true
+        default:
+            useViewAPIs = false
+        }
+        let sanitizedPosition = CGPoint(
+            x: position.x.mappingNaN(to: 0),
+            y: position.y.mappingNaN(to: 0)
+        )
+        let sanitizedBounds = CGRect(
+            x: bounds.origin.x.mappingNaN(to: 0),
+            y: bounds.origin.y.mappingNaN(to: 0),
+            width: bounds.size.width.mappingNaN(to: 0),
+            height: bounds.size.height.mappingNaN(to: 0)
+        )
+        setGeometry(
+            of: viewInfo.view,
+            useViewAPIs: useViewAPIs,
+            positionChanged: positionChanged,
+            boundsOriginChanged: boundsOriginChanged,
+            boundsSizeChanged: boundsSizeChanged,
+            position: sanitizedPosition,
+            bounds: sanitizedBounds
+        )
+
+        if boundsChanged, viewInfo.state.kind == .mask {
+            setMaskGeometry(of: viewInfo.view, bounds: bounds)
+        }
+        return boundsChanged
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        return false
+        #endif
+    }
+
+    private func updateShadow(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>,
+        item: DisplayList.Item
+    ) {
+        #if canImport(QuartzCore)
+        guard let shadow = state.pointee.shadow?.value else {
+            let shadowSeed = DisplayList.Seed(state.pointee.versions.shadow)
+            guard viewInfo.seeds.shadow != shadowSeed else {
+                return
+            }
+            switch viewInfo.state.kind {
+            case .platformView, .platformGroup, .platformLayer:
+                return
+            default:
+                CoreViewSetShadow(
+                    system: viewSystem,
+                    view: viewInfo.view,
+                    color: nil,
+                    radius: 0,
+                    offset: .zero
+                )
+                return
+            }
+        }
+        guard viewInfo.state.kind != .inherited,
+              case let .content(content) = item.value
+        else {
+            CoreViewSetShadow(
+                system: viewSystem,
+                view: viewInfo.view,
+                color: shadow.color.cgColor,
+                radius: shadow.radius,
+                offset: shadow.offset
+            )
+            return
+        }
+        switch content.value {
+        case let .color(color):
+            var colorShadow = shadow
+            colorShadow.color = shadow.color.multiplyingOpacity(by: color.opacity)
+            viewInfo.layer.shadowPathIsBounds = true
+            viewInfo.layer.shadowPath = nil
+            setShadow(colorShadow, layer: viewInfo.layer)
+        case let .shape(path, paint, _):
+            let bounds = ShapeLayerHelper.makeLayerBounds(
+                size: item.size,
+                path: path,
+                layerType: type(of: viewInfo.layer),
+                contentsScale: state.pointee.globals.pointee.environment.contentsScale
+            )
+            var helper = ShapeLayerShadowHelper(
+                platform: self,
+                layer: viewInfo.layer,
+                path: path,
+                offset: bounds.origin,
+                shadow: shadow,
+                updateShape: false
+            )
+            paint.visit(&helper)
+        default:
+            CoreViewSetShadow(
+                system: viewSystem,
+                view: viewInfo.view,
+                color: shadow.color.cgColor,
+                radius: shadow.radius,
+                offset: shadow.offset
+            )
+        }
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        #endif
+    }
+
+    private func updateProperties(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) {
+        let properties = state.pointee.properties
+        definition.setIgnoresEvents(
+            properties.contains(.ignoresEvents),
+            of: viewInfo.view
+        )
+        #if canImport(QuartzCore)
+        // TODO: Add CALayerDisableUpdateMask enum in the future
+        viewLayer(viewInfo.view).disableUpdateMask = properties.contains(.screencaptureProhibited) ? 0x12 : 0
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        #endif
+    }
+
+    private func updateClipShapesAsync(
+        asyncLayer: inout DisplayList.ViewUpdater.AsyncLayer,
+        oldState: UnsafePointer<DisplayList.ViewUpdater.Model.State>,
+        newState: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) -> Bool {
+        _openSwiftUIUnimplementedFailure()
+    }
+
+    private func updateGeometryAsync(
+        asyncLayer: inout DisplayList.ViewUpdater.AsyncLayer,
+        oldItem: DisplayList.Item,
+        oldSize: CGSize,
+        oldState: UnsafePointer<DisplayList.ViewUpdater.Model.State>,
+        newItem: DisplayList.Item,
+        newSize: CGSize,
+        newState: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) -> Bool? {
+        _openSwiftUIUnimplementedFailure()
+    }
+
+    private func updateShadowAsync(
+        asyncLayer: inout DisplayList.ViewUpdater.AsyncLayer,
+        oldState: UnsafePointer<DisplayList.ViewUpdater.Model.State>,
+        oldItem: DisplayList.Item,
+        newState: UnsafePointer<DisplayList.ViewUpdater.Model.State>,
+        newItem: DisplayList.Item,
+        boundsChanged: Bool
+    ) -> Bool {
+        _openSwiftUIUnimplementedFailure()
+    }
 
     func updateDrawingView(
         _ drawingView: inout AnyObject,
@@ -133,9 +1120,123 @@ extension DisplayList.ViewUpdater.Platform {
         return drawable
     }
 
-    // TODO:
-    // private func updateDrawingView
-    // private func updateDrawingViewAsync
+    // TBA
+    @inline(__always)
+    private func updateContentView(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        content: DisplayList.Content,
+        item: DisplayList.Item,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) {
+        switch content.value {
+        case let .color(resolved):
+            #if canImport(QuartzCore)
+            let cgColor = resolved.cgColor
+            viewLayer(viewInfo.view).backgroundColor = cgColor
+            #else
+            _openSwiftUIPlatformUnimplementedWarning()
+            #endif
+        case .backdrop, .chameleonColor, .image, .shadow, .view, .placeholder:
+            break
+        case let .shape(path, _, _):
+            definition.setPath(path, shapeView: viewInfo.view)
+        case let .platformView(factory):
+            var view = viewInfo.view
+            factory.updatePlatformView(&view)
+            updateViewReference(&viewInfo, view: view, kind: .platformView)
+        case let .platformLayer(factory):
+            #if canImport(QuartzCore)
+            if let layer = viewInfo.view as? CALayer {
+                factory.updatePlatformLayer(layer)
+            }
+            #endif
+        case .text, .flattened, .drawing:
+            updateDrawingContent(&viewInfo, content: content, item: item, state: state)
+        }
+    }
+
+    // TBA
+    @inline(__always)
+    private func updateEffectView(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        effect: DisplayList.Effect,
+        item: DisplayList.Item,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) {
+        switch effect {
+        case let .transform(transform):
+            if case let .projection(projectionTransform) = transform {
+                definition.setProjectionTransform(
+                    projectionTransform,
+                    projectionView: viewInfo.view
+                )
+            }
+        case let .platformGroup(factory):
+            var view = viewInfo.view
+            factory.updatePlatformGroup(&view)
+            updateViewReference(&viewInfo, view: view, kind: .platformGroup)
+            viewInfo.container = factory.platformGroupContainer(viewInfo.view)
+        case .identity, .geometryGroup, .compositingGroup, .backdropGroup, .archive,
+             .properties, .opacity, .blendMode, .clip, .mask, .filter, .animation,
+             .contentTransition, .view, .accessibility, .platform, .state,
+             .interpolatorRoot, .interpolatorLayer, .interpolatorAnimation:
+            break
+        }
+    }
+
+    // TBA
+    @inline(__always)
+    private func updateDrawingContent(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        content: DisplayList.Content,
+        item: DisplayList.Item,
+        state: UnsafePointer<DisplayList.ViewUpdater.Model.State>
+    ) {
+        _openSwiftUIUnimplementedFailure()
+//        let contentsScale = state.pointee.globals.pointee.environment.contentsScale
+//        let options = drawingOptions(for: content, state: state)
+//        var view = viewInfo.view
+//        let drawable = updateDrawingView(
+//            &view,
+//            options: options,
+//            contentsScale: contentsScale
+//        )
+//        updateViewReference(&viewInfo, view: view, kind: .drawing)
+//        var drawableContent = PlatformDrawableContent()
+//        switch content.value {
+//        case let .flattened(list, offset, _):
+//            drawableContent.storage = .displayList(
+//                list,
+//                offset,
+//                state.pointee.globals.pointee.time
+//            )
+//        case let .drawing(contents, offset, _):
+//            drawableContent.storage = .rbDisplayList(contents, offset)
+//        case .text:
+//            drawableContent.storage = .empty
+//        default:
+//            return
+//        }
+//        _ = drawable.update(
+//            content: drawableContent,
+//            required: item.features.contains(.required)
+//        )
+    }
+
+    // TBA
+    @inline(__always)
+    private func updateViewReference(
+        _ viewInfo: inout DisplayList.ViewUpdater.ViewInfo,
+        view: AnyObject,
+        kind: PlatformViewDefinition.ViewKind
+    ) {
+        guard viewInfo.view !== view else {
+            return
+        }
+        viewInfo.view = view
+        viewInfo.container = view
+        viewInfo.reset(platform: self)
+    }
 
     func forEachChild(
         of viewInfo: DisplayList.ViewUpdater.ViewInfo,
@@ -144,13 +1245,13 @@ extension DisplayList.ViewUpdater.Platform {
         #if canImport(Darwin)
         let kind = viewInfo.state.kind
         if kind.isContainer {
-            for subview in CoreViewSubviews(system: viewSystem, view: viewInfo.container) {
-                body(subview as AnyObject)
+            for subview in subviews(viewInfo.container) {
+                body(subview)
             }
         }
         if kind == .mask,
-           let maskView = CoreViewMaskView(system: viewSystem, view: viewInfo.view) {
-            for subview in CoreViewSubviews(system: viewSystem, view: maskView) {
+           let maskView = maskView(viewInfo.view) {
+            for subview in subviews(maskView) {
                 body(subview as AnyObject)
             }
         }
@@ -181,3 +1282,34 @@ extension DisplayList.GraphicsRenderer {
         #endif
     }
 }
+
+// MARK: - GraphicsFilter + Platform Filters
+
+extension [GraphicsFilter] {
+    fileprivate mutating func popColorMultiply(
+        drawable: @autoclosure () -> PlatformDrawable?
+    ) -> Color.Resolved? {
+        guard case let .colorMultiply(color) = last,
+              let drawable = drawable(),
+              type(of: drawable).allowsContentsMultiplyColor
+        else {
+            return nil
+        }
+        removeLast()
+        return color
+    }
+
+    @inline(__always)
+    func caFilters() -> [Any]? {
+        // _CAFilterArrayAppend + makeCAFilter
+        _openSwiftUIUnimplementedWarning()
+        return nil
+    }
+}
+
+//extension GraphicsFilter {
+//    // 07401C2C9845FAA2984B0D65D34F2B64
+//    fileprivate func makeCAFilter() -> CAFilter? {
+//        _openSwiftUIUnimplementedFailure()
+//    }
+//}
diff --git a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewRenderer.swift b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewRenderer.swift
index b3ebcace6..556403f10 100644
--- a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewRenderer.swift
+++ b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewRenderer.swift
@@ -256,16 +256,7 @@ extension DisplayList {
             self.options = options
             self.renderer = DisplayList.GraphicsRenderer(platformViewMode: options.drawsPlatformViews ? .rendered(update: true) : .unsupported)
             self.drawingView = platform.definition.makeDrawingView(options: .init(base: .init(options)))
-            #if canImport(Darwin)
-            CoreViewAddSubview(
-                system: platform.viewSystem,
-                parent: rootView,
-                child: drawingView!,
-                index: 0
-            )
-            #else
-            _openSwiftUIPlatformUnimplementedWarning()
-            #endif
+            platform.addSubview(drawingView!, to: rootView, at: 0)
         }
 
         var exportedObject: AnyObject? {
@@ -288,17 +279,10 @@ extension DisplayList {
                 lastContentsScale = contentsScale
                 seed = .init()
             }
-            #if canImport(Darwin)
-            let drawingViewFrame = drawingView!.frame
-            if let rootViewBounds = rootView.bounds, drawingViewFrame != rootViewBounds {
-                CoreViewSetFrame(
-                    system: platform.viewSystem,
-                    view: drawingView!,
-                    frame: rootView.bounds!
-                )
+            if platform.frame(of: drawingView!) != platform.bounds(of: rootView) {
+                platform.setFrame(platform.bounds(of: rootView)!, of: drawingView!)
                 seed = .init()
             }
-            #endif
             let newSeed = DisplayList.Seed(version)
             if newSeed == seed, renderer.nextTime >= time {
                 return renderer.nextTime
@@ -352,14 +336,7 @@ extension DisplayList {
         }
 
         func destroy(rootView: AnyObject) {
-            #if canImport(Darwin)
-            CoreViewRemoveFromSuperview(
-                system: platform.viewSystem,
-                view: drawingView!
-            )
-            #else
-            _openSwiftUIPlatformUnimplementedWarning()
-            #endif
+            platform.removeFromSuperview(drawingView!)
         }
 
         var viewCacheIsEmpty: Bool {
diff --git a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewUpdater.swift b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewUpdater.swift
index 7ec92cae6..8a2040ebf 100644
--- a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewUpdater.swift
+++ b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayListViewUpdater.swift
@@ -2,17 +2,22 @@
 //  DisplayListViewUpdater.swift
 //  OpenSwiftUICore
 //
-//  Audited for 6.0.87
-//  Status: WIP
+//  Audited for 6.5.4
+//  Status: Complete
 //  ID: B86250B2E056EB47628ECF46032DFA4C (SwiftUICore)
 
-private var printTree: Bool?
-
 import Foundation
+import OpenSwiftUI_SPI
 import OpenQuartzCoreShims
+#if canImport(QuartzCore)
+import QuartzCore_Private
+#endif
+
+// MARK: - DisplayList.ViewUpdater
+
+private var printTree: Bool?
 
 extension DisplayList {
-    // FIXME
     final package class ViewUpdater: ViewRendererBase {
         weak var host: (any ViewRendererHost)?
         var viewCache: DisplayList.ViewUpdater.ViewCache
@@ -38,6 +43,14 @@ extension DisplayList {
             self.wasValid = false
         }
         
+        var platform: Platform {
+            viewCache.platform
+        }
+
+        var exportedObject: AnyObject? {
+            nil
+        }
+        
         func render(
             rootView: AnyObject,
             from list: DisplayList,
@@ -46,33 +59,75 @@ extension DisplayList {
             maxVersion: DisplayList.Version,
             environment: DisplayList.ViewRenderer.Environment
         ) -> Time {
-            viewCache.clearAsyncValues()
+            if environment != lastEnv {
+                lastEnv = environment
+                isValid = false
+                viewCache.invalidateAll()
+                seed = .init()
+            }
+            if isValid, DisplayList.Seed(version) == seed, nextUpdate >= time {
+                return nextUpdate
+            }
+            #if canImport(QuartzCore)
+            if lastTime == .zero {
+                let layer = platform.viewLayer(rootView)
+                layer.allowsGroupOpacity = false
+                layer.allowsGroupBlending = false
+            }
+            #endif
+            let newSeed = DisplayList.Seed(version)
+            seed = newSeed
+            asyncSeed = newSeed
+            wasValid = isValid
+            isValid = true
+            lastList = list
+            lastTime = time
             if printTree == nil {
                 printTree = ProcessEnvironment.bool(forKey: "OPENSWIFTUI_PRINT_TREE")
             }
             if let printTree, printTree {
                 print("View \(Unmanaged.passUnretained(rootView).toOpaque()) at \(time):\n\(list.description)")
             }
-
-            let newSeed = DisplayList.Seed(version)
-            let seedChanged = newSeed != seed
-            let envChanged = environment != lastEnv
-
-            wasValid = isValid
-
-            if seedChanged || envChanged || !isValid {
-                // TODO: Walk display list items and create/update platform views
+            let globals = Model.State.Globals(
+                updater: self,
+                time: time,
+                maxVersion: maxVersion,
+                environment: lastEnv
+            )
+            return withUnsafePointer(to: globals) { globalsPtr in
+                let parentState = Model.State(globals: globalsPtr)
+                viewCache.index = .init()
                 viewCache.currentList = list
-                seed = newSeed
-                lastEnv = environment
-                isValid = true
+                viewCache.clearAsyncValues()
+                #if canImport(QuartzCore)
+                let layer = platform.viewLayer(rootView)
+                let needsLayoutOnGeometryChange = layer.needsLayoutOnGeometryChange
+                layer.needsLayoutOnGeometryChange = false
+                #endif
+                var container = Container(rootView: rootView, platform: viewCache.platform)
+                withUnsafePointer(to: parentState) { parentStatePtr in
+                    update(
+                        container: &container,
+                        from: list,
+                        parentState: parentStatePtr
+                    )
+                }
+                container.removeRemaining(viewCache: &viewCache)
+                viewCache.reclaim(time: time)
+                viewCache.currentList = DisplayList()
+                if !isValid {
+                    container.nextTime = time
+                }
+                if let host, let observer = host.as(ViewGraphRenderObserver.self) {
+                    observer.didRender()
+                }
+                let nextTime = container.nextTime
+                nextUpdate = nextTime
+                #if canImport(QuartzCore)
+                layer.needsLayoutOnGeometryChange = needsLayoutOnGeometryChange
+                #endif
+                return nextTime
             }
-
-            lastList = list
-            lastTime = time
-            nextUpdate = .infinity
-
-            return nextUpdate
         }
         
         func renderAsync(
@@ -82,124 +137,543 @@ extension DisplayList {
             version: DisplayList.Version,
             maxVersion: DisplayList.Version
         ) -> Time? {
-            // Phase 1: Version hash early return
-            let newAsyncSeed = DisplayList.Seed(version)
-            if newAsyncSeed == asyncSeed, lastTime >= time {
+            if isValid, DisplayList.Seed(version) == asyncSeed, nextUpdate >= time {
                 return nextUpdate
             }
-
-            // Phase 2: Debug print
             if printTree == nil {
                 printTree = ProcessEnvironment.bool(forKey: "OPENSWIFTUI_PRINT_TREE")
             }
             if let printTree, printTree {
                 print("Async view at \(time):\n\(list.description)")
             }
-
-            // Phase 3: Save state and call updateAsync
-            wasValid = isValid
-            let oldList = viewCache.currentList
-
-            guard let resultTime = updateAsync(oldList: oldList, newList: list) else {
-                // Cancelled: rollback
-                isValid = wasValid
-                return nil
+            let newGlobals = Model.State.Globals(
+                updater: self,
+                time: time,
+                maxVersion: maxVersion,
+                environment: lastEnv
+            )
+            let oldGlobals = Model.State.Globals(
+                updater: self,
+                time: lastTime,
+                maxVersion: maxVersion,
+                environment: lastEnv
+            )
+            return withUnsafePointer(to: newGlobals) { newGlobalsPtr in
+                withUnsafePointer(to: oldGlobals) { oldGlobalsPtr in
+                    let oldParentState = Model.State(globals: oldGlobalsPtr)
+                    let newParentState = Model.State(globals: newGlobalsPtr)
+                    viewCache.index = .init()
+                    wasValid = isValid
+                    isValid = true
+                    let oldList = lastList
+                    let resultTime = withUnsafePointer(to: oldParentState) { oldParentStatePtr in
+                        withUnsafePointer(to: newParentState) { newParentStatePtr in
+                            updateAsync(
+                                oldList: oldList,
+                                oldParentState: oldParentStatePtr,
+                                newList: list,
+                                newParentState: newParentStatePtr
+                            )
+                        }
+                    }
+                    guard let resultTime else {
+                        viewCache.clearPendingAsyncValues()
+                        isValid = wasValid
+                        return nil
+                    }
+                    viewCache.commitAsyncValues(targetTimestamp: targetTimestamp)
+                    lastList = list
+                    lastTime = time
+                    asyncSeed = seed
+                    nextUpdate = resultTime
+                    return resultTime
+                }
             }
-
-            // Phase 4: Commit
-            viewCache.commitAsyncValues(targetTimestamp: targetTimestamp)
-            viewCache.currentList = list
-            asyncSeed = newAsyncSeed
-            lastTime = time
-            nextUpdate = resultTime
-            isValid = true
-
-            return resultTime
         }
-
-        private func updateAsync(oldList: DisplayList, newList: DisplayList) -> Time? {
-            let oldItems = oldList.items
-            let newItems = newList.items
-            guard oldItems.count == newItems.count else {
+        
+        func destroy(rootView: AnyObject) {
+            var container = Container(rootView: rootView, platform: viewCache.platform)
+            container.removeRemaining(viewCache: &viewCache)
+            viewCache.reclaim(time: .infinity)
+        }
+        
+        var viewCacheIsEmpty: Bool {
+            viewCache.map.isEmpty
+        }
+        
+        private func update(
+            container: inout Container,
+            from list: DisplayList,
+            parentState: UnsafePointer<Model.State>
+        ) {
+            guard !list.items.isEmpty else {
+                return
+            }
+            for var item in list.items {
+                let savedIndex = viewCache.index.enter(identity: item.identity)
+                defer { viewCache.index.leave(index: savedIndex) }
+                let nextTime = viewCache.prepare(item: &item, parentState: parentState)
+                container.nextTime = min(container.nextTime, nextTime)
+                updateInheritedView(
+                    container: &container,
+                    from: item,
+                    parentState: parentState
+                )
+            }
+        }
+        
+        private func updateAsync(
+            oldList: DisplayList,
+            oldParentState: UnsafePointer<Model.State>,
+            newList: DisplayList,
+            newParentState: UnsafePointer<Model.State>
+        ) -> Time? {
+            guard oldList.items.count == newList.items.count else {
                 return nil
             }
-
+            guard !oldList.items.isEmpty else {
+                return .infinity
+            }
             var nextTime: Time = .infinity
-
-            for i in 0 ..< oldItems.count {
-                let oldItem = oldItems[i]
-                let newItem = newItems[i]
-
+            for index in oldList.items.indices {
+                var oldItem = oldList.items[index]
+                var newItem = newList.items[index]
+                guard oldItem.identity == newItem.identity else {
+                    return nil
+                }
                 guard oldItem.matchesTopLevelStructure(of: newItem) else {
                     return nil
                 }
+                let savedIndex = viewCache.index.enter(identity: newItem.identity)
+                defer { viewCache.index.leave(index: savedIndex) }
+                let oldNextTime = viewCache.prepare(
+                    item: &oldItem,
+                    parentState: oldParentState
+                )
+                let newNextTime = viewCache.prepare(
+                    item: &newItem,
+                    parentState: newParentState
+                )
+                guard let childNextTime = updateInheritedViewAsync(
+                    oldItem: oldItem,
+                    oldParentState: oldParentState,
+                    newItem: newItem,
+                    newParentState: newParentState
+                ) else {
+                    return nil
+                }
+                nextTime = min(nextTime, oldNextTime, newNextTime, childNextTime)
+            }
+            return nextTime
+        }
 
-                switch (oldItem.value, newItem.value) {
-                case let (.effect(_, oldChild), .effect(_, newChild)):
-                    guard let childTime = updateAsync(oldList: oldChild, newList: newChild) else {
-                        return nil
+        private func updateInheritedView(
+            container: inout Container,
+            from item: DisplayList.Item,
+            parentState: UnsafePointer<Model.State>
+        ) {
+            var item = item
+            var state = parentState.pointee
+            let requirements = Model.merge(
+                item: &item,
+                index: viewCache.index,
+                into: &state
+            )
+            guard requirements.contains(.visibleContent) || item.features.contains(.required) else {
+                if case let .effect(_, list) = item.value {
+                    viewCache.index.skip(list: list)
+                }
+                return
+            }
+            if requirements.contains(.inheritedView) {
+                var result = withUnsafePointer(to: state) { statePtr in
+                    viewCache.update(
+                        item: item,
+                        state: statePtr,
+                        tag: .inherited,
+                        in: container.id
+                    ) { [platform] _, item, state in
+                        // TODO: Optimize the call here in Platform
+                        var info = ViewInfo(platform: platform, kind: .inherited)
+                        platform.updateState(
+                            &info,
+                            item: item,
+                            size: item.size,
+                            state: state
+                        )
+                        return info
+                    } updateView: { [platform] info, _, item, state in
+                        // TODO: Optimize the call here in Platform
+                        platform.updateState(
+                            &info,
+                            item: item,
+                            size: item.size,
+                            state: state
+                        )
                     }
-                    nextTime = min(nextTime, childTime)
-                case let (.states(oldStates), .states(newStates)):
-                    guard oldStates.count == newStates.count else {
-                        return nil
+                }
+                isValid = isValid && result.isValid
+                container.platform.addSubview(
+                    result.view,
+                    to: container.rootView,
+                    at: container.count
+                )
+                container.count &+= 1
+                container.nextTime = min(container.nextTime, result.nextUpdate)
+                guard result.changed || !wasValid else {
+                    if case let .effect(effect, list) = item.value {
+                        viewCache.index.skip(list: list)
+                        viewCache.index.skip(effect: effect)
                     }
-                    for j in 0 ..< oldStates.count {
-                        let (oldHash, oldChild) = oldStates[j]
-                        let (newHash, newChild) = newStates[j]
-                        guard oldHash == newHash else {
-                            return nil
-                        }
-                        guard let stateTime = updateAsync(
-                            oldList: oldChild,
-                            newList: newChild
-                        ) else {
-                            return nil
+                    return
+                }
+                var childContainer = Container(
+                    rootView: result.container,
+                    platform: platform,
+                    id: result.id
+                )
+                if requirements.contains(.itemView) {
+                    updateItemView(
+                        container: &childContainer,
+                        from: item,
+                        localState: &state
+                    )
+                } else if case let .effect(_, list) = item.value {
+                    withUnsafePointer(to: state) { statePtr in
+                        update(
+                            container: &childContainer,
+                            from: list,
+                            parentState: statePtr
+                        )
+                    }
+                }
+                childContainer.removeRemaining(viewCache: &viewCache)
+                viewCache.setNextUpdate(childContainer.nextTime, in: &result)
+            } else if requirements.contains(.itemView) {
+                updateItemView(
+                    container: &container,
+                    from: item,
+                    localState: &state
+                )
+            } else if case let .effect(_, list) = item.value {
+                withUnsafePointer(to: state) { statePtr in
+                    update(
+                        container: &container,
+                        from: list,
+                        parentState: statePtr
+                    )
+                }
+            }
+        }
+
+        private func updateInheritedViewAsync(
+            oldItem: DisplayList.Item,
+            oldParentState: UnsafePointer<Model.State>,
+            newItem: DisplayList.Item,
+            newParentState: UnsafePointer<Model.State>
+        ) -> Time? {
+            var oldItem = oldItem
+            var oldState = oldParentState.pointee
+            let oldRequirements = Model.merge(
+                item: &oldItem,
+                index: viewCache.index,
+                into: &oldState
+            )
+            var newItem = newItem
+            var newState = newParentState.pointee
+            let newRequirements = Model.merge(
+                item: &newItem,
+                index: viewCache.index,
+                into: &newState
+            )
+            guard oldRequirements == newRequirements else {
+                return nil
+            }
+            if oldRequirements.contains(.inheritedView) {
+                let result = withUnsafePointer(to: oldState) { oldStatePtr in
+                    withUnsafePointer(to: newState) { newStatePtr in
+                        viewCache.updateAsync(
+                            oldItem: oldItem,
+                            oldState: oldStatePtr,
+                            newItem: newItem,
+                            newState: newStatePtr,
+                            tag: .inherited
+                        ) { layer, _, oldItem, oldState, newItem, newState in
+                            platform.updateStateAsync(
+                                layer: &layer,
+                                oldItem: oldItem,
+                                oldSize: oldItem.size,
+                                oldState: oldState,
+                                newItem: newItem,
+                                newSize: newItem.size,
+                                newState: newState
+                            )
                         }
-                        nextTime = min(nextTime, stateTime)
                     }
-                case (.content, .content):
-                    // TODO: updateItemViewAsync — leaf platform view property update
-                    if oldItem.version != newItem.version {
-                        // Content changed but structure same — would update platform view here
+                }
+                guard var result else {
+                    return nil
+                }
+                isValid = isValid && result.isValid
+                guard result.changed else {
+                    if case let .effect(_, list) = oldItem.value {
+                        viewCache.index.skip(list: list)
                     }
-                case (.empty, .empty):
-                    break
-                default:
-                    break
+                    return result.nextUpdate
                 }
+                guard let nextTime = updateRequiredContentAsync(
+                    oldItem: oldItem,
+                    oldState: &oldState,
+                    newItem: newItem,
+                    newState: &newState,
+                    requirements: oldRequirements
+                ) else {
+                    return nil
+                }
+                viewCache.setNextUpdate(nextTime, in: &result)
+                return result.nextUpdate
+            } else {
+                return updateRequiredContentAsync(
+                    oldItem: oldItem,
+                    oldState: &oldState,
+                    newItem: newItem,
+                    newState: &newState,
+                    requirements: oldRequirements
+                )
             }
-
-            return nextTime
         }
         
-        func destroy(rootView: AnyObject) {
-            isValid = false
-            wasValid = false
-            lastList = DisplayList()
-            lastEnv = .invalid
-            seed = DisplayList.Seed()
-            asyncSeed = DisplayList.Seed()
-            nextUpdate = .infinity
-            viewCache.currentList = DisplayList()
-            viewCache.pendingAsyncUpdates.removeAll()
+        private func updateRequiredContentAsync(
+            oldItem: DisplayList.Item,
+            oldState: inout Model.State,
+            newItem: DisplayList.Item,
+            newState: inout Model.State,
+            requirements: Model.MergedViewRequirements
+        ) -> Time? {
+            guard requirements.contains(.visibleContent) || newItem.features.contains(.required) else {
+                guard oldItem.features == newItem.features else {
+                    return nil
+                }
+                if case let .effect(effect, list) = oldItem.value {
+                    viewCache.index.skip(list: list)
+                    viewCache.index.skip(effect: effect)
+                }
+                return .infinity
+            }
+            guard requirements.contains(.itemView) else {
+                guard case let .effect(_, oldList) = oldItem.value,
+                      case let .effect(_, newList) = newItem.value
+                else {
+                    return .infinity
+                }
+                return updateAsync(
+                    oldList: oldList,
+                    oldParentState: &oldState,
+                    newList: newList,
+                    newParentState: &newState
+                )
+            }
+            return updateItemViewAsync(
+                oldItem: oldItem,
+                oldState: &oldState,
+                newItem: newItem,
+                newState: &newState
+            )
         }
         
-        var viewCacheIsEmpty: Bool {
-            viewCache.map.isEmpty
+        private func updateItemView(
+            container: inout Container,
+            from item: DisplayList.Item,
+            localState: inout Model.State
+        ) {
+            var result = viewCache.update(
+                item: item,
+                state: &localState,
+                tag: .item,
+                in: container.id
+            ) { [platform] index, item, state in
+                var info = platform._makeItemView(item: item, state: state)
+                platform.updateItemView(
+                    &info,
+                    index: index,
+                    item: item,
+                    state: state
+                )
+                return info
+            } updateView: { [platform] info, index, item, state in
+                platform.updateItemView(
+                    &info,
+                    index: index,
+                    item: item,
+                    state: state
+                )
+            }
+            isValid = isValid && result.isValid
+            container.platform.addSubview(
+                result.view,
+                to: container.rootView,
+                at: container.count
+            )
+            container.count &+= 1
+            container.nextTime = min(container.nextTime, result.nextUpdate)
+            guard case let .effect(effect, list) = item.value else {
+                return
+            }
+            guard result.changed || !wasValid else {
+                viewCache.index.skip(list: list)
+                if case let .mask(list, _) = effect {
+                    viewCache.index.skip(list: list)
+                }
+                return
+            }
+            localState.reset()
+            var childContainer = Container(
+                rootView: result.container,
+                platform: platform,
+                id: result.id
+            )
+            update(
+                container: &childContainer,
+                from: list,
+                parentState: &localState
+            )
+            childContainer.removeRemaining(viewCache: &viewCache)
+            var nextTime = childContainer.nextTime
+            if case let .mask(maskList, _) = effect,
+               let maskView = platform.maskView(result.view) {
+                var maskContainer = Container(
+                    rootView: maskView,
+                    platform: platform,
+                    id: result.id
+                )
+                update(
+                    container: &maskContainer,
+                    from: maskList,
+                    parentState: &localState
+                )
+                maskContainer.removeRemaining(viewCache: &viewCache)
+                nextTime = min(nextTime, maskContainer.nextTime)
+            }
+            viewCache.setNextUpdate(nextTime, in: &result)
+        }
+        
+        private func updateItemViewAsync(
+            oldItem: DisplayList.Item,
+            oldState: inout Model.State,
+            newItem: DisplayList.Item,
+            newState: inout Model.State
+        ) -> Time? {
+            let asyncResult = viewCache.updateAsync(
+                oldItem: oldItem,
+                oldState: &oldState,
+                newItem: newItem,
+                newState: &newState,
+                tag: .item
+            ) { [platform] layer, index, oldItem, oldState, newItem, newState in
+                platform.updateItemViewAsync(
+                    layer: &layer,
+                    index: index,
+                    oldItem: oldItem,
+                    oldState: oldState,
+                    newItem: newItem,
+                    newState: newState
+                )
+            }
+            guard var result = asyncResult else {
+                return nil
+            }
+            isValid = isValid && result.isValid
+            guard case let .effect(oldEffect, oldList) = oldItem.value,
+                  case let .effect(newEffect, newList) = newItem.value
+            else {
+                return result.nextUpdate
+            }
+            guard result.changed || !wasValid else {
+                if case let .mask(oldMaskList, _) = oldEffect {
+                    viewCache.index.skip(list: oldMaskList)
+                }
+                viewCache.index.skip(list: oldList)
+                return result.nextUpdate
+            }
+            oldState.reset()
+            newState.reset()
+            let childNextTime = updateAsync(
+                oldList: oldList,
+                oldParentState: &oldState,
+                newList: newList,
+                newParentState: &newState
+            )
+            guard var nextTime = childNextTime else {
+                return nil
+            }
+            if case let .mask(oldMaskList, _) = oldEffect,
+               case let .mask(newMaskList, _) = newEffect {
+                let maskNextTime = updateAsync(
+                    oldList: oldMaskList,
+                    oldParentState: &oldState,
+                    newList: newMaskList,
+                    newParentState: &newState
+                )
+                guard let maskNextTime else {
+                    return nil
+                }
+                nextTime = min(nextTime, maskNextTime)
+            }
+            viewCache.setNextUpdate(nextTime, in: &result)
+            return result.nextUpdate
         }
+    }
+}
 
-        var platform: Platform {
-            viewCache.platform
+// MARK: - DisplayList.ViewUpdater.Container
+
+extension DisplayList.ViewUpdater {
+    private struct Container {
+        var rootView: AnyObject
+        var platform: Platform
+        var id: ViewInfo.ID
+        var nextTime: Time
+        var count: Int
+
+        init(
+            rootView: AnyObject,
+            platform: Platform,
+            id: ViewInfo.ID = .init(value: 0),
+            nextTime: Time = .infinity,
+            count: Int = 0
+        ) {
+            self.rootView = rootView
+            self.platform = platform
+            self.id = id
+            self.nextTime = nextTime
+            self.count = count
         }
 
-        var exportedObject: AnyObject? {
-            // TODO
-            nil
+        mutating func removeRemaining(viewCache: inout ViewCache) {
+            let subviews = platform.subviews(rootView)
+            guard count < subviews.count else {
+                return
+            }
+            for index in (count..<subviews.count).reversed() {
+                let view = subviews[index]
+                let pointer = unsafeBitCast(view, to: OpaquePointer.self)
+                guard let key = viewCache.reverseMap[pointer] else {
+                    continue
+                }
+                var info = viewCache.map[key]!
+                if !info.isRemoved {
+                    info.isRemoved = true
+                    viewCache.map[key] = info
+                    viewCache.removed.insert(key)
+                }
+                platform.removeFromSuperview(view)
+            }
         }
     }
 }
 
+// MARK: - DisplayList.ViewUpdater.ViewInfo
+
 extension DisplayList.ViewUpdater {
     struct ViewInfo {
         struct Seeds {
@@ -214,6 +688,30 @@ extension DisplayList.ViewUpdater {
             var properties: DisplayList.Seed
             var platformSeeds: DisplayList.ViewUpdater.PlatformViewInfo.Seeds
 
+            init(_ seed: DisplayList.Seed = .init()) {
+                item = seed
+                content = seed
+                opacity = seed
+                blend = seed
+                transform = seed
+                clips = seed
+                filters = seed
+                shadow = seed
+                properties = .init()
+                platformSeeds = .init()
+            }
+
+            @inline(__always)
+            init(kind: PlatformViewDefinition.ViewKind) {
+                let seed: DisplayList.Seed = switch kind {
+                case .platformView, .platformGroup:
+                    .undefined
+                default:
+                    .init()
+                }
+                self.init(seed)
+            }
+
             mutating func invalidate() {
                 item.invalidate()
                 content.invalidate()
@@ -225,6 +723,11 @@ extension DisplayList.ViewUpdater {
                 shadow.invalidate()
                 properties.invalidate()
             }
+            
+            @inline(__always)
+            mutating func reset() {
+                self = .init()
+            }
         }
 
         struct ID: Equatable {
@@ -253,14 +756,9 @@ extension DisplayList.ViewUpdater {
             self.layer = layer
             self.container = container
             self.state = state
-            self.id = ID(value: 0)
-            self.parentID = ID(value: 0)
-            self.seeds = Seeds(
-                item: .init(), content: .init(), opacity: .init(),
-                blend: .init(), transform: .init(), clips: .init(),
-                filters: .init(), shadow: .init(), properties: .init(),
-                platformSeeds: .init()
-            )
+            self.id = ID(value: UniqueID().value)
+            self.parentID = ID(value: -1)
+            self.seeds = Seeds(kind: state.kind)
             self.cacheSeed = 0
             self.isRemoved = false
             self.isInvalid = false
@@ -271,84 +769,17 @@ extension DisplayList.ViewUpdater {
             platform: Platform,
             kind: PlatformViewDefinition.ViewKind
         ) {
-            _openSwiftUIUnimplementedFailure()
+            let view = platform.definition.makeView(kind: kind)
+            let layer = platform.viewLayer(view)
+            let state = Platform.State(kind: kind)
+            self.init(view: view, layer: layer, container: view, state: state)
         }
 
-        func reset() {
-            _openSwiftUIUnimplementedFailure()
-        }
-    }
-}
-
-// MARK: - DisplayList.ViewUpdater.Model [WIP]
-
-extension DisplayList.ViewUpdater {
-    enum Model {
-        struct Clip {
-            var path: Path
-            var transform: CGAffineTransform?
-            var style: FillStyle
-
-            var isEmpty: Bool {
-                // TODO
-                false
-            }
-        }
-
-        struct State {
-            struct Versions {
-                var opacity: DisplayList.Version
-                var blend: DisplayList.Version
-                var transform: DisplayList.Version
-                var clips: DisplayList.Version
-                var filters: DisplayList.Version
-                var shadow: DisplayList.Version
-                var properties: DisplayList.Version
-            }
-
-            struct Globals {
-                var updater: DisplayList.ViewUpdater
-                var time: Time
-                var maxVersion: DisplayList.Version
-                var environment: DisplayList.ViewRenderer.Environment
-            }
-
-            var globals: UnsafePointer<Globals>
-            var opacity: Float
-            var blend: GraphicsBlendMode
-            var transform: CGAffineTransform
-            var clips: [Clip]
-            var filters: [GraphicsFilter]
-            var shadow: Indirect<ResolvedShadowStyle>
-            var properties: DisplayList.Properties
-            var rewriteVibrantColorMatrix: Bool
-            var compositingGroup: Bool
-            var backdropGroupID: UInt32
-            var stateHashes: [StrongHash]
-            var platformState: PlatformState
-            var versions: Versions
-
-            var hasDODEffects: Bool {
-                // TODO
-                false
-            }
-
-            func reset() {
-                // TODO
-            }
-
-            func clipRect() -> FixedRoundedRect? {
-                // TODO
-                nil
-            }
-
-            func adjust(for transform: CGAffineTransform) {
-                // TODO
-            }
-
-            mutating func addClip(_ path: Path, style: FillStyle) {
-                // TODO
-            }
+        mutating func reset(platform: Platform) {
+            layer = platform.viewLayer(view)
+            seeds.reset()
+            state.reset()
+            nextUpdate = .infinity
         }
     }
 }
diff --git a/Sources/OpenSwiftUICore/Render/PlatformViewFactory.swift b/Sources/OpenSwiftUICore/Render/PlatformViewFactory.swift
index 78de96ec7..623210aec 100644
--- a/Sources/OpenSwiftUICore/Render/PlatformViewFactory.swift
+++ b/Sources/OpenSwiftUICore/Render/PlatformViewFactory.swift
@@ -6,9 +6,7 @@
 //  ID: 7A45621CE16223183E03CAC88E8C5E60 (SwiftUICore)
 
 package import Foundation
-#if canImport(QuartzCore)
-package import QuartzCore
-#endif
+package import OpenQuartzCoreShims
 
 // MARK: - AnyViewFactory
 
@@ -33,11 +31,9 @@ extension AnyViewFactory where Self: View {
 // MARK: - PlatformLayerFactory [TODO]
 
 package protocol PlatformLayerFactory: AnyViewFactory {
-    #if canImport(QuartzCore)
     var platformLayerType: CALayer.Type { get }
 
     func updatePlatformLayer(_ layer: CALayer)
-    #endif
 
     func renderPlatformLayer(
         in ctx: GraphicsContext,
@@ -198,9 +194,9 @@ package struct EmptyViewFactory: AnyViewFactory {
     }
 }
 
-#if canImport(QuartzCore)
 extension EmptyViewFactory: PlatformLayerFactory {
     private class MissingLayer: CALayer {
+        #if canImport(QuartzCore)
         required init?(coder: NSCoder) {
             super.init(coder: coder)
         }
@@ -227,6 +223,7 @@ extension EmptyViewFactory: PlatformLayerFactory {
             get { true }
             set {}
         }
+        #endif
     }
 
     package var platformLayerType: CALayer.Type {
@@ -245,7 +242,6 @@ extension EmptyViewFactory: PlatformLayerFactory {
         _openSwiftUIUnimplementedFailure()
     }
 }
-#endif
 
 extension EmptyViewFactory: PlatformViewFactory {
     package func makePlatformView() -> AnyObject? {
diff --git a/Sources/OpenSwiftUICore/Shape/MaskLayer.swift b/Sources/OpenSwiftUICore/Shape/MaskLayer.swift
new file mode 100644
index 000000000..fbafcbc53
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/MaskLayer.swift
@@ -0,0 +1,117 @@
+//
+//  MaskLayer.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: WIP (Async)
+//  ID: A60BC6C4EC21A2F308B4F151783AE2A3 (SwiftUICore)
+
+import Foundation
+import OpenQuartzCoreShims
+import OpenSwiftUI_SPI
+
+#if canImport(QuartzCore)
+
+// MARK: - MaskLayer
+
+final class MaskLayer: CAShapeLayer {
+    var clips: [DisplayList.ViewUpdater.Model.Clip] = []
+    var clipTransform: CGAffineTransform = .init()
+
+    override init() {
+        super.init()
+    }
+
+    override init(layer: Any) {
+        super.init(layer: layer)
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+    }
+
+    func setClips(_ clips: [DisplayList.ViewUpdater.Model.Clip], transform: CGAffineTransform) {
+        self.clips = clips
+        clipTransform = transform
+        switch clips.count {
+        case 0:
+            path = nil
+            sublayers = []
+        case 1:
+            Self.update(layer: self, clip: clips[0], transform: transform)
+            sublayers = []
+        default:
+            path = nil
+            var newSublayers = sublayers ?? []
+            var sublayersChanged = false
+            for (index, clip) in clips.enumerated() {
+                let layer: CAShapeLayer
+                if index < newSublayers.count {
+                    layer = newSublayers[index] as! CAShapeLayer
+                } else {
+                    layer = CAShapeLayer()
+                    layer.anchorPoint = .zero
+                    layer.setNoAnimationDelegate()
+                    newSublayers.append(layer)
+                    sublayersChanged = true
+                }
+                Self.update(layer: layer, clip: clip, transform: transform)
+                layer.compositingFilter = index == 0 ? nil : "sourceIn"
+            }
+            if newSublayers.count > clips.count {
+                newSublayers.removeSubrange(clips.count..<newSublayers.count)
+                sublayersChanged = true
+            }
+            if sublayersChanged {
+                sublayers = newSublayers
+            }
+        }
+    }
+
+    private static func update(
+        layer: CAShapeLayer,
+        clip: DisplayList.ViewUpdater.Model.Clip,
+        transform: CGAffineTransform
+    ) {
+        let shapeType = ShapeType(clip.path)
+        let position: CGPoint
+        switch shapeType {
+        case let .rect(rect, radius, style):
+            position = rect.origin
+            layer.position = rect.origin
+            layer.bounds = CGRect(origin: .zero, size: rect.size)
+            layer.path = nil
+            layer.cornerRadius = radius
+            layer.cornerCurve = style == .continuous ? .continuous : .circular
+            layer.borderWidth = 0
+            layer.backgroundColor = layer.borderColor
+        case let .rectBorder(rect, radius, style, lineWidth):
+            position = rect.origin
+            layer.position = rect.origin
+            layer.bounds = CGRect(origin: .zero, size: rect.size)
+            layer.path = nil
+            layer.cornerRadius = radius
+            layer.cornerCurve = style == .continuous ? .continuous : .circular
+            layer.borderWidth = lineWidth
+            layer.backgroundColor = nil
+        case .strokedPath, .other:
+            position = .zero
+            layer.position = .zero
+            layer.borderWidth = 0
+            layer.backgroundColor = nil
+            layer.path = clip.path.cgPath
+            layer.fillRule = clip.style.isEOFilled ? .evenOdd : .nonZero
+        case .empty:
+            position = .zero
+            layer.path = nil
+            layer.borderWidth = 0
+            layer.backgroundColor = nil
+        }
+        var finalTransform = clip.transform.map { $0.concatenating(transform) } ?? transform
+        finalTransform.tx += position.x * finalTransform.a + position.y * finalTransform.c - position.x
+        finalTransform.ty += position.x * finalTransform.b + position.y * finalTransform.d - position.y
+        layer.setAffineTransform(finalTransform)
+    }
+}
+
+#endif
diff --git a/Sources/OpenSwiftUICore/Shape/Path.swift b/Sources/OpenSwiftUICore/Shape/Path.swift
index 790e37720..459a44526 100644
--- a/Sources/OpenSwiftUICore/Shape/Path.swift
+++ b/Sources/OpenSwiftUICore/Shape/Path.swift
@@ -161,6 +161,26 @@ public struct Path: Equatable, LosslessStringConvertible, @unchecked Sendable {
                 return ORBPath(storage: storage, callbacks: Self.bufferCallbacks)
             }
         }
+        
+        @inline(__always)
+        fileprivate var boundingRect: CGRect {
+            switch kind {
+            case .cgPath:
+                #if canImport(CoreGraphics)
+                return data.cgPath.takeUnretainedValue().boundingBoxOfPath
+                #else
+                _openSwiftUIPlatformUnimplementedWarning()
+                return .zero
+                #endif
+            case .rbPath:
+                _openSwiftUIUnimplementedWarning()
+                // return data.rbPath.boundingBox // FIXME: RB API
+                return .zero
+            case .buffer:
+                let storage = unsafeBitCast(self, to: ORBPath.Storage.self)
+                return storage.boundingRect
+            }
+        }
 
         @inline(__always)
         fileprivate func retainRBPath() -> ORBPath {
@@ -451,7 +471,20 @@ public struct Path: Equatable, LosslessStringConvertible, @unchecked Sendable {
 
     /// A Boolean value indicating whether the path contains zero elements.
     public var isEmpty: Bool {
-        _openSwiftUIUnimplementedFailure()
+        switch storage {
+        case .empty:
+            true
+        case let .rect(rect):
+            rect.isNull
+        case let .ellipse(rect):
+            rect.isNull
+        case let .roundedRect(fixedRoundedRect):
+            fixedRoundedRect.rect.isNull
+        case .stroked, .trimmed:
+            _openSwiftUIUnreachableCode()
+        case let .path(pathBox):
+            pathBox.rbPath.isEmpty
+        }
     }
 
     /// A rectangle containing all path segments.
@@ -460,7 +493,20 @@ public struct Path: Equatable, LosslessStringConvertible, @unchecked Sendable {
     /// in the path but not including control points for Bézier
     /// curves.
     public var boundingRect: CGRect {
-        _openSwiftUIUnimplementedFailure()
+        switch storage {
+        case .empty:
+            .null
+        case let .rect(rect):
+            rect
+        case let .ellipse(rect):
+            rect
+        case let .roundedRect(fixedRoundedRect):
+            fixedRoundedRect.rect
+        case .stroked, .trimmed:
+            _openSwiftUIUnreachableCode()
+        case let .path(pathBox):
+            pathBox.boundingRect
+        }
     }
 
     /// Returns true if the path contains a specified point.
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeLayer.swift b/Sources/OpenSwiftUICore/Shape/ShapeLayer.swift
new file mode 100644
index 000000000..30a962bbf
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeLayer.swift
@@ -0,0 +1,203 @@
+//
+//  ShapeLayer.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: WIP
+//  ID: E19F490D25D5E0EC8A24903AF958E341 (SwiftUICore)
+
+import Foundation
+import OpenQuartzCoreShims
+import OpenSwiftUI_SPI
+// import OpenRenderBoxShims
+
+// MARK: - ShapeLayerHelper [WIP]
+
+struct ShapeLayerHelper: ResolvedPaintVisitor {
+    struct Visitor: ResolvedPaintVisitor {
+        var shapeType: ShapeType
+        var mayClip: Bool
+        var requiredType: CALayer.Type?
+
+        mutating func visitPaint<P>(_ paint: P) where P: ResolvedPaint {
+            _openSwiftUIUnimplementedFailure()
+        }
+    }
+
+    var layer: CALayer
+    var layerType: CALayer.Type
+    var path: Path
+    var origin: CGPoint
+    var paint: AnyResolvedPaint
+    var paintBounds: CGRect
+    var style: FillStyle
+    var contentsScale: CGFloat
+    var mayClip: Bool
+
+    mutating func visitPaint<P>(_ paint: P) where P: ResolvedPaint {
+        _openSwiftUIUnimplementedFailure()
+    }
+
+    static func makeLayerBounds(
+        size: CGSize,
+        path: Path,
+        layerType: CALayer.Type,
+        contentsScale: CGFloat
+    ) -> CGRect {
+        _openSwiftUIUnimplementedFailure()
+    }
+}
+
+// MARK: - ShapeLayerShadowHelper [WIP]
+
+struct ShapeLayerShadowHelper: ResolvedPaintVisitor {
+    var platform: DisplayList.ViewUpdater.Platform
+    var layer: CALayer
+    var path: Path
+    var offset: CGPoint
+    var shadow: ResolvedShadowStyle
+    var updateShape: Bool
+
+    mutating func visitPaint<P>(_ paint: P) where P: ResolvedPaint {
+        _openSwiftUIUnimplementedFailure()
+    }
+}
+
+// MARK: - Async Shape Helpers
+
+private struct ShapeLayerAsyncHelper: ResolvedPaintVisitor {
+    var layer: UnsafeMutablePointer<DisplayList.ViewUpdater.AsyncLayer>
+    var old: UnsafeMutablePointer<ShapeLayerHelper>
+    var new: UnsafeMutablePointer<ShapeLayerHelper>
+    var result: Bool
+
+    mutating func visitPaint<P>(_ paint: P) where P: ResolvedPaint {
+        _openSwiftUIUnimplementedFailure()
+    }
+}
+
+private struct ShapeLayerAsyncShadowHelper: ResolvedPaintVisitor {
+    var layer: UnsafeMutablePointer<DisplayList.ViewUpdater.AsyncLayer>
+    var old: UnsafeMutablePointer<ShapeLayerShadowHelper>
+    var new: UnsafeMutablePointer<ShapeLayerShadowHelper>
+    var newPaint: AnyResolvedPaint
+    var result: Bool
+
+    mutating func visitPaint<P>(_ paint: P) where P: ResolvedPaint {
+        _openSwiftUIUnimplementedFailure()
+    }
+}
+
+// FIXME: ShapeLayerShadowHelper & ShapeLayerAsyncShadowHelper
+
+extension DisplayList.ViewUpdater.AsyncLayer {
+    @discardableResult
+    mutating func updateShadowStyle(
+        oldShadow: ResolvedShadowStyle?,
+        newShadow: ResolvedShadowStyle?
+    ) -> Bool {
+        switch (oldShadow, newShadow) {
+        case (nil, nil):
+            return true
+        case let (oldShadow?, newShadow?):
+            guard oldShadow.kind == newShadow.kind else {
+                return false
+            }
+            update(ShadowOffsetProperty.self, from: oldShadow.offset, to: newShadow.offset)
+            update(ShadowRadiusProperty.self, from: oldShadow.radius, to: newShadow.radius)
+            update(ShadowColorProperty.self, from: oldShadow.color, to: newShadow.color)
+            return !isInvalid
+        default:
+            return false
+        }
+    }
+
+    private mutating func update<P>(
+        _ property: P.Type,
+        from oldValue: P.Value,
+        to newValue: P.Value
+    ) where P: Property, P.Value: Equatable {
+        guard oldValue != newValue else {
+            return
+        }
+        setValue(newValue, for: property)
+    }
+
+    private mutating func setValue<P>(
+        _ value: P.Value,
+        for property: P.Type
+    ) where P: Property {
+        guard !isInvalid else {
+            return
+        }
+        cache.pointee.setAsyncValue(
+            P.boxValue(value),
+            for: P.keyPath,
+            in: layer,
+            usingPresentationModifier: P.supportsPresentationModifier
+        )
+    }
+}
+
+private struct ShadowColorProperty: DisplayList.ViewUpdater.AsyncLayer.Property {
+    static let keyPath = "shadowColor"
+
+    static func boxValue(_ value: Color.Resolved) -> NSObject {
+        #if canImport(Darwin)
+        return value.cgColor as! NSObject
+        #else
+        return NSObject()
+        #endif
+    }
+}
+
+private struct ShadowRadiusProperty: DisplayList.ViewUpdater.AsyncLayer.Property {
+    static let keyPath = "shadowRadius"
+
+    static func boxValue(_ value: CGFloat) -> NSObject {
+        NSNumber(value: Double(value))
+    }
+}
+
+private struct ShadowOffsetProperty: DisplayList.ViewUpdater.AsyncLayer.Property {
+    static let keyPath = "shadowOffset"
+
+    static func boxValue(_ value: CGSize) -> NSObject {
+        #if canImport(Darwin)
+//        return NSValue(size: value)
+        // FIXME
+        return NSObject()
+        #else
+        return NSObject()
+        #endif
+    }
+}
+
+// MARK: - ShapeType [WIP]
+
+enum ShapeType {
+    case rect(CGRect, radius: CGFloat, style: RoundedCornerStyle)
+    case rectBorder(CGRect, radius: CGFloat, style: RoundedCornerStyle, lineWidth: CGFloat)
+    case strokedPath(Path, style: StrokeStyle)
+    case empty
+    case other
+
+    init(_ path: Path) {
+        _openSwiftUIUnimplementedFailure()
+    }
+
+//    private func initFromFilled(
+//        type: ORBPathShapeType,
+//        shape: UnsafePointer<ORBPathShape>
+//    ) {
+//        _openSwiftUIUnimplementedFailure()
+//    }
+//
+//    private func initFromStroked(
+//        type: ORBPathShapeType,
+//        shape: UnsafePointer<ORBPathShape>,
+//        style: StrokeStyle
+//    ) {
+//        _openSwiftUIUnimplementedFailure()
+//    }
+}
diff --git a/Sources/OpenSwiftUICore/Util/Extension/CGRect+Extension.swift b/Sources/OpenSwiftUICore/Util/Extension/CGRect+Extension.swift
index 2beaa93b1..29d292ccd 100644
--- a/Sources/OpenSwiftUICore/Util/Extension/CGRect+Extension.swift
+++ b/Sources/OpenSwiftUICore/Util/Extension/CGRect+Extension.swift
@@ -49,6 +49,12 @@ extension CGRect {
     package var isFinite: Bool {
         x.isFinite && y.isFinite && width.isFinite && height.isFinite
     }
+
+    @inline(__always)
+    package func approximates(_ other: CGRect, epsilon: CGFloat) -> Bool {
+        origin.approximates(other.origin, epsilon: epsilon)
+        && size.approximates(other.size, epsilon: epsilon)
+    }
     
     @inlinable
     package func flushNullToZero() -> CGRect {
diff --git a/Sources/OpenSwiftUICore/Util/Extension/CGSize+Extension.swift b/Sources/OpenSwiftUICore/Util/Extension/CGSize+Extension.swift
index 6a7141f02..29e5811e9 100644
--- a/Sources/OpenSwiftUICore/Util/Extension/CGSize+Extension.swift
+++ b/Sources/OpenSwiftUICore/Util/Extension/CGSize+Extension.swift
@@ -113,6 +113,11 @@ extension CGSize {
 }
 
 extension CGSize {
+    @inlinable
+    package static var infinity: CGSize {
+        CGSize(width: CGFloat.infinity, height: CGFloat.infinity)
+    }
+    
     package static let invalidValue: CGSize = CGSize(width: Double.nan, height: Double.nan)
 }
 
diff --git a/Sources/OpenSwiftUICore/View/Text/Text/Text+View.swift b/Sources/OpenSwiftUICore/View/Text/Text/Text+View.swift
index fa83cfc73..abe3ab104 100644
--- a/Sources/OpenSwiftUICore/View/Text/Text/Text+View.swift
+++ b/Sources/OpenSwiftUICore/View/Text/Text/Text+View.swift
@@ -484,7 +484,10 @@ package class ResolvedStyledText: CustomStringConvertible {
     final private var _computedMaxFontMetrics: NSAttributedString.EncodedFontMetrics?
 
     final package var isDynamic: Bool {
-        _openSwiftUIUnimplementedFailure()
+        guard let storage else {
+            return false
+        }
+        return storage.isDynamic
     }
 
     final package var isEmpty: Bool {
@@ -506,8 +509,10 @@ package class ResolvedStyledText: CustomStringConvertible {
     }
 
     final var schedule: (any TimelineSchedule)? {
-        _openSwiftUIUnimplementedWarning()
-        return nil
+        guard let storage, storage.isDynamic else {
+            return nil
+        }
+        return storage.updateSchedule
     }
 
     package init(
@@ -530,7 +535,7 @@ package class ResolvedStyledText: CustomStringConvertible {
         self.layoutProperties = layoutProperties
         self.layoutMargins = layoutMargins ?? .zero
         self.stylePadding = stylePadding
-        self.archiveOptions = .isArchived
+        self.archiveOptions = archiveOptions
         self.isCollapsible = isCollapsible
         self.features = features
         self.styles = styles
diff --git a/Sources/OpenSwiftUICore/View/Text/Util/String+Extension.swift b/Sources/OpenSwiftUICore/View/Text/Util/String+Extension.swift
index 179a07f57..fbaeae41b 100644
--- a/Sources/OpenSwiftUICore/View/Text/Util/String+Extension.swift
+++ b/Sources/OpenSwiftUICore/View/Text/Util/String+Extension.swift
@@ -46,4 +46,8 @@ extension NSAttributedString {
         )
         return value != nil
     }
+    
+    var updateSchedule: any TimelineSchedule {
+        _openSwiftUIUnimplementedFailure()
+    }
 }
diff --git a/Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreViewFunctions.h b/Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreViewFunctions.h
index 060f1fe98..28e36826a 100644
--- a/Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreViewFunctions.h
+++ b/Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreViewFunctions.h
@@ -14,6 +14,7 @@
 
 #include "OpenSwiftUIViewSystem.h"
 #include <QuartzCore/QuartzCore.h>
+#include <Foundation/Foundation.h>
 
 OPENSWIFTUI_ASSUME_NONNULL_BEGIN
 
diff --git a/Sources/OpenSwiftUI_SPI/Overlay/QuartzCore/CALayer+OpenSwiftUIAdditions.h b/Sources/OpenSwiftUI_SPI/Overlay/QuartzCore/CALayer+OpenSwiftUIAdditions.h
index 86e580618..a34d2567c 100644
--- a/Sources/OpenSwiftUI_SPI/Overlay/QuartzCore/CALayer+OpenSwiftUIAdditions.h
+++ b/Sources/OpenSwiftUI_SPI/Overlay/QuartzCore/CALayer+OpenSwiftUIAdditions.h
@@ -22,7 +22,7 @@
 
 @property (nonatomic, assign) int64_t openSwiftUI_displayListID;
 
-- (void)openSwiftUI_setNoAnimationDelegate;
+- (void)openSwiftUI_setNoAnimationDelegate OPENSWIFTUI_SWIFT_NAME(setNoAnimationDelegate());
 
 @end
 
diff --git a/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CABackdropLayer.h b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CABackdropLayer.h
new file mode 100644
index 000000000..95326c8cf
--- /dev/null
+++ b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CABackdropLayer.h
@@ -0,0 +1,16 @@
+//  CABackdropLayer.h
+//  OpenSwiftUI_SPI
+
+#ifndef CABackdropLayer_h
+#define CABackdropLayer_h
+
+#if __has_include(<QuartzCore/CALayer.h>)
+
+#import <QuartzCore/CALayer.h>
+
+@interface CABackdropLayer : CALayer
+@end
+
+#endif /* __has_include(<QuartzCore/CALayer.h>) */
+
+#endif /* CABackdropLayer_h */
diff --git a/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.h b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.h
index 1116dcb57..03285321d 100644
--- a/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.h
+++ b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.h
@@ -22,6 +22,9 @@ typedef NSString *CALayerContentsScaling NS_TYPED_ENUM;
 @property (nonatomic, assign, readonly) BOOL hasBeenCommitted_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(hasBeenCommitted);
 @property (nonatomic, assign) BOOL allowsGroupBlending_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(allowsGroupBlending);
 @property (nonatomic, assign) BOOL allowsHitTesting_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(allowsHitTesting);
+@property (nonatomic, assign) BOOL needsLayoutOnGeometryChange_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(needsLayoutOnGeometryChange);
+@property (nonatomic, assign) uint32_t disableUpdateMask_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(disableUpdateMask);
+@property (nonatomic, assign) BOOL shadowPathIsBounds_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(shadowPathIsBounds);
 
 /// Private property to control contents alpha channel swizzling.
 /// When set to kCALayerContentsSwizzleAAAA, the alpha channel is replicated to all channels.
diff --git a/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.m b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.m
index 95599e258..ede41df9d 100644
--- a/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.m
+++ b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.m
@@ -41,6 +41,36 @@ - (void)setAllowsGroupBlending_openswiftui_safe_wrapper:(BOOL)allows {
     func(self, selector, allows);
 }
 
+- (BOOL)needsLayoutOnGeometryChange_openswiftui_safe_wrapper {
+    OPENSWIFTUI_SAFE_WRAPPER_IMP(BOOL, @"needsLayoutOnGeometryChange", NO);
+    return func(self, selector);
+}
+
+- (void)setNeedsLayoutOnGeometryChange_openswiftui_safe_wrapper:(BOOL)needsLayout {
+    OPENSWIFTUI_SAFE_WRAPPER_IMP(void, @"setNeedsLayoutOnGeometryChange:", , BOOL);
+    func(self, selector, needsLayout);
+}
+
+- (uint32_t)disableUpdateMask_openswiftui_safe_wrapper {
+    OPENSWIFTUI_SAFE_WRAPPER_IMP(uint32_t, @"disableUpdateMask", 0);
+    return func(self, selector);
+}
+
+- (void)setDisableUpdateMask_openswiftui_safe_wrapper:(uint32_t)mask {
+    OPENSWIFTUI_SAFE_WRAPPER_IMP(void, @"setDisableUpdateMask:", , uint32_t);
+    func(self, selector, mask);
+}
+
+- (BOOL)shadowPathIsBounds_openswiftui_safe_wrapper {
+    OPENSWIFTUI_SAFE_WRAPPER_IMP(BOOL, @"shadowPathIsBounds", NO);
+    return func(self, selector);
+}
+
+- (void)setShadowPathIsBounds_openswiftui_safe_wrapper:(BOOL)value {
+    OPENSWIFTUI_SAFE_WRAPPER_IMP(void, @"setShadowPathIsBounds:", , BOOL);
+    func(self, selector, value);
+}
+
 - (BOOL)allowsHitTesting_openswiftui_safe_wrapper {
     OPENSWIFTUI_SAFE_WRAPPER_IMP(BOOL, @"allowsHitTesting", YES);
     return func(self, selector);
diff --git a/Tests/OpenSwiftUICoreTests/Render/DisplayList/DisplayListTests.swift b/Tests/OpenSwiftUICoreTests/Render/DisplayList/DisplayListTests.swift
index d58ff17f4..d809d6bbf 100644
--- a/Tests/OpenSwiftUICoreTests/Render/DisplayList/DisplayListTests.swift
+++ b/Tests/OpenSwiftUICoreTests/Render/DisplayList/DisplayListTests.swift
@@ -7,6 +7,7 @@ import OpenSwiftUICore
 import Testing
 
 @MainActor
+@Suite
 struct DisplayListTests {
     @Test
     func version() {
@@ -24,4 +25,144 @@ struct DisplayListTests {
         combineVersion.combine(with: v1)
         #expect(combineVersion.value == 999)        
     }
+
+    @Suite
+    struct DisplayListItemMatchesTopLevelStructureTests {
+        enum TestCase {
+            case emptyWithDifferentIdentity
+            case sameColorContent
+            case samePlaceholderContent
+            case differentContentKinds
+            case sameOpacityEffect
+            case sameStateEffect
+            case differentEffectKinds
+            case sameStateKeys
+            case reorderedStateKeys
+            case shorterStateKeys
+            case differentItemKinds
+        }
+
+        private func itemStructureFixture(
+            for testCase: TestCase
+        ) -> (lhs: DisplayList.Item, rhs: DisplayList.Item, expected: Bool) {
+            func item(
+                _ value: DisplayList.Item.Value,
+                identity: DisplayList.Identity = .init(decodedValue: 1)
+            ) -> DisplayList.Item {
+                DisplayList.Item(
+                    value,
+                    frame: .zero,
+                    identity: identity,
+                    version: .init(decodedValue: 0)
+                )
+            }
+
+            let redContent = item(.content(.init(
+                .color(.init(red: 1, green: 0, blue: 0, opacity: 1)),
+                seed: .init(decodedValue: 1)
+            )))
+            let greenContent = item(.content(.init(
+                .color(.init(red: 0, green: 1, blue: 0, opacity: 1)),
+                seed: .init(decodedValue: 2)
+            )))
+            let placeholder1 = item(.content(.init(
+                .placeholder(id: .init(decodedValue: 1)),
+                seed: .init(decodedValue: 1)
+            )))
+            let placeholder2 = item(.content(.init(
+                .placeholder(id: .init(decodedValue: 2)),
+                seed: .init(decodedValue: 2)
+            )))
+            let key1 = StrongHash(of: 1)
+            let key2 = StrongHash(of: 2)
+
+            switch testCase {
+            case .emptyWithDifferentIdentity:
+                return (
+                    item(.empty),
+                    item(.empty, identity: .init(decodedValue: 2)),
+                    true
+                )
+            case .sameColorContent:
+                return (redContent, greenContent, true)
+            case .samePlaceholderContent:
+                return (placeholder1, placeholder2, true)
+            case .differentContentKinds:
+                return (redContent, placeholder1, false)
+            case .sameOpacityEffect:
+                return (
+                    item(.effect(.opacity(1), .init())),
+                    item(.effect(.opacity(0.5), DisplayList(redContent))),
+                    true
+                )
+            case .sameStateEffect:
+                return (
+                    item(.effect(.state(StrongHash(of: 1)), .init())),
+                    item(.effect(.state(StrongHash(of: 2)), DisplayList(redContent))),
+                    true
+                )
+            case .differentEffectKinds:
+                return (
+                    item(.effect(.opacity(1), .init())),
+                    item(.effect(.identity, .init())),
+                    false
+                )
+            case .sameStateKeys:
+                return (
+                    item(.states([
+                        (key1, .init()),
+                        (key2, DisplayList(redContent)),
+                    ])),
+                    item(.states([
+                        (key1, DisplayList(placeholder1)),
+                        (key2, .init()),
+                    ])),
+                    true
+                )
+            case .reorderedStateKeys:
+                return (
+                    item(.states([
+                        (key1, .init()),
+                        (key2, DisplayList(redContent)),
+                    ])),
+                    item(.states([
+                        (key2, .init()),
+                        (key1, DisplayList(redContent)),
+                    ])),
+                    false
+                )
+            case .shorterStateKeys:
+                return (
+                    item(.states([
+                        (key1, .init()),
+                        (key2, DisplayList(redContent)),
+                    ])),
+                    item(.states([
+                        (key1, .init()),
+                    ])),
+                    false
+                )
+            case .differentItemKinds:
+                return (item(.empty), redContent, false)
+            }
+        }
+
+        @Test(arguments: [
+            TestCase.emptyWithDifferentIdentity,
+            .sameColorContent,
+            .samePlaceholderContent,
+            .differentContentKinds,
+            .sameOpacityEffect,
+            .sameStateEffect,
+            .differentEffectKinds,
+            .sameStateKeys,
+            .reorderedStateKeys,
+            .shorterStateKeys,
+            .differentItemKinds,
+        ])
+        func itemMatchesTopLevelStructure(_ testCase: TestCase) {
+            let fixture = itemStructureFixture(for: testCase)
+            #expect(fixture.lhs.matchesTopLevelStructure(of: fixture.rhs) == fixture.expected)
+        }
+    }
 }